<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
	<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
	<meta name="GENERATOR" content="Mozilla/4.76 [en] (Windows NT 5.0; U) [Netscape]">
	<title>Platform Text 3.6 Plan</title>

<script type="text/javascript">
<!--
function linkifyBugs() {
	// Replaces plain text 'bug xyz' by a link to Eclipse's bugzilla.
	traverseLinkifyBugs(document.getElementsByTagName("body")[0]);
}
function nextNode(node, stopNode) {
	if (node.nextSibling) {
		return node.nextSibling;
	} else if (node.parentNode == stopNode) {
		return null;
	} else {
		return nextNode(node.parentNode);
	}
}
function traverseLinkifyBugs(node) {
    var stopNode= node.parentNode; 
	var regex= /(Bug\s*)(\d+)/i;
	while (node) {
		if (node.nodeType == 1/*element*/ && node.nodeName == "a") {
			node= nextNode(node, stopNode);
			
		} else if (node.childNodes != null && node.childNodes.length > 0) {
			node= node.childNodes[0];
			
		} else if (node.nodeType == 3/*text*/) {
			var txt= node.data;
			var res= regex.exec(txt);
			if (res) {
				var matchStart= txt.indexOf(res[0]);
				
				var beforeNode= document.createTextNode(txt.substring(0, matchStart));
				node.parentNode.insertBefore(beforeNode, node);
				
				var linkNode= document.createElement("a");
				linkNode.href= "https://bugs.eclipse.org/bugs/show_bug.cgi?id=" + res[2];
				linkNode.appendChild(document.createTextNode(res[1] + res[2]));
				node.parentNode.insertBefore(linkNode, node);
				
				node.data= txt.substr(matchStart + res[0].length);
				// continue with current (shortened) node...
			} else {
				node= nextNode(node, stopNode);
			}
			
		} else {
			node= nextNode(node, stopNode);
		}
	}
}

function showHiddenWork() {
	// Open this document with an URL ending in ?work, and the "work" class becomes visible. 
	if (window.location.search == "?work") {
		var spans= document.getElementsByTagName("span")
		for (var i in spans) {
			var s= spans[i];
			if (s.className == "work") {
				s.style.visibility= "visible";
				s.insertBefore(document.createTextNode("\u00a0"), s.firstChild);
				s.insertBefore(document.createTextNode("\u00a0"), s.lastChild.nextSibling);
			}
		};
	}
}

//-->
</script>

<!--
	<style>
		body {  
			background-image: url('../images/proposal.gif');
			background-repeat: repeat-y
		}
	</style>
-->
	
	 <style type="text/css">
  		.priority {
  			color: blue;
  			font-style: italic;
  		}
  		.work {
  			background: lightgreen;
  			visibility: hidden;
  		}
	</style>	
	
</head>

<body text="#000000" bgcolor="#FFFFFF" onload="linkifyBugs();showHiddenWork();">

