[//]: # (title: Run Configurations Tutorial) These series of steps show how to register and implement a simple Run Configuration. Run Configurations are used to run internal and external processes from within IntelliJ Platform based products. To get familiar with the concept of a Run Configuration refer [Run/Debug Configuration](https://www.jetbrains.com/idea/help/run-debug-configuration.html) section of [IntelliJ IDEA Web Help](https://www.jetbrains.com/idea/help/intellij-idea.html) ## Pre-Requirements Create an empty plugin project as described in [Creating a Plugin Project](getting_started.md). ## Register a New ConfigurationType Add new `configurationType` extension to the [plugin.xml](https://github.com/JetBrains/intellij-sdk-code-samples/blob/main/run_configuration/src/main/resources/META-INF/plugin.xml) ```xml ``` ## Implement ConfigurationType Implement [`ConfigurationType`](upsource:///platform/lang-api/src/com/intellij/execution/configurations/ConfigurationType.java) interface registered in the Step 1. ```java public class DemoRunConfigurationType implements ConfigurationType { @Override public String getDisplayName() { return "Demo"; } @Override public String getConfigurationTypeDescription() { return "Demo Run Configuration Type"; } @Override public Icon getIcon() { return AllIcons.General.Information; } @NotNull @Override public String getId() { return "DemoRunConfiguration"; } @Override public ConfigurationFactory[] getConfigurationFactories() { return new ConfigurationFactory[]{new DemoConfigurationFactory(this)}; } } ``` ## Implement a ConfigurationFactory Implement a new [`ConfigurationFactory`](upsource:///platform/lang-api/src/com/intellij/execution/configurations/ConfigurationFactory.java) through which custom run configurations will be created. ```java public class DemoConfigurationFactory extends ConfigurationFactory { private static final String FACTORY_NAME = "Demo configuration factory"; protected DemoConfigurationFactory(ConfigurationType type) { super(type); } @Override public RunConfiguration createTemplateConfiguration(Project project) { return new DemoRunConfiguration(project, this, "Demo"); } @Override public String getName() { return FACTORY_NAME; } } ``` ## Implement a Run Configuration To make your changes visible from the UI, implement a new Run Configuration. **Note:** In most of the cases you can derive a custom Run Configuration class from the [`RunConfigurationBase`](upsource:///platform/lang-api/src/com/intellij/execution/configurations/RunConfigurationBase.java). If you need to implement specific settings externalization rules and I/O behaviour, use [`RunConfiguration`](upsource:///platform/lang-api/src/com/intellij/execution/configurations/RunConfiguration.java) interface. ```java public class DemoRunConfiguration extends RunConfigurationBase { protected DemoRunConfiguration(Project project, ConfigurationFactory factory, String name) { super(project, factory, name); } @NotNull @Override public SettingsEditor getConfigurationEditor() { return new DemoSettingsEditor(); } @Override public void checkConfiguration() throws RuntimeConfigurationException { } @Nullable @Override public RunProfileState getState(@NotNull Executor executor, @NotNull ExecutionEnvironment executionEnvironment) throws ExecutionException { return null; } } ``` ## Create and Implement Run Configuration UI Form Make sure _UI Designer_ plugin is [enabled](https://www.jetbrains.com/help/idea/managing-plugins.html). Create a new [UI form](https://www.jetbrains.com/help/idea/designing-gui-major-steps.html) that defines, how an inner part of the new Run Configuration should look like. Default Run Configuration will be looking like this: ![Default Run Configuration Look](ui_form.png) ## Bind the UI Form The UI Form should be bound with a Java class responsible for handling UI components logic. ```java public class DemoSettingsEditor extends SettingsEditor { private JPanel myPanel; private LabeledComponent myMainClass; @Override protected void resetEditorFrom(DemoRunConfiguration demoRunConfiguration) { } @Override protected void applyEditorTo(DemoRunConfiguration demoRunConfiguration) throws ConfigurationException { } @NotNull @Override protected JComponent createEditor() { return myPanel; } private void createUIComponents() { myMainClass = new LabeledComponent(); myMainClass.setComponent(new TextFieldWithBrowseButton()); } } ``` ## Compile and Run the Plugin Refer to [Running and Debugging a Plugin](running_and_debugging_a_plugin.md). After going through the steps described above you can create a custom Run Configuration from your plugin. ![New Run Configuration Type](new_run_configuration.png)