Java SettingsEditor类代码示例

import com.intellij.openapi.options.SettingsEditor; //导入依赖的package包/类
@NotNull
@Override
public final SettingsEditor<T> getConfigurationEditor() {
  final SettingsEditor<T> runConfigurationEditor = createConfigurationEditor();

  final SettingsEditorGroup<T> group = new SettingsEditorGroup<T>();

  // run configuration settings tab:
  group.addEditor(ExecutionBundle.message("run.configuration.configuration.tab.title"), runConfigurationEditor);

  // tabs provided by extensions:
  //noinspection unchecked
  PythonRunConfigurationExtensionsManager.getInstance().appendEditors(this, (SettingsEditorGroup)group);
  group.addEditor(ExecutionBundle.message("logs.tab.title"), new LogConfigurationPanel<T>());

  return group;
}
 

import com.intellij.openapi.options.SettingsEditor; //导入依赖的package包/类
@Override
public RunConfiguration createTemplateConfiguration(Project project) {
    return new RunConfigurationBase(project,this,"Perl RunConfiguration Template") {
        @NotNull
        @Override
        public SettingsEditor<? extends RunConfiguration> getConfigurationEditor() {
            return new PerlSettingsEditor();
        }

        @Override
        public void checkConfiguration() throws RuntimeConfigurationException {
        }

        @Nullable
        @Override
        public RunProfileState getState(Executor executor, ExecutionEnvironment executionEnvironment) throws ExecutionException {
            return new PerlRunProfileState(executionEnvironment);
        }

    };
}
 

import com.intellij.openapi.options.SettingsEditor; //导入依赖的package包/类
@Nullable
@Override
public SettingsEditor<AppEngineDeploymentConfiguration> createEditor(
    @NotNull DeploymentSource source,
    @NotNull RemoteServer<AppEngineServerConfiguration> server) {
  if (!(source instanceof AppEngineDeployable)) {
    logger.error(
        String.format(
            "Deployment source with name %s is not deployable to App Engine.",
            source.getPresentableName()));
    return null;
  }

  AppEngineDeployable gaeSource = (AppEngineDeployable) source;

  AppEngineEnvironment environment = gaeSource.getEnvironment();
  if (environment != null && environment.isFlexible()) {
    return new AppEngineFlexibleDeploymentEditor(project, gaeSource);
  }

  return new AppEngineStandardDeploymentEditor(project, gaeSource);
}
 

import com.intellij.openapi.options.SettingsEditor; //导入依赖的package包/类
@NotNull
@Override
public SettingsEditor<? extends RunConfiguration> getConfigurationEditor() {

    SettingsEditorGroup<RemoteRunConfiguration> settingsEditorGroup = new SettingsEditorGroup<>();
    settingsEditorGroup.addEditor(ExecutionBundle.message("run.configuration.configuration.tab.title"), new RunConfigurationEditor(getProject()));
    settingsEditorGroup.addEditor(ExecutionBundle.message("logs.tab.title"), new LogConfigurationPanel<>());
    return settingsEditorGroup;
}
 

import com.intellij.openapi.options.SettingsEditor; //导入依赖的package包/类
@Override
public SettingsEditor<GenericDebuggerRunnerSettings> getSettingsEditor(final Executor executor, RunConfiguration configuration) {
  if (configuration instanceof RunConfigurationWithRunnerSettings) {
    if (((RunConfigurationWithRunnerSettings)configuration).isSettingsNeeded()) {
      return new GenericDebuggerParametersRunnerConfigurable(configuration.getProject());
    }
  }
  return null;
}
 

import com.intellij.openapi.options.SettingsEditor; //导入依赖的package包/类
@NotNull
@Override
public SettingsEditor<? extends RunConfiguration> getConfigurationEditor() {
  SettingsEditorGroup<JarApplicationConfiguration> group = new SettingsEditorGroup<JarApplicationConfiguration>();
  group.addEditor(ExecutionBundle.message("run.configuration.configuration.tab.title"), new JarApplicationConfigurable(getProject()));
  JavaRunConfigurationExtensionManager.getInstance().appendEditors(this, group);
  group.addEditor(ExecutionBundle.message("logs.tab.title"), new LogConfigurationPanel<JarApplicationConfiguration>());
  return group;
}
 

import com.intellij.openapi.options.SettingsEditor; //导入依赖的package包/类
@Override
@NotNull
public SettingsEditor<? extends RunConfiguration> getConfigurationEditor() {
  SettingsEditorGroup<ApplicationConfiguration> group = new SettingsEditorGroup<ApplicationConfiguration>();
  group.addEditor(ExecutionBundle.message("run.configuration.configuration.tab.title"), new ApplicationConfigurable(getProject()));
  JavaRunConfigurationExtensionManager.getInstance().appendEditors(this, group);
  group.addEditor(ExecutionBundle.message("logs.tab.title"), new LogConfigurationPanel<ApplicationConfiguration>());
  return group;
}
 

import com.intellij.openapi.options.SettingsEditor; //导入依赖的package包/类
@NotNull
@Override
public SettingsEditor<? extends RunConfiguration> getConfigurationEditor() {
  SettingsEditorGroup<TestDiscoveryConfiguration> group = new SettingsEditorGroup<TestDiscoveryConfiguration>();
  group.addEditor(ExecutionBundle.message("run.configuration.configuration.tab.title"),
                  new TestDiscoveryConfigurable<TestDiscoveryConfiguration>(getProject()));
  JavaRunConfigurationExtensionManager.getInstance().appendEditors(this, group);
  group.addEditor(ExecutionBundle.message("logs.tab.title"), new LogConfigurationPanel<TestDiscoveryConfiguration>());
  return group;
}
 

