com.intellij.openapi.options.UnnamedConfigurable Java Examples

public VcsConfigurationsDialog(Project project, @Nullable JComboBox vcses, VcsDescriptor selectedVcs) {
  super(project, false);
  myProject = project;

  VcsDescriptor[] abstractVcses = collectAvailableNames();
  initList(abstractVcses);

  initVcsConfigurable(abstractVcses);

  updateConfiguration();
  myVcsesToUpdate = vcses;
  for (String vcsName : myVcsNameToConfigurableMap.keySet()) {
     UnnamedConfigurable configurable = myVcsNameToConfigurableMap.get(vcsName);
     if (configurable != null && configurable.isModified()) configurable.reset();
  }
  updateConfiguration();
  if (selectedVcs != null){
    myVcses.setSelectedValue(selectedVcs, true);
  }
  init();
  setTitle(VcsBundle.message("dialog.title.version.control.configurations"));
}
 

public void apply() throws ConfigurationException {
  ExportToHTMLSettings exportToHTMLSettings = ExportToHTMLSettings.getInstance(myProject);

  if (myRbCurrentFile.isSelected()){
    exportToHTMLSettings.setPrintScope(PrintSettings.PRINT_FILE);
  }
  else if (myRbSelectedText.isSelected()){
    exportToHTMLSettings.setPrintScope(PrintSettings.PRINT_SELECTED_TEXT);
  }
  else if (myRbCurrentPackage.isSelected()){
    exportToHTMLSettings.setPrintScope(PrintSettings.PRINT_DIRECTORY);
  }

  exportToHTMLSettings.setIncludeSubpackages(myCbIncludeSubpackages.isSelected());
  exportToHTMLSettings.PRINT_LINE_NUMBERS = myCbLineNumbers.isSelected();
  exportToHTMLSettings.OPEN_IN_BROWSER = myCbOpenInBrowser.isSelected();
  exportToHTMLSettings.OUTPUT_DIRECTORY = myTargetDirectoryField.getText();
  for (UnnamedConfigurable printOption : myExtensions) {
    printOption.apply();
  }
}
 

private void updateVcsConfigurable() {
  if (myVcsConfigurable != null) {
    myVcsConfigurablePlaceholder.remove(myVcsConfigurableComponent);
    myVcsConfigurable.disposeUIResources();
    myVcsConfigurable = null;
  }
  VcsDescriptor wrapper = (VcsDescriptor) myVCSComboBox.getSelectedItem();
  if (wrapper != null && (! wrapper.isNone())) {
    final AbstractVcs vcs = myVcsManager.findVcsByName(wrapper.getName());
    if (vcs != null) {
      UnnamedConfigurable configurable = vcs.getRootConfigurable(myMappingCopy);
      if (configurable != null) {
        myVcsConfigurable = configurable;
        myVcsConfigurableComponent = myVcsConfigurable.createComponent();
        myVcsConfigurablePlaceholder.add(myVcsConfigurableComponent, BorderLayout.CENTER);
      }
    }
  }
  pack();
}
 

public void reset() {
  ExportToHTMLSettings exportToHTMLSettings = ExportToHTMLSettings.getInstance(myProject);

  myRbSelectedText.setEnabled(myIsSelectedTextEnabled);
  myRbSelectedText.setSelected(myIsSelectedTextEnabled);
  myRbCurrentFile.setEnabled(myFileName != null);
  myRbCurrentFile.setSelected(myFileName != null && !myIsSelectedTextEnabled);
  myRbCurrentPackage.setEnabled(myDirectoryName != null);
  myRbCurrentPackage.setSelected(myDirectoryName != null && !myIsSelectedTextEnabled && myFileName == null);
  myCbIncludeSubpackages.setSelected(exportToHTMLSettings.isIncludeSubdirectories());
  myCbIncludeSubpackages.setEnabled(myRbCurrentPackage.isSelected());

  myCbLineNumbers.setSelected(exportToHTMLSettings.PRINT_LINE_NUMBERS);
  myCbOpenInBrowser.setSelected(exportToHTMLSettings.OPEN_IN_BROWSER);

  myTargetDirectoryField.setText(exportToHTMLSettings.OUTPUT_DIRECTORY);

  for (UnnamedConfigurable printOption : myExtensions) {
    printOption.reset();
  }
}
 

