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

	* src/org/eclipse/linuxtools/internal/cdt/libhover/LibHover.java (HelpResourceDescriptor.getHelpResources): 
	Use getDocs() rather than getLocation().

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

	* src/org/eclipse/linuxtools/internal/cdt/libhover/LibHover.java (isParmMatch): Fix to
	allow for the case when we have a referenced version of the class were in passed as an
	argument.

2011-02-24  Jeff Johnston  <jjohnstn@redhat.com>

	* META-INF/MANIFEST.MF: Allow tests to access internal classes.
	* schema/org.eclipse.linuxtools.cdt.libhover.library.exsd: Update schema description.

2011-02-17  Jeff Johnston  <jjohnstn@redhat.com>

	Resolves #328655
	* src/org/eclipse/linuxtools/internal/cdt/libhover/properties/LibHoverPropertyPage.java: Removed.
	* src/org/eclipse/linuxtools/internal/cdt/libhover/LibHoverLoadJob.java: New file.
	* META-INF/MANIFEST.MF: Bump version to 1.1.0.
	* plugin.xml: Add extensions to support preferences page.
	* src/org/eclipse/linuxtools/cdt/libhover/LibhoverPlugin.java (start): Add code to
	start job which loads all library hover info data.  Also add a save participant that
	will cache library hover info on workspace save.
	(save): New method to save library hover info.
	* src/org/eclipse/linuxtools/internal/cdt/libhover/LibHover.java (constructTypes): Fix format.
	(getLibraries): New static method to get the known libraries.
	(saveLibraries): New static method to save libraries in cache location.
	(getLibHoverDocs): Add support for cached library info and also store plug-in name space
	information with LibHoverLibrary.
	library info data local to their own plug-in instead of being local to this plug-in.
	(getTransformedName): New method. 
	(getCleanName): Ditto.
	(getCachedLibraries): Ditto.
	* src/org/eclipse/linuxtools/internal/cdt/libhover/LibHoverLibrary.java (LibHoverLibrary): Add
	plug-in name space field. 
	(setDocs): New method.
	(getNameSpace): New method.
	(setNameSpace): Ditto.
	(getHoverInfo): Add code to read library info local to a plug-in using the library
	extension and remove the code that assumed the data was local to this plug-in.
	(setHoverinfo): New method.
	* src/org/eclipse/linuxtools/internal/cdt/libhover/LibHoverMessages.java: Rewritten. 
	* src/org/eclipse/linuxtools/internal/cdt/libhover/LibHoverMessages.properties: Updated.
	* src/org/eclipse/linuxtools/internal/cdt/libhover/preferences/LibHoverPreferencePage.java (createFieldEditors): Rewritten
	to add caching and lazy-loading preferences via field editors.
	* src/org/eclipse/linuxtools/internal/cdt/libhover/preferences/PreferenceConstants.java: Add new constants
	for caching and lazy loading.
	* src/org/eclipse/linuxtools/internal/cdt/libhover/preferences/PreferenceInitializer.java (initializeDefaultPreferences): 
	Initialize defaults for new preferences. 

2010-11-17  Jeff Johnston  <jjohnstn@redhat.com>

	* src/org/eclipse/linuxtools/internal/cdt/libhover/LibHover.java (getFunctionInfo): Look for
	Exception instead of DOMException so code can work in CDT 8.0.0 and prior CDT releases.

2010-10-18  Jeff Johnston  <jjohnstn@redhat.com>

	* src/org/eclipse/linuxtools/internal/cdt/libhover/LibHoverLibrary.java (getHoverInfo): Don't
	print out stack trace for a time-out exception.  Set read time-out to be 5 seconds.