import com.intellij.openapi.options.SettingsEditor; //导入依赖的package包/类
@Override
@NotNull
public SettingsEditor<? extends RunConfiguration> getConfigurationEditor() {
  SettingsEditorGroup<RemoteConfiguration> group = new SettingsEditorGroup<RemoteConfiguration>();
  group.addEditor(ExecutionBundle.message("run.configuration.configuration.tab.title"), new RemoteConfigurable(getProject()));
  group.addEditor(ExecutionBundle.message("logs.tab.title"), new LogConfigurationPanel<RemoteConfiguration>());
  return group;
}
 

import com.intellij.openapi.options.SettingsEditor; //导入依赖的package包/类
@NotNull
@Override
public SettingsEditor<DeployToServerRunConfiguration> getConfigurationEditor() {
  SettingsEditor<DeployToServerRunConfiguration> commonEditor
    = new DeployToServerSettingsEditor(myServerType, myDeploymentConfigurator, getProject());

  SettingsEditorGroup<DeployToServerRunConfiguration> group = new SettingsEditorGroup<DeployToServerRunConfiguration>();
  group.addEditor("Deployment", commonEditor);
  DeployToServerRunConfigurationExtensionsManager.getInstance().appendEditors(this, group);
  return group.getEditors().size() == 1 ? commonEditor : group;
}
 

import com.intellij.openapi.options.SettingsEditor; //导入依赖的package包/类
public <V extends U> void appendEditors(@NotNull final U configuration,
                                        @NotNull final SettingsEditorGroup<V> group) {
  for (T extension : getApplicableExtensions(configuration)) {
    @SuppressWarnings("unchecked")
    final SettingsEditor<V> editor = extension.createEditor((V)configuration);
    if (editor != null) {
      group.addEditor(extension.getEditorTitle(), editor);
    }
  }
}
 

import com.intellij.openapi.options.SettingsEditor; //导入依赖的package包/类
private SingleConfigurationConfigurable(RunnerAndConfigurationSettings settings, @Nullable Executor executor) {
  super(new ConfigurationSettingsEditorWrapper(settings), settings);
  myExecutor = executor;

  final Config configuration = getConfiguration();
  myDisplayName = getSettings().getName();
  myHelpTopic = "reference.dialogs.rundebug." + configuration.getType().getId();

  myBrokenConfiguration = configuration instanceof UnknownRunConfiguration;
  setFolderName(getSettings().getFolderName());

  setNameText(configuration.getName());
  myNameDocument.addDocumentListener(new DocumentAdapter() {
    @Override
    public void textChanged(DocumentEvent event) {
      setModified(true);
      if (!myChangingNameFromCode) {
        RunConfiguration runConfiguration = getSettings().getConfiguration();
        if (runConfiguration instanceof LocatableConfigurationBase) {
          ((LocatableConfigurationBase) runConfiguration).setNameChangedByUser(true);
        }
      }
    }
  });

  getEditor().addSettingsEditorListener(new SettingsEditorListener<RunnerAndConfigurationSettings>() {
    @Override
    public void stateChanged(SettingsEditor<RunnerAndConfigurationSettings> settingsEditor) {
      myValidationResultValid = false;
    }
  });
}
 

import com.intellij.openapi.options.SettingsEditor; //导入依赖的package包/类
@Override
protected SettingsEditor<? extends RunConfiguration> createConfigurationEditor() {
  RestConfigurationEditor editor = new RestConfigurationEditor(getProject(), this, new DocutilsTasksModel());
  editor.setConfigurationName("Docutils task");
  editor.setInputDescriptor(FileChooserDescriptorFactory.createSingleFileNoJarsDescriptor());
  editor.setOutputDescriptor(FileChooserDescriptorFactory.createSingleFileNoJarsDescriptor());
  return editor;
}
 

import com.intellij.openapi.options.SettingsEditor; //导入依赖的package包/类
@Override
protected SettingsEditor<? extends RunConfiguration> createConfigurationEditor() {
  RestConfigurationEditor editor = new RestConfigurationEditor(getProject(), this, new SphinxTasksModel());
  editor.setConfigurationName("Sphinx task");
  editor.setOpenInBrowserVisible(false);
  editor.setInputDescriptor(FileChooserDescriptorFactory.createSingleFolderDescriptor());
  editor.setOutputDescriptor(FileChooserDescriptorFactory.createSingleFolderDescriptor());
  return editor;
}
 

import com.intellij.openapi.options.SettingsEditor; //导入依赖的package包/类
@NotNull
@Override
public SettingsEditor<? extends RunConfiguration> getConfigurationEditor() {
  Project project = getProject();
  AndroidRunConfigurationEditor<AndroidRunConfiguration> editor =
    new AndroidRunConfigurationEditor<AndroidRunConfiguration>(project, Predicates.<AndroidFacet>alwaysFalse());
  editor.setConfigurationSpecificEditor(new ApplicationRunParameters(project, editor.getModuleSelector()));
  return editor;
}