<?xml version="1.0" encoding="utf-8" standalone="yes" ?>
<?xml-stylesheet type="text/xsl" href="http://www.eclipse.org/projects/project-plan.xsl"?>
<plan xmlns="http://www.eclipse.org/project/plan" xmlns:html="http://www.w3.org/1999/xhtml">
	<release projectid="tools.gef" version="3.6.0" />
	<introduction>
		<html:p>This document lays out the feature and API set for the
			next
			feature release of the Graphical Editing Framework (GEF)
			project,
			designated release 3.6.0.</html:p>
	</introduction>
	<release_deliverables>
		<html:p>
			The release deliverables are:
			<html:ul>
				<html:li>
					GEF source code for the release is available in the eclipse.org
					<html:a
						href="http://dev.eclipse.org/viewcvs/index.cgi/?cvsroot=Tools_Project">CVS
						repositories</html:a>
					.
				</html:li>
				<html:li>GEF runtime binaries and SDK distributions
					(downloadable).
				</html:li>
				<html:li>GEF runtime binaries and SDK features on eclipse.org
					update
					site
					(install via Eclipse update manager).</html:li>
			</html:ul>
		</html:p>
	</release_deliverables>
	<release_milestones>
		<preamble>
			<html:p>
				GEF builds are available weekly as Integration builds. GEF
				Milestone
				Releases are approximately one week after the
				Eclipse Milestone
				Releases. It is anticipated that GEF will synchronize its
				release
				milestones with the
				<a href="http://wiki.eclipse.org/index.php/Helios_Simultaneous_Release">
					Helios release schedule
					</a>
				.
			</html:p>
		</preamble>
	<milestone date="08/19/2009" milestone="M1" />
    <milestone date="09/30/2009" milestone="M2" />
    <milestone date="11/11/2009" milestone="M3" />
    <milestone date="12/16/2009" milestone="M4" />
    <milestone date="02/03/2010" milestone="M5" />
    <milestone date="03/17/2010" milestone="M6">
      <html:div>API Freeze</html:div>
    </milestone>
    <milestone date="05/05/2010" milestone="M7">
      <html:div>Feature Freeze</html:div>
    </milestone>
    <milestone date="05/19/2010" milestone="RC1" />
    <milestone date="05/26/2010" milestone="RC2" />
    <milestone date="06/02/2010" milestone="RC3" />
    <milestone date="06/09/2010" milestone="RC4" />
    <milestone date="06/16/2010" milestone="Final" />
    <milestone date="06/23/2010" milestone="Helios" />
	</release_milestones>
	<target_environments>
		<html:p>
			GEF 3.6 will support all operating environments supported by the
			Eclipse
			Platform itself. For a list of supported environments, refer
			to the Target Environments list in the 
			<html:a
				href="http://www.eclipse.org/projects/project-plan.php?projectid=eclipse.platform">
				Eclipse Project 3.6 plan</html:a>
		</html:p>
	</target_environments>
	<compatibility_with_previous_releases>
		<html:p>GEF 3.6 will be upwards compatible with GEF 3.5 to the
			greatest
			extent
			possible. Any exceptions will be noted in the 3.6
			release notes so that
			clients
			can assess the impact of these changes on
			their plug-ins and products.</html:p>
		<html:p>
			<html:b>API Contract Compatibility:</html:b>
			GEF 3.6 will be upwards
			contract-compatible with GEF 3.5 unless noted.
			This means that programs in full
			compliance with contracts specified
			in 3.5 APIs will automatically be
			in full
			compliance with 3.6 APIs.
			Refer to

			<html:a href="http://wiki.eclipse.org/index.php/Evolving_Java-based_APIs"> Evolving
				Java-based APIs</html:a>

			for a discussion of the kinds of API changes that maintain
			contract
			compatibility.
		</html:p>
		<html:p>
			<html:b>Binary (plug-in) Compatibility:</html:b>
			GEF 3.6 will be upwards binary-compatible with GEF 3.5 unless noted.
			This means that plug-ins built for GEF 3.5 will continue to work
			correctly in 3.6 without change. Plug-ins with hard-coded references
			in
			their plug-in manifest file to the 3.5 version of GEF
			plug-ins will
			work in 3.6 provided the version match rule is
			"greaterOrEqual" or
			"compatible" (the default); references using "perfect" or
			"equivalent" match
			rules will be broken. Refer to

			<html:a href="http://wiki.eclipse.org/index.php/Evolving_Java-based_APIs"> Evolving
				Java-based APIs</html:a>

			for a discussion of the kinds of API changes that maintain
			binary
			compatibility.
		</html:p>
		<html:p>
			<html:b>Source Compatibility:</html:b>
			GEF 3.6 will be upwards source-compatible
			with GEF 3.5 to the greatest
			extent possible. This means that source
			files
			written to use 3.5 APIs
			can often be successfully compiled and run against
			GEF
			3.6 APIs. Since
			source incompatibilities are easy to deal with,
			maintaining
			source
			compatibility is considered much less important than maintaining
			contract
			and binary compatibility. The addition of a single method
			anywhere could
			be an incompatible source change. For this reason,
			source-incompatibilities will not be noted.
		</html:p>
		<html:p>
			<html:b>Non-compliant usage of API's</html:b>
			: All non-API methods and classes, and
			certainly everything in a
			package with "internal" in its name, are considered
			implementation
			details which may vary between operating environment
			and are
			subject to
			change without notice. Client plug-ins that directly depend on
			anything other than what is specified as API are inherently
			unsupportable and
			receive no guarantees about compatibility within a
			single release much less
			with
			an earlier releases. Refer to
			<html:a
				href="http://www.eclipse.org/articles/Article-API%20use/eclipse-api-usage-rules.html">
				How to Use the Eclipse API</html:a>
			for information about how to write compliant
			plug-ins.
		</html:p>
		<html:p>
			<html:b>Ramp Down Policy</html:b>
		</html:p>
		<html:p>
			The GEF project uses the <html:a href="http://wiki.eclipse.org/Modeling_Project_Ramp_Down_Policy/Helios">Modeling Project Ramp Down Policy/Helios</html:a> 
			following EMF as a 1+ component.		
		</html:p>
	</compatibility_with_previous_releases>
	<themes_and_priorities>
		<preamble>
			<html:p>
				The project has identified major areas of work, that
				will be the
				priorities for this development cycle. 
			</html:p>
		</preamble>
		<theme name="Consumability">
			<description>
				<html:p>This work will make it easier to make effective use of
					the
					GEF components. We seek to deliver enhancements and
					defect
					fixes that are important for our consumers.
					A list of
					those plan items related to Consumability can be found by searching
					Bugzilla for flag=Helios.
				</html:p>
			</description>
			<committed
				bugzilla="https://bugs.eclipse.org/bugs/buglist.cgi?query_format=advanced&amp;short_desc_type=allwordssubstr&amp;short_desc=&amp;classification=Tools&amp;product=GEF&amp;long_desc_type=allwordssubstr&amp;long_desc=&amp;bug_file_loc_type=allwordssubstr&amp;bug_file_loc=&amp;status_whiteboard_type=substring&amp;keywords_type=allwords&amp;keywords=&amp;emailtype1=substring&amp;email1=&amp;emailtype2=substring&amp;email2=&amp;bugidtype=include&amp;bug_id=&amp;votes=&amp;chfieldfrom=&amp;chfieldto=Now&amp;chfieldvalue=&amp;cmdtype=doit&amp;order=Reuse+same+sort+as+last+time&amp;field0-0-0=flagtypes.name&amp;type0-0-0=substring&amp;value0-0-0=Helios&amp;field0-1-0=flagtypes.name&amp;type0-1-0=notsubstring&amp;value0-1-0=Helios-&amp;field0-2-0=target_milestone&amp;type0-2-0=notequals&amp;value0-2-0=---">
			</committed>
			<proposed
				bugzilla="https://bugs.eclipse.org/bugs/buglist.cgi?query_format=advanced&amp;short_desc_type=allwordssubstr&amp;short_desc=&amp;classification=Tools&amp;product=GEF&amp;target_milestone=---&amp;long_desc_type=allwordssubstr&amp;long_desc=&amp;bug_file_loc_type=allwordssubstr&amp;bug_file_loc=&amp;status_whiteboard_type=substring&amp;keywords_type=allwords&amp;keywords=&amp;emailtype1=substring&amp;email1=&amp;emailtype2=substring&amp;email2=&amp;bugidtype=include&amp;bug_id=&amp;votes=&amp;chfieldfrom=&amp;chfieldto=Now&amp;chfieldvalue=&amp;cmdtype=doit&amp;order=Reuse+same+sort+as+last+time&amp;field0-0-0=flagtypes.name&amp;type0-0-0=substring&amp;value0-0-0=Helios&amp;field0-1-0=flagtypes.name&amp;type0-1-0=notsubstring&amp;value0-1-0=Helios-">
			</proposed>
			<deferred
				bugzilla="https://bugs.eclipse.org/bugs/buglist.cgi?query_format=advanced&amp;short_desc_type=allwordssubstr&amp;short_desc=&amp;classification=Tools&amp;product=GEF&amp;long_desc_type=allwordssubstr&amp;long_desc=&amp;bug_file_loc_type=allwordssubstr&amp;bug_file_loc=&amp;status_whiteboard_type=allwordssubstr&amp;keywords_type=allwords&amp;keywords=&amp;emailtype1=substring&amp;email1=&amp;emailtype2=substring&amp;email2=&amp;bugidtype=include&amp;bug_id=&amp;votes=&amp;chfieldfrom=&amp;chfieldto=Now&amp;chfieldvalue=&amp;cmdtype=doit&amp;order=Reuse+same+sort+as+last+time&amp;field0-0-0=flagtypes.name&amp;type0-0-0=equals&amp;value0-0-0=Helios-">
			</deferred>
		</theme>
	</themes_and_priorities>
</plan>