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

	* src/org/eclipse/linuxtools/profiling/ui/ProfileUIUtils.java (findFunctionsInProject): 
	Add a catchall for any type of java.lang.Exception and remove the catch for
	DomException to allow the code to work both in CDT 8.0.0 and prior releases of CDT.

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

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

2010-05-28  Elliott Baron  <ebaron@fedoraproject.org>

	Bug #314680
	* META-INF/MANIFEST.MF: Added new dependency.
	* src/org/eclipse/linuxtools/profiling/ui/ProfileUIUtils.java (openEditorAndSelect): Account
		for source lookup returning LocalFileStorage.

2010-05-06  Roland Grunberg  <rgrunber@redhat.com>

	* src/org/eclipse/linuxtools/profiling/ui/ProfileUIUtils.java (findFunctionsInProject):
		Use a stronger comparison when determining if two files have the same path.

2010-04-08  Roland Grunberg  <rgrunber@redhat.com>

	* META-INF/MANIFEST.MF: Added imports needed for using CDT Indexer.
	* src/org/eclipse/linuxtools/profiling/ui/ProfileUIUtils.java
		(findCProjectWithAbsolutePath): New, for purpose of locating an ICProject.
		(findFunctionsInProject): New, for purpose of finding data needed to link
		to source code of a function call.

2010-03-22  Roland Grunberg  <rgrunber@redhat.com>

	* src/org/eclipse/linuxtools/profiling/ui/ProfileUIUtils.java:
		(openEditorAndSelect): Overload to take an offset and length.

2009-08-11  Elliott Baron  <ebaron@redhat.com>

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

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

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

2009-07-30  Elliott Baron  <ebaron@redhat.com>

	* src/org/eclipse/linuxtools/profiling/ui/ProfileUIPlugin.java: Removed.
	* src/org/eclipse/linuxtools/internal/profiling/ui/ProfileUIPlugin.java: New file.
	* .project: Enabled API analysis.
	* META-INF/MANIFEST.MF: Export internal package.
	* src/org/eclipse/linuxtools/profiling/ui/ProfileUIUtils.java: Import internal class.

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

	* META-INF/MANIFEST.MF: Add core.resources to deps.

2009-04-30  Elliott Baron  <ebaron@redhat.com>

	* META-INF/MANIFEST.MF: New deps.
	* ProfileUIUtils.java (openEditorAndSelect): Overloaded to take ISourceLookupResult.

2009-04-03  Elliott Baron  <ebaron@redhat.com>

	* META-INF/MANIFEST.MF: 0.2.0 version.

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

	* META-INF/MANIFEST.MF: Changed version to 0.1.0.
	* build.properties: Include about.html.
	* about.html: Added.