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

	* pom.xml: Bump version to 0.4.0.
	* feature.xml: Ditto.

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.
