### Adding launchers to the platform

Your plug-in can add launch configuration types to the platform using the org.eclipse.debug.core.launchConfigurationTypes extension point. This extension point allows you to declare a configuration type using a unique id. You must provide a corresponding implementation of ILaunchConfigurationDelegate. The delegate is responsible for launching its launch configuration in a specified mode. Optionally, you can implement ILaunchConfigurationDelegate2, which enhances the delegate interface to allow your delegate to abort a launch, build relevant projects in the workspace before a launch, and control the creation of the launch object that is used in a launch.

In addition to defining the delegate, you can specify which launch modes are supported by your delegate, and a name that should be used when showing launchers of this type to the user.

The following markup shows how the Java tools declare a Java launch configuration for launching local Java programs:

    <extension point = "org.eclipse.debug.core.launchConfigurationTypes">
       <launchConfigurationType
       	   id="org.eclipse.jdt.launching.localJavaApplication"
    	   name="%localJavaApplication"
    	   delegate="org.eclipse.jdt.internal.launching.JavaLocalApplicationLaunchConfigurationDelegate"
    	   modes= "run, debug"
    	   sourceLocatorId="org.eclipse.jdt.launching.sourceLocator.JavaSourceLookupDirector"
           sourcePathComputerId="org.eclipse.jdt.launching.sourceLookup.javaSourcePathComputer">
       </launchConfigurationType>
    </extension>

This extension defines a launch configuration delegate that can be used to run or debug programs that are launched using the local Java launch configuration.

#### Defining new launch modes

We mentioned previously that the platform defines launch modes for running, debugging, or profiling a program. These modes are defined using the org.eclipse.debug.core.launchModes extension point. This extension point allows you to declare a launch mode by defining its string mode name and the label that should be shown to the user to describe the mode. The following markup shows the definition of the platform's three standard launch modes:

    <extension point="org.eclipse.debug.core.launchModes">
    	<launchMode
    		label="%run"
    		mode="run">
    	</launchMode>
    	<launchMode
    		label="%debug"
    		mode="debug">
    	</launchMode>
    	<launchMode
    		label="%profile"
    		mode="profile">
    	</launchMode>
    </extension>

Note that the mode is not associated with any particular launch configuration type. As shown earlier, that association occurs when a launch delegate is specified for a configuration type.

#### Defining launch delegates

Since launch modes can be specified independently of launch configuration types, it's possible that new modes are defined that are not implemented by the original delegate for a launch configuration. In this case, a plug-in may define a launch delegate that implements a particular mode for a particular launch configuration type. This can be done using the org.eclipse.debug.core.launchDelegates extension point. This extension point allows you to define a launch delegate that implements the specified modes for a given configuration type. The following markup shows how you could define a delegate for profiling a local Java application:

    <extension point="org.eclipse.debug.core.launchDelegates">
      <launchDelegate
       id="com.example.MyJavaProfileDelegate"
       delegate="com.example.MyJavaProfileDelegate"
       type="org.eclipse.jdt.launching.localJavaApplication"
       modes="profile">
      </launchDelegate>
     </extension>

The specification of the delegate is similar to the way it is done when defining a launch configuration type, except that in this case the type of launch configuration is specified along with the supported modes. As seen previously, the delegate must implement ILaunchConfigurationDelegate, and can optionally implement ILaunchConfigurationDelegate2 for more control over the launch sequence.

#### Other references

We Have Lift-off: The Launching Framework in Eclipse provides a start to finish example for defining your own launch type.