<!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.5 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) {
	if (node.nextSibling) {
		return node.nextSibling;
	} else if (node.parentNode == document.getElementsByTagName("body")[0]) {
		return null;
	} else {
		return nextNode(node.parentNode);
	}
}
function traverseLinkifyBugs(node) {
	while (node) {
		if (node.nodeType == 1/*element*/ && node.nodeName == "a") {
			node= nextNode(node);
			
		} else if (node.childNodes != null && node.childNodes.length > 0) {
			node= node.childNodes[0];
			
		} else if (node.nodeType == 3/*text*/) {
			var txt= node.data;
			var regex= /([Bb]ug\s*)([0-9]+)/;
			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);
			}
			
		} else {
			node= nextNode(node);
		}
	}
}

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: 2009/08/03 12:47:49 $</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_5/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.5 for the Platform 
        Text component as listed on the 
        <a href="http://www.eclipse.org/eclipse/development/eclipse_project_plan_3_5.html">Eclipse Project 3.5 Draft Plan</a>.
        </p>


		<p>
		<strong><a name="1"></a>[1] Performance</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] Reliability</strong>.
		Provide APIs for clients where needed and fix critical bugs.
		</p>
		
		<p>
		<strong><a name="3"></a>[3] Keep Eclipse vibrant and attractive</strong>.
		Deliver new productivity features like improved quick diff hovers and column based editing capabilities. 
		</p>

	<h2><a NAME="Work_Items"></a><br>Work Items</h2>
	<p>
		This section lists the possible work items for Eclipse 3.5 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>Adopt New Platform Features [<a href="#2">2</a>]</h4>
		<ul>
			<li><img src="../images/ok.gif" border="0" height="10" width="10"> adopt new Platform UI constants<span class="work">0.5d</span></li>
			<li><img src="../images/ok.gif" border="0" height="10" width="10"> investigate using new <code>PixelConverter</code><span class="work">0.5d</span></li>
			<li><img src="../images/ok.gif" border="0" height="10" width="10"> investigate using new <code>ListDialog</code><span class="work">0.5d</span></li>
		</ul></li>
	
		<li><h4>Find/Replace [<a href="#2">2</a>]</h4>
		<ul>
			<li>improve Find/Replace dialog: merge into editor area, ... [from external contributor] (bug 99294)</li>
		</ul>
		</li>
	
		<li><h4><a name="Hovering"></a>Hovering [<a href="#3">3</a>]</h4>
		<ul>
			<li class="priority"><font class="indexsub" color="#8080ff">[&gt;3.5]</font> quick diff usability improvements in hover (Next/Prev support etc.) <span class="work">7d</span></li>
			<li class="priority"><img src="../images/ok.gif" border="0" height="10" width="10"> improve ruler hover accessibility (bug 78244 and bug 243304) <span class="work">3d</span></li>
		</ul>
		</li>

		<li><h4>Ruler improvements [<a href="#2">2</a>]</h4>
		<ul>
			<li>improve overview ruler arming and size of active area</li>
			<li><img src="../images/ok.gif" border="0" height="10" width="10"> add support to contribute actions and context menus to ruler columns (depends on Platform UI bug 134526)</li>
			<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="#2">2</a>]</h4>
		<ul>
			<li>investigate and reduce memory consumption</li>
		</ul>
		</li>
	
		<li><h4>Performance [<a href="#1">1</a>]</h4>
		<ul>
			<li>investigate to reduce garbage when typing</li>
			<li>revisit the text viewer's support for redraw, compound updates, and selection preservation
			<ul>
				<li>check all setRedraw(on/off) users whether they really need that expensive operation (e.g. undo)</li>
			</ul>
			</li>
		  
			<li class="priority"><img src="../images/ok.gif" border="0" height="10" width="10"> constantly watch performance test results and act when red</li>
			<li class="priority"><img src="../images/ok.gif" border="0" height="10" width="10"> 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"> change folding paradigm: no longer eat first key stroke [experimental] (bug 64050, bug 67500, bug 97815) <span class="work">2d</span></li>
			<li class="priority"><font class="indexsub" color="#8080ff">[&gt;3.5]</font> generalize save actions i.e. push down from JDT Text (bug 195063) <span class="work">1m</span></li>
			<li class="priority"><img src="../images/ok.gif" border="0" height="10" width="10"> API/extension points to contribute new context types (to allow clients to add something like SWT templates) (bug 236878) <span class="work">1d</span></li>
			<li class="priority"><img src="../images/ok.gif" border="0" height="10" width="10"> add column based editing capabilities to textual editors (bug 19771, depends on SWT bug 8521) <span class="work">1w</span></li>
			<li><li><font class="indexsub" color="#8080ff">[&gt;3.5]</font> provide API for <code>BrowserInformationControl</code> (bug 218482) and <code>HTML2TextReader</code> (bug 241896) <span class="work">3d</span>
			<li><img src="../images/ok.gif" border="0" height="10" width="10"> generalize breadcrumbs (needs to be discussed with Platform UI whether/how we want to do it)
				<br>&rarr; discussed with Platform UI: no further work planned before e4
			</li>
			<li>provide LTK layer for text editing support (bug 125825, bug 149817, ...)</li>
			<li><img src="../images/ok.gif" border="0" height="10" width="10"> up/down navigation loses context when reconciler kicks in (bug 79992)
				<br>&rarr; this turned out to be an SWT bug
			</li>
			<li><img src="../images/ok.gif" border="0" height="10" width="10"> restore editor selection on restart should restore visible view port as well (bug 169838)</li>
			<li>problems with undo grouping in linked mode (bug 77575)</li>
			<li><img src="../images/ok.gif" border="0" height="10" width="10"> leverage link support in <code>StyledText</code> (depends on SWT bug 83408) <span class="work">0.5d</span></li>
			<li><img src="../images/ok.gif" border="0" height="10" width="10"> simplify the setup of <code>ContentAssistAction</code> (bug 138370) <span class="work">0.5d</span></li>
		</ul>
		</li>
		
		<li><h4>General Items [<a href="#2">2</a>]</h4>
		<ul>
			<li class="priority"><img src="../images/ok.gif" border="0" height="10" width="10"> 3.4.x maintenance work <span class="work">1w</span></li>
			<li>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>
				<li><img src="../images/ok.gif" border="0" height="10" width="10"> bug 8521 needs to get fixed in order to add add column based editing capabilities to textual editors (bug 19771)</li>
				<li><img src="../images/ok.gif" border="0" height="10" width="10"> bug 83408 needs to get fixed in order to leverage link support from <code>StyledText</code></li>
			</ul>
		</li>
		<li>Platform UI
			<ul>
				<li><img src="../images/ok.gif" border="0" height="10" width="10"> discuss further work regarding breadcrumbs with Platform UI
					<br>&rarr; discussed with Platform UI: no further work planned before e4
				</li>
				<li><img src="../images/ok.gif" border="0" height="10" width="10"> bug 134526 needs to get fixed in order to add support to contribute actions and context menus to ruler columns</li>
			</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 (2008-08-08)</font></font></td>
