<?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="CDO Model Repository">
   <release projectid="modeling.emf.cdo" version="4.2"/>
   <introduction>
     <html:div>
This document lays out the feature and API set for the
third release of the CDO Model Repository
Project (CDO), version 4.2. This project plan inherits from the Modeling
Project Plan, which should be referenced when consulting this
individual project plan.
     </html:div>
   </introduction>
   <release_deliverables>
     <html:div>
The release deliverables have the same form as is found in most Eclipse projects, namely:
<!-- Created by /org.eclipse.emf.cdo.releng/src/org/eclipse/emf/cdo/releng/PrintReleaseDeliverablesForPlan.java -->
<html:ul>
  <html:li><html:b>CDO Dawn Codegen EMF</html:b> (Contains the code generation aspects for collaborative EMF support over CDO.)</html:li>
  <html:li><html:b>CDO Dawn Codegen GMF</html:b> (Contains the code generation aspects for collaborative GMF support over CDO.)</html:li>
  <html:li><html:b>CDO Dawn Codegen</html:b> (Contains the code generation aspects for graphical collaboration support over CDO.)</html:li>
  <html:li><html:b>CDO Dawn Ecore Editor Extension</html:b> (CDO Dawn Ecore Editor Extension contains bundles which enable the EMF Ecore Editor to work with CDO.)</html:li>
  <html:li><html:b>CDO Dawn EcoreTools Diagram Extension</html:b> (CDO Dawn EcoreTools Diagram Extension contains bundles which enable the EMF EcoreTools Diagram to work with CDO.)</html:li>
  <html:li><html:b>CDO Dawn Examples</html:b> (Contains example plugins to demonstrate a range of functions of Dawn.)</html:li>
  <html:li><html:b>CDO Dawn Runtime</html:b> (Contains the runtime aspects for graphical collaboration support over CDO.)</html:li>
  <html:li><html:b>CDO Dawn SDK</html:b> (Includes Runtime, Codegen, Tools, Examples, Documentation and Source.)</html:li>
  <html:li><html:b>CDO Dawn Tests</html:b> (Contains the CDO Dawn test plugins and sources. Ensure that SWTBot is already installed! Visit http://download.eclipse.org/technology/swtbot/helios/dev-build/update-site for a p2 repository that contains SWTBot.)</html:li>
  <html:li><html:b>CDO Electronic Restaurant Example</html:b> (Contains the CDO Gastro RCP plugins, models and sources.)</html:li>
  <html:li><html:b>CDO Model Repository Client (Compare Integration)</html:b> (Contains the core and user interface plugins of the CDO / EMF Compare integration. This feature is optional and requires EMF Compare 2.1 or higher.)</html:li>
  <html:li><html:b>CDO Model Repository Client</html:b> (Contains the CDO client core and user interface plugins.)</html:li>
  <html:li><html:b>CDO Model Repository Definitions</html:b> (Contains the EMF-based definition and wiring plugins for CDO.)</html:li>
  <html:li><html:b>CDO Model Repository Documentation</html:b> (Contains the documentation of the CDO Model Repository.)</html:li>
  <html:li><html:b>CDO Model Repository EPP</html:b> (Contains a minimum CDO client and server environment for the Eclipse Modeling package.)</html:li>
  <html:li><html:b>CDO Model Repository Examples Hibernate</html:b> (Contains the CDO Hibernate example plugin and sources. Ensure that Hibernate is already installed! Visit http://www.elver.org/eclipse/2.0.0/update for a p2 repository that contains Hibernate.)</html:li>
  <html:li><html:b>CDO Model Repository Examples Installer</html:b> (Contains a New Wizard that creates CDO example projects in the workspace.)</html:li>
  <html:li><html:b>CDO Model Repository Examples</html:b> (Contains the CDO example plugin, models and sources.)</html:li>
  <html:li><html:b>CDO Model Repository Explorer Product</html:b> (Contains the product definition of an installable CDO explorer.)</html:li>
  <html:li><html:b>CDO Model Repository Migrator Tool</html:b> (Contains the CDO Genmodel migrator/importer plugin.)</html:li>
  <html:li><html:b>CDO Model Repository SDK</html:b> (Includes Client, Server, Tools, Examples, Documentation and Source.)</html:li>
  <html:li><html:b>CDO Model Repository Server DB Store</html:b> (Contains the DBStore plugins.)</html:li>
  <html:li><html:b>CDO Model Repository Server DB4O Store</html:b> (Contains the DB4O Store bundle. Ensure that DB4O Driver is already installed! Visit http://www.elver.org/eclipse/2.0.0/update for a p2 repository that contains DB4O Driver.)</html:li>
  <html:li><html:b>CDO Model Repository Server Hibernate Store</html:b> (Contains the HibernateStore and Teneo integration plugins. Ensure that Hibernate is already installed! Visit http://www.elver.org/eclipse/2.0.0/update for a p2 repository that contains Hibernate.)</html:li>
  <html:li><html:b>CDO Model Repository Server Lissome Store</html:b> (Contains the LissomeStore plugins.)</html:li>
  <html:li><html:b>CDO Model Repository Server MongoDB Store</html:b> (Contains the MongoDBStore plugins. Ensure that a MongoDB Java driver is already installed! Visit http://www.elver.org/eclipse/2.0.0/update for a p2 repository that contains a MongoDB Java driver.)</html:li>
  <html:li><html:b>CDO Model Repository Server Objectivity Store</html:b> (Contains the Objectivity Store and stubbed jar file bundle. For runtime, ensure that you have Objectivity /DB installed!)</html:li>
  <html:li><html:b>CDO Model Repository Server Product</html:b> (Contains the product definition of an installable CDO server.)</html:li>
  <html:li><html:b>CDO Model Repository Server</html:b> (Contains the CDO server plugins.)</html:li>
  <html:li><html:b>CDO Model Repository Tests Hibernate</html:b> (Contains the CDO Hibernate test plugins and sources. Ensure that Hibernate is already installed! Visit http://www.elver.org/eclipse/2.0.0/update for a p2 repository that contains Hibernate.)</html:li>
  <html:li><html:b>CDO Model Repository Tests</html:b> (Contains the CDO test plugins, models and sources.)</html:li>
  <html:li><html:b>CDO Release Engineering API Reports</html:b> (Contains a Buckminster actor that produces API evolution reports by comparing the workspace API to an API baseline.)</html:li>
  <html:li><html:b>CDO Release Engineering Build Stamp</html:b> (Contains a build listener that writes the timestamp of successful builds to a file (can be used with Hudson CI).)</html:li>
  <html:li><html:b>CDO Release Engineering Documentation</html:b> (Contains the documentation of the CDO release engineering infrastructure.)</html:li>
  <html:li><html:b>CDO Release Engineering Dynamic Working Sets</html:b> (Contains a set of CDO-specific working sets that are automatically populated with the appropriate workspace projects.)</html:li>
  <html:li><html:b>CDO Release Engineering Git Bash</html:b> (Contains a popup action that starts a Git bash and some other actions on the selected Git repository.)</html:li>
  <html:li><html:b>CDO Release Engineering Launch Decorator</html:b> (Contains a label decorator that highlights unshared launch configurations to ease their removal.)</html:li>
  <html:li><html:b>CDO Release Engineering Manifest Opener</html:b> (Contains context-sensitive openers for plugin manifests (F6) and project properties (Shift+F6).)</html:li>
  <html:li><html:b>CDO Release Engineering Project Copy</html:b> (Contains a popup action that copies projects and adjusts their fundamental artifacts.)</html:li>
  <html:li><html:b>CDO Release Engineering Relative Paths</html:b> (Contains a popup action that copies the relative path between two workspace resources into the clipboard.)</html:li>
  <html:li><html:b>CDO Release Engineering Tasks</html:b> (Contains a decorator that appends the name of the assignee to a task label.)</html:li>
  <html:li><html:b>CDO Release Engineering Window Title Setter</html:b> (Contains a plugin that sets the IDE window title to the name of the workspace location directory.)</html:li>
  <html:li><html:b>CDO Release Engineering Windows Explorer</html:b> (Contains a popup action that starts the Windows Explorer on the selected workspace resource.)</html:li>
  <html:li><html:b>Net4j DB Framework DB2 Adapter</html:b> (Net4j DB Framework DB2 Adapter contains the DB2 Adapter matching the Net4j DB Framework BUT NOT the database driver bundle for DB2. This needs to be installed separately.)</html:li>
  <html:li><html:b>Net4j DB Framework Derby Adapter</html:b> (Contains the Derby Adapter matching the Net4j DB Framework and the database driver bundle for Derby.)</html:li>
  <html:li><html:b>Net4j DB Framework Documentation</html:b> (Contains the documentation of the Net4j DB Framework.)</html:li>
  <html:li><html:b>Net4j DB Framework H2 Adapter</html:b> (Contains the H2 Adapter matching the Net4j DB Framework and the database driver bundle for H2.)</html:li>
  <html:li><html:b>Net4j DB Framework HSQLDB Adapter</html:b> (Contains the HSQLDB Adapter matching the Net4j DB Framework BUT NOT the database driver bundle for HSQLDB. This needs to be installed separately, for example from http://www.elver.org/eclipse/2.0.0/update)</html:li>
  <html:li><html:b>Net4j DB Framework MYSQL Adapter</html:b> (Contains the MYSQL Adapter matching the Net4j DB Framework BUT NOT the database driver bundle for MYSQL. This needs to be installed separately, for example from http://www.elver.org/eclipse/2.0.0/update)</html:li>
  <html:li><html:b>Net4j DB Framework Oracle Adapter</html:b> (Contains the Oracle Adapter matching the Net4j DB Framework BUT NOT the database driver bundle for Oracle. This needs to be installed separately, for example from http://download.oracle.com/otn_software/oepe/juno)</html:li>
  <html:li><html:b>Net4j DB Framework PostgreSQL Adapter</html:b> (Contains the PostgreSQL Adapter matching the Net4j DB Framework BUT NOT the database driver bundle for PostgreSQL. This needs to be installed separately, for example from http://www.elver.org/eclipse/2.0.0/update)</html:li>
  <html:li><html:b>Net4j DB Framework</html:b> (Contains the database core framework and database adapter plugins for Derby, Mysql, HSQLDB and PostgreSQL. Additional database drivers are available via http://www.elver.org/eclipse/2.0.0/update (read the license informations).)</html:li>
  <html:li><html:b>Net4j Signalling Platform Definitions</html:b> (Contains the EMF-based definition and wiring plugins for Net4j.)</html:li>
  <html:li><html:b>Net4j Signalling Platform Documentation</html:b> (Contains the documentation of the Net4j Signalling Platform.)</html:li>
  <html:li><html:b>Net4j Signalling Platform Examples Installer</html:b> (Contains a New Wizard that creates Net4j example projects in the workspace.)</html:li>
  <html:li><html:b>Net4j Signalling Platform Examples</html:b> (Contains the general Net4j examples, the buddies collaboration + chat examples and the experimental JMS provider implementation plugins, as well as all sources.)</html:li>
  <html:li><html:b>Net4j Signalling Platform Runtime</html:b> (Contains the Net4j core and transport provider plugins (tcp, jvm and http).)</html:li>
  <html:li><html:b>Net4j Signalling Platform SDK</html:b> (Includes Runtime, UI, DB, Examples, Documentation and Source.)</html:li>
  <html:li><html:b>Net4j Signalling Platform Tests</html:b> (Contains the Net4j test plugins and sources.)</html:li>
  <html:li><html:b>Net4j Signalling Platform UI</html:b> (Contains the Net4j user interface and utilities user interface plugins.)</html:li>
  <html:li><html:b>Net4j Utilities Documentation</html:b> (Contains the documentation of the Net4j Utilities.)</html:li>
  <html:li><html:b>Net4j Utilities UI</html:b> (Contains the Net4j utilities user interface plugins.)</html:li>
  <html:li><html:b>Net4j Utilities</html:b> (Contains the Net4j utilities plugin.)</html:li>
  <html:li><html:b>Version Management Tool Documentation</html:b> (Contains the documentation of the Version Management Tool.)</html:li>
  <html:li><html:b>Version Management Tool Headless</html:b> (Contains an incremental builder that performs version validation on plug-ins and features. Does not contain the documentation or the user interface.)</html:li>
  <html:li><html:b>Version Management Tool SDK</html:b> (Includes the runtime, the sources and the documentation.)</html:li>
  <html:li><html:b>Version Management Tool Tests</html:b> (Contains the Version Management Tool test plugins and their sources.)</html:li>
  <html:li><html:b>Version Management Tool</html:b> (Contains an incremental builder that performs version validation on plug-ins and features. Also contains the documentation and the user interface.)</html:li>
</html:ul>

			</html:div>
   </release_deliverables>
   <release_milestones>
      <preamble>
         <html:div>
Release milestone occurring at roughly 6 week intervals and follow the
Platform milestone releases by approximately 1 week; that is, until the
final 4.3 release of the Platform, upon which CDO and other projects
will release simultaneously. CDO will deliver its milestones within one week of
the Eclipse Platform. It is anticipated that CDO will synchronize its
milestones with the Juno milestone schedule.
         </html:div>
      </preamble>
<milestone date="08/21/2012" milestone="M1"></milestone>
<milestone date="10/02/2012" milestone="M2"></milestone>
<milestone date="11/13/2012" milestone="M3"></milestone>
<milestone date="12/18/2012" milestone="M4"></milestone>
<milestone date="05/02/2013" milestone="M5"></milestone>
<milestone date="03/19/2013" milestone="M6"><html:div>API freeze</html:div></milestone>
<milestone date="05/07/2013" milestone="M7"><html:div>Feature Freeze</html:div></milestone>
<milestone date="05/21/2013" milestone="RC1"></milestone>
<milestone date="05/28/2013" milestone="RC2"></milestone>
<milestone date="06/04/2013" milestone="RC3"></milestone>
<milestone date="06/11/2013" milestone="RC4"></milestone>
<milestone date="06/26/2013" milestone="Final"></milestone>
      <postamble><html:div>
CDO will produce maintenance releases to align with the Juno SR
releases, that includes the Eclipse Platform 4.2.x release.
CDO may produce interim maintenance releases in addition to these in
order to satisfy client requests. Maintenance releases will only be published
if they have any new fixes to offer.
<html:ul>
  <html:li>09/28/2012 - CDO 4.1-SR1 maintenance release (Juno Service Release 1)</html:li>
  <html:li>02/22/2013 - CDO 4.1-SR2 maintenance release (Juno Service Release 2)</html:li>
  <html:li>A list of issues indicated for the 4.1.x maintenance stream can be found in
      bugzilla, or by using links on maintenance stream build pages.</html:li>
</html:ul>
      </html:div></postamble>
   </release_milestones>
   <target_environments>
     <html:div>
In order to remain current, each Eclipse release targets reasonably
current versions of the underlying operating environments. The CDO Model Repository
Project (CDO) depends upon on the
Platform and other projects, which are mostly "pure" Java<html:sup>TM</html:sup>. CDO
will target the same Java version as EMF Core, which currently requires
Java 5. Eclipse Platform SDK 3.8 will be tested and validated on a
number of reference platforms. CDO will be tested and validated
against a subset of those listed for the platform.
     </html:div>
     <internationalization>
          <html:div>
The CDO Model Repository is a runtime technology with most of the
components having no user interface. The remaining user interface
parts of CDO are considered exemplary and thus no attention has been
paid to externalize them for internationalization.
          </html:div>
     </internationalization>
   </target_environments>
   <compatibility_with_previous_releases>
       <html:div>
The 4.2 release of the CDO Model Repository will contain a large set of new
functionality and an enhanced API as driven by the community. Therefore CDO
will not be binary compatible with previous releases, but API compatible.
       </html:div>
   </compatibility_with_previous_releases>
   <themes_and_priorities>
     <preamble>
         <html:div>
A list of project requirements and agreed upon
implementation time frames is found in this document. For the
milestones listed in this document, a set of overall themes is used
to indicate what major set of functionalities is to be concentrated
on for each. These themes are presented below, while the requirements
document and associated Bugzilla entries are left to those wanting
more detailed information on each.
         </html:div>
     </preamble>
        <theme name="Power to the People">
            <description>
                <html:div>
Major improvements in the API and configuration will give clients considerably more
control over the behaviour and performance of their repositories and sessions.
                </html:div>
            </description>
            <committed
                bugzilla="https://bugs.eclipse.org/bugs/buglist.cgi?status_whiteboard_type=allwordssubstr&amp;query_format=advanced&amp;status_whiteboard=Power+to+the+People&amp;bug_status=RESOLVED&amp;version=4.2&amp;component=cdo.core&amp;component=cdo.dawn&amp;component=cdo.db&amp;component=cdo.docs&amp;component=cdo.hibernate&amp;component=cdo.legacy&amp;component=cdo.net4j&amp;component=cdo.net4j.db&amp;component=cdo.net4j.ui&amp;component=cdo.objy&amp;component=cdo.releng&amp;component=cdo.ui&amp;resolution=FIXED&amp;product=EMF&amp;classification=Modeling">
            </committed>
			<!--
            <proposed
                bugzilla="https://bugs.eclipse.org/bugs/buglist.cgi?query_format=advanced&amp;short_desc_type=allwordssubstr&amp;short_desc=&amp;classification=Modeling&amp;product=EMF&amp;component=CDO&amp;target_milestone=Helios&amp;long_desc_type=allwordssubstr&amp;long_desc=&amp;bug_file_loc_type=allwordssubstr&amp;bug_file_loc=&amp;status_whiteboard_type=substring&amp;status_whiteboard=Power+to+the+People&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=indigo%2B">
            </proposed>
            <deferred
                bugzilla="https://bugs.eclipse.org/bugs/buglist.cgi?query_format=advanced&amp;short_desc_type=allwordssubstr&amp;short_desc=&amp;classification=Modeling&amp;product=EMF&amp;component=CDO&amp;long_desc_type=allwordssubstr&amp;long_desc=&amp;bug_file_loc_type=allwordssubstr&amp;bug_file_loc=&amp;status_whiteboard_type=allwordssubstr&amp;status_whiteboard=Power+to+the+People&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=indigo-">
            </deferred>
			-->
        </theme>
        <theme name="Appealing to a Broader Community">
            <description>
                <html:div>
The CDO project has a proven record of robustness and flexibility.
The upcoming 4.2 release will be even better aligned with EMF and other standards.
                </html:div>
            </description>
            <committed
                bugzilla="https://bugs.eclipse.org/bugs/buglist.cgi?status_whiteboard_type=allwordssubstr&amp;query_format=advanced&amp;status_whiteboard=Appealing+to+a+Broader+Community&amp;bug_status=RESOLVED&amp;version=4.2&amp;component=cdo.core&amp;component=cdo.dawn&amp;component=cdo.db&amp;component=cdo.docs&amp;component=cdo.hibernate&amp;component=cdo.legacy&amp;component=cdo.net4j&amp;component=cdo.net4j.db&amp;component=cdo.net4j.ui&amp;component=cdo.objy&amp;component=cdo.releng&amp;component=cdo.ui&amp;resolution=FIXED&amp;product=EMF&amp;classification=Modeling">
            </committed>
			<!--
            <proposed
                bugzilla="https://bugs.eclipse.org/bugs/buglist.cgi?query_format=advanced&amp;short_desc_type=allwordssubstr&amp;short_desc=&amp;classification=Modeling&amp;product=EMF&amp;component=CDO&amp;target_milestone=Helios&amp;long_desc_type=allwordssubstr&amp;long_desc=&amp;bug_file_loc_type=allwordssubstr&amp;bug_file_loc=&amp;status_whiteboard_type=substring&amp;status_whiteboard=Appealing+to+a+Broader+Community&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=indigo%2B">
            </proposed>
            <deferred
                bugzilla="https://bugs.eclipse.org/bugs/buglist.cgi?query_format=advanced&amp;short_desc_type=allwordssubstr&amp;short_desc=&amp;classification=Modeling&amp;product=EMF&amp;component=CDO&amp;long_desc_type=allwordssubstr&amp;long_desc=&amp;bug_file_loc_type=allwordssubstr&amp;bug_file_loc=&amp;status_whiteboard_type=allwordssubstr&amp;status_whiteboard=Appealing+to+a+Broader+Community&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=indigo-">
            </deferred>
			-->
        </theme>
        <theme name="Lighter, Faster and Better">
            <description>
                <html:div>
The CDO project has a proven track record of quality, reliability, and extensibility
but all these aspects can be continuously improved.
Existing and new clients often desire more functionality from the framework
while long established clients generally desire mostly improvements in performance.
Often these two are at odds since additional extensibility often has a performance cost
and any changes, even performance boosting ones, potentially impact reliability.
Every effort will be made to introduce new capabilities
so that they have negligible impact on established clients
based on the guiding principle:
if you don't use it,
you don't pay for it.
Because service and support has and always will take priority over new development work,
development commitments and schedules are subject to arbitrary change, slippage, or even deferral.
Be sure to establish direct communication to ensure that any hard commitments
are seen as that by the development team itself!
                </html:div>
            </description>
            <committed
                bugzilla="https://bugs.eclipse.org/bugs/buglist.cgi?status_whiteboard_type=allwordssubstr&amp;query_format=advanced&amp;status_whiteboard=Lighter,+Faster+and+Better&amp;bug_status=RESOLVED&amp;version=4.2&amp;component=cdo.core&amp;component=cdo.dawn&amp;component=cdo.db&amp;component=cdo.docs&amp;component=cdo.hibernate&amp;component=cdo.legacy&amp;component=cdo.net4j&amp;component=cdo.net4j.db&amp;component=cdo.net4j.ui&amp;component=cdo.objy&amp;component=cdo.releng&amp;component=cdo.ui&amp;resolution=FIXED&amp;product=EMF&amp;classification=Modeling">
            </committed>
			<!--
            <proposed
                bugzilla="https://bugs.eclipse.org/bugs/buglist.cgi?query_format=advanced&amp;short_desc_type=allwordssubstr&amp;short_desc=&amp;classification=Modeling&amp;product=EMF&amp;component=CDO&amp;target_milestone=Helios&amp;long_desc_type=allwordssubstr&amp;long_desc=&amp;bug_file_loc_type=allwordssubstr&amp;bug_file_loc=&amp;status_whiteboard_type=substring&amp;status_whiteboard=Lighter,+Faster+and+Better&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=indigo%2B">
            </proposed>
            <deferred
                bugzilla="https://bugs.eclipse.org/bugs/buglist.cgi?query_format=advanced&amp;short_desc_type=allwordssubstr&amp;short_desc=&amp;classification=Modeling&amp;product=EMF&amp;component=CDO&amp;long_desc_type=allwordssubstr&amp;long_desc=&amp;bug_file_loc_type=allwordssubstr&amp;bug_file_loc=&amp;status_whiteboard_type=allwordssubstr&amp;status_whiteboard=Lighter,+Faster+and+Better&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=indigo-">
            </deferred>
			-->
        </theme>
        <theme name="Eclipse 4.3">
            <description>
                <html:div>
No specific support, no testing on 4.3
				</html:div>
            </description>
        </theme>
   </themes_and_priorities>
   <appendix name="A: Legal Notices">
        <html:div>
<html:ul>
<html:li>Java is a trademark or a registered trademark of Sun Microsystems, Inc.</html:li>
<html:li>All other products or company names are mentioned for identification purposes only, and
    may be trademarks or service marks of their respective owners.</html:li>
</html:ul>
        </html:div>
   </appendix>
</plan>
