2011-01-25  Jeff Johnston  <jjohnstn@redhat.com>

	* feature.xml: Bump to 0.3.0 and remove libstdc++ from set of plug-ins.

2010-05-18  Andrew Overholt  <overholt@redhat.com>

	* feature.properties: Fix provider name.

2010-04-26  Andrew Overholt  <overholt@redhat.com>

	* feature.properties: Match consistent license text (bug #306627).  Update
	copyright year.
	* license.html: New file.  HTML version of SUA (bug #306627).
	* build.properties: Include license.html.
	* about.html: Remove.
	* feature.xml: Use licenseURL property instead of explicit URL.

2010-04-12  Andrew Overholt  <overholt@redhat.com>

	* feature.properties: Match consistent license text (bug #306627).

2010-02-08  Andrew Overholt  <overholt@redhat.com>

	* feature.properties: Capitalize "library" in featureName.

2009-11-10  Andrew Overholt  <overholt@redhat.com>

	* feature.properties: Make featureName a bit more user-friendly.

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

	* feature.xml: Remove newlib as included feature.

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

	* feature.xml: Rename to org.eclipse.linuxtools.cdt.libhover.

2009-05-19  Andrew Overholt  <overholt@redhat.com>

	Bug #273931

	* feature.properties: Change provider from Eclipse.org to Eclipse.

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

	* feature.xml: Bump up to 0.2.0.  Add libhover newlib feature as
	optional included feature.  Add libhover libstdcxx plugin.
	
2009-01-15  Jeff Johnston  <jjohnstn@redhat.com>

	* feature.xml: Bump up to 0.1.1.

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

	* feature.xml: Add .qualifier to version id.

2009-01-06  Andrew Overholt  <overholt@redhat.com>

	* feature.xml: 1.0.0 -> 0.1.0.  Add update site information.
	* build.properties: Add feature.properties and epl-v10.html.

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

	* feature.xml: Use feature.properties.  Add "(Incubation)".
	* feature.properties: Initial checkin.
	* epl-v10.html: Likewise.

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

	* feature.xml: Add org.eclipse.linuxtools.cdt.libhover.library_docs plugin.
	Also change org.eclipse.linuxtools.cdt.libhover.glibc reference to be plugin
	instead of fragment.

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

	* feature.xml: Initial check-in.
	* about.html: Ditto.
	* build.properties: Ditto.