<table BORDER=0 CELLSPACING=5 CELLPADDING=2 WIDTH="100%" >

  <tr> 
    <td WIDTH="100%"> 
	<p>Last revised $Date: 2010/03/05 15:56:24 $</p>

    
      <p>This plan is under continuous refinement. Please send comments about this plan to the <a href="mailto:platform-text-dev@eclipse.org">platform-text-dev@eclipse.org</a> developer mailing list.</p>
      <p><strong>Note:</strong> The JDT Text plan is now hosted on the <a href="http://www.eclipse.org/jdt/ui/r3_6/plan.php">Combined JDT Text and JDT UI Plan</a>.</p>
      <h2><a NAME="Overall_Planning"></a>Overall Goals</h2>
      <p>This section lists the goals for Eclipse 3.6 for the Platform 
        Text component as listed on the 
        <a href="http://www.eclipse.org/projects/project-plan.php?projectid=eclipse">Eclipse Project 3.6 Draft Plan</a>.
        </p>


		<p>
		<strong><a name="1"></a>[1] Scaling Up</strong>.
		Monitor overall performance and memory consumption which includes the addition of new performance tests for new features.
		</p>
		
		<p>
		<strong><a name="2"></a>[2] Design for Extensibility</strong>.
		Provide APIs for clients where needed.
		</p>
		
		<p>
		<strong><a name="3"></a>[3] Ease of Use</strong>.
		Make sure we run on the e4 compatibility layer and deliver new productivity features like TBD.
		</p>
		
		<p>
		<strong><a name="4"></a>[4] Platform Support</strong>.
		Make sure we run Windows 7.
		</p>

	<h2><a NAME="Work_Items"></a><br>Work Items</h2>
	<p>
		This section lists the <em>possible</em> work items for Eclipse 3.6 for the Platform Text component
		with the [corresponding theme].
		Some of those items have a <span class="priority">higher priority</span> than others.
	</p>

	<ul>
		<li><h4>Windows 7 Support [<a href="#4">4</a>]</h4>
		<ul>
			<li class="priority"><img src="../images/ok.gif" border="0" height="10" width="10"> test pass on Windows 7 <span class="work">Dani: 1w</span></li>
			<li class="priority"><img src="../images/ok.gif" border="0" height="10" width="10"> fix bugs that arise during test pass <span class="work">Dani: 1w</span></li>
		</ul></li>
		
		<li><h4>Adopt New Platform Features [<a href="#3">3</a>]</h4>
		<ul>
			<li class="priority">make sure that we run on the e4 compatibility layer <span class="work">2w</span>
				<ul>
					<li>test our bundles against it</li>
					<li>help to investigate and fix bugs in the compatibility layer</li>
				</ul>
			</li>
		</ul></li>
		
		<li><h4>API [<a href="#2">2</a>]</h4>
		<ul>
			<li><font class="indexsub" color="#8080ff">[&gt;3.6]</font> provide API for <code>BrowserInformationControl</code> (bug 218482) and <code>HTML2TextReader</code> (bug 241896) <span class="work">6w</span>
				<br>&rarr; might be done if we push the whole hover support down to JFace</li>
			<li>provide LTK layer for text editing support (bug 125825, bug 149817, ...) <span class="work">1w</span>
				<br>&rarr; not full blown but start step by step, especially with the command definitions</li>
		</ul></li>
			
		<li><h4><a name="Hovering"></a>Hovering [<a href="#3">3</a>]</h4>
		<ul>
			<li class="priority"><img src="../images/ok.gif" border="0" height="10" width="10"> allow to resize hovers on Linux by providing a workaround for bug 23980 (bug 62652) <span class="work">Markus: 5d</span></li>
			<li class="priority">quick diff usability improvements in hover (Next/Prev support etc.) (bug 229255) <span class="work">Markus: 1w</span></li>
		</ul>
		</li>

		<li><h4>Ruler improvements [<a href="#3">3</a>] <span class="work">2w</span></li></h4>
		<ul>
			<li class="priority">improve overview ruler arming and size of active area (bug 163769) <span class="work">Markus: 1d</span></li></h4>
			<li class="priority"><img src="../images/ok.gif" border="0" height="10" width="10"> provide a command that allows to show the vertical ruler hover (bug 272172) <span class="work">Deepak: 2d</span></li></h4>
			<li>investigate improving the usability of icons in the vertical ruler [experimental]
			<ul>
				<li>fix most common layering problem (breakpoints) by changing their layer</li>
				<li>alpha blending so that underlying icons can be seen</li>
				<li>down-size images so that we can show 4 instead of one</li>
				<li>allow to increase ruler width</li>
				<li>allow users to configure the annotation presentation layer for each annotation</li>
				<li>finish/cleanup the roll-over annotation work that was kicked off during 3.0</li>
			</ul>
			</li>
		</ul>
		</li>
	
		<li><h4>Spell Checking [<a href="#3">3</a>]</h4>
		<ul>
			<li><img src="../images/ok.gif" border="0" height="10" width="10"> investigate and reduce memory consumption <span class="work">Deepak: 1w</span></li>
		</ul>
		</li>
	
		<li><h4>Performance [<a href="#1">1</a>]</h4>
		<ul>
			<li class="priority"><img src="../images/progress.gif" border="0" height="5" width="14" align="absmiddle"> constantly watch performance test results and act when red</li>
			<li class="priority"><img src="../images/progress.gif" border="0" height="5" width="14" align="absmiddle"> continue to provide new tests</li>
		</ul>
		</li>
	  
		<li><h4>Miscellaneous</h4>
		<ul>
			<li class="priority"><img src="../images/ok.gif" border="0" height="10" width="10"> improve failing save when encoding can't handle a character (bug 144422) <span class="work">Dani: 3d</span></li>
			<li>problems with undo grouping in linked mode (bug 77575) <span class="work">Dani: 2d</span></li>
		</ul>
		</li>
		
		<li><h4>General Items</h4>
		<ul>
			<li class="priority"><img src="../images/ok.gif" border="0" height="10" width="10"> 3.5.x maintenance work <span class="work">2w</span></li>
			<li><img src="../images/progress.gif" border="0" height="5" width="14" align="absmiddle"> look at bugs with patches and review those</li>
		</ul>
		</li>
	</ul>


	<h2><br>Cross Team Issues</h2>
	<p>This section contains cross team issues that have to be clarified. The 
		concrete outcome affects the plan items listed above.</p>
	<ul>
		<li>Platform SWT
			<ul>
			TBD
			</ul>
		</li>
		<li>Platform UI
			<ul>
			TBD
			</ul>
		</li>
	</ul>
	</td>
