com.intellij.openapi.options.Configurable Java Examples

@Nonnull
public static Collection<Configurable> getConfigurables(@Nonnull DebuggerSettingsCategory category) {
  List<Configurable> list;
  if (category == DebuggerSettingsCategory.GENERAL) {
    list = new SmartList<>(new XDebuggerGeneralConfigurable());
  }
  else {
    list = null;
  }

  for (XDebuggerSettings<?> settings : XDebuggerSettingManagerImpl.getInstanceImpl().getSettingsList()) {
    Collection<? extends Configurable> configurables = settings.createConfigurables(category);
    if (!configurables.isEmpty()) {
      if (list == null) {
        list = new SmartList<>();
      }
      list.addAll(configurables);
    }
  }
  return ContainerUtil.notNullize(list);
}
 

@RequiredUIAccess
@Override
public final void apply() throws ConfigurationException {
  if (root != null) {
    root.apply(getSettings());
    XDebuggerConfigurableProvider.generalApplied(getCategory());
  }

  if (isChildrenMerged()) {
    for (Configurable child : children) {
      if (child.isModified()) {
        child.apply();
      }
    }
  }
}
 

private List<ConfigurableNode> buildChildren(final Configurable configurable, SimpleNode parent) {
  if (configurable instanceof Configurable.Composite) {
    final Configurable[] kids = ((Configurable.Composite)configurable).getConfigurables();
    final List<ConfigurableNode> result = new ArrayList<>(kids.length);
    for (Configurable child : kids) {
      if (isInvisibleNode(child)) {
        result.addAll(buildChildren(child, parent));
      }
      result.add(new ConfigurableNode(parent, child));
      myContext.registerKid(configurable, child);
    }

    result.sort(UnifiedConfigurableComparator.INSTANCE);
    return result;
  }
  else {
    return Collections.emptyList();
  }
}
 

@RequiredUIAccess
public SingleConfigurableEditor(@Nullable Project project,
                                Configurable configurable,
                                @Nullable String title,
                                @NonNls String dimensionKey,
                                final boolean showApplyButton,
                                final IdeModalityType ideModalityType) {
  super(project, true, ideModalityType);
  myDimensionKey = dimensionKey;
  myShowApplyButton = showApplyButton;
  setTitle(title);

  myProject = project;
  myConfigurable = configurable;
  init();
  myConfigurable.reset();
}
 

@Nullable
@Override
public Configurable createConfigurable(Collection<FilePath> collection) {
    // Note the way this is currently implemented: synchronize options will always be reset.
    options = SyncOptions.createDefaultSyncOptions();

    ProjectConfigRegistry registry = ProjectConfigRegistry.getInstance(project);
    if (registry == null || registry.isDisposed()) {
        return new SyncOptionConfigurable(project, options, Collections.emptyList());
    }
    Map<P4ServerName, ClientConfig> configMap = new HashMap<>();
    collection.forEach((fp) -> {
        ClientConfigRoot clientRoot = registry.getClientFor(fp);
        if (clientRoot != null) {
            configMap.put(clientRoot.getServerConfig().getServerName(), clientRoot.getClientConfig());
        }
    });
    return new SyncOptionConfigurable(project, options, configMap.values());
}
 

@RequiredUIAccess
public SingleConfigurableEditor(Component parent,
                                Configurable configurable,
                                @Nullable String title,
                                String dimensionServiceKey,
                                final boolean showApplyButton,
                                final IdeModalityType ideModalityType) {
  super(parent, true);
  myDimensionKey = dimensionServiceKey;
  myShowApplyButton = showApplyButton;
  setTitle(StringUtil.notNullize(title, createTitleString(configurable)));

  myParentComponent = parent;
  myConfigurable = configurable;
  init();
  myConfigurable.reset();
}
 

@Nullable
public SearchableConfigurable findConfigurableById(@Nonnull String configurableId) {
  for (Configurable configurable : myConfigurable2Node.keySet()) {
    if (configurable instanceof SearchableConfigurable) {
      SearchableConfigurable searchableConfigurable = (SearchableConfigurable)configurable;
      if (configurableId.equals(searchableConfigurable.getId())) {
        return searchableConfigurable;
      }
    }
  }
  return null;
}
 

public Configurable[] getConfigurables() {
    if (configurables == null) {
        configurables = new Configurable[]{
                new TemplateConfigurable("Activity Template", "Setup Template for Activity code generation:", "Activity_template"),
                new TemplateConfigurable("Adapter Template", "Setup Template for Adapter code generation:", "Adapter_template"),
                new TemplateConfigurable("Fragment Template", "Setup Template for Fragment code generation:", "Fragment_template"),
                new TemplateConfigurable("Menu Template", "Setup Template for Menu code generation:", "Menu_template")
        };
    }
    return configurables;
}
 

@Nullable
private static Configurable findLastSavedConfigurable(Configurable[] configurables, final Project project) {
  final String id = PropertiesComponent.getInstance(project).getValue(LAST_SELECTED_CONFIGURABLE);
  if (id == null) return null;

  return findConfigurableInGroups(id, configurables);
}
 

