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

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

2010-10-21  Alexander Kurtakov  <akurtako@redhat.com>

	* src/org/eclipse/linuxtools/internal/valgrind/doc/anttask/MediaWikiImageFetcher.java: Removed.
	* src/org/eclipse/linuxtools/internal/valgrind/doc/anttask/tasks.properties: Removed.
	* userguide/General-Usage.html: Removed.
	* userguide/images/CachegrindOptions.png: Removed.
	* userguide/images/CachegrindOutput.png: Removed.
	* userguide/images/Exportbuttonvalgrindview.gif: Removed.
	* userguide/images/exportbuttonvalgrindview.png: Removed.
	* userguide/images/hierarchy.gif: Removed.
	* userguide/images/MassifChartSelect.png: Removed.
	* userguide/images/MassifOptions.png: Removed.
	* userguide/images/MassifTable.png: Removed.
	* userguide/images/MassifTree.png: Removed.
	* userguide/images/MemcheckOptions.png: Removed.
	* userguide/images/MemcheckOutput.png: Removed.
	* userguide/images/Screenshot-ProfileConfigurations-valgrind-options-tab.png: Removed.
	* userguide/images/Screenshot-ProfileConfigurations.png: Removed.
	* userguide/images/Screenshot-Suppressions.png: Removed.
	* userguide/images/Shortcut.png: Removed.
	* userguide/images/SwitchCachegrind.png: Removed.
	* userguide/images/SwitchCoreTool.png: Removed.
	* userguide/images/SwitchMassif.png: Removed.
	* userguide/images/Thread.gif: Removed.
	* userguide/images/ValgrindExportWizard.png: Removed.
	* userguide/images/ValgrindSegfault.png: Removed.
	* userguide/Installing.html: Removed.
	* userguide/Special-Cases.html: Removed.
	* userguide/Updating-This-Document.html: Removed.
	* userguide/Using-Cachegrind.html: Removed.
	* userguide/Using-Massif.html: Removed.
	* userguide/Using-Memcheck.html: Removed.
	* userguide/Valgrind\ Reference-toc.xml: Removed.
	* userguide/Valgrind\ Reference.html: Removed.
	* userguide/Valgrind\ Reference.xml: Removed.
	* images/home.gif: New file.
	* images/next.gif: New file.
	* images/prev.gif: New file.
	* Linux_Tools_Project/Valgrind/User_Guide/General-Usage.html: New file.
	* Linux_Tools_Project/Valgrind/User_Guide/images/CachegrindOptions.png: New file.
	* Linux_Tools_Project/Valgrind/User_Guide/images/CachegrindOutput.png: New file.
	* Linux_Tools_Project/Valgrind/User_Guide/images/Exportbuttonvalgrindview.gif: New file.
	* Linux_Tools_Project/Valgrind/User_Guide/images/Hierarchy.gif: New file.
	* Linux_Tools_Project/Valgrind/User_Guide/images/MassifChartSelect.png: New file.
	* Linux_Tools_Project/Valgrind/User_Guide/images/MassifOptions.png: New file.
	* Linux_Tools_Project/Valgrind/User_Guide/images/MassifTable.png: New file.
	* Linux_Tools_Project/Valgrind/User_Guide/images/MassifTree.png: New file.
	* Linux_Tools_Project/Valgrind/User_Guide/images/MemcheckOptions.png: New file.
	* Linux_Tools_Project/Valgrind/User_Guide/images/MemcheckOutput.png: New file.
	* Linux_Tools_Project/Valgrind/User_Guide/images/Screenshot-ProfileConfigurations-valgrind-options-tab.png: New file.
	* Linux_Tools_Project/Valgrind/User_Guide/images/Screenshot-ProfileConfigurations.png: New file.
	* Linux_Tools_Project/Valgrind/User_Guide/images/Screenshot-Suppressions.png: New file.
	* Linux_Tools_Project/Valgrind/User_Guide/images/Shortcut.png: New file.
	* Linux_Tools_Project/Valgrind/User_Guide/images/SwitchCachegrind.png: New file.
	* Linux_Tools_Project/Valgrind/User_Guide/images/SwitchCoreTool.png: New file.
	* Linux_Tools_Project/Valgrind/User_Guide/images/SwitchMassif.png: New file.
	* Linux_Tools_Project/Valgrind/User_Guide/images/Thread.gif: New file.
	* Linux_Tools_Project/Valgrind/User_Guide/images/ValgrindExportWizard.png: New file.
	* Linux_Tools_Project/Valgrind/User_Guide/images/ValgrindSegfault.png: New file.
	* Linux_Tools_Project/Valgrind/User_Guide/Installing.html: New file.
	* Linux_Tools_Project/Valgrind/User_Guide/Special-Cases.html: New file.
	* Linux_Tools_Project/Valgrind/User_Guide/Updating-This-Document.html: New file.
	* Linux_Tools_Project/Valgrind/User_Guide/User-Guide.html: New file.
	* Linux_Tools_Project/Valgrind/User_Guide/Using-Cachegrind.html: New file.
	* Linux_Tools_Project/Valgrind/User_Guide/Using-Massif.html: New file.
	* Linux_Tools_Project/Valgrind/User_Guide/Using-Memcheck.html: New file.
	* toc-doc.xml: New file.
	* .classpath: No longer java project.
	* .project: Likewise.
	* build-helper.xml: Use mediawiki-to-eclipse-help task directly.
	* build.properties: New files to ship.
	* META-INF/MANIFEST.MF: Doesn't need ant bundle.
	* plugin.xml: Fix toc names.
	* toc.xml: Regenerated.
	* toc-doc.xml: New primary toc.

