<!DOCTYPE HTML PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"><head>


	<title>Project Plan - webtools.dali</title><meta name="author" content="Bjorn Freeman-Benson">
	<meta name="keywords" content="">
	<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
	<link rel="stylesheet" type="text/css" href="dali-project-plan.php_files/reset-fonts-grids.css">
	<link rel="stylesheet" type="text/css" href="dali-project-plan.php_files/menu.css">
	<link rel="stylesheet" type="text/css" href="dali-project-plan.php_files/reset.css">
	<link rel="stylesheet" type="text/css" href="dali-project-plan.php_files/layout.css" media="screen">
	<link rel="stylesheet" type="text/css" href="dali-project-plan.php_files/header.css" media="screen">
	<link rel="stylesheet" type="text/css" href="dali-project-plan.php_files/footer.css" media="screen">
	<link rel="stylesheet" type="text/css" href="dali-project-plan.php_files/visual.css" media="screen">
	<!--[if IE]> 	<link rel="stylesheet" type="text/css" href="/eclipse.org-common/themes/Nova/css/ie_style.css" media="screen"/> <![endif]-->
	<!--[if IE 6]> 	<link rel="stylesheet" type="text/css" href="/eclipse.org-common/themes/Nova/css/ie6_style.css" media="screen"/> <![endif]-->
	<!-- Dependencies --> 
	<!-- Source File -->
	</head><body>
	<div id="novaWrapper">		<div id="clearHeader">
			<div id="logo">
					<div id="promotion">
			<a href="http://www.eclipse.org/galileo/">
				<img src="dali-project-plan.php_files/here.png" alt="Eclipse.org">
			</a>
	   	</div> 
	
			</div>
			<div id="otherSites">
				<div id="sites">
				<ul id="sitesUL">
					<li><a href="http://www.eclipseplugincentral.com/"><img alt="Eclipse Plugin Central" src="dali-project-plan.php_files/network-wired-bw.png">&nbsp;<div>Eclipse Plugin Central</div></a></li>
					<li><a href="http://live.eclipse.org/"><img alt="Eclipse Live" src="dali-project-plan.php_files/audio-input-microphone-bw.png">&nbsp;<div>Eclipse Live</div></a></li>
		    		<li><a href="https://bugs.eclipse.org/bugs/"><img alt="Bugzilla" src="dali-project-plan.php_files/system-search-bw.png">&nbsp;<div>Bugzilla</div></a></li>
		    		<li><a href="http://www.planeteclipse.org/"><img alt="Planet Eclipse" src="dali-project-plan.php_files/audio-card.png">&nbsp;<div>Planet Eclipse</div></a></li>
		    		<li><a href="http://wiki.eclipse.org/"><img alt="Eclipse Wiki" src="dali-project-plan.php_files/accessories-text-editor-bw.png">&nbsp;<div>Eclipse Wiki</div></a></li>
		    		<li><a href="http://portal.eclipse.org/"><img alt="MyFoundation Portal" src="dali-project-plan.php_files/preferences-system-network-proxy-bw.png"><div>My Foundation Portal</div></a></li>
		    	</ul>
		    	</div>
			</div>		
		</div>

	<div id="header">			
		<div id="menu">
			<ul>
						<li><a href="http://www.eclipse.org/" target="_self">Home</a></li> 
			<li><a href="http://www.eclipse.org/downloads/" target="_self">Downloads</a></li> 
			<li><a href="http://www.eclipse.org/users/" target="_self">Users</a></li> 
			<li><a href="http://www.eclipse.org/membership/" target="_self">Members</a></li> 
			<li><a href="http://www.eclipse.org/committers/" target="_self">Committers</a></li> 
			<li><a href="http://www.eclipse.org/resources/" target="_self">Resources</a></li> 
			<li><a href="http://www.eclipse.org/projects/" target="_self">Projects</a></li> 
			<li><a href="http://www.eclipse.org/org/" target="_self">About Us</a></li> 
				</ul>
		</div>

		<div id="search">
				<form action="http://www.google.com/cse" id="searchbox_017941334893793413703:sqfrdtd112s">
			 	<input name="cx" value="017941334893793413703:sqfrdtd112s" type="hidden">
		  		<input style="border: 1px solid rgb(126, 157, 185); padding: 2px; background: rgb(255, 255, 255) url(http://www.google.com/coop/intl/en/images/google_custom_search_watermark.gif) no-repeat scroll left center; -moz-background-clip: -moz-initial; -moz-background-origin: -moz-initial; -moz-background-inline-policy: -moz-initial;" id="searchBox" name="q" size="25" type="text">
		  		<input id="searchButton" name="sa" value="Search" type="submit">
				</form>
			<script type="text/javascript" src="dali-project-plan.php_files/brand.htm"></script>			
		</div>
	</div>
		<div id="novaContent" class="faux">		<br style="clear: both; height: 1em;">
	<div id="leftcol">
