private void updateText() {
StringBuilder sb = new StringBuilder();
if (myShowSettingsBeforeRunCheckBox.isSelected()) {
sb.append(ExecutionBundle.message("configuration.edit.before.run")).append(", ");
}
List<BeforeRunTask> tasks = myModel.getItems();
if (!tasks.isEmpty()) {
LinkedHashMap<BeforeRunTaskProvider, Integer> counter =
new LinkedHashMap<BeforeRunTaskProvider, Integer>();
for (BeforeRunTask task : tasks) {
BeforeRunTaskProvider<BeforeRunTask> provider =
BeforeRunTaskProvider.getProvider(
myRunConfiguration.getProject(), task.getProviderId());
if (provider != null) {
Integer count = counter.get(provider);
if (count == null) {
count = task.getItemsCount();
} else {
count += task.getItemsCount();
}
counter.put(provider, count);
}
}
for (Iterator<Map.Entry<BeforeRunTaskProvider, Integer>> iterator =
counter.entrySet().iterator();
iterator.hasNext(); ) {
Map.Entry<BeforeRunTaskProvider, Integer> entry = iterator.next();
BeforeRunTaskProvider provider = entry.getKey();
String name = provider.getName();
if (name.startsWith("Run ")) {
name = name.substring(4);
}
sb.append(name);
if (entry.getValue() > 1) {
sb.append(" (").append(entry.getValue().intValue()).append(")");
}
if (iterator.hasNext()) sb.append(", ");
}
}
if (sb.length() > 0) {
sb.insert(0, ": ");
}
sb.insert(0, ExecutionBundle.message("before.launch.panel.title"));
myListener.titleChanged(sb.toString());
}
@Override
public Component getTreeCellRendererComponent(
JTree tree,
Object value,
boolean selected,
boolean expanded,
boolean leaf,
int row,
boolean hasFocus) {
invalidate();
final VirtualFile file = getFile(value);
final DefaultMutableTreeNode node = (DefaultMutableTreeNode) value;
if (file == null) {
if (value instanceof DefaultMutableTreeNode) {
final Object uo = node.getUserObject();
if (uo instanceof String) {
myColoredRenderer.getTreeCellRendererComponent(
tree, value, selected, expanded, leaf, row, hasFocus);
return myColoredRenderer;
}
}
return myEmpty;
}
myCheckbox.setVisible(true);
final TreeNodeState state = mySelectionManager.getState(node);
myCheckbox.setEnabled(
TreeNodeState.CLEAR.equals(state) || TreeNodeState.SELECTED.equals(state));
myCheckbox.setSelected(!TreeNodeState.CLEAR.equals(state));
myCheckbox.setOpaque(false);
myCheckbox.setBackground(null);
setBackground(null);
myTextRenderer.getListCellRendererComponent(myFictive, file, 0, selected, hasFocus);
revalidate();
return this;
}
private void resetFromFile(@NotNull VirtualFile file, @NotNull Project project) {
final Module moduleForFile = ModuleUtilCore.findModuleForFile(file, project);
if (moduleForFile == null) {
return;
}
final VirtualFile parent = file.getParent();
if (parent == null) {
return;
}
if (myModule == null) {
final Object prev = myModuleCombo.getSelectedItem();
myModuleCombo.setSelectedItem(moduleForFile);
if (!moduleForFile.equals(myModuleCombo.getSelectedItem())) {
myModuleCombo.setSelectedItem(prev);
return;
}
} else if (!myModule.equals(moduleForFile)) {
return;
}
final JCheckBox checkBox = myCheckBoxes.get(parent.getName());
if (checkBox == null) {
return;
}
for (JCheckBox checkBox1 : myCheckBoxes.values()) {
checkBox1.setSelected(false);
}
checkBox.setSelected(true);
myFileNameCombo.getEditor().setItem(file.getName());
}
public void apply(CodeStyleSettings settings) {
stopTableEditing();
settings.LAYOUT_STATIC_IMPORTS_SEPARATELY = myImportLayoutPanel.areStaticImportsEnabled();
settings.USE_FQ_CLASS_NAMES = myCbUseFQClassNames.isSelected();
settings.USE_SINGLE_CLASS_IMPORTS = myCbUseSingleClassImports.isSelected();
settings.INSERT_INNER_CLASS_IMPORTS = myCbInsertInnerClassImports.isSelected();
try {
settings.CLASS_COUNT_TO_USE_IMPORT_ON_DEMAND = Integer.parseInt(myClassCountField.getText());
} catch (NumberFormatException e) {
// just a bad number
}
try {
settings.NAMES_COUNT_TO_USE_IMPORT_ON_DEMAND = Integer.parseInt(myNamesCountField.getText());
} catch (NumberFormatException e) {
// just a bad number
}
final PackageEntryTable list = myImportLayoutPanel.getImportLayoutList();
list.removeEmptyPackages();
settings.IMPORT_LAYOUT_TABLE.copyFrom(list);
myPackageList.removeEmptyPackages();
settings.PACKAGES_TO_USE_IMPORT_ON_DEMAND.copyFrom(myPackageList);
myFqnInJavadocOption.apply(settings);
}
public void reset(CodeStyleSettings settings) {
myCbUseFQClassNames.setSelected(settings.USE_FQ_CLASS_NAMES);
myCbUseSingleClassImports.setSelected(settings.USE_SINGLE_CLASS_IMPORTS);
myCbInsertInnerClassImports.setSelected(settings.INSERT_INNER_CLASS_IMPORTS);
myClassCountField.setText(Integer.toString(settings.CLASS_COUNT_TO_USE_IMPORT_ON_DEMAND));
myNamesCountField.setText(Integer.toString(settings.NAMES_COUNT_TO_USE_IMPORT_ON_DEMAND));
myImportLayoutPanel.getImportLayoutList().copyFrom(settings.IMPORT_LAYOUT_TABLE);
myPackageList.copyFrom(settings.PACKAGES_TO_USE_IMPORT_ON_DEMAND);
myFqnInJavadocOption.reset(settings);
myImportLayoutPanel
.getCbLayoutStaticImportsSeparately()
.setSelected(settings.LAYOUT_STATIC_IMPORTS_SEPARATELY);
final JBTable importLayoutTable = myImportLayoutPanel.getImportLayoutTable();
AbstractTableModel model = (AbstractTableModel) importLayoutTable.getModel();
model.fireTableDataChanged();
model = (AbstractTableModel) myPackageTable.getModel();
model.fireTableDataChanged();
if (importLayoutTable.getRowCount() > 0) {
importLayoutTable.getSelectionModel().setSelectionInterval(0, 0);
}
if (myPackageTable.getRowCount() > 0) {
myPackageTable.getSelectionModel().setSelectionInterval(0, 0);
}
}
public void setTreeActionState(Class<? extends TreeAction> action, boolean state) {
final JCheckBox checkBox = myCheckBoxes.get(action);
if (checkBox != null) {
checkBox.setSelected(state);
for (ActionListener listener : checkBox.getActionListeners()) {
listener.actionPerformed(new ActionEvent(this, 1, ""));
}
}
}
protected JComponent createNorthPanel() {
if (!mySearchTextOccurencesEnabled) {
myCbSearchTextOccurences.setEnabled(false);
myCbSearchTextOccurences.setVisible(false);
myCbSearchTextOccurences.setSelected(false);
}
return myMainPanel;
}
protected void customizeOptionsPanel() {
if (myInsertOverrideAnnotationCheckbox != null && myIsInsertOverrideVisible) {
CodeStyleSettings styleSettings =
CodeStyleSettingsManager.getInstance(myProject).getCurrentSettings();
myInsertOverrideAnnotationCheckbox.setSelected(styleSettings.INSERT_OVERRIDE_ANNOTATION);
}
if (myCopyJavadocCheckbox != null) {
myCopyJavadocCheckbox.setSelected(
PropertiesComponent.getInstance().isTrueValue(PROP_COPYJAVADOC));
}
}
private void updateCurrentRule() {
if (myLastSelected >= 0 && myLastSelected < myRulesModel.getSize()) {
LibraryBundlificationRule newRule = new LibraryBundlificationRule();
newRule.setRuleRegex(myLibraryRegex.getText().trim());
newRule.setAdditionalProperties(myManifestEditor.getText().trim());
newRule.setDoNotBundle(myNeverBundle.isSelected());
newRule.setStopAfterThisRule(myStopAfterThisRule.isSelected());
if (!newRule.equals(myRulesModel.getElementAt(myLastSelected))) {
myRulesModel.setElementAt(newRule, myLastSelected);
}
}
}
void doReset(RunnerAndConfigurationSettings settings) {
myRunConfiguration = settings.getConfiguration();
originalTasks.clear();
RunManagerImpl runManager = RunManagerImpl.getInstanceImpl(myRunConfiguration.getProject());
originalTasks.addAll(runManager.getBeforeRunTasks(myRunConfiguration));
myModel.replaceAll(originalTasks);
myShowSettingsBeforeRunCheckBox.setSelected(settings.isEditBeforeRun());
myShowSettingsBeforeRunCheckBox.setEnabled(!(isUnknown()));
myPanel.setVisible(checkBeforeRunTasksAbility(false));
updateText();
}
private MyCheckboxTreeCellRenderer(
final SelectionManager selectionManager,
Map<VirtualFile, String> modulesSet,
final Project project,
final JTree tree,
final Collection<VirtualFile> roots) {
super(new BorderLayout());
mySelectionManager = selectionManager;
myModulesSet = modulesSet;
myRoots = roots;
setBackground(tree.getBackground());
myColoredRenderer =
new ColoredTreeCellRenderer() {
@Override
public void customizeCellRenderer(
JTree tree,
Object value,
boolean selected,
boolean expanded,
boolean leaf,
int row,
boolean hasFocus) {
append(value.toString());
}
};
myFictive = new JBList();
myFictive.setBackground(tree.getBackground());
myFictive.setSelectionBackground(UIUtil.getListSelectionBackground());
myFictive.setSelectionForeground(UIUtil.getListSelectionForeground());
myTextRenderer =
new WithModulesListCellRenderer(project, myModulesSet) {
@Override
protected void putParentPath(Object value, FilePath path, FilePath self) {
if (myRoots.contains(self.getVirtualFile())) {
super.putParentPath(value, path, self);
}
}
};
myTextRenderer.setBackground(tree.getBackground());
myCheckbox = new JCheckBox();
myCheckbox.setBackground(tree.getBackground());
myEmpty = new JLabel("");
add(myCheckbox, BorderLayout.WEST);
add(myTextRenderer, BorderLayout.CENTER);
myCheckbox.setVisible(true);
}
private void updateFields() {
int index = myRulesList.getSelectedIndex();
if (index >= 0 && index != myLastSelected) {
final LibraryBundlificationRule rule = myRulesModel.getElementAt(index);
myLibraryRegex.setText(rule.getRuleRegex());
UIUtil.invokeLaterIfNeeded(() -> myManifestEditor.setText(rule.getAdditionalProperties()));
myNeverBundle.setSelected(rule.isDoNotBundle());
myStopAfterThisRule.setSelected(rule.isStopAfterThisRule());
myLastSelected = index;
}
myLibraryRegex.setEnabled(index >= 0);
myManifestEditor.setEnabled(index >= 0);
myNeverBundle.setEnabled(index >= 0);
myStopAfterThisRule.setEnabled(index >= 0);
}
@NotNull
@Override
public Component getTableCellRendererComponent(
@NotNull JTable table,
Object value,
boolean isSelected,
boolean hasFocus,
int row,
int column) {
final RegistryValue v = ((MyTableModel) table.getModel()).getRegistryValue(row);
myLabel.setIcon(null);
myLabel.setText(null);
myLabel.setHorizontalAlignment(SwingConstants.LEFT);
Color fg = isSelected ? table.getSelectionForeground() : table.getForeground();
Color bg = isSelected ? table.getSelectionBackground() : table.getBackground();
if (v != null) {
switch (column) {
case 0:
myLabel.setIcon(v.isRestartRequired() ? RESTART_ICON : null);
myLabel.setHorizontalAlignment(SwingConstants.CENTER);
break;
case 1:
myLabel.setText(v.getKey());
break;
case 2:
if (v.asColor(null) != null) {
myLabel.setIcon(createColoredIcon(v.asColor(null)));
} else if (v.isBoolean()) {
final JCheckBox box = new JCheckBox();
box.setSelected(v.asBoolean());
box.setBackground(bg);
return box;
} else {
myLabel.setText(v.asString());
}
}
myLabel.setOpaque(true);
myLabel.setFont(
myLabel.getFont().deriveFont(v.isChangedFromDefault() ? Font.BOLD : Font.PLAIN));
myLabel.setForeground(fg);
myLabel.setBackground(bg);
}
return myLabel;
}
private void updateComponents() {
boolean archetypesEnabled = myUseArchetypeCheckBox.isSelected();
myAddArchetypeButton.setEnabled(archetypesEnabled);
myArchetypesTree.setEnabled(archetypesEnabled);
myArchetypesTree.setBackground(
archetypesEnabled ? UIUtil.getListBackground() : UIUtil.getPanelBackground());
}
public void requestUpdate() {
MavenArchetype selectedArch = getSelectedArchetype();
if (selectedArch == null) {
selectedArch = myBuilder.getArchetype();
}
if (selectedArch != null) myUseArchetypeCheckBox.setSelected(true);
if (myArchetypesTree.getRowCount() == 0) updateArchetypesList(selectedArch);
}
private String getPropertiesFileSuffix() {
if (myResourceBundle == null) {
return myUseXMLBasedPropertiesCheckBox.isSelected() ? ".xml" : ".properties";
}
return "."
+ myResourceBundle
.getDefaultPropertiesFile()
.getContainingFile()
.getFileType()
.getDefaultExtension();
}
@Override
public boolean stopCellEditing() {
if (myValue != null) {
if (myValue.isBoolean()) {
myValue.setValue(myCheckBox.isSelected());
} else {
myValue.setValue(myField.getText().trim());
}
}
revaliateActions();
return super.stopCellEditing();
}
public CreateResourceBundleDialogComponent(
Project project, PsiDirectory directory, ResourceBundle resourceBundle) {
myProject = project;
myDirectory = directory;
myResourceBundle = resourceBundle;
if (resourceBundle != null) {
myResourceBundleNamePanel.setVisible(false);
myUseXMLBasedPropertiesCheckBox.setVisible(false);
} else {
final String checkBoxSelectedStateKey = getClass() + ".useXmlPropertiesFiles";
myUseXMLBasedPropertiesCheckBox.setSelected(
PropertiesComponent.getInstance().getBoolean(checkBoxSelectedStateKey));
myUseXMLBasedPropertiesCheckBox.addContainerListener(
new ContainerAdapter() {
@Override
public void componentRemoved(ContainerEvent e) {
PropertiesComponent.getInstance()
.setValue(checkBoxSelectedStateKey, myUseXMLBasedPropertiesCheckBox.isSelected());
}
});
}
}
private JComponent createSouthPanel() {
final JCheckBox checkBox = new JCheckBox(IdeBundle.message("checkbox.narrow.down.on.typing"));
checkBox.setSelected(PropertiesComponent.getInstance().getBoolean(narrowDownPropertyKey, true));
checkBox.addChangeListener(
new ChangeListener() {
public void stateChanged(ChangeEvent e) {
myShouldNarrowDown = checkBox.isSelected();
PropertiesComponent.getInstance()
.setValue(narrowDownPropertyKey, Boolean.toString(myShouldNarrowDown));
if (mySpeedSearch.isPopupActive()
&& !StringUtil.isEmpty(mySpeedSearch.getEnteredPrefix())) {
myAbstractTreeBuilder.queueUpdate();
}
}
});
checkBox.setFocusable(false);
UIUtil.applyStyle(UIUtil.ComponentStyle.MINI, checkBox);
final JPanel panel = new JPanel(new BorderLayout());
panel.add(checkBox, BorderLayout.WEST);
return panel;
}
@Nullable
public Component getTableCellEditorComponent(
JTable table, Object value, boolean isSelected, int row, int column) {
myValue = ((MyTableModel) table.getModel()).getRegistryValue(row);
if (myValue.asColor(null) != null) {
final Color color =
ColorChooser.chooseColor(
table, "Choose color", ((RegistryValue) value).asColor(Color.WHITE));
if (color != null) {
myValue.setValue(color.getRed() + "," + color.getGreen() + "," + color.getBlue());
}
return null;
} else if (myValue.isBoolean()) {
myCheckBox.setSelected(myValue.asBoolean());
myCheckBox.setBackground(table.getBackground());
return myCheckBox;
} else {
myField.setText(myValue.asString());
myField.setBorder(null);
myField.selectAll();
return myField;
}
}
@Override
public void dispose() {
PropertiesComponent instance = PropertiesComponent.getInstance();
instance.setValue(PROP_SORTED, Boolean.toString(isAlphabeticallySorted()));
instance.setValue(PROP_SHOWCLASSES, Boolean.toString(myShowClasses));
if (myCopyJavadocCheckbox != null) {
instance.setValue(PROP_COPYJAVADOC, Boolean.toString(myCopyJavadocCheckbox.isSelected()));
}
final Container contentPane = getContentPane();
if (contentPane != null) {
contentPane.removeAll();
}
mySelectedNodes.clear();
myElements = null;
super.dispose();
}
public void setData(
PsiElement[] psiElements,
String targetPackageName,
final PsiDirectory initialTargetDirectory,
boolean isTargetDirectoryFixed,
boolean searchInComments,
boolean searchForTextOccurences,
String helpID) {
myInitialTargetDirectory = initialTargetDirectory;
myTargetDirectoryFixed = isTargetDirectoryFixed;
if (targetPackageName.length() != 0) {
myWithBrowseButtonReference.prependItem(targetPackageName);
myClassPackageChooser.prependItem(targetPackageName);
}
String nameFromCallback =
myMoveCallback instanceof MoveClassesOrPackagesCallback
? ((MoveClassesOrPackagesCallback) myMoveCallback).getElementsToMoveName()
: null;
if (nameFromCallback != null) {
myNameLabel.setText(nameFromCallback);
} else if (psiElements.length == 1) {
PsiElement firstElement = psiElements[0];
if (firstElement instanceof PsiClass) {
LOG.assertTrue(!MoveClassesOrPackagesImpl.isClassInnerOrLocal((PsiClass) firstElement));
} else {
PsiElement parent = firstElement.getParent();
LOG.assertTrue(parent != null);
}
myNameLabel.setText(
RefactoringBundle.message(
"move.single.class.or.package.name.label",
UsageViewUtil.getType(firstElement),
UsageViewUtil.getLongName(firstElement)));
} else if (psiElements.length > 1) {
myNameLabel.setText(
psiElements[0] instanceof PsiClass
? RefactoringBundle.message("move.specified.classes")
: RefactoringBundle.message("move.specified.packages"));
}
selectInitialCard();
myCbSearchInComments.setSelected(searchInComments);
myCbSearchTextOccurences.setSelected(searchForTextOccurences);
((DestinationFolderComboBox) myDestinationFolderCB)
.setData(
myProject,
myInitialTargetDirectory,
new Pass<String>() {
@Override
public void pass(String s) {
setErrorText(s);
}
},
myClassPackageChooser.getChildComponent());
UIUtil.setEnabled(
myTargetPanel,
getSourceRoots().length > 0 && isMoveToPackage() && !isTargetDirectoryFixed,
true);
validateButtons();
myHelpID = helpID;
}
@Nullable
public MavenArchetype getSelectedArchetype() {
if (!myUseArchetypeCheckBox.isSelected() || myArchetypesTree.isSelectionEmpty()) return null;
return getArchetypeInfoFromPathComponent(myArchetypesTree.getLastSelectedPathComponent());
}
protected final boolean isSearchInComments() {
return myCbSearchInComments.isSelected();
}
private void addCheckbox(final JPanel panel, final TreeAction action) {
String text =
action instanceof FileStructureFilter
? ((FileStructureFilter) action).getCheckBoxText()
: action instanceof FileStructureNodeProvider
? ((FileStructureNodeProvider) action).getCheckBoxText()
: null;
if (text == null) return;
Shortcut[] shortcuts =
action instanceof FileStructureFilter
? ((FileStructureFilter) action).getShortcut()
: ((FileStructureNodeProvider) action).getShortcut();
final JCheckBox chkFilter = new JCheckBox();
UIUtil.applyStyle(UIUtil.ComponentStyle.SMALL, chkFilter);
final boolean selected = getDefaultValue(action);
chkFilter.setSelected(selected);
myTreeActionsOwner.setActionIncluded(
action, action instanceof FileStructureFilter ? !selected : selected);
chkFilter.addActionListener(
new ActionListener() {
public void actionPerformed(final ActionEvent e) {
final boolean state = chkFilter.isSelected();
if (!myAutoClicked.contains(chkFilter)) {
saveState(action, state);
}
myTreeActionsOwner.setActionIncluded(
action, action instanceof FileStructureFilter ? !state : state);
// final String filter = mySpeedSearch.isPopupActive() ?
// mySpeedSearch.getEnteredPrefix() : null;
// mySpeedSearch.hidePopup();
Object selection =
ContainerUtil.getFirstItem(myAbstractTreeBuilder.getSelectedElements());
if (selection instanceof FilteringTreeStructure.FilteringNode) {
selection = ((FilteringTreeStructure.FilteringNode) selection).getDelegate();
}
myTreeStructure.rebuildTree();
myFilteringStructure.rebuild();
final Object sel = selection;
final Runnable runnable =
new Runnable() {
public void run() {
ApplicationManager.getApplication()
.runReadAction(
new Runnable() {
@Override
public void run() {
myAbstractTreeBuilder
.refilter(sel, true, false)
.doWhenProcessed(
new Runnable() {
@Override
public void run() {
if (mySpeedSearch.isPopupActive()) {
mySpeedSearch.refreshSelection();
}
}
});
}
});
}
};
if (ApplicationManager.getApplication().isUnitTestMode()) {
runnable.run();
} else {
ApplicationManager.getApplication().invokeLater(runnable);
}
}
});
chkFilter.setFocusable(false);
if (shortcuts.length > 0) {
text += " (" + KeymapUtil.getShortcutText(shortcuts[0]) + ")";
new AnAction() {
public void actionPerformed(final AnActionEvent e) {
chkFilter.doClick();
}
}.registerCustomShortcutSet(new CustomShortcutSet(shortcuts), myTree);
}
chkFilter.setText(text);
panel.add(chkFilter);
myCheckBoxes.put(action.getClass(), chkFilter);
}
public boolean isInsertOverrideAnnotation() {
return myIsInsertOverrideVisible && myInsertOverrideAnnotationCheckbox.isSelected();
}
public boolean isCopyJavadoc() {
return myCopyJavadocCheckbox.isSelected();
}
public void setCopyJavadocVisible(boolean state) {
myCopyJavadocCheckbox.setVisible(state);
}
protected final boolean isSearchInNonJavaFiles() {
return myCbSearchTextOccurences.isSelected();
}
public MavenArchetypesStep(MavenModuleBuilder builder, @Nullable StepAdapter step) {
myBuilder = builder;
myStep = step;
Disposer.register(this, myLoadingIcon);
myArchetypesTree = new Tree();
myArchetypesTree.setModel(new DefaultTreeModel(new DefaultMutableTreeNode()));
JScrollPane archetypesScrollPane = ScrollPaneFactory.createScrollPane(myArchetypesTree);
myArchetypesPanel.add(archetypesScrollPane, "archetypes");
JPanel loadingPanel = new JPanel(new GridBagLayout());
JPanel bp = new JPanel(new BorderLayout(10, 10));
bp.add(new JLabel("Loading archetype list..."), BorderLayout.NORTH);
bp.add(myLoadingIcon, BorderLayout.CENTER);
loadingPanel.add(bp, new GridBagConstraints());
myArchetypesPanel.add(ScrollPaneFactory.createScrollPane(loadingPanel), "loading");
((CardLayout) myArchetypesPanel.getLayout()).show(myArchetypesPanel, "archetypes");
myUseArchetypeCheckBox.addItemListener(
new ItemListener() {
@Override
public void itemStateChanged(ItemEvent e) {
updateComponents();
archetypeMayBeChanged();
}
});
myAddArchetypeButton.addActionListener(
new ActionListener() {
public void actionPerformed(ActionEvent e) {
doAddArchetype();
}
});
myArchetypesTree.setRootVisible(false);
myArchetypesTree.setShowsRootHandles(true);
myArchetypesTree.setCellRenderer(new MyRenderer());
myArchetypesTree.getSelectionModel().setSelectionMode(TreeSelectionModel.SINGLE_TREE_SELECTION);
myArchetypesTree
.getSelectionModel()
.addTreeSelectionListener(
new TreeSelectionListener() {
public void valueChanged(TreeSelectionEvent e) {
updateArchetypeDescription();
archetypeMayBeChanged();
}
});
new TreeSpeedSearch(
myArchetypesTree,
new Convertor<TreePath, String>() {
public String convert(TreePath path) {
MavenArchetype info =
getArchetypeInfoFromPathComponent(path.getLastPathComponent());
return info.groupId + ":" + info.artifactId + ":" + info.version;
}
})
.setComparator(new SpeedSearchComparator(false));
myArchetypeDescriptionField.setEditable(false);
myArchetypeDescriptionField.setBackground(UIUtil.getPanelBackground());
requestUpdate();
updateComponents();
}