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

	#*****************************************************************************
	#
	# template.php
	#
	# Author: 		Wayne Beaton
	# Date:			2006-06-06
	#
	# Description: 
	# This page contains pointers to download and tutorial information for
	# individuals interested in using Eclipse for Java development.
	#****************************************************************************
	
	#
	# Begin: page-specific settings.  Change these. 
	$pageTitle 		= "Eclipse for Java and Web Developers";
	$pageKeywords	= "callisto java mustang 3.2 matisse windowbuilder j2ee enterprise servlet tomcat eclipse resource screencam screen cam tutorial ";
	$pageAuthor		= "Wayne Beaton";
	
	# 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)
	# $Nav->addNavSeparator("My Page Links", 	"downloads.php");
	# $Nav->addCustomNav("My Link", "mypage.php", "_self", 1);
	# $Nav->addCustomNav("Google", "http://www.google.com/", "_blank", 1);
	
	#$Nav->addCustomNav("<img src=\"http://www.eclipsecon.org/2007/image125x125.gif\"/>","http://www.eclipsecon.org/2007", "_self", 1);
	# End: page-specific settings
	#
			
	require_once("links.php");
	
	# Paste your HTML content between the EOHTML markers!	
	$html = <<<EOHTML
<script type="text/javascript">
function show_section(name) {
	if (document.getElementById(name).style.display=='block') return;
	document.getElementById(name +'-down').style.display='none';
	document.getElementById(name).style.display='block'
}
function hide_section(name) {
	if (document.getElementById(name).style.display=='none') return;
	document.getElementById(name +'-down').style.display='inline';
	document.getElementById(name).style.display='none'
}
</script>
<link rel="stylesheet" type="text/css" href="callisto.css" media="screen" />