<ul id="leftnav">
<li class="separator"><a class="separator" href="http://www.eclipse.org/projects/">
				Projects<img src="dali-project-plan.php_files/separator.png"></a></li>
<li><a href="http://www.eclipse.org/projects/whatsnew.php">What's New?</a></li>
<li><a href="http://www.eclipse.org/projects/listofprojects.php">List of Projects</a></li>
<li><a href="http://www.eclipse.org/projects/searchpage.php">Search through Projects...</a></li>
<li><a href="http://www.eclipse.org/projects/dev_process/index-quick.php">Rules &amp; Processes</a></li>
<li><a href="http://www.eclipse.org/projects/dev_process/index.php">FAQ</a></li>
</ul>

</div>
<style>
h2 {
	border-bottom: 2px solid gray;
}
h3 {
	border-bottom: 1px dotted gray;
}
</style>
<div id="fullcolumn">
<div id="midcolumn">
<div xmlns="http://www.w3.org/1999/xhtml" id="rendered-plan">
  <div id="maincontent">
    <div id="midcolumn"><h1>
                    Project Plan For
                        <a href="http://www.eclipse.org/projects/project_summary.php?projectid=webtools.dali">Dali Java Persistence Tools</a>, version 2.2</h1><div id="toc"><p><a name="toc"><strong>Table of Contents</strong></a></p><ul><li><a href="#introduction">Introduction</a></li><li><a href="#release_deliverables">
                       Release Deliverables
                    </a></li><li><a href="#release_milestones">
                       Release Milestones
                    </a></li><li><a href="#target_environments">
                        Target Environments
                    </a></li><li><a href="#compatibility">
                        Compatibility with Previous Releases
                    </a></li><li><a href="#themes_and_priorities">
                        Themes and Priorities
                    </a></li><li><a href="#appendix">
                        Appendix
                    </a></li></ul></div><h2><a name="introduction">Introduction</a></h2><p>The Web Tool Platform (WTP) project provides extensible frameworks and exemplary tools to build Web and Java EE applications. 
    This document describes the features and the API set in the Dali JPA Tools subproject for the Galileo release.</p><h2><a name="release_deliverables">Release Deliverables</a></h2><p>
			</p><ul>
				<li>WTP non-SDK package</li>
				<li>WTP SDK Package</li>
				<li>WST non-SDK package</li>
				<li>WST SDK Package</li>
				<li>The Eclipse IDE for JEE Developers package</li>
			</ul>
		<p><a href="#toc">Table of Contents</a></p><h2><a name="release_milestones">Release Milestones</a></h2><p><a href="http://www.eclipse.org/projects/project-plan.php?projectid=webtools#release_milestones">WTP Milestones</a>.</p><p><a href="#toc">Table of Contents</a></p><h2><a name="target_environments">Target Environments</a></h2><p>
			WTP will support the platforms certified by the Eclipse Platform
			project. For a list of platforms supported in Dali 2.2, see
			<a href="http://www.eclipse.org/eclipse/development/eclipse_project_plan_3_4.html#TargetOperatingEnvironments%20Eclipse%20Target%20Operating%20Environments">Eclipse Target Operating Environments</a>
		</p><p>.</p><h3>Internationalization</h3>
			<p>
				Internationalization and Localization will be supported.
				</p><ul>
					<li>
						Internationalization (I18N)
						<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.).</p>
					</li>
					<li>
						Localization
						<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.</p>
					</li>
					<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.</p>
				</ul>
			
		<p><a href="#toc">Table of Contents</a></p><h2><a name="compatibility">Compatibility with Previous Releases</a></h2><p><a href="#toc">Table of Contents</a></p><h2><a name="themes_and_priorities">Themes and Priorities</a></h2><p> Themes and their priorities communicate the main objectives of
				the project and their importance. The following themes are derived
				from those defined by the Eclipse Requirement council for the
				Eclipse Galileo release and from the WTP 3.0 release themes. These
				will be prioritized based on the community feedback. New themes
				could be synthesized from the requirements submitted by the
				community.</p><p>The sections to follow defines the plan items in the Dali Java
				Persistence Tools project. The plan items are grouped under the
				respective themes where applicable. Each plan item corresponds to a
				new feature, API or some apsects of the project that needs to be
				improved. A plan item has an entry in the Eclipse Bugzilla system
				that has a detailed description of the plan item. Not all plan items
				represent the same amount of work; some may be quite large, others,
				quite small. Although some plan items are for work that is more
				pressing than others, the plan items appear in no particular order.
				See the corresponding bugzilla items for up-to-date status
				information on ongoing work and planned delivery milestones.</p><h3>Ease of Use</h3><p>
					Features provided by WTP should be simple to use for users with
					widely-varying backgrounds and skill sets.
					</p><ul>
						<li>WTP User Interface should be consistent and should follow
							the Eclipse User Experience Guidelines.</li>
						<li>Usability and Accessibility reviews should be done
							for the most common task flows. Cheat Sheets should be provided
							to assist users in performing tasks</li>
						<li>WTP should provide enhanced user documentation, tutorials,
							white papers, demonstrations.</li>
					</ul>
				<ul><li><b>Committed</b><ul><li>code assist for java TableGenerator table [<a href="http://bugs.eclipse.org/231230">231230</a>] <strike>(target milestone: 2.2 M7)</strike></li></ul></li></ul><ul><li><b>Proposed</b><ul><li><div>No items.</div></li></ul></li></ul><ul><li><b>Deferred</b><ul><li><div>No items.</div></li></ul></li></ul><h3>Support for EclipseLink</h3><p> Specific tooling support for the EclipseLink runtime</p><ul><li><b>Committed</b><ul><li>[EclipseLink] support uni-directional one-to-many mapping using a foreign key mapping [<a href="http://bugs.eclipse.org/258525">258525</a>] <strike>(target milestone: 2.2 M6)</strike></li><li>[EclipseLink] Use Galileo EclipseLink in Platform [<a href="http://bugs.eclipse.org/262437">262437</a>] <strike>(target milestone: 2.2 M7)</strike></li><li>[EclipseLink] An EclipseLink 1.1 platform is needed [<a href="http://bugs.eclipse.org/260347">260347</a>] <strike>(target milestone: 2.2 M5)</strike></li></ul></li></ul><ul><li><b>Proposed</b><ul><li><div>No items.</div></li></ul></li></ul><ul><li><b>Deferred</b><ul><li>[EclipseLink] Support for Transformation mapping [<a href="http://bugs.eclipse.org/238466">238466</a>] (target milestone: Future)</li><li>[EclipseLink] Support for OptimisticLocking [<a href="http://bugs.eclipse.org/239148">239148</a>] (target milestone: Future)</li><li>[EclipseLink] Support for CopyPolicy, InstantiationCopyPolicy, CloneCopyPolicy [<a href="http://bugs.eclipse.org/240035">240035</a>] (target milestone: Future)</li><li>[EclipseLink] validation errors Cache and ExistenceChecking [<a href="http://bugs.eclipse.org/245430">245430</a>] (target milestone: Future)</li><li>[EclipseLink] ConversionValue dataType and objectType need default values [<a href="http://bugs.eclipse.org/249504">249504</a>] (target milestone: Future)</li><li>[EclipseLink] persistence.xml logging categories [<a href="http://bugs.eclipse.org/259637">259637</a>] (target milestone: Future)</li></ul></li></ul><h3>Generic JPA Support</h3><p> Following are plan items that represent core JPA support or items that are not yet categorized into a
					theme.</p><ul><li><b>Committed</b><ul><li>Support for entities in Jars [<a href="http://bugs.eclipse.org/197069">197069</a>] <strike>(target milestone: 2.2 M7)</strike></li><li>Table Per Class inheritance support [<a href="http://bugs.eclipse.org/258691">258691</a>] <strike>(target milestone: 2.2 M6)</strike></li><li>[Contributions] New JPA Entities from Tables Wizard [<a href="http://bugs.eclipse.org/251293">251293</a>] <strike>(target milestone: 2.2 M6)</strike></li><li>Integrate JPA facet with library provider framework [<a href="http://bugs.eclipse.org/250210">250210</a>] <strike>(target milestone: 2.2 M5)</strike></li></ul></li></ul><ul><li><b>Proposed</b><ul><li><div>No items.</div></li></ul></li></ul><ul><li><b>Deferred</b><ul><li><div>No items.</div></li></ul></li></ul><p><a href="#toc">Table of Contents</a></p><h2><a name="appendix">Appendix References</a></h2><ol>
			<li>The general WTP plan can be found <a href="http://www.eclipse.org/projects/project-plan.php?projectid=webtools">here</a>.</li>
		</ol><p><a href="#toc">Table of Contents</a></p>
  