private void addConfigurationPanelFor(final VcsDescriptor vcs) {
  String name = vcs.getName();
  final JPanel parentPanel = new JPanel();
  final LazyConfigurable lazyConfigurable = new LazyConfigurable(new Getter<Configurable>() {
    @Override
    public Configurable get() {
      return AllVcses.getInstance(myProject).getByName(vcs.getName()).getConfigurable();
    }
  }, parentPanel);
  myVcsNameToConfigurableMap.put(name, lazyConfigurable);
  myVcsConfigurationPanel.add(parentPanel, name);
}
 

protected Configurable[] buildConfigurables() {
  LanguageExtensionPoint[] extensions = LanguagePostfixTemplate.EP_NAME.getExtensions();
  List<Configurable> list = new ArrayList<>(extensions.length);
  for (LanguageExtensionPoint extensionPoint : extensions) {
    list.add(new PostfixTemplatesChildConfigurable(extensionPoint));
  }
  Collections.sort(list, (o1, o2) -> StringUtil.compare(o1.getDisplayName(), o2.getDisplayName(), true));
  return list.toArray(new Configurable[list.size()]);
}
 

@RequiredUIAccess
public static JComponent getPreferredFocusedComponent(@Nonnull Configurable.HoldPreferredFocusedComponent component) {
  JComponent preferredFocusedComponent = component.getPreferredFocusedComponent();
  if(preferredFocusedComponent != null) {
    return preferredFocusedComponent;
  }
  consulo.ui.Component uiComponent = component.getPreferredFocusedUIComponent();
  if (uiComponent != null) {
    return (JComponent)TargetAWT.to(uiComponent);
  }
  return null;
}
 

@Override
public AsyncResult<Void> navigateTo(@Nullable final Place place, final boolean requestFocus) {
  final Configurable config = (Configurable)place.getPath("configurable");
  final String filter = (String)place.getPath("filter");

  final AsyncResult<Void> result = AsyncResult.undefined();

  myFilter.refilterFor(filter, false, true).onSuccess((c) -> myTree.select(config).notifyWhenDone(result));

  return result;
}
 

private ActionCallback updateIfCurrent(final Configurable configurable) {
  if (getContext().getCurrentConfigurable() == configurable && configurable != null) {
    updateContent();
    return new ActionCallback.Done();
  }
  else {
    return new ActionCallback.Rejected();
  }
}
 

public static String createDimensionKey(@Nonnull Configurable configurable) {
  String displayName = configurable.getDisplayName();
  if (displayName == null) {
    displayName = configurable.getClass().getName();
  }
  return '#' + StringUtil.replaceChar(StringUtil.replaceChar(displayName, '\n', '_'), ' ', '_');
}
 

private static void processConfigurables(final Configurable[] configurables,
                                         final HashMap<SearchableConfigurable, TreeSet<OptionDescription>> options) {
  for (Configurable configurable : configurables) {
    if (configurable instanceof SearchableConfigurable) {
      TreeSet<OptionDescription> configurableOptions = new TreeSet<OptionDescription>();

      if (configurable instanceof Configurable.Composite) {
        final Configurable[] children = ((Configurable.Composite)configurable).getConfigurables();
        processConfigurables(children, options);
      }

      //ignore invisible root nodes
      if (configurable instanceof SearchableConfigurable.Parent && !((SearchableConfigurable.Parent)configurable).isVisible()) {
        continue;
      }

      options.put((SearchableConfigurable)configurable, configurableOptions);

      if (configurable instanceof MasterDetails) {
        final MasterDetails md = (MasterDetails)configurable;
        md.initUi();
        _processComponent(configurable, configurableOptions, md.getMaster());
        _processComponent(configurable, configurableOptions, md.getDetails().getComponent());
      }
      else {
        _processComponent(configurable, configurableOptions, configurable.createComponent());
      }
    }
  }
}
 

private void fireModification(final Configurable actual) {
  Collection<Configurable> toCheck = collectAllParentsAndSiblings(actual);

  for (Configurable configurable : toCheck) {
    fireModificationForItem(configurable);
  }
}
 

@Override
protected QualityToolMessageProcessor createMessageProcessor(@NotNull QualityToolAnnotatorInfo qualityToolAnnotatorInfo) {
    return new CheckstyleQualityToolMessageProcessor(qualityToolAnnotatorInfo) {
        @Override
        protected Configurable getToolConfigurable(@NotNull Project project) {
            return new PhpStanValidatorConfigurable(project);
        }
    };
}
 

private void saveCurrentConfigurable() {
  final Configurable current = myEditor.getContext().getCurrentConfigurable();
  if (current == null) return;

  final PropertiesComponent props = PropertiesComponent.getInstance(myProject);

  if (current instanceof SearchableConfigurable) {
    props.setValue(LAST_SELECTED_CONFIGURABLE, ((SearchableConfigurable)current).getId());
  }
  else {
    props.setValue(LAST_SELECTED_CONFIGURABLE, current.getClass().getName());
  }
}
 