2010-07-26  Elliott Baron  <ebaron@fedoraproject.org>

	* META-INF/MANIFEST.MF: Bump version to 0.7.0. 

2010-04-19  Elliott Baron  <ebaron@fedoraproject.org>

	* userguide/General-Usage.html: Regenerated to include Mac OSX info.
	* userguide/Valgrind\ Reference-toc.xml: Likewise.
	* userguide/Valgrind\ Reference.xml: Likewise.

2009-08-07  Andrew Overholt  <overholt@redhat.com>

	Bug #285861

	* plugin.properties: Change Provider to Eclipse.

2009-06-26  Elliott Baron  <ebaron@redhat.com>

	* userguide/General-Usage.html: New file.
	* userguide/images/Exportbuttonvalgrindview.gif: New file.
	* userguide/Installing.html: New file.
	* userguide/Special-Cases.html: New file.
	* userguide/Using-Cachegrind.html: New file.
	* userguide/Using-Massif.html: New file.
	* userguide/Using-Memcheck.html: New file.
	* userguide/Updating-This-Document.html: Regenerated documentation.
	* userguide/Valgrind\ Reference-toc.xml: Likewise.
	* userguide/Valgrind\ Reference.html: Likewise.
	* userguide/Valgrind\ Reference.xml: Likewise.

2009-06-18  Elliott Baron  <ebaron@redhat.com>

	* build-helper.xml: Added call to wikitext-to-docbook target.
	* META-INF/MANIFEST.MF: New dep for Eclipse help.
	* plugin.xml: New extension for Eclipse help.
	* userguide/images/Screenshot-ProfileConfigurations.png: Retook screenshot.
	* userguide/Valgrind Reference.xml: Generated docbook.

2009-05-28  Elliott Baron  <ebaron@redhat.com>

	* .classpath: New file.
	* .project: New file.
	* .settings/org.eclipse.jdt.core.prefs: New file.
	* about.html: New file.
	* build-helper.xml: New file.
	* build.properties: New file.
	* doc/notices.html: New file.
	* extract-markup.xsl: New file.
	* META-INF/MANIFEST.MF: New file.
	* plugin.properties: New file.
	* plugin.xml: New file.
	* src/org/eclipse/linuxtools/internal/valgrind/doc/anttask/MediaWikiImageFetcher.java: New file.
	* src/org/eclipse/linuxtools/internal/valgrind/doc/anttask/tasks.properties: New file.
	* toc.xml: New file.
	* userguide/images/CachegrindOptions.png: New file.
	* userguide/images/CachegrindOutput.png: New file.
	* userguide/images/exportbuttonvalgrindview.png: New file.
	* userguide/images/MassifChartSelect.png: New file.
	* userguide/images/MassifOptions.png: New file.
	* userguide/images/MassifTable.png: New file.
	* userguide/images/MassifTree.png: New file.
	* userguide/images/MemcheckOptions.png: New file.
	* userguide/images/MemcheckOutput.png: New file.
	* userguide/images/Screenshot-ProfileConfigurations-valgrind-options-tab.png: New file.
	* userguide/images/Screenshot-ProfileConfigurations.png: New file.
	* userguide/images/Screenshot-Suppressions.png: New file.
	* userguide/images/Shortcut.png: New file.
	* userguide/images/SwitchCachegrind.png: New file.
	* userguide/images/SwitchCoreTool.png: New file.
	* userguide/images/SwitchMassif.png: New file.
	* userguide/images/Thread.gif: New file.
	* userguide/images/ValgrindExportWizard.png: New file.
	* userguide/images/ValgrindSegfault.png: New file.
	* userguide/Updating-This-Document.html: New file.
	* userguide/Valgrind\ Reference-toc.xml: New file.
	* userguide/Valgrind\ Reference.html: New file.