2010-03-17  Jeff Johnston  <jjohnstn@redhat.com>

	Resolves #306283
	* src/org/eclipse/linuxtools/internal/cdt/libhover/LibHover.java (getMemberSummary): Remove
	code that looks in editor text for class name and then asks the AST.  Just get the class name
	from the member we already do the lookup for.  Get the fully templated name using the new
	getClassName method. 
	(getMatchingFunctions): Remove commented out code.
	(getClassName): New method to get class name including template parameters.
	(getFunctionInfo): Change to specify fully qualified name and not remove
	namespace.
	* src/org/eclipse/linuxtools/internal/cdt/libhover/LibHoverLibrary.java (getClassInfo): Check
	info is not null before accessing.

2010-03-04  Jeff Johnston  <jjohnstn@redhat.com>

	* src/org/eclipse/linuxtools/internal/cdt/libhover/LibHover.java (getMemberSummary): Change
	DOMException catch statement to Exception since the IFunction interface getReturnType method
	changes in CDT 7.0.

2009-12-22  Andrew Overholt  <overholt@redhat.com>

	* src/org/eclipse/linuxtools/internal/cdt/libhover/LibHover.java (getMemberSummary):
	Revert Helios-only change on trunk.

2009-12-17  Andrew Overholt  <overholt@redhat.com>

	* src/org/eclipse/linuxtools/internal/cdt/libhover/LibHover.java (getMemberSummary):
	Remove unnecessary catch block.

2009-09-23  Jeff Johnston  <jjohnstn@redhat.com>

	* META-INF/MANIFEST.MF: Load plugin if any of its classes are used.
	* src/org/eclipse/linuxtools/cdt/libhover/LibhoverPlugin.java (LibhoverPlugin): Set
	plugin in constructor. 
	* src/org/eclipse/linuxtools/internal/cdt/libhover/LibHover.java (resolveArgs): Change
	to resolve template parms to actual types where known. 
	(isParmMatch): Resolve the member prototype using template types so we are comparing
	apples to apples.
	(getMemberSummary): Change calls to isParmMatch and resolveArgs. 
	* src/org/eclipse/linuxtools/internal/cdt/libhover/LibHoverLibrary.java (getHoverInfo): Add
	code to try accessing a path locally within the plugin, then try the file system. 

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

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

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

	* META-INF/MANIFEST.MF: Bump release to 1.0.3. 
	
2009-07-30  Jeff Johnston  <jjohnstn@redhat.com>

	Refactor to hide internal classes in new packages.
	
	* src/org/eclipse/linuxtools/cdt/libhover/LibHover.java: Removed.
	* src/org/eclipse/linuxtools/cdt/libhover/LibHoverLibrary.java: Removed.
	* src/org/eclipse/linuxtools/cdt/libhover/LibHoverMessages.java: Removed.
	* src/org/eclipse/linuxtools/cdt/libhover/LibHoverMessages.properties: Removed.
	* src/org/eclipse/linuxtools/cdt/libhover/preferences/CheckboxFieldEditor.java: Removed.
	* src/org/eclipse/linuxtools/cdt/libhover/preferences/LibHoverPreferencePage.java: Removed.
	* src/org/eclipse/linuxtools/cdt/libhover/preferences/PreferenceConstants.java: Removed.
	* src/org/eclipse/linuxtools/cdt/libhover/preferences/PreferenceInitializer.java: Removed.
	* src/org/eclipse/linuxtools/cdt/libhover/properties/LibHoverPropertyPage.java: Removed.
	* src/org/eclipse/linuxtools/internal/cdt/libhover/LibHover.java: New file.
	* src/org/eclipse/linuxtools/internal/cdt/libhover/LibHoverLibrary.java: New file.
	* src/org/eclipse/linuxtools/internal/cdt/libhover/LibHoverMessages.java: New file.
	* src/org/eclipse/linuxtools/internal/cdt/libhover/LibHoverMessages.properties: New file.
	* plugin.xml: Changed to match new packages. 
	* src/org/eclipse/linuxtools/internal/cdt/libhover/preferences/CheckboxFieldEditor.java: New file. 
	* src/org/eclipse/linuxtools/internal/cdt/libhover/preferences/LibHoverPreferencePage.java: New file.
	* src/org/eclipse/linuxtools/internal/cdt/libhover/preferences/PreferenceConstants.java: New file.
	* src/org/eclipse/linuxtools/internal/cdt/libhover/preferences/PreferenceInitializer.java: New file.
	* src/org/eclipse/linuxtools/internal/cdt/libhover/properties/LibHoverPropertyPage.java: New file.
	

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

	* src/org/eclipse/linuxtools/cdt/libhover/LibHover.java (getMemberSummary): Fix compiler warnings. 
	(getFunctionInfo): Ditto.
	* src/org/eclipse/linuxtools/cdt/libhover/preferences/CheckboxFieldEditor.java (doLoad): Ditto. 
	(doLoadDefault): Ditto.
	(adjustForNumColumns): Ditto.
	* src/org/eclipse/linuxtools/cdt/libhover/properties/LibHoverPropertyPage.java (updateCheckboxData): Ditto. 

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

	* src/org/eclipse/linuxtools/cdt/libhover/LibHover.java (getFunctionInfo): Add logic
	to find the qualified name of the class, even when namespaces are being used.
	