@Nullable
private static Configurable findPreselectedByDisplayName(final String preselectedConfigurableDisplayName, Configurable[] configurables) {
  final List<Configurable> all = SearchUtil.expand(configurables);
  for (Configurable each : all) {
    if (preselectedConfigurableDisplayName.equals(each.getDisplayName())) return each;
  }
  return null;
}
 

private static Map<AbstractVcs, Configurable> revertMap(final Map<Configurable, AbstractVcs> confs) {
  final HashMap<AbstractVcs, Configurable> result = new HashMap<AbstractVcs, Configurable>();
  for (Configurable configurable : confs.keySet()) {
    result.put(confs.get(configurable), configurable);
  }
  return result;
}
 

@RequiredUIAccess
@Override
public JComponent getPreferredFocusedComponent() {
  if (myConfigurable instanceof Configurable.HoldPreferredFocusedComponent) {
    JComponent preferred = ConfigurableUIMigrationUtil.getPreferredFocusedComponent((Configurable.HoldPreferredFocusedComponent)myConfigurable);
    if (preferred != null) return preferred;
  }
  return IdeFocusTraversalPolicy.getPreferredFocusedComponent(myCenterPanel);
}
 

@Nonnull
public ActionCallback select(Class<? extends Configurable> configurableClass) {
  final Configurable configurable = findConfigurable(configurableClass);
  if (configurable == null) {
    return new ActionCallback.Rejected();
  }
  return select(configurable);
}
 

void setContent(final JComponent component, ConfigurationException e, @Nonnull Configurable configurable) {
  if (component != null && mySimpleContent == component && myException == e) {
    return;
  }

  removeAll();

  if (component != null) {
    boolean noMargin = ConfigurableWrapper.isNoMargin(configurable);
    JComponent wrapComponent = component;
    if (!noMargin) {
      wrapComponent = JBUI.Panels.simplePanel().addToCenter(wrapComponent);
      wrapComponent.setBorder(new EmptyBorder(UIUtil.PANEL_SMALL_INSETS));
    }


    boolean noScroll = ConfigurableWrapper.isNoScroll(configurable);
    if (!noScroll) {
      JScrollPane scroll = ScrollPaneFactory.createScrollPane(wrapComponent, true);
      scroll.setHorizontalScrollBarPolicy(ScrollPaneConstants.HORIZONTAL_SCROLLBAR_AS_NEEDED);
      scroll.setVerticalScrollBarPolicy(ScrollPaneConstants.VERTICAL_SCROLLBAR_AS_NEEDED);
      add(scroll, BorderLayout.CENTER);
    }
    else {
      add(wrapComponent, BorderLayout.CENTER);
    }
  }

  if (e != null) {
    myErrorLabel.setText(UIUtil.toHtml(e.getMessage()));
    add(myErrorLabel, BorderLayout.NORTH);
  }

  mySimpleContent = component;
  myException = e;
}
 

public WholeWestSingleConfigurableEditor(Component parent,
                                         Configurable configurable,
                                         String dimensionServiceKey,
                                         final boolean showApplyButton,
                                         final IdeModalityType ideModalityType) {
  super(parent, true);
  myDimensionKey = dimensionServiceKey;
  myShowApplyButton = showApplyButton;
  setTitle(createTitleString(configurable));

  myParentComponent = parent;
  myConfigurable = configurable;
  init();
  myConfigurable.reset();
}
 

@RequiredUIAccess
@Override
public final void disposeUIResources() {
  root = null;
  rootComponent = null;

  if (isChildrenMerged()) {
    for (Configurable child : children) {
      child.disposeUIResources();
    }
  }
  children = null;
}
 

@RequiredUIAccess
@Override
public JComponent getPreferredFocusedComponent() {
  if (myConfigurable instanceof Configurable.HoldPreferredFocusedComponent) {
    JComponent preferred = ConfigurableUIMigrationUtil.getPreferredFocusedComponent((Configurable.HoldPreferredFocusedComponent)myConfigurable);
    if (preferred != null) return preferred;
  }
  return IdeFocusTraversalPolicy.getPreferredFocusedComponent(myRootPanel);
}
 

@RequiredUIAccess
@Override
public final void reset() {
  if (root != null) {
    root.reset(getSettings());
  }

  if (isChildrenMerged()) {
    for (Configurable child : children) {
      child.reset();
    }
  }
}
 

@Nullable
private static Configurable findConfigurable2Select(String id2Select, Configurable[] configurables) {
  for (Configurable configurable : configurables) {
    final Configurable conf = containsId(id2Select, configurable);
    if (conf != null) return conf;
  }
  return null;
}
 

@Nonnull
protected Action[] createActions() {
  for(Configurable conf: myEnvToConfMap.values()) {
    if (conf.getHelpTopic() != null) {
      return new Action[] { getOKAction(), getCancelAction(), getHelpAction() };
    }
  }
  return super.createActions();
}