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

	* toc.xml: Change anchor reference to moreclibdocs.

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

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

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

	* plugin.properties: New file to fill in bundlename and provider.

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

	* src/org/eclipse/linuxtools/cdt/libhover/libstdcxx/DoxygenCPPInfo.java (getParameters):
	New method. 
	(getReturn): Ditto. 
	(buildDoxygenCPPInfo): Add code to get detailed description and break this up into
	parameters and return value.  For return type, use refid to find a referenced class. 
	(getElementText): Fix to be recursive.

2009-02-10  Jeff Johnston  <jjohnstn@redhat.com>

	* .project: New file.
	* toc.xml: Add missing toc file referenced by plugin. 

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

	* plugin.xml: Initial creation.
	* plugin.properties: Ditto.
	* toc.xml: Ditto.
	* build.properties: Ditto.
	* META-INF/MANIFEST.MF: Ditto.
	* about.html: Ditto.
	* src/org/eclipse/linuxtools/cdt/libhover/libstdcxx/DoxygenCPPInfo.java: New file
	for creating serialized LibHover info from libstdc++ Doxygen xml documentation.