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

	* src/org/eclipse/linuxtools/profiling/launch/IRemoteProxyManager.java: Add URI
	apis.
	* src/org/eclipse/linuxtools/profiling/launch/RemoteProxyManager.java (getFileProxy): Ditto. 
	(getLauncher): Ditto.
	(getOS): Ditto.
	
2011-11-11  Jeff Johnston  <jjohnstn@redhat.com>

	* schema/RemoteProxyManager.exsd: Switch to specify URI scheme instead of project nature.
	* src/org/eclipse/linuxtools/profiling/launch/RemoteProxyManager.java: Rewrite to look for
	project URI scheme rather than using project nature.
	* src/org/eclipse/linuxtools/profiling/launch/IRemoteProxyManager.java (SCHEME_ID): New define.

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

	* src/org/eclipse/linuxtools/profiling/launch/IRemoteCommandLauncher.java (execute): Change to
	return Process.
	* src/org/eclipse/linuxtools/internal/profiling/launch/LocalLauncher.java (execute): Ditto.
	* src/org/eclipse/linuxtools/profiling/launch/IProcess.java: Removed.
	* src/org/eclipse/linuxtools/internal/profiling/launch/LocalProcess.java: Ditto.
	
2011-10-11  Jeff Johnston  <jjohnstn@redhat.com>

	* src/org/eclipse/linuxtools/profiling/launch/RemoteProxyManager.java (getLauncher): Add
	missing logic for RDT projects.
	(getOS): Ditto.
	(RDT_SYNC_NATURE): New nature to look for.
	(getFileProxy): Add support for RDT_SYNC_NATURE.

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

	* src/org/eclipse/linuxtools/profiling/launch/RemoteProxyManager.java (getRemoteManager): Fill in
	logic to use RemoteProxyManager extension.
	* src/org/eclipse/linuxtools/profiling/launch/IRemoteProxyManager.java (EXTENSION_POINT_ID): New field.
	(MANAGER_NAME): Ditto.
	(NATURE_ID): Ditto.
	* build.properties: Add schema and plugin.xml.
	* plugin.xml: New file with RemoteProxyManager extension.
	* META-INF/MANIFEST.MF: Make singleton and bump version.
	* schema/RemoteProxyManager.exsd: New file.

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

	* META-INF/MANIFEST.MF: Add new dependencies.
	* src/org/eclipse/linuxtools/profiling/launch/RemoteProxyManager.java: New file.
	* src/org/eclipse/linuxtools/profiling/launch/IRemoteProxyManager.java: New file.
	* src/org/eclipse/linuxtools/profiling/launch/IRemoteFileProxy.java: New file.
	* src/org/eclipse/linuxtools/profiling/launch/IRemoteCommandLauncher.java: New file.
	* src/org/eclipse/linuxtools/profiling/launch/IProcess.java: New file.
	* src/org/eclipse/linuxtools/internal/profiling/launch/LocalProcess.java: New file.
	* src/org/eclipse/linuxtools/internal/profiling/launch/LocalLauncher.java: New file.
	* src/org/eclipse/linuxtools/internal/profiling/launch/LocalFileProxy.java: New file.

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

	* META-INF/MANIFEST.MF: Bump version.
	* src/org/eclipse/linuxtools/profiling/launch/ProfileLaunchShortcut.java (createConfiguration): Change deprecated method. 

2009-12-08  Roland Grunberg  <rgrunber@redhat.com>

	* src/org/eclipse/linuxtools/profiling/launch/ProfileLaunchConfigurationDelegate.java:
		Get rid of error checking for (createProcess) since subprocess cannot be null as long as initial command is 'exec'.

2009-12-08  Charley Wang  <chwang@redhat.com>

	* src/org/eclipse/linuxtools/profiling/launch/ProfileLaunchConfigurationDelegate.java: Change delegate to launch by creating a temporary shell script, rather than launch directly.
	Make generateCommand public
	Do not setExecutable.

2009-12-06  rgrunber  <rgrunber@redhat.com>

	* src/org/eclipse/linuxtools/profiling/launch/ProfileLaunchConfigurationDelegate.java 
		(createProcess): Return null when a process fails to execute and let user decide action to take.

2009-11-26  Charley Wang  <chwang@redhat.com>

	* META-INF/MANIFEST.MF: Add org.eclipse.cdt.core, which seems needed with some versions and not with others.
	* src/org/eclipse/linuxtools/profiling/launch/ProfileLaunchConfigurationDelegate.java: Add generateCommand abstract function for command generation. This is called by createProcess()

2009-11-23  Charley Wang  <chwang@redhat.com>

	* src/org/eclipse/linuxtools/profiling/launch/ProfileLaunchConfigurationTab.java: Add (Currently empty) ProfileLaunchConfigurationTab
	* src/org/eclipse/linuxtools/profiling/launch/ProfileLaunchShortcut.java: Improve documentation on abstract functions
	* src/org/eclipse/linuxtools/profiling/launch/ProfileLaunchConfigurationDelegate.java: Add ProfileLaunchConfigurationDelegate. This class contains functions that Roland and I had difficulty with when we were creating the SystemTap plugin, namely the creation and reading of a process. 

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/launch/Messages.java: Removed.
	* src/org/eclipse/linuxtools/profiling/launch/messages.properties: Removed.
	* src/org/eclipse/linuxtools/profiling/launch/ProfileLaunchPlugin.java: Removed.
	* src/org/eclipse/linuxtools/internal/profiling/launch/Messages.java: New file.
	* src/org/eclipse/linuxtools/internal/profiling/launch/messages.properties: New file.
	* src/org/eclipse/linuxtools/internal/profiling/launch/ProfileLaunchPlugin.java: New file.
	* .project: Enabled API analysis.
	* META-INF/MANIFEST.MF: Export internal package.
	* src/org/eclipse/linuxtools/profiling/launch/ProfileLaunchShortcut.java (findLaunchConfiguration): Replace deprecated method calls. 

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.