</tr>

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

		<h4><img src="http://www.eclipse.org/images/Adarrow.gif" border="0" height="16" width="16" align="top"> General Items [<a href="#2">2</a>]</h4>
		<ul>
			<li class="priority"><img src="../images/progress.gif" border="0" height="5" width="14" align="absmiddle"> <font class="indexsub" color="#8080ff">[3.5 M3]</font> 3.4.1 maintenance work <span class="work">1w</span></li>
			<li class="priority"><img src="../images/ok.gif" border="0" height="10" width="10"> 3.5 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"> 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_5/testing/M1_Test_Plan.html">test plan</a> for the 3.5 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="	ne_Planning_M2"></a>Milestone M2 (2008-09-19)</font></font></td>
</tr>

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

		<h4><img src="http://www.eclipse.org/images/Adarrow.gif" border="0" height="16" width="16" align="top"> General Items [<a href="#2">2</a>]</h4>
		<ul>
			<li class="priority"><img src="../images/ok.gif" border="0" height="10" width="10"> 3.4.1 maintenance work <span class="work">1w</span></li>
			<li class="priority"><img src="../images/ok.gif" border="0" height="10" width="10"> 3.5 milestone level 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"> Miscellaneous [<a href="#3">3</a>]</h4>
		<ul>
			<li class="priority"><img src="../images/progress.gif" border="0" height="5" width="14" align="absmiddle"> <font class="indexsub" color="#8080ff">[3.5 M3]</font> change folding paradigm: no longer eat first key stroke [experimental] (bug 67500, bug 66264) <span class="work">2d</span></li>
			<li class="priority"><img src="../images/ok.gif" border="0" height="10" width="10"> resolve cross team issues (get target milestones for required work) <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"> 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_5/testing/M2_Test_Plan.html">test plan</a> for the 3.5 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 (2008-10-31)</font></font></td>