</tr>



<tr>
	<td ALIGN=LEFT VALIGN=TOP COLSPAN="2" WIDTH="100%" BGCOLOR="#595791"><font face="Arial,Helvetica"><font color="#FFFFFF"><a name="Milestone_Planning_M1"></a>Milestone M1 (2009-08-07)</font></font></td>
</tr>

 <tr> 
	<td WIDTH="100%">
		See also the <a href="http://www.eclipse.org/jdt/ui/r3_6/plan.php#Milestone_Planning_M1">Combined JDT Text and JDT UI 3.6 M1 Plan</a>.

		<h4><img src="http://www.eclipse.org/images/Adarrow.gif" border="0" height="16" width="16" align="top"> General Items</h4>
		<ul>
			<li class="priority"><img src="../images/progress.gif" border="0" height="5" width="14" align="absmiddle"> <font class="indexsub" color="#8080ff">[3.6 M2]</font> 3.5.1 maintenance work <span class="work">1w</span></li>
			<li class="priority"><img src="../images/ok.gif" border="0" height="10" width="10"> 3.6 planning <span class="work">1d</span></li>
		</ul>
		
		<h4><img src="http://www.eclipse.org/images/Adarrow.gif" border="0" height="16" width="16" align="top"> Hovering [<a href="#3">3</a>]</h4>
		<ul>
			<li class="priority"><img src="../images/ok.gif" border="0" height="10" width="10"> allow to resize hovers on Linux by providing a workaround for bug 23980 (bug 62652) <span class="work">Markus: 3d</span></li>
		</ul>
		</li>
		
		<h4><img src="http://www.eclipse.org/images/Adarrow.gif" border="0" height="16" width="16" align="top"> Permanent Items</h4>
		<ul>
			<li><img src="../images/ok.gif" border="0" height="10" width="10"> bugzilla inbox tracking</li>
			<li><img src="../images/ok.gif" border="0" height="10" width="10"> bug fixing</li>
			<li><img src="../images/ok.gif" border="0" height="10" width="10"> watch performance tests</li>
			<li><img src="../images/ok.gif" border="0" height="10" width="10"> increase correctness test coverage</li>
		</ul>
		
		
		<h4><img src="http://www.eclipse.org/images/Adarrow.gif" nosave="" border="0" height="16" width="16" align="top"> Testing</h4>
		<ul>
			<li><img src="../images/ok.gif" border="0" height="10" width="10"> <a href="http://www.eclipse.org/jdt/ui/r3_6/testing/M1_Test_Plan.html">test plan</a> for the 3.6 M1 test pass.</li>
		</ul>
	      
	</td>
</tr>
<tr>
	<td ALIGN=LEFT VALIGN=TOP COLSPAN="2" WIDTH="100%" BGCOLOR="#595791"><font face="Arial,Helvetica"><font color="#FFFFFF"><a name="Milestone_Planning_M2"></a>Milestone M2 (2009-09-18)</font></font></td>