@Override
protected JComponent createCenterPanel() {
  OptionGroup optionGroup = new OptionGroup(CodeEditorBundle.message("export.to.html.options.group"));

  myCbLineNumbers = new JCheckBox(CodeEditorBundle.message("export.to.html.options.show.line.numbers.checkbox"));
  optionGroup.add(myCbLineNumbers);

  for (UnnamedConfigurable printOption : myExtensions) {
    optionGroup.add(printOption.createComponent());
  }

  myCbOpenInBrowser = new JCheckBox(CodeEditorBundle.message("export.to.html.open.generated.html.checkbox"));
  optionGroup.add(myCbOpenInBrowser);

  return optionGroup.createPanel();
}
 

private void initExtensions() {
  final HaxeModuleSettings settings = HaxeModuleSettings.getInstance(myModule);
  final HaxeModuleConfigurationExtensionPoint[] extensionPoints = HaxeModuleConfigurationExtensionPoint.EP_NAME.getExtensions();

  if (extensionPoints.length > 0) {
    final GridLayoutManager layoutManager = new GridLayoutManager(extensionPoints.length, 1);
    myAdditionalComponentPanel.setLayout(layoutManager);
  }
  for (int i = 0; i < extensionPoints.length; i++) {
    HaxeModuleConfigurationExtensionPoint extensionPoint = extensionPoints[i];
    final GridConstraints gridConstraints = new GridConstraints();
    gridConstraints.setFill(GridConstraints.FILL_HORIZONTAL);
    gridConstraints.setRow(i);

    final UnnamedConfigurable configurable = extensionPoint.createConfigurable(settings);
    configurables.add(configurable);
    myAdditionalComponentPanel.add(configurable.createComponent(), gridConstraints);
  }
}
 

@Nullable
protected UnnamedConfigurable getItemConfigurable(final T item) {
  final Ref<UnnamedConfigurable> result = new Ref<UnnamedConfigurable>();
  TreeUtil.traverse((TreeNode)myTree.getModel().getRoot(), new TreeUtil.Traverse() {
    @Override
    public boolean accept(Object node) {
      final NamedConfigurable configurable = (NamedConfigurable)((DefaultMutableTreeNode)node).getUserObject();
      if (configurable.getEditableObject() == item) {
        result.set(((ItemConfigurable)configurable).myConfigurable);
        return false;
      }
      else {
        return true;
      }
    }
  });
  return result.get();
}
 

@Override
public JComponent createComponent() {
  JPanel panel = new JPanel(new VerticalLayout(/* gap= */ 0));
  for (UnnamedConfigurable configurable : getConfigurables()) {
    JComponent component = configurable.createComponent();
    if (component != null) {
      panel.add(component);
    }
  }
  return panel;
}
 

private void updateConfiguration() {
  int selectedIndex = myVcses.getSelectionModel().getMinSelectionIndex();
  final VcsDescriptor currentVcs;
  currentVcs = selectedIndex >= 0 ? (VcsDescriptor)(myVcses.getModel()).getElementAt(selectedIndex) : null;
  String currentName = currentVcs == null ? NONE : currentVcs.getName();
  if (currentVcs != null) {
    final UnnamedConfigurable unnamedConfigurable = myVcsNameToConfigurableMap.get(currentName);
    unnamedConfigurable.createComponent();
    unnamedConfigurable.reset();
  }
  final CardLayout cardLayout = (CardLayout)myVcsConfigurationPanel.getLayout();
  cardLayout.show(myVcsConfigurationPanel, currentName);
}
 