</tr>

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

	    <h4><img src="http://www.eclipse.org/images/Adarrow.gif" border="0" height="16" width="16" align="top"> General Items [<a href="#2">2</a>]</h4>
		<ul>
			<li class="priority"><img src="../images/progress.gif" border="0" height="5" width="14" align="absmiddle"> <font class="indexsub" color="#8080ff">[3.5 M4]</font> 3.4.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"> API</h4>
		<ul>
			<li class="priority"><font class="indexsub" color="#8080ff">[&gt;3.5 M3]</font> API/extension points to contribute new context types (to allow clients to add something like SWT templates) (bug 236878) <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"> Miscellaneous [<a href="#3">3</a>]</h4>
		<ul>
			<li class="priority"><img src="../images/ok.gif" border="0" height="10" width="10"> change folding paradigm: no longer eat first key stroke [experimental] (bug 64050, bug 67500, bug 97815) <span class="work">2d</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_5/testing/M3_Test_Plan.html">test plan</a> for the 3.5 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 (2008-12-12)</font></font></td>
</tr>

 <tr> 
	<td WIDTH="100%">
		See also the <a href="http://www.eclipse.org/jdt/ui/r3_5/plan.php#Milestone_Planning_M4">Combined JDT Text and JDT UI 3.5 M4 Plan</a>.
		
		<h4><img src="http://www.eclipse.org/images/Adarrow.gif" border="0" height="16" width="16" align="top"> General Items [<a href="#2">2</a>]</h4>
		<ul>
			<li class="priority"><img src="../images/progress.gif" border="0" height="5" width="14" align="absmiddle"> 3.4.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"> Hovering [<a href="#3">3</a>]</h4>
		<ul>
			<li class="priority"><font class="indexsub" color="#8080ff">[&gt;3.5 M4]</font> quick diff usability improvements in hover (Next/Prev support etc.) <span class="work">7d</span></li>
			<li class="priority"><font class="indexsub" color="#8080ff">[&gt;3.5 M4]</font> improve ruler hover accessibility (bug 78244 and bug 243304) <span class="work">3d</span></li></li>
		</ul>

		<h4><img src="http://www.eclipse.org/images/Adarrow.gif" border="0" height="16" width="16" align="top"> API</h4>
		<ul>
			<li><font class="indexsub" color="#8080ff">[&gt;3.5]</font> provide API for <code>BrowserInformationControl</code> (bug 218482) and <code>HTML2TextReader</code> (bug 241896) <span class="work">3d</span>
			<li class="priority"><font class="indexsub" color="#8080ff">[&gt;3.5 M4]</font> API/extension points to contribute new context types (to allow clients to add something like SWT templates) (bug 236878) <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"> Ruler improvements [<a href="#2">2</a>]</h4>
		<ul>
			<li><img src="../images/ok.gif" border="0" height="10" width="10"> add support to contribute actions and context menus to ruler columns (depends on Platform UI bug 134526)</li>
  	  	</ul>

		<h4><img src="http://www.eclipse.org/images/Adarrow.gif" border="0" height="16" width="16" align="top"> Miscellaneous</h4>
		<ul>
			<li class="priority"><font class="indexsub" color="#8080ff">[&gt;3.5 M4]</font> generalize save actions i.e. push down from JDT Text (bug 195063) <span class="work">1m</span></li>
			<li class="priority"><img src="../images/progress.gif" border="0" height="5" width="14" align="absmiddle"> <font class="indexsub" color="#8080ff">[3.5 M5]</font> add column based editing capabilities to textual editors (bug 19771, depends on SWT bug 8521) <span class="work">1w</span></li>
			<li><img src="../images/ok.gif" border="0" height="10" width="10"> simplify the setup of <code>ContentAssistAction</code> (bug 138370) <span class="work">0.5d</span></li>
			<li><img src="../images/ok.gif" border="0" height="10" width="10"> leverage link support in <code>StyledText</code> (depends on SWT bug 83408) <span class="work">0.5d</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_5/testing/M4_Test_Plan.html">test plan</a> for the 3.5 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 (2009-01-30) -  Major/Big Features Done</font></font></td>
