<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<!--
   Licensed to the Apache Software Foundation (ASF) under one
   or more contributor license agreements.  See the NOTICE file
   distributed with this work for additional information
   regarding copyright ownership.  The ASF licenses this file
   to you under the Apache License, Version 2.0 (the
   "License"); you may not use this file except in compliance
   with the License.  You may obtain a copy of the License at

     http://www.apache.org/licenses/LICENSE-2.0

   Unless required by applicable law or agreed to in writing,
   software distributed under the License is distributed on an
   "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
   KIND, either express or implied.  See the License for the
   specific language governing permissions and limitations
   under the License.    
-->
<html xmlns="http://www.w3.org/1999/xhtml" lang="en" xml:lang="en">
<head>
	<META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=ISO-8859-1">
<title>${title} | Apache IvyDE&#153;</title>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
  <link rel="stylesheet" type="text/css" href="style/print-style.css" />
</head>

<body>

<div id="body">

<table id="header" summary="Navigation elements." border="0"
	cellpadding="0" cellspacing="0" width="100%">
	<tr>
		<td id="home" width="30%"><a href="http://ant.apache.org/"
			title="Apache Ant&#153;"><img src="images/ant-group-logo.gif" alt="Apache Ant&#153;"
			border="0" /></a></td>

		<td class="product" width="70%" align="right" valign="middle"><img
			src="images/logo.png" alt="Apache IvyDE&#153;" border="0" /></td>
	</tr>
</table>

		<div id="main">
            ${body}
 		</div><!-- main -->

<div id="footer-message" class="footer">
    <hr />
    <i>Copyright &#169; 2013 The Apache Software Foundation, Licensed under the <a href="http://www.apache.org/licenses/LICENSE-2.0.txt">Apache License, Version 2.0</a>.</i><br />
    <i>Apache IvyDE, Apache Ivy, Apache Ant, IvyDE, Ivy, Ant, Apache, the Apache IvyDE logo, the Apache Ivy logo, the Apache Ant logo and the Apache feather logo are trademarks of The Apache Software Foundation.</i><br />
    <i>Eclipse and the Eclipse logo are trademarks of Eclipse Foundation, Inc.</i>
    <i>All other marks mentioned may be trademarks or registered trademarks of their respective owners. </i>
</div>

</div><!-- body -->
</body>
</html>
