<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
<?xml-stylesheet type="text/xsl" href="http://www.eclipse.org/projects/project-plan.xsl"?>
<plan plan-format="1.0" xmlns="http://www.eclipse.org/project/plan" xmlns:html="http://www.w3.org/1999/xhtml"
      name="Project Name">
   <release projectid="modeling.m2t.acceleo" version="3.2.0"/>
   <introduction>
     <html:div>
     This document lays out the feature and API set for the 3.2.0 release of the M2T Acceleo project.  
     The Acceleo component is an open source component under the Eclipse Modeling / Model-To-Text (M2T) project.
     Its primary goal is to provide an implementation of the MOF Model-To-Text OMG standard.
     
	 The new release of Acceleo introduces no API or feature breakage, and is thus labeled 3.2.0.
     </html:div>
   </introduction>
   <release_deliverables>
	<html:p>
    The release deliverables have the same form as is found in most Eclipse projects, namely:
	<html:ul>
		<html:li>Acceleo SDK (includes runtime and tooling components, with sources, examples, and documentation) (downloadable and update site).</html:li>
		<html:li>Acceleo runtime binary distribution (downloadable and update site).</html:li>
		<html:li>Acceleo examples (downloadable and update site)</html:li>
		<html:li>Acceleo tests (downloadable and update site)</html:li>
	</html:ul>
	</html:p>
    </release_deliverables>
   <release_milestones>
      <preamble>
         <html:div>
         The implementation will be compliant with the advanced feature compliance level of the MOF Model-To-Text OMG language (No Macro and alternative syntax).
         The milestones for this release of Acceleo will be synchronized with the Indigo release schedule.
         </html:div>
      </preamble>
      <milestone date="10/10/2011" milestone="RC1"><html:div></html:div></milestone>
      <milestone date="10/11/2011" milestone="RC2"><html:div></html:div></milestone>
      <milestone date="10/12/2011" milestone="RC3"><html:div></html:div></milestone>
      <milestone date="10/13/2011" milestone="RC4"><html:div></html:div></milestone>
      <milestone date="10/14/2010" milestone="3.1 Final"><html:div></html:div></milestone>
      <postamble><html:div></html:div></postamble>
   </release_milestones>
   <target_environments>
     <html:div>
     The acceleo project depends upon the Platform and other projects, which are mostly "pure" Java.
     Acceleo 3.2.0 will be compatible with Eclipse Ganymede, Galileo, Helios and Indigo. 
     EMF is used throughout Acceleo both for its inner mechanics and accessing the target models.
     The MDT-OCL component is reused to edit, parse, and interpret OCL as a sub-language of Acceleo. 
     Acceleo will target the same Java version as EMF, which currently requires Java 5.
     Acceleo will be tested and validated against Eclipse SDK 3.4.2, 3.5.2, 3.6.2 and 3.7.0.
     </html:div>
          <internationalization>
          <html:div>
          <html:p>
	The Eclipse Platform is designed as the basis for internationalized products. The user interface
	elements provided by the Eclipse SDK components, including dialogs and error messages, are
	externalized. The English strings are provided as the default resource bundles. Likewise, the
	Acceleo project will provide English strings in its default bundles and be localized to a subset
	of those locales offered by the Platform. This plan will be updated to indicate which locales
	will be provided and the time frame for availability.
          </html:p>
          </html:div>
     </internationalization>
   </target_environments>
   <compatibility_with_previous_releases>
       <html:div>
       The acceleo 3.2 version will be compatible with the 3.1, 3.0 and 0.8 versions.
       </html:div>
   </compatibility_with_previous_releases>
   <themes_and_priorities>
     <preamble>
         <html:div></html:div>
     </preamble>
     <theme name="Advanced feature compliance">
        <description>
        	<html:ul>
        <html:li>Standalone Component.</html:li>
        <html:li>Advanced feature compliance level of the MOF Model-To-Text language.</html:li>
		<html:li>Keep the user code you typed manually : User tags and JMerge support.</html:li>
		<html:li>Complete Acceleo Runtime library.</html:li>
		<html:li>Java developer facilities : Java extensions and Properties files.</html:li>
		<html:li>Files encoding.</html:li>
		<html:li>MTL Syntax Documentation.</html:li>
			</html:ul>
        </description>
     </theme>
     <theme name="Eclipse IDE components">
        <description>
        	<html:ul>
        <html:li>2 modes for the Eclipse Builder : The fully OMG-compliant standard mode and the EMF addict mode.</html:li>
        <html:li>Advanced code completion and quick fixes to create a template from an example.</html:li>
        <html:li>Overrides View : Show the workspace and the plugin generators to make it possible to easily override the behavior of the code generation.</html:li>
        <html:li>Traceability information : The Result view shows the synchronization between the code and the model.</html:li>
        <html:li>Export a generator as a plugin and build a generator on the Eclipse build server.</html:li>
        <html:li>Debug and Profile a code generation.</html:li>
        <html:li>Real time syntax error detection.</html:li>
        <html:li>IDE Documentation.</html:li>
        	</html:ul>
        </description>
     </theme>
	 <theme name="Integration with other tools">
	    <description>
	    	<html:ul>
	    <html:li>Workflow facilities for acceleo.</html:li>
	    <html:li>Compatibility with other Eclipse modeling projects like QVTo, ATL, JET, and Xpand.</html:li>
	    <html:li>A wizard to migrate an Acceleo template from the 2.x versions to the 3.x versions.</html:li>
	    	</html:ul>
	    </description>
     </theme>
     <theme name="Examples">
        <description>Examples for end-users : Python, Java</description>
     </theme>
   </themes_and_priorities>
 </plan>
