<!doctype html public "-//w3c//dtd html 4.0//en">
<html>
<head>
   <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
   <title>Readme Tool Extension Points</title>
</head>
<body link="#0000FF" vlink="#800080">

<center>
<h1>
Readme Tool</h1></center>
The Readme Tool is provided as an example for tool developers. It demonstrates
the extension of various aspects of the workbench, both visually and functionally.
As well, the Readme Tool provides extension points of its own.
<p>
<hr WIDTH="100%">
<h1>
Extension Points</h1>
The following extension points can be used to extend the Readme Tool:
<ul>
<li>
<a href="org_eclipse_ui_examples_readmetool_sectionParser.html">org.eclipse.ui.readmetool.sectionParser</a></li>
</ul>

<p><a href="hglegal.htm"><img src="ngibmcpy.gif" alt="Copyright IBM Corp. 2000, 2001.  All Rights Reserved." width="195" height="12" border="0"></a></p>

</body>
</html>