</tr>

 <tr> 
	<td WIDTH="100%">
		See also the <a href="http://www.eclipse.org/jdt/ui/r3_6/plan.php#Milestone_Planning_M2">Combined JDT Text and JDT UI 3.6 M2 Plan</a>.

		<h4><img src="http://www.eclipse.org/images/Adarrow.gif" border="0" height="16" width="16" align="top"> General Items</h4>
		<ul>
			<li class="priority"><img src="../images/ok.gif" border="0" height="10" width="10"> 3.5.1 maintenance work <span class="work">1w</span></li>
		</ul>
		
		<h4><img src="http://www.eclipse.org/images/Adarrow.gif" border="0" height="16" width="16" align="top"> Ruler improvements [<a href="#3">3</a>] <span class="work">2w</span></li></h4>
		<ul>
			<li class="priority"><img src="../images/progress.gif" border="0" height="5" width="14" align="absmiddle"> <font class="indexsub" color="#8080ff">[3.6 M3]</font> improve overview ruler arming and size of active area  (bug 163769) <span class="work">Markus: 1d</span></li></h4>
		</ul>
		
		<h4><img src="http://www.eclipse.org/images/Adarrow.gif" border="0" height="16" width="16" align="top"> Permanent Items</h4>
		<ul>
			<li><img src="../images/ok.gif" border="0" height="10" width="10"> bugzilla inbox tracking</li>
			<li><img src="../images/ok.gif" border="0" height="10" width="10"> bug fixing</li>
			<li><img src="../images/ok.gif" border="0" height="10" width="10"> watch performance tests</li>
			<li><img src="../images/ok.gif" border="0" height="10" width="10"> increase correctness test coverage</li>
		</ul>
		
		
		<h4><img src="http://www.eclipse.org/images/Adarrow.gif" nosave="" border="0" height="16" width="16" align="top"> Testing</h4>
		<ul>
			<li><img src="../images/ok.gif" border="0" height="10" width="10"> <a href="http://www.eclipse.org/jdt/ui/r3_6/testing/3.5.1_RC2_Test_Plan.html">test plan</a> for the 3.5.1 RC2 test pass.</li>
			<li><img src="../images/ok.gif" border="0" height="10" width="10"> <a href="http://www.eclipse.org/jdt/ui/r3_6/testing/3.5.1_RC3_Test_Plan.html">test plan</a> for the 3.5.1 RC3 test pass.</li>
			<li><img src="../images/ok.gif" border="0" height="10" width="10"> <a href="http://www.eclipse.org/jdt/ui/r3_6/testing/M2_Test_Plan.html">test plan</a> for the 3.6 M2 test pass.</li>
		</ul>
	</td>
</tr>
<tr>
	<td ALIGN=LEFT VALIGN=TOP COLSPAN="2" WIDTH="100%" BGCOLOR="#595791"><font face="Arial,Helvetica"><font color="#FFFFFF"><a name="Milestone_Planning_M3"></a>Milestone M3 (2009-10-30)</font></font></td>
</tr>

 <tr> 
	<td WIDTH="100%">
		See also the <a href="http://www.eclipse.org/jdt/ui/r3_6/plan.php#Milestone_Planning_M3">Combined JDT Text and JDT UI 3.6 M3 Plan</a>.

	    <h4><img src="http://www.eclipse.org/images/Adarrow.gif" border="0" height="16" width="16" align="top"> General Items</h4>
		<ul>
			<li class="priority"><img src="../images/progress.gif" border="0" height="5" width="14" align="absmiddle"> <font class="indexsub" color="#8080ff">[3.6 M4]</font> 3.5.2 maintenance work <span class="work">1w</span></li>
		</ul>
		
		<h4><img src="http://www.eclipse.org/images/Adarrow.gif" border="0" height="16" width="16" align="top"> Ruler improvements [<a href="#3">3</a>] <span class="work">2w</span></li></h4>
		<ul>
			<li class="priority"><img src="../images/progress.gif" border="0" height="5" width="14" align="absmiddle"> <font class="indexsub" color="#8080ff">[3.6 M4]</font> improve overview ruler arming and size of active area  (bug 163769) <span class="work">Markus: 1d</span></li></h4>
		</ul>
		
		<h4><img src="http://www.eclipse.org/images/Adarrow.gif" border="0" height="16" width="16" align="top"> Windows 7 Support [<a href="#4">4</a>]</h4>
		<ul>
			<li class="priority"><img src="../images/ok.gif" border="0" height="10" width="10"> test pass on Windows 7 <span class="work">Dani: 1w</span></li>
			<li class="priority"><img src="../images/ok.gif" border="0" height="10" width="10"> fix bugs that arise during test pass <span class="work">Dani: 1w</span></li>
		</ul></li>
		
		<h4><img src="http://www.eclipse.org/images/Adarrow.gif" border="0" height="16" width="16" align="top"> Miscellaneous [<a href="#3">3</a>]</h4>
		<ul>
			<li class="priority"><img src="../images/ok.gif" border="0" height="10" width="10"> improve failing save when encoding can't handle a character (bug 144422) <span class="work">Dani: 3d</span></li>			
		</ul>
		
		<h4><img src="http://www.eclipse.org/images/Adarrow.gif" border="0" height="16" width="16" align="top"> Permanent Items</h4>
		<ul>
			<li><img src="../images/ok.gif" border="0" height="10" width="10"> bugzilla inbox tracking</li>
			<li><img src="../images/ok.gif" border="0" height="10" width="10"> bug fixing</li>
			<li><img src="../images/ok.gif" border="0" height="10" width="10"> watch performance tests</li>
			<li><img src="../images/ok.gif" border="0" height="10" width="10"> increase correctness test coverage</li>
		</ul>
		
		
		<h4><img src="http://www.eclipse.org/images/Adarrow.gif" nosave="" border="0" height="16" width="16" align="top"> Testing</h4>
		<ul>
			<li><img src="../images/ok.gif" border="0" height="10" width="10"> <a href="http://www.eclipse.org/jdt/ui/r3_6/testing/M3_Test_Plan.html">test plan</a> for the 3.6 M3 test pass.</li>
		</ul>
		
	</td>