2009-05-08  Jeff Johnston  <jjohnstn@redhat.com>

	* src/org/eclipse/linuxtools/cdt/libhover/LibHover.java (resolveArgs): New method.
	(isParmMatch): Ditto. 
	(getMemberSummary): Add parameter matching support and template resolution.
	(getFunctionInfo): Add AST logic to resolve member name for C++.
	* src/org/eclipse/linuxtools/cdt/libhover/LibHoverLibrary.java (resolveTemplateTypes):
	New method. 
	(getClassInfo): Add additional parameter of template types and fill in.
	* src/org/eclipse/linuxtools/cdt/libhover/MemberInfo.java (getReturnType): New method.
	(setParamTypes): Ditto. 
	(getParamTypes): Ditto.

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

	* schema/org.eclipse.linuxtools.cdt.libhover.library.exsd: Change description for
	location field which now points to a serialized LibHoverInfo instance rather than
	xml.
	* src/org/eclipse/linuxtools/cdt/libhover/ClassInfo.java: New file.
	* src/org/eclipse/linuxtools/cdt/libhover/FunctionInfo.java: New file.
	* src/org/eclipse/linuxtools/cdt/libhover/HelpBook.java: New file.
	* src/org/eclipse/linuxtools/cdt/libhover/LibHoverInfo.java: New file.
	* src/org/eclipse/linuxtools/cdt/libhover/LibHoverLibrary.java: New file.
	* src/org/eclipse/linuxtools/cdt/libhover/MemberInfo.java: New file.
	* src/org/eclipse/linuxtools/cdt/libhover/TypedefInfo.java: New file.
	* src/org/eclipse/linuxtools/cdt/libhover/utils/BuildFunctionInfos.java: New file to
	create serialized LibHoverInfo file from an xml file in standard function format
	used by previous version of LibHover.
	* META-INF/MANIFEST.MF: Add additional dependencies and bump version to 1.0.2.
	* src/org/eclipse/linuxtools/cdt/libhover/LibHover.java (isCPPCharacter): New method.
	(EnclosingASTNameJob): New internal class to query the AST for IASTName
	for a symbol in the document.
	(ASTDeclarationFinderJob): New internal class to get the declaration of a symbol from
	the AST.
	(getMemberSummary): New method to get the summary of a C++ method. 
	(getLibHoverDocs): Modified to no longer parse xml documentation.  It now expects
	documentation to be in LibHoverInfo format, serialized via Java.  The method leaves
	reading of the actual serialized info to LibHoverLibrary.
	(getFunctionSummary): Rewritten to fetch info from the new LibHoverInfo class and
	to handle C++.
	(getMatchingFunctions): Ditto. 
	(FunctionSummary): Added a boolean to mark whether the prototype already has
	brackets in it.
	(FunctionSummary.FunctionPrototypeSummary.getPrototypeString):  Use new boolean
	to determine whether to add brackets or not. 
	(getFunctionInfo): Add C++ support.

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

	* META-INF/MANIFEST.MF: Add .qualifier to version and bump to 1.0.1.

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

	* META-INF/MANIFEST.MF: Use bundleName and provider from plugin.properties. Add
	"(Incubation)".
	* plugin.properties: Initial import.

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

	* plugin.xml: Remove libhover property and preferences pages which are not needed since
	C/C++ Documentation properties page does the job.
	* src/org/eclipse/linuxtools/cdt/libhover/LibHover.java:
	(getMatchingFunctions): Pass document to getFunctionSummaryFromNode.
	(constructTypes): Add groupsynopsis.
	(getFunctionInfo): Pass document to getFunctionSummaryFromNode.
	(getFunctionSummaryFromNode): Add groupsynopsis support.

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

	* plugin.properties: New file.
	* src/org/eclipse/linuxtools/cdt/libhover/preferences/CheckboxFieldEditor.java: New file.
	* build.properties: Add plugin.properties to list of binary files.
	* META-INF/MANIFEST.MF: Add Bundle-Localization statement.
	* plugin.xml: Use translatable names for preference and property pages.
	* schema/org.eclipse.linuxtools.cdt.libhover.library.exsd: Make id and name required.
	* src/org/eclipse/linuxtools/cdt/libhover/LibHover.java:
	* src/org/eclipse/linuxtools/cdt/libhover/LibHoverMessages.java: Fix bundle name.
	* src/org/eclipse/linuxtools/cdt/libhover/LibHoverMessages.properties: New messages.
	* src/org/eclipse/linuxtools/cdt/libhover/LibhoverPlugin.java (getID): New method.
	* src/org/eclipse/linuxtools/cdt/libhover/preferences/LibHoverPreferencePage.java (createFieldEditors):
	Rewrite to use new CheckboxFieldEditor.
	* src/org/eclipse/linuxtools/cdt/libhover/preferences/PreferenceConstants.java: Add P_LIBHOVER.
	* src/org/eclipse/linuxtools/cdt/libhover/preferences/PreferenceInitializer.java (initializeDefaultPreferences):
	Set up an unused default string.
	* src/org/eclipse/linuxtools/cdt/libhover/properties/LibHoverPropertyPage.java: Rewritten to use the
	CheckboxFieldEditor widgets on a property page.

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

	* build.properties: Specify javacSource and javacTarget to be 1.5.

2008-09-19  Jeff Johnston  <jjohnstn@redhat.com>

	* src/org/eclipse/linuxtools/cdt/libhover/LibHover.java: Initial implementation moved
	org.eclipse.cdt.linuxtools.autotools.
	* src/org/eclipse/linuxtools/cdt/libhover/LibHoverMessages.java: Ditto.
	* src/org/eclipse/linuxtools/cdt/libhover/LibHoverMessages.properties: Ditto.
	* src/org/eclipse/linuxtools/cdt/libhover/LibHoverPlugin.java: New file.
	* META-INF/MANIFEST.MF: Ditto.
	* schema/org.eclipse.linuxtools.cdt.libhover.library.exsd: Ditto.
	* about.html, build.properties, plugin.xml, plugin.properties: Ditto.
	* src/org/eclipse/linuxtools/cdt/libhover/preferences/LibHoverPreferencesPage.java: Ditto.
	* src/org/eclipse/linuxtools/cdt/libhover/preferences/PreferenceConstants.java: Ditto.
	* src/org/eclipse/linuxtools/cdt/libhover/preferences/PreferenceInitializer.java: Ditto.
	* src/org/eclipse/linuxtools/cdt/libhover/properties/LibHoverPropertyPage.java: Ditto.
