<!doctype html public "-//w3c//dtd html 4.0 transitional//en">
<html XMLNS:Style>
<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 Search 3.7 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 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: 2011/08/09 12:16:13 $</p>

    
      <p>This plan is under continuous refinement. Please send comments about this plan to the <a href="mailto:platform-search-dev@eclipse.org">platform-search-dev@eclipse.org</a> developer mailing list.</p>

      <h2><a NAME="Overall_Planning"></a>Overall Goals</h2>
      <p>This section lists the goals for Eclipse 3.7 for the Platform 
        Search component as listed on the 
         <a href="http://www.eclipse.org/projects/project-plan.php?projectid=eclipse">Eclipse Project 3.7 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.
		</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.7 for the Platform Search 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="#3">3</a>]</h4>
		<ul>
			<li class="priority"><img src="../images/ok.gif" border="0" height="10" width="10">  make sure that we run on the e4 compatibility layer <span class="work">1w</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>Usability</h4>
		<ul>
		  <li><img src="../images/ok.gif" border="0" height="10" width="10"> allow to use editor input as 'Selected resources' scope (bug 108247) <span class="work">Dani: 1d</span></li>
		</ul>
		</li>
		
		<li><h4>Miscellaneous</h4>
		<ul>
		  <li><font class="indexsub" color="#8080ff">[&gt;3.7]</font> BiDi: fix incorrect search result rendering (bug 222889, depends on SWT bug 229010) <span class="work">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.6.x maintenance work <span class="work">1d</span></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>Equinox
		<ul>
			<li><font class="indexsub" color="#8080ff">[&gt; 3.7]</font> bug 229010 needs to be fixed in order to fix wrong search result rendering for BiDi languages</li>
		</ul>
		</li>
		</li>
  </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=Search&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-search-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=Search&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=Search%2BInbox&tofooter=1&order=Reuse%2Bsame%2Bsort%2Bas%2Blast%2Btime">accepted Platform Search bug reports</a></li>
<li><a href="https://bugs.eclipse.org/bugs/query.cgi?bug_file_loc=&bug_file_loc_type=allwordssubstr&bug_id=&bug_status=UNCONFIRMED&bug_status=NEW&bug_status=ASSIGNED&bug_status=REOPENED&bugidtype=include&chfieldfrom=&chfieldto=Now&chfieldvalue=&component=Search&email1=&email2=&emailtype1=substring&emailtype2=substring&field-1-0-0=product&field-1-1-0=component&field-1-2-0=bug_status&field0-0-0=noop&keywords=&keywords_type=allwords&long_desc=&long_desc_type=allwordssubstr&product=Platform&query_format=advanced&remaction=&short_desc=&short_desc_type=allwordssubstr&status_whiteboard=&status_whiteboard_type=allwordssubstr&type-1-0-0=anyexact&type-1-1-0=anyexact&type-1-2-0=anyexact&type0-0-0=noop&value-1-0-0=Platform&value-1-1-0=Search&value-1-2-0=UNCONFIRMED%2CNEW%2CASSIGNED%2CREOPENED&value0-0-0=&votes=">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>
