<?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'
	$pageTitle 		= "SMILA - Getting Started";
	$pageKeywords	= "SMILA, Unified Information Access Architecture, unstructured information management, information logistics, semantic web, framework, platform, eclipse, big data, bigdata";
	$pageAuthor		= "Igor Novakovic";

	# Paste your HTML content between the EOHTML markers!	
	$html = <<<EOHTML

	<div id="midcolumn">
		<h1>Getting started</h1>
		<p>
			This page will give you a quick overview of available resources and help you getting started with SMILA.
		</p>
		<div class="homeitem3col">
			<h3>Download</h3>
			<p>
			To find out how to get SMILA binaries please go to our 
			<a href="http://www.eclipse.org/smila/downloads.php">download page</a>.
			</p> 
		</div>
		<div class="homeitem3col">
			<h3>Installation</h3>
			<p>
			To install SMILA just pick up the latest stable build (a release or a milestone) form the 
			<a href="http://www.eclipse.org/smila/downloads.php">download page</a> for your platform and 
			simply unzip the contents in some arbitrary folder (e.g. "C:\SMILA").
			</p> 
			<p>
			You can now start SMILA by executing either SMILA.exe (Win32) or SMILA (Linux). For configuration
			options please consult the documentation in our <a href="http://wiki.eclipse.org/SMILA" target="_blank">wiki</a>.
			</p> 
		</div>
		<div class="homeitem3col">
			<h3>SMILA in 5 Minutes</h3>
			<p>
			Want to make your first steps in SMILA without reading too much of the documentation? 
			In our <a href="http://wiki.eclipse.org/SMILA/5_Minutes_Tutorial" target="_blank">5 Minutes Tutorial</a> 
			we will crawl a web source, process and index the data and provide a basic search.		
			</p>
		</div>
		<div class="homeitem3col">
			<h3>Documentation</h3>
			<p>
			Full technical documentation as well as specification/concepts together with integration and 
			development guidelines can be found in our <a href="http://wiki.eclipse.org/SMILA" target="_blank">wiki</a>.
			</p> 
		</div>
		<div class="homeitem3col">
			<h3>Source code</h3>
			<p>
			SMILA's source code is being maintained in SVN repository located at:<br> 
			<a href="http://dev.eclipse.org/svnroot/rt/org.eclipse.smila/">http://dev.eclipse.org/svnroot/rt/org.eclipse.smila/</a>
			</p> 
		</div>
	</div>
	  
EOHTML;

	include('rightColumn.php');
	$html .= $rightColumn;

	# Generate the web page
	$App->generatePage($theme, $Menu, $Nav, $pageAuthor, $pageKeywords, $pageTitle, $html);
?>
