2011-06-16  Jeff Johnston  <jjohnstn@redhat.com>

	* build.properties: Add book.css.
	* book.css: New file.

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

	Regenerate from updated wiki-pages.
	* Linux_Tools_Project/GProf/User_Guide/Troubleshooting.html: Regenerated.

2011-06-02  Jeff Johnston  <jjohnstn@redhat.com>
	
	Regenerate from update wiki-pages.
	* Linux_Tools_Project/GProf/User_Guide/images/gprof-binary-file.png: Removed.
	* Linux_Tools_Project/GProf/User_Guide/images/Gprof-binary-file.png: Added.
	* Linux_Tools_Project/GProf/User_Guide/images/gprof-display-call-graph.png: Removed.
	* Linux_Tools_Project/GProf/User_Guide/images/Gprof-display-call-graph.png: Added.
	* Linux_Tools_Project/GProf/User_Guide/images/gprof-project-explorer.png: Removed.
	* Linux_Tools_Project/GProf/User_Guide/images/Gprof-project-explorer.png: Added.
	* Linux_Tools_Project/GProf/User_Guide/Opening-gmon-out.html: Regenerated.
	* Linux_Tools_Project/GProf/User_Guide/Installation-and-Set-Up.html: Ditto.

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

	* META-INF/MANIFEST.MF: Add bundle localization plugin. 

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

	* plugin.xml: New file.
	* toc.xml: Ditto.
	* META-INF/MANIFEST.MF: Ditto.
	* images/*.gif: Ditto.
	* Linux_Tools_Project/*: Ditto.
	* about.html: Ditto.
	* build-doc.xml: Ditto.
	* build.properties: Ditto.
	* extract-markup.xsl: Ditto.
	* pom.xml: Ditto.
	* toc.xml: Ditto.
	* plugin.properties: Ditto.