public void testEditJUnitConfiguration() throws ConfigurationException { if (PlatformTestUtil.COVERAGE_ENABLED_BUILD) return; PsiClass testA = findTestA(getModule2()); JUnitConfiguration configuration = createConfiguration(testA); JUnitConfigurable editor = new JUnitConfigurable(myProject); try { Configurable configurable = new RunConfigurationConfigurableAdapter(editor, configuration); configurable.reset(); final EditorTextFieldWithBrowseButton component = ((LabeledComponent<EditorTextFieldWithBrowseButton>) editor.getTestLocation(JUnitConfigurationModel.CLASS)) .getComponent(); assertEquals(testA.getQualifiedName(), component.getText()); PsiClass otherTest = findClass(getModule2(), "test2.Test2"); component.setText(otherTest.getQualifiedName()); configurable.apply(); assertEquals(otherTest.getName(), configuration.getName()); String specialName = "My name"; configuration.setName(specialName); configuration.setNameChangedByUser(true); configurable.reset(); component.setText(testA.getQualifiedName()); configurable.apply(); assertEquals(specialName, configuration.getName()); } finally { Disposer.dispose(editor); } }
@Override public void disposeUIResources() { if (!myUiInitialized) return; final PropertiesComponent propertiesComponent = PropertiesComponent.getInstance(myProject); propertiesComponent.setValue("project.structure.last.edited", myUiState.lastEditedConfigurable); propertiesComponent.setValue( "project.structure.proportion", String.valueOf(myUiState.proportion)); propertiesComponent.setValue( "project.structure.side.proportion", String.valueOf(myUiState.sideProportion)); myWasUiDisposed = true; myUiState.proportion = mySplitter.getProportion(); saveSideProportion(); myContext.getDaemonAnalyzer().stop(); for (Configurable each : myName2Config) { each.disposeUIResources(); } myContext.clear(); myName2Config.clear(); myModuleConfigurator.getFacetsConfigurator().clearMaps(); Disposer.dispose(myErrorsComponent); myUiInitialized = false; }
private void createEditors(@Nullable Module module) { if (module == null) return; ModuleConfigurationState state = createModuleConfigurationState(); for (ModuleConfigurationEditorProvider provider : collectProviders(module)) { ModuleConfigurationEditor[] editors = provider.createEditors(state); if (editors.length > 0 && provider instanceof ModuleConfigurationEditorProviderEx && ((ModuleConfigurationEditorProviderEx) provider).isCompleteEditorSet()) { myEditors.clear(); ContainerUtil.addAll(myEditors, editors); break; } else { ContainerUtil.addAll(myEditors, editors); } } for (Configurable moduleConfigurable : ServiceKt.getComponents(module, Configurable.class)) { reportDeprecatedModuleEditor(moduleConfigurable.getClass()); myEditors.add(new ModuleConfigurableWrapper(moduleConfigurable)); } for (ModuleConfigurableEP extension : module.getExtensions(MODULE_CONFIGURABLES)) { if (extension.canCreateConfigurable()) { Configurable configurable = extension.createConfigurable(); if (configurable != null) { reportDeprecatedModuleEditor(configurable.getClass()); myEditors.add(new ModuleConfigurableWrapper(configurable)); } } } }
@Override public boolean isModified() { for (Configurable each : myName2Config) { if (each.isModified()) return true; } return false; }
@NotNull protected Action[] createActions() { for (Configurable conf : myEnvToConfMap.values()) { if (conf.getHelpTopic() != null) { return new Action[] {getOKAction(), getCancelAction(), getHelpAction()}; } } return super.createActions(); }
protected void createConfigurableTabs() { for (Configurable configurable : getConfigurables()) { myTabbedPane.addTab( configurable.getDisplayName(), configurable.getIcon(), configurable.createComponent(), null); } }
public boolean isModified() { if (!Comparing.equal(mySelectedCompiler, myCompilerConfiguration.getDefaultCompiler())) { return true; } for (Configurable configurable : myConfigurables) { if (configurable.isModified()) { return true; } } return false; }
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()); } }
protected void doOKAction() { for (Configurable configurable : myEnvToConfMap.values()) { try { configurable.apply(); } catch (CancelledConfigurationException e) { return; } catch (ConfigurationException e) { Messages.showErrorDialog( myProject, VcsBundle.message("messge.text.cannot.save.settings", e.getLocalizedMessage()), getRealTitle()); return; } } super.doOKAction(); }
@Nls @Override public String getDisplayName() { if (myEp.displayName == null && myEp.key == null) { boolean loaded = myConfigurable != null; Configurable configurable = cast(Configurable.class, this); if (configurable != null) { String name = configurable.getDisplayName(); if (!loaded && LOG.isDebugEnabled()) { LOG.debug("XML does not provide displayName for " + configurable.getClass()); } return name; } } return myEp.getDisplayName(); }
private void addConfigurable(Configurable configurable, boolean addToSidePanel) { myName2Config.add(configurable); if (addToSidePanel) { mySidePanel.addPlace( createPlaceFor(configurable), new Presentation(configurable.getDisplayName())); } }
private void editColorsAndFonts() { final String toConfigure = getSelectedType().getSeverity(null).myName; doOKAction(); myOptionsList.clearSelection(); final DataContext dataContext = DataManager.getInstance().getDataContext(myPanel); final OptionsEditor optionsEditor = OptionsEditor.KEY.getData(dataContext); if (optionsEditor != null) { final ColorAndFontOptions colorAndFontOptions = optionsEditor.findConfigurable(ColorAndFontOptions.class); assert colorAndFontOptions != null; final SearchableConfigurable javaPage = colorAndFontOptions.findSubConfigurable(InspectionColorSettingsPage.class); LOG.assertTrue(javaPage != null); optionsEditor .clearSearchAndSelect(javaPage) .doWhenDone( new Runnable() { @Override public void run() { final Runnable runnable = javaPage.enableSearch(toConfigure); if (runnable != null) { SwingUtilities.invokeLater(runnable); } } }); } else { ColorAndFontOptions colorAndFontOptions = new ColorAndFontOptions(); final Configurable[] configurables = colorAndFontOptions.buildConfigurables(); try { final SearchableConfigurable javaPage = colorAndFontOptions.findSubConfigurable(InspectionColorSettingsPage.class); LOG.assertTrue(javaPage != null); ShowSettingsUtil.getInstance() .editConfigurable(CommonDataKeys.PROJECT.getData(dataContext), javaPage); } finally { for (Configurable configurable : configurables) { configurable.disposeUIResources(); } colorAndFontOptions.disposeUIResources(); } } }
@Override public void reset() { // need this to ensure VFS operations will not block because of storage flushing // and other maintenance IO tasks run in background HeavyProcessLatch.INSTANCE.processStarted(); try { myWasUiDisposed = false; myContext.reset(); myProjectJdksModel.reset(myProject); Configurable toSelect = null; for (Configurable each : myName2Config) { if (myUiState.lastEditedConfigurable != null && myUiState.lastEditedConfigurable.equals(each.getDisplayName())) { toSelect = each; } if (each instanceof MasterDetailsComponent) { ((MasterDetailsComponent) each).setHistory(myHistory); } each.reset(); } myHistory.clear(); if (toSelect == null && myName2Config.size() > 0) { toSelect = myName2Config.iterator().next(); } removeSelected(); navigateTo(toSelect != null ? createPlaceFor(toSelect) : null, false); if (myUiState.proportion > 0) { mySplitter.setProportion(myUiState.proportion); } } finally { HeavyProcessLatch.INSTANCE.processFinished(); } }
static void warn(Configurable configurable, String action, long time) { if (ApplicationManager.getApplication().isDispatchThread()) { time = System.currentTimeMillis() - time; int threshold = Registry.intValue("ide.settings.configurable.loading.threshold", 0); if (0 < threshold && threshold < time) { String name = configurable.getDisplayName(); String id = ConfigurableVisitor.ByID.getID(configurable); LOG.warn(String.valueOf(time) + " ms to " + action + " '" + name + "' id=" + id); } } }
public static void reset(Configurable configurable) { if (configurable != null) { long time = System.currentTimeMillis(); try { configurable.reset(); } catch (Exception unexpected) { LOG.error("cannot reset configurable", unexpected); } finally { warn(configurable, "reset", time); } } }
@Override public void apply() throws ConfigurationException { for (Configurable each : myName2Config) { if (each instanceof BaseStructureConfigurable && each.isModified()) { ((BaseStructureConfigurable) each).checkCanApply(); } } for (Configurable each : myName2Config) { if (each.isModified()) { each.apply(); } } myContext.getDaemonAnalyzer().clearCaches(); SwingUtilities.invokeLater( new Runnable() { public void run() { BuildManager.getInstance().scheduleAutoMake(); } }); }
public JavaCompilersTab( final Project project, Collection<BackendCompiler> compilers, BackendCompiler defaultCompiler) { myDefaultCompiler = defaultCompiler; myCompilerConfiguration = (CompilerConfigurationImpl) CompilerConfiguration.getInstance(project); myConfigurables = new ArrayList<Configurable>(compilers.size()); myCardLayout = new CardLayout(); myContentPanel.setLayout(myCardLayout); for (BackendCompiler compiler : compilers) { Configurable configurable = compiler.createConfigurable(); myConfigurables.add(configurable); myContentPanel.add(configurable.createComponent(), compiler.getId()); } myCompiler.setModel(new DefaultComboBoxModel(new Vector(compilers))); myCompiler.setRenderer( new DefaultListCellRenderer() { public Component getListCellRendererComponent( JList list, Object value, int index, boolean isSelected, boolean cellHasFocus) { JLabel component = (JLabel) super.getListCellRendererComponent( list, value, index, isSelected, cellHasFocus); component.setText(((BackendCompiler) value).getPresentableName()); return component; } }); myCompiler.addActionListener( new ActionListener() { public void actionPerformed(ActionEvent e) { BackendCompiler compiler = (BackendCompiler) myCompiler.getSelectedItem(); if (compiler == null) return; selectCompiler(compiler); } }); }
public void testModulesSelector() throws ConfigurationException { if (PlatformTestUtil.COVERAGE_ENABLED_BUILD) return; Module module1 = getModule1(); Module module2 = getModule2(); JUnitConfigurable editor = new JUnitConfigurable(myProject); try { JUnitConfiguration configuration = createConfiguration(findTestA(module2)); editor.getComponent(); // To get all the watchers installed. Configurable configurable = new RunConfigurationConfigurableAdapter(editor, configuration); JComboBox comboBox = editor.getModulesComponent(); configurable.reset(); assertFalse(configurable.isModified()); assertEquals(module2.getName(), ((Module) comboBox.getSelectedItem()).getName()); assertEquals( ModuleManager.getInstance(myProject).getModules().length + 1, comboBox.getModel().getSize()); // no module comboBox.setSelectedItem(module1); assertTrue(configurable.isModified()); configurable.apply(); assertFalse(configurable.isModified()); assertEquals( Collections.singleton(module1), ContainerUtilRt.newHashSet(configuration.getModules())); } finally { Disposer.dispose(editor); } }
@Override protected void dispose(Configurable configurable) { if (configurable != null) { long time = System.currentTimeMillis(); try { configurable.disposeUIResources(); } catch (Exception unexpected) { LOG.error("cannot dispose configurable", unexpected); } finally { warn(configurable, "dispose", time); } } }
public void testCreatingApplicationConfiguration() throws ConfigurationException { if (PlatformTestUtil.COVERAGE_ENABLED_BUILD) return; ApplicationConfiguration configuration = new ApplicationConfiguration(null, myProject, ApplicationConfigurationType.getInstance()); ApplicationConfigurable editor = new ApplicationConfigurable(myProject); try { editor.getComponent(); // To get all the watchers installed. Configurable configurable = new RunConfigurationConfigurableAdapter(editor, configuration); configurable.reset(); CommonJavaParametersPanel javaParameters = editor.getCommonProgramParameters(); javaParameters.setProgramParameters("prg"); javaParameters.setVMParameters("vm"); javaParameters.setWorkingDirectory("dir"); assertTrue(configurable.isModified()); configurable.apply(); assertEquals("prg", configuration.getProgramParameters()); assertEquals("vm", configuration.getVMParameters()); assertEquals("dir", configuration.getWorkingDirectory()); } finally { Disposer.dispose(editor); } }
public void reset() { for (Configurable configurable : myConfigurables) { configurable.reset(); } selectCompiler(myCompilerConfiguration.getDefaultCompiler()); }
public void apply() throws ConfigurationException { myConfigurable.apply(); }
public void apply() throws ConfigurationException { for (Configurable configurable : myConfigurables) { configurable.apply(); } myCompilerConfiguration.setDefaultCompiler(mySelectedCompiler); }
private void addComponent(AbstractVcs vcs, Configurable configurable, String constraint) { myEnvToConfMap.put(vcs, configurable); myMainPanel.add(configurable.createComponent(), constraint); configurable.reset(); }
public boolean isModified() { return myConfigurable.isModified(); }
@Override @Nullable @NonNls public String getHelpTopic() { return mySelectedConfigurable != null ? mySelectedConfigurable.getHelpTopic() : ""; }
public void reset() { myConfigurable.reset(); }
@Override public ActionCallback navigateTo(@Nullable final Place place, final boolean requestFocus) { final Configurable toSelect = (Configurable) place.getPath(CATEGORY); JComponent detailsContent = myDetails.getTargetComponent(); if (mySelectedConfigurable != toSelect) { if (mySelectedConfigurable instanceof BaseStructureConfigurable) { ((BaseStructureConfigurable) mySelectedConfigurable).onStructureUnselected(); } saveSideProportion(); removeSelected(); if (toSelect != null) { detailsContent = toSelect.createComponent(); myDetails.setContent(detailsContent); } mySelectedConfigurable = toSelect; if (mySelectedConfigurable != null) { myUiState.lastEditedConfigurable = mySelectedConfigurable.getDisplayName(); } if (toSelect instanceof MasterDetailsComponent) { final MasterDetailsComponent masterDetails = (MasterDetailsComponent) toSelect; if (myUiState.sideProportion > 0) { masterDetails.getSplitter().setProportion(myUiState.sideProportion); } masterDetails.setHistory(myHistory); } if (toSelect instanceof DetailsComponent.Facade) { ((DetailsComponent.Facade) toSelect) .getDetailsComponent() .setBannerMinHeight(myToolbarComponent.getPreferredSize().height); } if (toSelect instanceof BaseStructureConfigurable) { ((BaseStructureConfigurable) toSelect).onStructureSelected(); } } if (detailsContent != null) { JComponent toFocus = IdeFocusTraversalPolicy.getPreferredFocusedComponent(detailsContent); if (toFocus == null) { toFocus = detailsContent; } if (requestFocus) { myToFocus = toFocus; UIUtil.requestFocus(toFocus); } } final ActionCallback result = new ActionCallback(); Place.goFurther(toSelect, place, requestFocus).notifyWhenDone(result); myDetails.revalidate(); myDetails.repaint(); if (toSelect != null) { mySidePanel.select(createPlaceFor(toSelect)); } if (!myHistory.isNavigatingNow() && mySelectedConfigurable != null) { myHistory.pushQueryPlace(); } return result; }
public JComponent createComponent() { return myConfigurable.createComponent(); }
public void disposeUIResources() { myConfigurable.disposeUIResources(); }