2011-10-31  Jeff Johnston  <jjohnstn@redhat.com>

	Bug #362125
	
	* src/org/eclipse/linuxtools/internal/valgrind/ui/CoreMessagesViewer.java (CoreMessagesViewer): Use an
	ImageRegistry to store the Valgrind error icon.
	(.getImage): Get error image from image registry.
	* src/org/eclipse/linuxtools/internal/valgrind/ui/ValgrindUIPlugin.java (getImageDescriptor): New method.

2011-10-12  Jeff Johnston  <jjohnstn@redhat.com>

	Bug #360085
	
	* plugin.xml: Add new annotation icons for Valgrind markers.
	* icons/valgrind-error.gif: New file.
	* icons/valgrind-warning.gif: New file.
	* icons/valgrind-info.gif: New file.
	* plugin.properties: Add new labels for new additions to plugin.xml.

2011-09-12  Jeff Johnston  <jjohnstn@redhat.com>

	* src/org/eclipse/linuxtools/internal/valgrind/ui/ValgrindViewPart.java (refreshView): Add
	check for empty messages array in addition to messages being null.

2010-08-03  Elliott Baron  <ebaron@fedoraproject.org>

	* src/org/eclipse/linuxtools/valgrind/ui/ValgrindUIConstants.java: New file.
	* src/org/eclipse/linuxtools/internal/valgrind/ui/ValgrindUIPlugin.java: Extract view ID. 

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

	* META-INF/MANIFEST.MF: Bump version to 0.7.0.
	* src/org/eclipse/linuxtools/internal/valgrind/ui/CoreMessagesViewer.java: Remove unused import.

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

	Bug #314376
	* src/org/eclipse/linuxtools/internal/valgrind/ui/CoreMessagesViewer.java: Do not extend TreeViewer,
		act as wrapper instead.
	* src/org/eclipse/linuxtools/internal/valgrind/ui/ValgrindViewPart.java (refreshView): Change access to TreeViewer.
	(showCorePage): Likewise.

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>

	Bug #285861

	* plugin.properties: Change Provider to Eclipse.

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

	* src/org/eclipse/linuxtools/valgrind/ui: Removed.
	* src/org/eclipse/linuxtools/internal/valgrind/ui: New package.
	* .project: Added API analysis.
	* META-INF/MANIFEST.MF: Export internal package.
	* plugin.xml: Update class references.

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

	* META-INF/MANIFEST.MF: New dependencies. 
	* CoreMessagesViewer.java (.doubleClick): Recreate SourceLocator once disposed.

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

	* CoreMessagesViewer.java: New file.
	* META-INF/MANIFEST.MF: New deps.
	* ValgrindViewPart.java: Handle the work previously done in MemcheckViewPart.

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

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

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

	* CollapseAction.java: New file.
	* ExpandAction.java: New file.
	* messages.properties: New strings.
	* ValgrindViewPart.java (createPartControl): Remove margins for dynamic content.

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

	* ValgrindViewPart.java (createDynamicContent): Call dispose on old dynamicView.

2009-02-27  Elliott Baron  <ebaron@redhat.com>

	* ValgrindUIPlugin.java: Added some documentation.

2009-02-12  Elliott Baron  <ebaron@redhat.com>

	* schema/org.eclipse.linuxtools.valgrind.ui.valgrindToolViews.exsd: Renamed.
	* schema/valgrindToolViews.exsd: New file.
	* ValgrindUIPlugin.java: Refactoring.

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

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