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

	#*****************************************************************************
	#
	# index.php
	#
	# Author: 		Markus Knauer
	# Date:			2007-02-20
	#
	# Description: Download page of the Eclipse Packaging Project
	#
	#
	#****************************************************************************
	
	#
	# Begin: page-specific settings.  Change these. 
	$pageTitle 		= "EPP FAQ / Known Issues";
	$pageKeywords	= "eclipse, download, packages, packaging, features, content";
	$pageAuthor		= "Markus Knauer";
	
	# 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", 3);
	# $Nav->addCustomNav("Google", "http://www.google.com/", "_blank", 3);

	# End: page-specific settings
	#
		
	# Paste your HTML content between the EOHTML markers!	
	$html = <<<EOHTML

<div id="maincontent">


<!-- MIDCOLUMN START -->
<div id="midcolumn">

<h1>$pageTitle</h1>

<h3>Running the EPP package XY breaks with an out of memory exception?</h3>
<p>There is an error in the Eclipse launcher that prevents setting the correct
MaxPermSize automatically to the Java VM launch options. This results in many VM
crashes, especially in the large JEE package.
See <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=203325">bug 203325</a>
for further information.</p>
<p>As a workaround one can add <tt>-XX:MaxPermSize=128m</tt> manually to the 
<tt>-vmargs</tt> section of the <tt>eclipse.ini</tt>.</p>

<h3>Do the new Eclipse Europa Fall packages contain Eclipse Platform 3.3.0 or 3.3.1?</h3>
<p>If you download one of the new Eclipse Europa Fall packages 
('eclipse-XXX-europa-fall-YYY') and you open the about dialog, it still shows up with
Eclipse version 3.3.0, but it is based on Eclipse Platform 3.3.1.
See <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=205020">bug 205020</a>
for further information.</p>

<h3>Feature XYZ does not work</h3>
<p>Please check the version of your Java Runtime Environment. It is highly 
recommended to use version 1.5 or higher with the EPP packages! While the 
Eclipse Platform is 
<a href="http://www.eclipse.org/downloads/moreinfo/jre.php">known to run 
with version 1.4</a>, some features of the EPP packages will be disabled
silently. 
See <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=191597">bug 191597</a>
for further information.</p>

<h3>Using the Eclipse Update Manager with Eclipse IDE for Java EE Developers</h3>
<p>Because of a missing dependency it is not possible to use the Eclipse Update
Manager with the 20070628 version of this package. The bug has been reported as
<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=194959">bug 194959:
Pieces missing from Eclipse IDE for Java EE Developers distribution</a>. Packages
downloaded after 2007-07-02 are fixed.</p>
<p><strong>Workaround:</strong> Download the fixed package or add the features 
<strong>Data Tools Platform Enablement</strong> and <strong>Data Tools Platform 
Documentation</strong> manually from the Europa Discovery Update Site.</p>

<h3>Eclipse does not start</h3>
<p>In some rare environments the Eclipse Packages do not start on Windows. This
has been reported in bug 
<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=194943">194943</a> and
<a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=194929">194929</a>. Windows 
packages downloaded after 2007-07-02 do not contain the 
<code>-Dosgi.bundlefile.limit=100</code> parameter any more and should work.</p>
<p><strong>Workaround:</strong> Download a fixed package or remove the line
<strong><code>-Dosgi.bundlefile.limit=100</code></strong> from the 
<code>eclipse.ini</code> file.</p>

<hr class="clearer" />
</div>
<!-- MIDCOLUMN END -->

<!-- RIGHTCOLUMN START -->
<div id="rightcolumn">
</div>
<!-- RIGHTCOLUMN END -->

</div>

EOHTML;


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