protected void doOKAction() {
  for (String vcsName : myVcsNameToConfigurableMap.keySet()) {
    UnnamedConfigurable configurable = myVcsNameToConfigurableMap.get(vcsName);
    if (configurable != null && configurable.isModified()) {
      try {
        configurable.apply();
      }
      catch (ConfigurationException e) {
        Messages.showErrorDialog(VcsBundle.message("message.text.unable.to.save.settings", e.getMessage()),
                                 VcsBundle.message("message.title.unable.to.save.settings"));
      }
    }
  }

  final JComboBox vcsesToUpdate = myVcsesToUpdate;
  if (vcsesToUpdate != null) {
    final VcsDescriptor wrapper = (VcsDescriptor) myVcses.getSelectedValue();
    vcsesToUpdate.setSelectedItem(wrapper);
    final ComboBoxModel model = vcsesToUpdate.getModel();
    for(int i = 0; i < model.getSize(); i++){
      final Object vcsWrapper = model.getElementAt(i);
      if (vcsWrapper instanceof VcsDescriptor){
        final VcsDescriptor defaultVcsWrapper = (VcsDescriptor) vcsWrapper;
        if (defaultVcsWrapper.equals(wrapper)){
          vcsesToUpdate.setSelectedIndex(i);
          break;
        }
      }
    }
  }

  super.doOKAction();
}
 

@RequiredUIAccess
@Override
public JComponent createComponent() {
  for (UnnamedConfigurable provider : getConfigurables()) {
    myAddonPanel.add(provider.createComponent(), new GridBagConstraints(0, GridBagConstraints.RELATIVE, 1, 1, 0, 0, GridBagConstraints.NORTHWEST,
                                                                          GridBagConstraints.NONE, new Insets(0,0,15,0), 0,0));
  }
  return myRootPanel;
}
 

@RequiredUIAccess
public static JComponent createComponent(@Nonnull UnnamedConfigurable configurable) {
  JComponent component = configurable.createComponent();
  if (component != null) {
    return component;
  }

  consulo.ui.Component uiComponent = configurable.createUIComponent();
  if (uiComponent != null) {
    return (JComponent)TargetAWT.to(uiComponent);
  }
  return null;
}
 

public ExportToHTMLDialog(String fileName, String directoryName, boolean isSelectedTextEnabled, Project project) {
  super(project, true);
  myProject = project;
  setOKButtonText(CodeEditorBundle.message("export.to.html.save.button"));
  myFileName = fileName;
  myDirectoryName = directoryName;
  this.myIsSelectedTextEnabled = isSelectedTextEnabled;
  setTitle(CodeEditorBundle.message("export.to.html.title"));
  myExtensions = new ArrayList<UnnamedConfigurable>();
  for (PrintOption extension : Extensions.getExtensions(PrintOption.EP_NAME)) {
    myExtensions.add(extension.createConfigurable());
  }
  init();
}
 

ConfigDialog(Project project, String dir, UnnamedConfigurable config) {
    super(project, false, IdeModalityType.MODELESS);
    this.config = config;
    init();
    setTitle(P4Bundle.message("vcsroot.dialog.title", dir));
    pack();
    centerRelativeToParent();
}
 

@Override
protected void dispose() {
  for (UnnamedConfigurable extension : myExtensions) {
    extension.disposeUIResources();
  }
  super.dispose();
}
 

@Nonnull
@Override
public UnnamedConfigurable createConfigurable(@Nonnull SandServerConfiguration configuration) {
  return new UnnamedConfigurable() {
    @RequiredUIAccess
    @Override
    public boolean isModified() {
      return false;
    }

    @RequiredUIAccess
    @Nullable
    @Override
    public Component createUIComponent() {
      return Label.create("Sand stub UI");
    }

    @RequiredUIAccess
    @Override
    public void apply() throws ConfigurationException {

    }

    @RequiredUIAccess
    @Override
    public void reset() {

    }
  };
}
 

@Override
protected List<UnnamedConfigurable> createConfigurables() {
  return ConfigurableWrapper.createConfigurables(EP_NAME);
}
 

@Nonnull
public abstract UnnamedConfigurable createConfigurable();
 

