<?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="Libra">
	<release projectid="webtools.libra" version="0.1" />
	<introduction>
		<html:div>The Plug-in Development Environment project and Web Tools
			Platform project provide plenty of tools for OSGi development and
			Java EE development, respectively. Libra will provide the missing
			pieces that will bring the PDE and WTP tooling together for
			implementing OSGi Enterprise scenarios.</html:div>
	</introduction>
	<release_deliverables>
		<html:div>
			<html:p>
				Two main features will be delivered:
				<html:ul>
					<html:li>WAR Products tooling - originally developed to make the
						deployment of RAP applications easier, tooling itself is not RAP
						specific and can be used for deploying any Server-Side Equinox
						applications. </html:li>
					<html:li>OSGi Bundle Facet - links together the PDE and WTP tooling. It
						enable the WTP project wizards to create OSGi bundles projects,
						like Web Application Bundles and Persistence Bundles. It's the
						very first step towards providing OSGi tooling for enterprise
						applications. </html:li>
				</html:ul>
			</html:p>
		</html:div>
	</release_deliverables>
	<release_milestones>
		<preamble>
			<html:div>Some xhtml content here. Make sure to use the prefix before
				the elements</html:div>
		</preamble>
		<milestone date="3/18/2011" milestone="M6">
			<html:div>Feature completion, will be available as part of Indigo M6
			</html:div>
		</milestone>
		<milestone date="5/6/2011" milestone="M7">
			<html:div>Response to community feedback</html:div>
		</milestone>
		<milestone date="5/20/2011" milestone="RC1">
			<html:div>Updates to documentation</html:div>
		</milestone>
		<milestone date="5/27/2011" milestone="RC2">
			<html:div>Release Candidate</html:div>
		</milestone>
		<milestone date="6/3/2011" milestone="RC3">
			<html:div>Release Candidate</html:div>
		</milestone>
		<milestone date="6/10/2011" milestone="RC4">
			<html:div>Release Candidate</html:div>
		</milestone>
		<milestone date="6/22/2011" milestone="Final">
			<html:div>Final 0.1 Release as part of the Indigo Simultaneous Release</html:div>
		</milestone>
		<postamble>
			<html:div></html:div>
		</postamble>
	</release_milestones>
	<target_environments>
        <html:div>
            WTP will support the platforms certified by the Eclipse
            Platform project. For a list of platforms supported in
            Indigo, see <a href="http://www.eclipse.org/projects/project-plan.php?projectid=eclipse#target_environments">Eclipse Target Operating Environments</a>.</html:div>
        <internationalization>
            <html:div>
                Internationalization and Localization will be supported.
                <html:ul>
                    <html:li>
                        Internationalization (I18N)
                        <html:p>Each project should be able to work in an
                            international environment, including support
                            for operating in different locales and
                            processing/displaying international data
                            (dates, strings, etc.).</html:p>
                    </html:li>
                    <html:li>
                        Localization
                        <html:p>Each project should provide an environment
                            that supports the localization of the
                            technology (i.e. translation). This
                            includes, but is not limited to, ensuring
                            that strings are externalized for easy
                            translation.</html:p>
                    </html:li>
                    <html:p> Where possible, projects should use an open and
                        transparent process to create, maintain and
                        deliver language packs translated into multiple
                        languages in a timely manner. The primary
                        languages to consider are: English, Simplified
                        Chinese, Traditional Chinese, Japanese, French,
                        German, Spanish.</html:p>
                </html:ul>
            </html:div>
        </internationalization>
    </target_environments>
	<compatibility_with_previous_releases>
		<html:div></html:div>
	</compatibility_with_previous_releases>
	<themes_and_priorities>
		<preamble>
			<html:div></html:div>
		</preamble>
		<theme name="Basics">
			<description>
				<html:div>Deliever the basic features in the first release. </html:div> 
			</description>
			<committed bugzilla="https://bugs.eclipse.org/bugs/buglist.cgi?keywords=plan&amp;keywords_type=allwords&amp;bug_severity=enhancement&amp;classification=WebTools&amp;query_format=advanced&amp;target_milestone=0.1+M6&amp;target_milestone=0.1+M7&amp;target_milestone=0.1+RC1&amp;target_milestone=0.1+RC2&amp;target_milestone=0.1+RC3&amp;target_milestone=0.1+RC4&amp;product=Libra" />
			<proposed bugzilla="https://bugs.eclipse.org/bugs/buglist.cgi?keywords=plan&amp;query_format=advanced&amp;keywords_type=allwords&amp;bug_severity=enhancement&amp;target_milestone=0.1&amp;product=Libra" />
			<deferred bugzilla="https://bugs.eclipse.org/bugs/buglist.cgi?keywords=plan&amp;keywords_type=allwords&amp;bug_severity=enhancement&amp;classification=WebTools&amp;query_format=advanced&amp;target_milestone=---&amp;product=Libra" />
		</theme>
	</themes_and_priorities>
	<appendix name="Project Refactoring">
	</appendix>
</plan>