</tr>
<tr>
	<td ALIGN=LEFT VALIGN=TOP COLSPAN="2" WIDTH="100%" BGCOLOR="#595791"><font face="Arial,Helvetica"><font color="#FFFFFF"><a name="Milestone_Planning_M4"></a>Milestone M4 (2009-12-11)</font></font></td>
</tr>

 <tr> 
	<td WIDTH="100%">
		See also the <a href="http://www.eclipse.org/jdt/ui/r3_6/plan.php#Milestone_Planning_M4">Combined JDT Text and JDT UI 3.6 M4 Plan</a>.
		
		<h4><img src="http://www.eclipse.org/images/Adarrow.gif" border="0" height="16" width="16" align="top"> General Items</h4>
		<ul>
			<li class="priority"><img src="../images/progress.gif" border="0" height="5" width="14" align="absmiddle"> <font class="indexsub" color="#8080ff">[3.6 M5]</font> 3.5.2 maintenance work <span class="work">1w</span></li>
		</ul>

		<h4><img src="http://www.eclipse.org/images/Adarrow.gif" border="0" height="16" width="16" align="top"> Ruler improvements [<a href="#3">3</a>] <span class="work">2w</span></li></h4>
		<ul>
			<li class="priority"><img src="../images/progress.gif" border="0" height="5" width="14" align="absmiddle"> <font class="indexsub" color="#8080ff">[3.6 M5]</font> improve overview ruler arming and size of active area  (bug 163769) <span class="work">Markus: 1d</span></li></h4>
		</ul>

		<h4><img src="http://www.eclipse.org/images/Adarrow.gif" border="0" height="16" width="16" align="top"> Spell Checking [<a href="#3">3</a>]</h4>
		<ul>
			<li><img src="../images/progress.gif" border="0" height="5" width="14" align="absmiddle"> <font class="indexsub" color="#8080ff">[3.6 M5]</font> investigate and reduce memory consumption <span class="work">Deepak: 1w</span></li>
		</ul>
		
		<h4><img src="http://www.eclipse.org/images/Adarrow.gif" border="0" height="16" width="16" align="top"> <a name="Hovering"></a>Hovering [<a href="#3">3</a>]</h4>
		<ul>
			<li class="priority"><font class="indexsub" color="#8080ff">[&gt;3.6 M4]</font> quick diff usability improvements in hover (Next/Prev support etc.) (bug 229255) <span class="work">Markus: 1w</span></li>
		</ul>
		
		<h4><img src="http://www.eclipse.org/images/Adarrow.gif" border="0" height="16" width="16" align="top"> Permanent Items</h4>
		<ul>
			<li><img src="../images/ok.gif" border="0" height="10" width="10"> bugzilla inbox tracking</li>
			<li><img src="../images/ok.gif" border="0" height="10" width="10"> bug fixing</li>
			<li><img src="../images/ok.gif" border="0" height="10" width="10"> watch performance tests</li>
			<li><img src="../images/ok.gif" border="0" height="10" width="10"> increase correctness test coverage</li>
		</ul>
		
		
		<h4><img src="http://www.eclipse.org/images/Adarrow.gif" nosave="" border="0" height="16" width="16" align="top"> Testing</h4>
		<ul>
			<li><img src="../images/ok.gif" border="0" height="10" width="10"> <a href="http://www.eclipse.org/jdt/ui/r3_6/testing/M4_Test_Plan.html">test plan</a> for the 3.6 M4 test pass.</li>
		</ul>
		
	</td>
</tr>
<tr>
	<td ALIGN=LEFT VALIGN=TOP COLSPAN="2" WIDTH="100%" BGCOLOR="#595791"><font face="Arial,Helvetica"><font color="#FFFFFF"><a name="Milestone_Planning_M5"></a>Milestone M5 (2010-01-29) -  Major/Big Features Done</font></font></td>