<div style="float: right; text-align: right;"><a href="http://www.eclipse.org/projects/project-plan.php?projectid=webtools.dali&amp;raw=1">view raw xml of project plan</a><br>
<a href="http://www.eclipse.org/projects/dev_process/project-status-infrastructure.php">from project meta-data key "projectplanurl"</a></div>

 <!-- midcolumn -->
 <!-- fullcolumn -->
		<br style="clear: both; height: 1em;">&nbsp;
		 		
		<div id="clearFooter"></div>
			<div id="footer">
			<ul id="footernav">
				<li><a href="http://www.eclipse.org/">Home</a></li>
				<li><a href="http://www.eclipse.org/legal/privacy.php">Privacy Policy</a></li>
				<li><a href="http://www.eclipse.org/legal/termsofuse.php">Terms of Use</a></li>
				<li><a href="http://www.eclipse.org/legal/">Legal</a></li>
				<li><a href="http://www.eclipse.org/org/foundation/contact.php">Contact Us</a></li>
			</ul>
			<span id="copyright">Copyright © 2009 The Eclipse Foundation. All Rights Reserved.</span>
		</div>
	 		

<table align="center" border="1"><script type="text/javascript">
		var gaJsHost = (("https:" == document.location.protocol) ? "https://ssl." : "http://www.");
		document.write(unescape("%3Cscript src='" + gaJsHost + "google-analytics.com/ga.js' type='text/javascript'%3E%3C/script%3E"));
		</script><script src="dali-project-plan.php_files/ga.js" type="text/javascript"></script>
		<script type="text/javascript">
		var pageTracker = _gat._getTracker("UA-910670-2");
		pageTracker._initData();
		pageTracker._trackPageview();
		</script>		

		</table></div></div></div></div></div></div></div></body></html>