<!doctype html public "-//w3c//dtd html 4.0 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>3.1 Documentation Plan for Platform Search, Platform Text, JDT Text and JDT UI</title>
<link rel="stylesheet" href="http://dev.eclipse.org/default_style.css" type="text/css">
</head>
<body text="#000000" bgcolor="#FFFFFF">
&nbsp;
<table BORDER=0 CELLSPACING=5 CELLPADDING=2 WIDTH="100%" >
<tr>
    <td ALIGN=LEFT VALIGN=TOP COLSPAN="2" WIDTH="100%" BGCOLOR="#0080C0"><b><font face="Arial,Helvetica"><font color="#FFFFFF">3.1 Documentation Plan for Platform Search, Platform Text, JDT Text and JDT UI</font></font></b></td>
</tr>

  <tr> 
    <td WIDTH="100%"> 
    <p>Last revised 13:32 CET June 22, 2005

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

  <tr> 
    <td WIDTH="100%"> 

	<ul>
		<li><h3><img src="http://www.eclipse.org/images/Adarrow.gif" nosave="" border="0" height="16" width="16" align="center"> User Documentation</h5>
			<ul>
				<li>go through all our documentation and remove all out-dated contents</li>
				<li>check all views and editors in the new dynamic Help view:
					<ul>
						<li>summary is correct </li>
						<li>links work and make sense</li>
					</ul>
				</li>
				<li>Getting Started section: [David]<br>
					<ul>
						<li>update to 3.1</li>
						<li>add section about J2SE 5.0</li>
						<li>adapt project setup tutorial to new project wizard [Philippe]</li>
						<li>make sure the Getting Started section is of high-quality and easy to read</li>
						<li>test the getting started: go through it step by step</li>
					</ul>
				</li>
				<li>update the Tips & Tricks document</li>
				<li>complete the What's New in 3.1 section [Dirk and Tom]</li>
				<li>update the Welcome page, ensure there's a link to the icon's list</li>
				<li><img src="http://www.eclipse.org/jdt/ui/images/ok.gif" nosave="" border="0" height="10" width="10"> update the Readme document [Dirk and Dani]</li>
				<li>update the list of used icons</li>
				<li>check all our examples and corresponding example descriptions</li>
			</ul>
		</li>
		
		<li><h3><img src="http://www.eclipse.org/images/Adarrow.gif" nosave="" border="0" height="16" width="16" align="center"> ISV Documentation [Dirk, Tom]</h5>
			<ul>
				<li>review and complete extension point descriptions in the schemas (verify that all appear)</li>
				<li><img src="http://www.eclipse.org/jdt/ui/images/ok.gif" nosave="" border="0" height="10" width="10"> verify that all APIs and extension-points appear in the corresponding programmer's guide [Dani]</li>
			</ul>
		</li>
		
		<li><h3><img src="http://www.eclipse.org/images/Adarrow.gif" nosave="" border="0" height="16" width="16" align="center"> Code</h5>
			<ul>
				<li><img src="http://www.eclipse.org/jdt/ui/images/ok.gif" nosave="" border="0" height="10" width="10"> Javadoc [Dani]</li>
					<ul>
						<li>verify that all APIs have Javadoc</li>
						<li>check spelling</li>
						<li>new APIs have the @since3.1 tag</li>
					</ul>
				</li>
				<li><img src="http://www.eclipse.org/jdt/ui/images/ok.gif" nosave="" border="0" height="10" width="10"> spell check all *.properties files [Dani]</li>
				<li>spell check all *.htm* files</li>
				<li><img src="http://www.eclipse.org/jdt/ui/images/ok.gif" nosave="" border="0" height="10" width="10"> provide component.xml for text plug-ins [Dani]</li>
			</ul>
		</li>
	
		<li><h5>Miscellaneous</h5>
		<ul>
			<li>ensure there are no mixed line delimiters</li>
			<li>redo all screen shots</li>
			<li><img src="http://www.eclipse.org/jdt/ui/images/progress.gif" nosave="" border="0" height="5" width="14" align="middle"> check the whole doc with a link checker tool [Dani]</li>
			<li><img src="http://www.eclipse.org/jdt/ui/images/ok.gif" nosave="" border="0" height="10" width="10"> remove the copyright link and the copyright gif (tool see <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=99017">bug 99017</a>) [Dani]</li>
		</ul>
		</li>
	</ul>		
	
</tr>
</table>


<table border="0" cellpadding="2" cellspacing="5" width="100%"><tbody><tr><td colspan="4" align="left" bgcolor="#0080c0" valign="top" width="100%"><b><font face="Arial,Helvetica"><font color="#ffffff">Legend
			</font></font></b></td>
		</tr>
		<tr>
			<td valign="center"><img src="http://www.eclipse.org/jdt/ui/images/progress.gif" nosave="" border="0" height="5" width="14" align="middle"></td>
			<td width="50%">item is under development.</td>
			<td valign="top"><img src="http://www.eclipse.org/jdt/ui/images/glass.gif" nosave="" border="0" height="10" width="10"></td>
			<td width="50%">item is under investigation.</td>
		</tr>
		<tr>
			<td valign="center"><img src="http://www.eclipse.org/jdt/ui/images/ok.gif" nosave="" 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 to or continues in xyz.</td>
			<td valign="top"><font class="indexsub"><img src="http://www.eclipse.org/jdt/ui/images/new.gif" border="0"></font></td>
			<td width="50%">new</td>
		</tr>
	</tbody>
</table>

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