</tr>

 <tr> 
	<td WIDTH="100%">
		See also the <a href="http://www.eclipse.org/jdt/ui/r3_6/plan.php#Milestone_Planning_M5">Combined JDT Text and JDT UI 3.6 M5 Plan</a>.

	    <h4><img src="http://www.eclipse.org/images/Adarrow.gif" border="0" height="16" width="16" align="top"> General Items</h4>
		<ul>
			<li class="priority"><img src="../images/ok.gif" border="0" height="10" width="10"> 3.5.2 maintenance work <span class="work">1w</span></li>
			<li class="priority"><img src="../images/ok.gif" border="0" height="10" width="10"> 3.5.2 one day test pass (<a href="http://www.eclipse.org/jdt/ui/r3_6/testing/3.5.2_Test_Plan.html">test plan</a>)</li>
		</ul>
		
		<h4><img src="http://www.eclipse.org/images/Adarrow.gif" border="0" height="16" width="16" align="top"> Ruler improvements [<a href="#3">3</a>] <span class="work">2w</span></li></h4>
		<ul>
			<li class="priority"><img src="../images/progress.gif" border="0" height="5" width="14" align="absmiddle"> <font class="indexsub" color="#8080ff">[3.6 M5]</font> improve overview ruler arming and size of active area  (bug 163769) <span class="work">Markus: 1d</span></li></h4>
		</ul>

		<h4><img src="http://www.eclipse.org/images/Adarrow.gif" border="0" height="16" width="16" align="top"> Spell Checking [<a href="#3">3</a>]</h4>
		<ul>
			<li><img src="../images/ok.gif" border="0" height="10" width="10"> investigate and reduce memory consumption <span class="work">Deepak: 1w</span></li>
		</ul>
		
		<h4><img src="http://www.eclipse.org/images/Adarrow.gif" border="0" height="16" width="16" align="top"> <a name="Hovering"></a>Hovering [<a href="#3">3</a>]</h4>
		<ul>
			<li class="priority"><font class="indexsub" color="#8080ff">[&gt;3.6 M5]</font> quick diff usability improvements in hover (Next/Prev support etc.) (bug 229255) <span class="work">Markus: 1w</span></li>
		</ul>
		
		<h4><img src="http://www.eclipse.org/images/Adarrow.gif" border="0" height="16" width="16" align="top"> Permanent Items</h4>
		<ul>
			<li>bugzilla inbox tracking</li>
			<li>bug fixing</li>
			<li>watch performance tests</li>
			<li>increase correctness test coverage</li>
		</ul>
		
		
		
		<h4><img src="http://www.eclipse.org/images/Adarrow.gif" nosave="" border="0" height="16" width="16" align="top"> Testing</h4>
		<ul>
			<li><a href="http://www.eclipse.org/jdt/ui/r3_6/testing/M5_Test_Plan.html">test plan</a> for the 3.6 M5 test pass.</li>
		</ul>
		
	</td>
</tr>
<tr>
	<td ALIGN=LEFT VALIGN=TOP COLSPAN="2" WIDTH="100%" BGCOLOR="#595791"><font face="Arial,Helvetica"><font color="#FFFFFF"><a name="Milestone_Planning_M6"></a>Milestone M6 (2010-03-12) - API Freeze</font></font></td>
</tr>

 <tr> 
	<td WIDTH="100%">
		See also the <a href="http://www.eclipse.org/jdt/ui/r3_6/plan.php#Milestone_Planning_M6">Combined JDT Text and JDT UI 3.6 M6 Plan</a>.
		
		<h4><img src="http://www.eclipse.org/images/Adarrow.gif" border="0" height="16" width="16" align="top"> Ruler improvements [<a href="#3">3</a>] <span class="work">2w</span></li></h4>
		<ul>
			<li class="priority"><img src="../images/progress.gif" border="0" height="5" width="14" align="absmiddle"> improve overview ruler arming and size of active area  (bug 163769) <span class="work">Markus: 1d</span></li></h4>
			<li class="priority"><img src="../images/ok.gif" border="0" height="10" width="10"> provide a command that allows to show the vertical ruler hover (bug 272172) <span class="work">Deepak: 2d</span></li></h4>
		</ul>

		<h4><img src="http://www.eclipse.org/images/Adarrow.gif" border="0" height="16" width="16" align="top"> <a name="Hovering"></a>Hovering [<a href="#3">3</a>]</h4>
		<ul>
			<li class="priority"> quick diff usability improvements in hover (Next/Prev support etc.) (bug 229255) <span class="work">Markus: 1w</span></li>
		</ul>
		
		<h4><img src="http://www.eclipse.org/images/Adarrow.gif" border="0" height="16" width="16" align="top"> Permanent Items</h4>
		<ul>
			<li>bugzilla inbox tracking</li>
			<li>bug fixing</li>
			<li>watch performance tests</li>
			<li>increase correctness test coverage</li>
		</ul>
		
		
		<h4><img src="http://www.eclipse.org/images/Adarrow.gif" nosave="" border="0" height="16" width="16" align="top"> Testing</h4>
		<ul>
			<li><a href="http://www.eclipse.org/jdt/ui/r3_6/testing/M6_Test_Plan.html">test plan</a> for the 3.6 M6 test pass.</li>
		</ul>
		
	</td>