@Override
protected UnnamedConfigurable createConfigurable(StdArrangementRuleAliasToken item) {
  return new ArrangementRuleAliasConfigurable(mySettingsManager, myColorsProvider, item);
}
 

@Nonnull
@Override
public UnnamedConfigurable createConfigurable() {
  return new TestConfiguration();
}
 

@Nonnull
public abstract UnnamedConfigurable createConfigurable(@Nonnull C configuration);
 

@Nonnull
UnnamedConfigurable createConfigurable();
 

@Override
public UnnamedConfigurable createConfigurable(@NotNull HaxeModuleSettings settings) {
  return new HaxeFlexSDKConfigurable(settings);
}
 

public SyncProjectDialog(@NotNull Project project) {
    this.project = project;


    this.directoryMapping = createDirectoryMapping(project);
    final UnnamedConfigurable configurable =
            P4Vcs.getInstance(project).getRootConfigurable(directoryMapping);
    if (!(configurable instanceof P4VcsRootConfigurable)) {
        this.setupProblem = P4Bundle.getString("checkout.config.error.invalid-project");
        this.directoryField = null;
        this.dialog = null;
        this.configurable = null;
        return;
    }
    this.configurable = (P4VcsRootConfigurable) configurable;

    JComponent component = configurable.createComponent();
    if (component == null) {
        this.setupProblem = P4Bundle.getString("checkout.config.error.invalid-project");
        this.directoryField = null;
        this.dialog = null;
        return;
    }

    this.setupProblem = null;
    JPanel dirPanel = new JPanel(new BorderLayout());
    this.directoryField = new TextFieldWithBrowseButton();
    dirPanel.add(directoryField, BorderLayout.CENTER);
    directoryField.setButtonEnabled(true);
    directoryField.addBrowseFolderListener(
            P4Bundle.getString("checkout.config.directory.chooser.title"),
            P4Bundle.getString("checkout.config.directory.chooser.desc"),
            project,
            FileChooserDescriptorFactory.createSingleLocalFileDescriptor()
    );
    JLabel dirLabel = SwingUtil.createLabelFor(P4Bundle.getString("checkout.config.directory"), directoryField);
    dirPanel.add(dirLabel, BorderLayout.WEST);

    this.dialog = new DialogBuilder(project)
            .centerPanel(component)
            .title(P4Bundle.getString("checkout.config.title"));
    dialog.setNorthPanel(dirPanel);
}
 

@Override
public UnnamedConfigurable getConfigurable() {
  return new BlazeJavaUserSettingsConfigurable();
}
 

@Override
public UnnamedConfigurable getConfigurable() {
  return new BlazeUserSettingsConfigurable();
}
 

@Override
protected List<UnnamedConfigurable> createConfigurables() {
  return Arrays.stream(UiContributor.EP_NAME.getExtensions())
      .map(UiContributor::getConfigurable)
      .collect(toImmutableList());
}
 

/**
 * Returns the configurable to be shown in the VCS directory mapping dialog which should be displayed
 * for configuring VCS-specific settings for the specified root, or null if no such configuration is required.
 * The VCS-specific settings are stored in {@link VcsDirectoryMapping#getRootSettings()}.
 *
 * @param mapping the mapping being configured
 * @return the configurable instance, or null if no configuration is required.
 */
@Nullable
public UnnamedConfigurable getRootConfigurable(VcsDirectoryMapping mapping) {
  return null;
}
 

/**
 * Returns the configurable to be shown in the VCS directory mapping dialog which should be displayed
 * for configuring VCS-specific settings for the specified root, or null if no such configuration is required.
 * The VCS-specific settings are stored in {@link VcsDirectoryMapping#getRootSettings()}.
 *
 * @param mapping the mapping being configured
 * @return the configurable instance, or null if no configuration is required.
 */
@Override
public UnnamedConfigurable getRootConfigurable(VcsDirectoryMapping mapping) {
    return new P4VcsRootConfigurable(getProject(), mapping);
}
 

protected abstract UnnamedConfigurable createConfigurable(T item);