</tr>

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

	    <h4><img src="http://www.eclipse.org/images/Adarrow.gif" border="0" height="16" width="16" align="top"> General Items [<a href="#2">2</a>]</h4>
		<ul>
			<li class="priority"><img src="../images/ok.gif" border="0" height="10" width="10"> 3.4.2 maintenance work <span class="work">1w</span></li>
			<li class="priority"><img src="../images/ok.gif" border="0" height="10" width="10"> 3.4.2 one day test pass (<a href="http://www.eclipse.org/jdt/ui/r3_5/testing/3.4.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"> API</h4>
		<ul>
			<li class="priority"><font class="indexsub" color="#8080ff">[&gt;3.5 M5]</font> API/extension points to contribute new context types (to allow clients to add something like SWT templates) (bug 236878) <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"><font class="indexsub" color="#8080ff">[&gt;3.5 M5]</font> quick diff usability improvements in hover (Next/Prev support etc.) <span class="work">7d</span></li>
			<li class="priority"><font class="indexsub" color="#8080ff">[&gt;3.5 M5]</font> improve ruler hover accessibility (bug 78244 and bug 243304) <span class="work">3d</span></li></li>
		</ul>
		
		<h4><img src="http://www.eclipse.org/images/Adarrow.gif" border="0" height="16" width="16" align="top"> Miscellaneous</h4>
		<ul>
			<li class="priority"><font class="indexsub" color="#8080ff">[&gt;3.5]</font> generalize save actions i.e. push down from JDT Text (bug 195063) <span class="work">1m</span></li>
			<li class="priority"><img src="../images/ok.gif" border="0" height="10" width="10"> add column based editing capabilities to textual editors (bug 19771, depends on SWT bug 8521) <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"> 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_5/testing/M5_Test_Plan.html">test plan</a> for the 3.5 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 (2009-03-13) - API Freeze</font></font></td>
</tr>

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

		<h4><img src="http://www.eclipse.org/images/Adarrow.gif" border="0" height="16" width="16" align="top"> API</h4>
		<ul>
			<li class="priority"><img src="../images/ok.gif" border="0" height="10" width="10"> API/extension points to contribute new context types (to allow clients to add something like SWT templates) (bug 236878) <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"><font class="indexsub" color="#8080ff">[&gt;3.5 M6]</font> quick diff usability improvements in hover (Next/Prev support etc.) <span class="work">7d</span></li>
			<li class="priority"><font class="indexsub" color="#8080ff">[&gt;3.5 M6]</font> improve ruler hover accessibility (bug 78244 and bug 243304) <span class="work">3d</span></li></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_5/testing/M6_Test_Plan.html">test plan</a> for the 3.5 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 (2009-05-01) - 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_5/plan.php#Milestone_Planning_M7">Combined JDT Text and JDT UI 3.5 M7 Plan</a>.

		<h4><img src="http://www.eclipse.org/images/Adarrow.gif" border="0" height="16" width="16" align="top"> Adopt New Platform Features [<a href="#2">2</a>]</h4>
		<ul>
			<li><img src="../images/ok.gif" border="0" height="10" width="10"> adopt new Platform UI constants<span class="work">0.5d</span></li>
			<li><img src="../images/ok.gif" border="0" height="10" width="10"> investigate using new <code>PixelConverter</code><span class="work">0.5d</span></li>
			<li><img src="../images/ok.gif" border="0" height="10" width="10"> investigate using new <code>ListDialog</code><span class="work">0.5d</span></li>
		</ul></li>
		
		<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"><font class="indexsub" color="#8080ff">[&gt;3.5]</font> quick diff usability improvements in hover (Next/Prev support etc.) <span class="work">7d</span></li>
			<li class="priority"><img src="../images/ok.gif" border="0" height="10" width="10"> improve ruler hover accessibility (bug 78244 and bug 243304) <span class="work">3d</span></li></li>
		</ul>

		<h4><img src="http://www.eclipse.org/images/Adarrow.gif" border="0" height="16" width="16" align="top"> Miscellaneous</h4>
		<ul>
			<li><img src="../images/ok.gif" border="0" height="10" width="10"> restore editor selection on restart should restore visible view port as well (bug 169838)</li>
			<li><img src="../images/ok.gif" border="0" height="10" width="10"> up/down navigation loses context when reconciler kicks in (bug 79992)
				<br>&rarr; this turned out to be an SWT bug
			</li>
		</ul>
		
		<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>
		<img src="../images/ok.gif" border="0" height="10" width="10"> 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>
		<img src="../images/ok.gif" border="0" height="10" width="10"> 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"> 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_5/testing/M7_Test_Plan.html">test plan</a> for the 3.5 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>