</tr>
<tr>
	<td ALIGN=LEFT VALIGN=TOP COLSPAN="2" WIDTH="100%" BGCOLOR="#595791"><font face="Arial,Helvetica"><font color="#FFFFFF"><a name="Milestone_Planning_M7"></a>Milestone M7 (2010-04-30) - Feature Freeze, Focus on Performance and Polish</font></font></td>
</tr>

 <tr> 
	<td WIDTH="100%">
		See also the <a href="http://www.eclipse.org/jdt/ui/r3_6/plan.php#Milestone_Planning_M7">Combined JDT Text and JDT UI 3.6 M7 Plan</a>.

		<h4><img src="http://www.eclipse.org/images/Adarrow.gif" border="0" height="16" width="16" align="top"> Performance <span class="work">0.5m</span></h4>
		Work on bugs tagged with the <a href="https://bugs.eclipse.org/bugs/buglist.cgi?query_format=advanced&short_desc_type=allwordssubstr&short_desc=&classification=Eclipse&product=Platform&component=Text&long_desc_type=allwordssubstr&long_desc=&bug_file_loc_type=allwordssubstr&bug_file_loc=&status_whiteboard_type=allwordssubstr&status_whiteboard=&keywords_type=allwords&keywords=performance&bug_status=UNCONFIRMED&bug_status=NEW&bug_status=ASSIGNED&bug_status=REOPENED&emailtype1=substring&email1=&emailtype2=substring&email2=&bugidtype=include&bug_id=&votes=&chfieldfrom=&chfieldto=Now&chfieldvalue=&cmdtype=doit&order=Reuse+same+sort+as+last+time&field0-0-0=noop&type0-0-0=noop&value0-0-0=">'performance' keyword</a>.
		<ul>
		</ul>
		
		<h4><img src="http://www.eclipse.org/images/Adarrow.gif" border="0" height="16" width="16" align="top"> Polish <span class="work">0.5m</span></h4>
		Fix all bugs tagged with the <a href= "https://bugs.eclipse.org/bugs/buglist.cgi?query_format=advanced&short_desc_type=allwordssubstr&short_desc=&classification=Eclipse&product=Platform&component=Text&long_desc_type=allwordssubstr&long_desc=&bug_file_loc_type=allwordssubstr&bug_file_loc=&status_whiteboard_type=allwordssubstr&status_whiteboard=&keywords_type=allwords&keywords=polish&bug_status=UNCONFIRMED&bug_status=NEW&bug_status=ASSIGNED&bug_status=REOPENED&emailtype1=substring&email1=&emailtype2=substring&email2=&bugidtype=include&bug_id=&votes=&chfieldfrom=&chfieldto=Now&chfieldvalue=&cmdtype=doit&order=Reuse+same+sort+as+last+time&field0-0-0=noop&type0-0-0=noop&value0-0-0=">'polish' keyword</a>.
		<ul>
		</ul>
		
		<h4><img src="http://www.eclipse.org/images/Adarrow.gif" border="0" height="16" width="16" align="top"> Adopt New Platform Features [<a href="#3">3</a>]</h4>
		<ul>
			<li class="priority">make sure that we run on the e4 compatibility layer <span class="work">2w</span>
			<br>NOTE: Depends on the availability of the compatibility layer. 
				<ul>
					<li>test our bundles against it</li>
					<li>help to investigate and fix bugs in the compatibility layer</li>
				</ul>
			</li>
		</ul>
		
		<h4><img src="http://www.eclipse.org/images/Adarrow.gif" border="0" height="16" width="16" align="top"> Permanent Items</h4>
		<ul>
			<li>bugzilla inbox tracking</li>
			<li>bug fixing</li>
			<li>watch performance tests</li>
			<li>increase correctness test coverage</li>
		</ul>
		
		
		<h4><img src="http://www.eclipse.org/images/Adarrow.gif" nosave="" border="0" height="16" width="16" align="top"> Testing</h4>
		<ul>
			<li><a href="http://www.eclipse.org/jdt/ui/r3_6/testing/M7_Test_Plan.html">test plan</a> for the 3.6 M7 test pass.</li>
		</ul>
		
	</td>