<div class="callistoRealEstate paddingLeft">
	<div class="maincontent">
        <table cellspacing=0 class="callistoButtons">
        	<tr>
        		<td width="50"><img src="images/java.jpg"></a></td>
				<td width="100%"class="noRightBorder">$pageTitle</td>
			</tr>
		</table>
        <a href="http://www.eclipsecon.org/?tag=eclipse-callisto-java"><img style="margin-top:5px;" align="right" src="http://www.eclipsecon.org/2007/image125x125.gif"/></a>
        <h2><a name="sdk"></a></h2>
		<p>The Eclipse Software Development Kit (SDK) contains everything you need to build
		Java applications. Considered by many to be the best Java development tool available,
		the Eclipse Java Development Tools (JDT) provides superior Java editing with on-the-fly validation, 
		incremental compilation, cross-referencing, code assist and much more.</p>
		<p>The new Eclipse 3.2 release features some exciting new capabilities, including:
		<ul>
			<li>Java 6 support</li>
			<li>Refactoring scripts</li>
			<li>Static analysis of Java code</li>
			<li>Improved code completion and quick fix support</li>
			<li>Improved usability and performance</li>
			<li>Support for Mac OSX on Intel and preview support for Windows Vista</li>
		</ul>	
		<p>For a more complete list, check out the <a href="$new_noteworthy">New and Noteworthy</a>.</p>
		
		<p>If you are planning to use Eclipse to build Eclipse plug-ins or Eclipse Rich Client Platform (RCP)
		applications, please see <a href="plugin-dev.php">Eclipse for Plug-in Developers</a>.
			
      	<div class="homeitem">
      		<h3>What do you need?</h3>
			
			<p><strong><a href="$eclipse_sdk">Eclipse 3.2</a> is required for Callisto.</strong> 
			There is no upgrade path from previous versions of Eclipse.</p>
      		
			<ul>
      			<li style="border-style: none">The <a href="$eclipse_sdk">Eclipse SDK</a> <span style="white-space:nowrap">3.2<img id="platform-down" src="images/down.png" onclick="show_section('platform');"/></span>
      						<div id="platform" style="border-style:solid;border-width:1px;margin-left:5%;display:none">
      							<h3><img onclick="hide_section('platform');" align="right" src="images/close.png"/>Eclipse SDK 3.2</h3>
	      						The SDK provides Java development tools.
	      						<h4>Tutorials and Help</h4>
					      		<ul>
					      		    <li style="list-style-image: url(images/movie.png);border-style: none"><a href="http://www.eclipse.org/downloads/download.php?r=1&file=/technology/phoenix/demos/install-eclipse/install-eclipse.html">Installing the Eclipse SDK 3.2</a></li>
      		    					<li style="list-style-image: url(images/movie.png);border-style: none"><a href="http://www.eclipse.org/downloads/download.php?r=1&file=/technology/phoenix/demos/testfirst/testfirst.html">Test First Development using Eclipse</a></li>
					      		</ul>
      						</div>
      					</li>
      			</li>
      			<li style="border-style: none">Optional features available via the <a href="$callisto_discovery">Callisto&nbsp;Discovery&nbsp;Site</a>
      				<ul>
      					<li style="border-style: none">Visual Editor <span style="white-space:nowrap">(<a href="/vep">VE</a>)<img id="ve-down" src="images/down.png" onclick="show_section('ve');"/></span>
      						<div id="ve" style="border-style:solid;border-width:1px;margin-left:5%;display:none">
      							<h3><img onclick="hide_section('ve');" align="right" src="images/close.png"/>Visual Editor</h3>
	      						The Eclipse Visual Editor (VE) is a GUI builder
      							for Swing/JFC and <a href="/swt">SWT</a>/<a href="/rcp">RCP</a>.
					      		<h4>Suggested reading</h4>
					      		<ul>
					      		<li style="list-style-image: url(images/document.png);border-style: none"><a target="_blank" href="http://www-106.ibm.com/developerworks/opensource/library/os-ecvisual/">Build GUIs with the Eclipse Visual Editor project</a>
					      		</ul>
      							</div>
      					</li>      				
      					
      					<li style="border-style: none">Java EE and Web Tools <span style="white-space:nowrap">(<a href="/webtools">WTP</a>)<img id="wtp-down" src="images/down.png" onclick="show_section('wtp');"/></span>
      						<div id="wtp" style="border-style:solid;border-width:1px;margin-left:5%;display:none">
      							<h3><img onclick="hide_section('wtp');" align="right" src="images/close.png"/>Java EE and Web Tools</h3>
	      						The Eclipse Web Tools Platform (WTP) extends the Eclipse 
      							platform with tools for developing Java Enterprise Edition and
      							Web applications.
      							<ul>
					      		    <li style="list-style-image: url(images/tutorial.png);border-style: none"><a href="http://www.eclipse.org/webtools/community/tutorials/BuildJ2EEWebApp/BuildJ2EEWebApp.html">Building and Running a Web Application</a></li>
									<li style="list-style-image: url(images/tutorial.png);border-style: none"><a href="http://www.eclipse.org/dali/viewlets/01-Add_Persistence_viewlet_swf.html">Adding Java Persistence API (JPA) Support to a Project</a></li>
									<li style="list-style-image: url(images/tutorial.png);border-style: none"><a href="http://www.eclipse.org/webtools/community/communityresources.html#tutorials">More Web and Java EE Tutorials...</a></li>
								</ul>
      						</div>
      					</li>  
      					
      					<li style="border-style: none">Test and Performance Tools <span style="white-space:nowrap">(<a href="/tptp">TPTP</a>)<img id="tptp-down" src="images/down.png" onclick="show_section('tptp');"/></span>
      						<div id="tptp" style="border-style:solid;border-width:1px;margin-left:5%;display:none">
      							<h3><img onclick="hide_section('tptp');" align="right" src="images/close.png"/>Test and Performance Tools</h3>
	      						The Eclipse Test and Performance Tools Platform (TPTP) Project 
	      						provides an open platform supplying powerful frameworks and 
	      						services that allow software developers to build unique test 
	      						and performance tool, both open source and commercial, that 
	      						can be easily integrated with the platform and with other tools.
      							<h4>Suggested reading</h4>
					      		<ul>      		  	
					      			<li style="list-style-image: url(images/tutorial.png);border-style: none"><a href="http://www.eclipse.org/tptp/home/documents/conferences/eclipseCon2005/EclipseCon_2005_Tutorial_22_Antony_Miguel_Paul_Slauenwhite.pdf">Using TPTP Logging and Monitoring Tools</a></li>
					      			<li style="list-style-image: url(images/tutorial.png);border-style: none"><a href="http://www.eclipse.org/articles/Article-TPTP-Profiling-Tool/tptpProfilingArticle.html">Java Application Profiling using TPTP</a></li>
					      		</ul>
      						</div>
      					</li>
      					
      					<li style="border-style: none">Reporting Tools<span style="white-space:nowrap">(<a href="/birt">BIRT</a>)<img id="birt-down" src="images/down.png" onclick="show_section('birt');"/></span>
      						<div id="birt" style="border-style:solid;border-width:1px;margin-left:5%;display:none">
      							<h3><img onclick="hide_section('birt');" align="right" src="images/close.png"/>Reporting Tools</h3>
	      						BIRT is a reporting system that integrates with your application to produce 
	      						compelling reports for both web and PDF.
	      						<ul>
					      		    <li style="list-style-image: url(images/tutorial.png);border-style: none"><a href="http://www.eclipse.org/birt/phoenix/tutorial/basic">Building a Simple Report with BIRT</a></li>
									<li style="list-style-image: url(images/movie.png);border-style: none"><a href="http://download.eclipse.org/birt/downloads/demos/FirstReport/MyFirstReport.html">My First Report</a></li>
									<li style="list-style-image: url(images/tutorial.png);border-style: none"><a href="http://www.eclipse.org/birt/phoenix/tutorial/">More BIRT Tutorials and screen casts...</a></li>
								</ul>
      						</div>
      					</li>
      					
      					<li style="border-style: none">Data Tools <span style="white-space:nowrap">(<a href="/datatools">DTP</a>)<img id="dtp-down" src="images/down.png" onclick="show_section('dtp');"/></span>
      						<div id="dtp" style="border-style:solid;border-width:1px;margin-left:5%;display:none">
      							<h3><img onclick="hide_section('dtp');" align="right" src="images/close.png"/>Data Tools</h3>
	      						Data Tools provides tools for accessing, viewing and manipulating databases and
	      						other data sources.
      						</div>
      					</li>
      				</ul>
   				</li>
      		</ul>
      	</div>    	
      	<div class="homeitem">
      		<h3>Tutorials and Help</h3>
      		<ul>
      		    <li style="list-style-image: url(images/movie.png);border-style: none"><a href="http://www.eclipse.org/downloads/download.php?r=1&file=/technology/phoenix/demos/install-eclipse/install-eclipse.html">Installing the Eclipse SDK 3.2</a></li>
      		    <li style="list-style-image: url(images/movie.png);border-style: none"><a href="$install_callisto">Installing Features from the Callisto Discovery Site</a></li>
      			<li style="list-style-image: url(images/movie.png);border-style: none"><a href="http://www.eclipse.org/downloads/download.php?r=1&file=/technology/phoenix/demos/install-ve/install-ve.html">Installing and using the Eclipse Visual Editor</a></li>
				<li style="list-style-image: url(images/movie.png);border-style: none"><a href="http://www.eclipse.org/downloads/download.php?r=1&file=/technology/phoenix/demos/install-wtp/install-wtp.html">Installing and Using the Eclipse Web Tools</a></li>
				<li style="list-style-image: url(images/tutorial.png);border-style: none"><a href="http://www.eclipse.org/birt/phoenix/build/">Installing BIRT</a></li>      			    		
      		</ul>
      	</div>
      	
      		
      	<div class="homeitem">
      		<h3>Suggested reading</h3>
      		<ul>
      			<li style="list-style-image: url(images/book.png);border-style: none"><a href="http://www.oreilly.com/catalog/eclipsepg/cover.html">Eclipse IDE Pocket Guide</a></li>
			</ul>
      	</div>
	</div>

</div>

EOHTML;

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