2011-03-31  Jeff Johnston  <jjohnstn@redhat.com>

	* pom.xml: Fix pom to specify 1.0.2.
	* META-INF/MANIFEST.MF: Bump up to 1.0.2.
	* libraries.xml: Add devhelpdocs anchor.
	* doc/*: New files.
	* images/*.jpg: Ditto.
	* Linux_Tools_Project/*.html: Add libhover developer's guide.

2011-03-11  Jeff Johnston  <jjohnstn@redhat.com>

	* build-helper.xml: New file.
	* extract-markup.xsl: Ditto.
	* libraries.xml: Rename from toc.xml.

2010-06-14  Andrew Overholt  <overholt@redhat.com>

	* build.properties: Add about.html to binary build.

2009-08-06  Jeff Johnston  <jjohnstn@redhat.com>

	Resolves #285867
	* plugin.properties: Change Provider to Eclipse instead of Eclipse.org.

2009-01-15  Jeff Johnston  <jjohnstn@redhat.com>

	* META-INF/MANIFEST.MF: Add .qualifier to version and bump to 1.0.1.

2008-11-03  Jeff Johnston  <jjohnstn@redhat.com>

	* build.properties: Remove doc.zip.
	* doc.zip: Removed.

2008-11-03  Andrew Overholt  <overholt@redhat.com>

	* build.properties: Add plugin.properties.

2008-10-31  Andrew Overholt  <overholt@redhat.com>

	* plugin.properties: Initial import.
	* META-INF/MANIFEST.MF: Use plugin.propeties.  Add "(Incubation)".

2008-10-15  Jeff Johnston  <jjohnstn@redhat.com>

	* toc.xml: Initial release.
	* doc.zip: Ditto.
	* plugin.xml: Ditto.
	* about.html: Ditto.