</tr>


  <tr> 
    <td ALIGN=LEFT VALIGN=TOP COLSPAN="2" WIDTH="100%" BGCOLOR="#595791"><font face="Arial,Helvetica"><font color="#FFFFFF">Bug Tracking</font></font></td>
</tr>

<tr>
<td>
<ul>
<li><a href="https://bugs.eclipse.org/bugs/buglist.cgi?query_format=advanced&short_desc_type=allwordssubstr&short_desc=&product=JDT&product=Platform&component=Text&long_desc_type=allwordssubstr&long_desc=&bug_file_loc_type=allwordssubstr&bug_file_loc=&keywords_type=allwords&keywords=&bug_status=UNCONFIRMED&bug_status=NEW&bug_status=REOPENED&emailassigned_to1=1&emailtype1=substring&email1=inbox&emailtype2=substring&email2=&bugidtype=include&bug_id=&votes=&chfieldfrom=400d&chfieldto=Now&chfieldvalue=&cmdtype=doit&order=Reuse+same+sort+as+last+time&field0-0-0=noop&type0-0-0=noop&value0-0-0=">new bug reports</a></li>
<li><a href="http://dev.eclipse.org/bugs/buglist.cgi?bug_status=ASSIGNED&email1=platform-text-inbox@eclipse.org&emailtype1=exact&emailassigned_to1=1&email2=&emailtype2=substring&emailreporter2=1&bugidtype=include&bug_id=&changedin=&votes=&chfieldfrom=&chfieldto=Now&chfieldvalue=&product=Platform&component=Text&short_desc=&short_desc_type=allwordssubstr&long_desc=&long_desc_type=allwordssubstr&keywords=&keywords_type=anywords&field0-0-0=noop&type0-0-0=noop&value0-0-0=&namedcmd=All&newqueryname=Text%2BInbox&tofooter=1&order=Reuse%2Bsame%2Bsort%2Bas%2Blast%2Btime">accepted Platform Text bug reports</a></li>
<li><a href="https://bugs.eclipse.org/bugs/query.cgi?short_desc_type=allwordssubstr&short_desc=&product=JDT&product=Platform&component=Text&long_desc_type=allwordssubstr&long_desc=&bug_file_loc_type=allwordssubstr&bug_file_loc=&keywords_type=allwords&keywords=&bug_status=UNCONFIRMED&bug_status=NEW&bug_status=ASSIGNED&bug_status=REOPENED&emailtype1=substring&email1=&emailtype2=substring&email2=&bugidtype=include&bug_id=&votes=&changedin=&chfieldfrom=&chfieldto=Now&chfieldvalue=&namedcmd=Assigned&newqueryname=&field0-0-0=noop&type0-0-0=noop&value0-0-0=">find a bug report</a></li>
</ul>
</td>
</tr>
</table>
<table border="0" cellpadding="2" cellspacing="5" width="100%"><tbody><tr><td colspan="4" align="left" bgcolor="#595791" valign="top" width="100%"><font face="Arial,Helvetica"><font color="#ffffff">Legend
			</font></font></td>
		</tr>
		<tr>
			<td valign="center"><img src="../images/progress.gif" border="0" height="5" width="14" align="absmiddle"></td>
			<td width="50%">item is under development.</td>
			<td valign="top"><img src="../images/glass.gif" border="0" height="10" width="10"></td>
			<td width="50%">item is under investigation.</td>
		</tr>
		<tr>
			<td valign="center"><img src="../images/ok.gif" border="0" height="10" width="10"></td>
			<td width="50%">item is finished.</td>
			<td valign="top">( )</td>
			<td width="50%">item is time permitted.</td>
		</tr>
		<tr>
			<td valign="center"><font class="indexsub" color="#8080ff">[xyz]</font></td>
			<td width="50%">item is deferred (&gt;) from xyz or continues in xyz.</td>
			<td valign="center"><font class="indexsub"><img src="../images/new.gif" border="0"></font></td>
			<td width="50%">new</td>
		</tr>
	</tbody>
</table>

<br>&nbsp;
</body>
</html>
