<!DOCTYPE html>
<html lang="en">

	<head>
		<title>Virgo Splash Screen</title>
		<meta http-equiv="Content-Type" content="text/html;charset=utf-8" />
		<link rel="shortcut icon" href="images/favicon.ico" />
		<link rel="stylesheet" href="styles/main.css" type="text/css" />
		<link rel="stylesheet" href="styles/print.css" type="text/css" media="print" />
	</head>
	
	<body class="main">
	    <div id="page">
	        <div id="mini-header">
				<div id="mini-header-left"></div>
				<div id="mini-header-right"></div>
	        </div> <!-- /mini-header -->
	
	    <div id="primary-navigation">
	        <div id="primary-left">
	
	        </div>
	        <div id="left-cap"></div>
	        <div id="primary-right">
	            <ul>
	                <li><a href="/admin" title="Admin Console">Admin Console</a></li>
	            </ul>
	        </div>
	        <div id="right-cap"></div>
	    </div><!-- /primary-navigation -->
	
	    <div id="container">
	      <div id="content-no-nav">
	
	        <div id="splash-container"><img class="splash" src="images/server-splash.png" alt="EclipseRT Virgo Server" />
	        	<div id="version-text"><!--@<version@--></div>
	        </div>
	        
	        <h1>Welcome</h1>
	        <p>
	          Congratulations on installing the Virgo Server.
	          From this splash page you can access the web-based <a href="/admin" title="Admin Console">admin console</a>.
	        </p>
	        
	        <h1>Documentation</h1>
	        <p>
	          Documentation is available on-line for the server and related products.
	        </p>
	        <ul>
	          <li><a href="http://www.eclipse.org/virgo/documentation" target="_blank" title="Eclipse Virgo Server Documentation">Eclipse Virgo Server Documentation</a>.</li>
	          <li><a href="https://www.eclipse.org/gemini/blueprint/documentation/reference/2.0.0.RELEASE/html/index.html" target="_blank" title="Eclipse Gemini Blueprint Documentation">Eclipse Gemini Blueprint Documentation</a></li>
	          <li><a href="http://docs.spring.io/spring/docs/current/spring-framework-reference/htmlsingle/" target="_blank" title="Spring Framework Documentation">Spring Framework Documentation</a></li>
	        </ul>
	      </div><!-- /content -->
	    </div><!-- /container -->
	    
	    <div id="footer-wrapper">
	      <div id="footer-left">&#169; Copyright 2008, 2011 VMware Inc. Licensed under the Eclipse Public License v1.0.</div>
	
	      <div id="footer-right"></div> 
	    </div>
	
	  </div> <!-- /page-->
	
	</body>
</html>
