@Override
protected JComponent createTreePanel(final WatchDebuggerTree tree) {
final ToolbarDecorator decorator = ToolbarDecorator.createDecorator(tree);
decorator.setAddAction(
new AnActionButtonRunnable() {
@Override
public void run(AnActionButton button) {
executeAction(DebuggerActions.NEW_WATCH, tree);
}
});
// TODO[den]: add "Add to watches action" on Mac
if (!SystemInfo.isMac) {
decorator.addExtraAction(
AnActionButton.fromAction(
ActionManager.getInstance().getAction(XDebuggerActions.ADD_TO_WATCH)));
}
decorator.setRemoveAction(
new AnActionButtonRunnable() {
@Override
public void run(AnActionButton button) {
executeAction(DebuggerActions.REMOVE_WATCH, tree);
}
});
CustomLineBorder border =
new CustomLineBorder(
CaptionPanel.CNT_ACTIVE_BORDER_COLOR,
SystemInfo.isMac ? 1 : 0,
0,
SystemInfo.isMac ? 0 : 1,
0);
decorator.setToolbarBorder(border);
final JPanel panel = decorator.createPanel();
panel.setBorder(null);
return panel;
}
@Override
protected void addToolbarButtons(ToolbarDecorator toolbarDecorator) {
toolbarDecorator.setAddAction(
new AnActionButtonRunnable() {
@Override
public void run(AnActionButton button) {
final VirtualFile[] added = doAddItems();
if (added.length > 0) {
setModified(true);
}
requestDefaultFocus();
setSelectedRoots(added);
}
});
}
private JComponent getLibrariesTable() {
myLibraryTableModel = new LibraryTableModel();
final JBTable librariesTable = new JBTable(myLibraryTableModel);
librariesTable.setTableHeader(null);
librariesTable.setDefaultRenderer(String.class, new MyPathRenderer());
librariesTable.setShowHorizontalLines(false);
librariesTable.setShowVerticalLines(false);
librariesTable.setAutoCreateRowSorter(false);
librariesTable.setAutoscrolls(true);
ToolbarDecorator decorator = ToolbarDecorator.createDecorator(librariesTable);
decorator
.setAddAction(
new AnActionButtonRunnable() {
@Override
public void run(AnActionButton anActionButton) {
List<ModelRootDescriptor> modelRoots =
new ArrayList<ModelRootDescriptor>(
myJavaModuleFacet
.getModule()
.getModuleDescriptor()
.getModelRootDescriptors());
StubRootChooser stubRootChooser =
new StubRootChooser(
modelRoots,
(myJavaModuleFacet.getModule() instanceof Language ? true : false));
myLibraryTableModel.addAll(stubRootChooser.compute());
}
})
.setRemoveAction(
new AnActionButtonRunnable() {
@Override
public void run(AnActionButton anActionButton) {
TableUtil.removeSelectedItems(librariesTable);
myLibraryTableModel.fireTableDataChanged();
}
});
decorator.setToolbarBorder(IdeBorderFactory.createBorder());
decorator.setPreferredSize(new Dimension(500, 100));
JPanel table = decorator.createPanel();
table.setBorder(
IdeBorderFactory.createTitledBorder(
PropertiesBundle.message("mps.properties.configurable.module.javatab.librariesborder"),
false));
return table;
}
private JComponent getSourcePathsTable() {
myPathsTableModel = new PathsTableModel();
final JBTable sourcePathTable = new JBTable(myPathsTableModel);
sourcePathTable.setTableHeader(null);
sourcePathTable.setDefaultRenderer(String.class, new MyPathRenderer());
sourcePathTable.setShowHorizontalLines(false);
sourcePathTable.setShowVerticalLines(false);
sourcePathTable.setAutoCreateRowSorter(false);
sourcePathTable.setAutoscrolls(true);
ToolbarDecorator decorator = ToolbarDecorator.createDecorator(sourcePathTable);
decorator
.setAddAction(
new AnActionButtonRunnable() {
@Override
public void run(AnActionButton anActionButton) {
myPathsTableModel.add((new PathChooser()).compute());
}
})
.setRemoveAction(
new AnActionButtonRunnable() {
@Override
public void run(AnActionButton anActionButton) {
TableUtil.removeSelectedItems(sourcePathTable);
myPathsTableModel.fireTableDataChanged();
}
});
decorator.setToolbarBorder(IdeBorderFactory.createBorder());
decorator.setPreferredSize(new Dimension(500, 100));
JPanel table = decorator.createPanel();
table.setBorder(
IdeBorderFactory.createTitledBorder(
PropertiesBundle.message("mps.properties.configurable.module.javatab.sourcepathborder"),
false));
return table;
}
private JComponent createTableWithButtons() {
final boolean isAnalyzeShown = false;
final ClasspathPanelAction removeAction =
new ClasspathPanelAction(this) {
@Override
public void run() {
removeSelectedItems(TableUtil.removeSelectedItems(myEntryTable));
}
};
final AnActionButton analyzeButton =
new AnActionButton(
ProjectBundle.message("classpath.panel.analyze"), null, IconUtil.getAnalyzeIcon()) {
@Override
public void actionPerformed(@NotNull AnActionEvent e) {
AnalyzeDependenciesDialog.show(getRootModel().getModule());
}
};
// addButton.setShortcut(CustomShortcutSet.fromString("alt A", "INSERT"));
// removeButton.setShortcut(CustomShortcutSet.fromString("alt DELETE"));
// upButton.setShortcut(CustomShortcutSet.fromString("alt UP"));
// downButton.setShortcut(CustomShortcutSet.fromString("alt DOWN"));
final ToolbarDecorator decorator = ToolbarDecorator.createDecorator(myEntryTable);
AnActionButtonUpdater moveUpDownUpdater =
new AnActionButtonUpdater() {
@Override
public boolean isEnabled(AnActionEvent e) {
for (RowSorter.SortKey key : myEntryTable.getRowSorter().getSortKeys()) {
if (key.getSortOrder() != SortOrder.UNSORTED) {
return false;
}
}
return true;
}
};
decorator
.setAddAction(
new AnActionButtonRunnable() {
@Override
public void run(AnActionButton button) {
initPopupActions();
final JBPopup popup =
JBPopupFactory.getInstance()
.createListPopup(
new BaseListPopupStep<AddItemPopupAction<?>>(null, myPopupActions) {
@Override
public Icon getIconFor(AddItemPopupAction<?> aValue) {
return aValue.getIcon();
}
@Override
public boolean hasSubstep(AddItemPopupAction<?> selectedValue) {
return selectedValue.hasSubStep();
}
@Override
public boolean isMnemonicsNavigationEnabled() {
return true;
}
@Override
public PopupStep onChosen(
final AddItemPopupAction<?> selectedValue,
final boolean finalChoice) {
if (selectedValue.hasSubStep()) {
return selectedValue.createSubStep();
}
return doFinalStep(
new Runnable() {
@Override
public void run() {
selectedValue.execute();
}
});
}
@Override
@NotNull
public String getTextFor(AddItemPopupAction<?> value) {
return "&" + value.getIndex() + " " + value.getTitle();
}
});
popup.show(button.getPreferredPopupPoint());
}
})
.setRemoveAction(
new AnActionButtonRunnable() {
@Override
public void run(AnActionButton button) {
removeAction.actionPerformed(null);
}
})
.setRemoveActionUpdater(
new AnActionButtonUpdater() {
@Override
public boolean isEnabled(AnActionEvent e) {
final int[] selectedRows = myEntryTable.getSelectedRows();
for (final int selectedRow : selectedRows) {
if (!getItemAt(selectedRow).isRemovable()) {
return false;
}
}
return selectedRows.length > 0;
}
})
.setMoveUpAction(
new AnActionButtonRunnable() {
@Override
public void run(AnActionButton button) {
moveSelectedRows(-1);
}
})
.setMoveUpActionUpdater(moveUpDownUpdater)
.setMoveUpActionName("Move Up (disabled if items are shown in sorted order)")
.setMoveDownAction(
new AnActionButtonRunnable() {
@Override
public void run(AnActionButton button) {
moveSelectedRows(+1);
}
})
.setMoveDownActionUpdater(moveUpDownUpdater)
.setMoveDownActionName("Move Down (disabled if items are shown in sorted order)")
.addExtraAction(myEditButton);
if (isAnalyzeShown) {
decorator.addExtraAction(analyzeButton);
}
final JPanel panel = decorator.createPanel();
myRemoveButton = ToolbarDecorator.findRemoveButton(panel);
return panel;
}
private JComponent createTableWithButtons() {
final boolean isAnalyzeShown = false;
final ClasspathPanelAction removeAction =
new ClasspathPanelAction(this) {
@Override
public void run() {
removeSelectedItems(TableUtil.removeSelectedItems(myEntryTable));
}
};
final AnActionButton analyzeButton =
new AnActionButton(
ProjectBundle.message("classpath.panel.analyze"), null, IconUtil.getAnalyzeIcon()) {
@Override
public void actionPerformed(AnActionEvent e) {
AnalyzeDependenciesDialog.show(getRootModel().getModule());
}
};
// addButton.setShortcut(CustomShortcutSet.fromString("alt A", "INSERT"));
// removeButton.setShortcut(CustomShortcutSet.fromString("alt DELETE"));
// upButton.setShortcut(CustomShortcutSet.fromString("alt UP"));
// downButton.setShortcut(CustomShortcutSet.fromString("alt DOWN"));
myEntryTable.setBorder(new LineBorder(UIUtil.getBorderColor()));
// we need to register our listener before ToolbarDecorator registers its own. Otherwise
myEntryTable
.getSelectionModel()
.addListSelectionListener(
new ListSelectionListener() {
@Override
public void valueChanged(ListSelectionEvent e) {
if (e.getValueIsAdjusting()) {
return;
}
updateButtons();
}
});
final ToolbarDecorator decorator = ToolbarDecorator.createDecorator(myEntryTable);
decorator
.setAddAction(
new AnActionButtonRunnable() {
@Override
public void run(AnActionButton button) {
initPopupActions();
final JBPopup popup =
JBPopupFactory.getInstance()
.createListPopup(
new BaseListPopupStep<AddItemPopupAction<?>>(null, myPopupActions) {
@Override
public Icon getIconFor(AddItemPopupAction<?> aValue) {
return aValue.getIcon();
}
@Override
public boolean hasSubstep(AddItemPopupAction<?> selectedValue) {
return selectedValue.hasSubStep();
}
@Override
public boolean isMnemonicsNavigationEnabled() {
return true;
}
@Override
public PopupStep onChosen(
final AddItemPopupAction<?> selectedValue,
final boolean finalChoice) {
if (selectedValue.hasSubStep()) {
return selectedValue.createSubStep();
}
return doFinalStep(
new Runnable() {
@Override
public void run() {
selectedValue.execute();
}
});
}
@Override
@NotNull
public String getTextFor(AddItemPopupAction<?> value) {
return "&" + value.getIndex() + " " + value.getTitle();
}
});
popup.show(button.getPreferredPopupPoint());
}
})
.setRemoveAction(
new AnActionButtonRunnable() {
@Override
public void run(AnActionButton button) {
removeAction.actionPerformed(null);
}
})
.setMoveUpAction(
new AnActionButtonRunnable() {
@Override
public void run(AnActionButton button) {
moveSelectedRows(-1);
}
})
.setMoveDownAction(
new AnActionButtonRunnable() {
@Override
public void run(AnActionButton button) {
moveSelectedRows(+1);
}
})
.addExtraAction(myEditButton);
if (isAnalyzeShown) {
decorator.addExtraAction(analyzeButton);
}
final JPanel panel = decorator.createPanel();
myRemoveButton = ToolbarDecorator.findRemoveButton(panel);
return panel;
}
private void initializeUI() {
myTree = new Tree();
myTreeBuilder = new CertificateTreeBuilder(myTree);
// are not fully functional by now
myCheckHostname.setVisible(false);
myCheckValidityPeriod.setVisible(false);
myTrustManager = CertificateManager.getInstance().getCustomTrustManager();
// show newly added certificates
myTrustManager.addListener(this);
myTree.getEmptyText().setText("No certificates");
myTree.getSelectionModel().setSelectionMode(TreeSelectionModel.SINGLE_TREE_SELECTION);
myTree.setRootVisible(false);
// myTree.setShowsRootHandles(false);
ToolbarDecorator decorator = ToolbarDecorator.createDecorator(myTree).disableUpDownActions();
decorator
.setAddAction(
new AnActionButtonRunnable() {
@Override
public void run(AnActionButton button) {
// show choose file dialog, add certificate
FileChooser.chooseFile(
CERTIFICATE_DESCRIPTOR,
null,
null,
file -> {
String path = file.getPath();
X509Certificate certificate = CertificateUtil.loadX509Certificate(path);
if (certificate == null) {
Messages.showErrorDialog(
myRootPanel, "Malformed X509 server certificate", "Not Imported");
} else if (myCertificates.contains(certificate)) {
Messages.showWarningDialog(
myRootPanel, "Certificate already exists", "Not Imported");
} else {
myCertificates.add(certificate);
myTreeBuilder.addCertificate(certificate);
addCertificatePanel(certificate);
myTreeBuilder.selectCertificate(certificate);
}
});
}
})
.setRemoveAction(
new AnActionButtonRunnable() {
@Override
public void run(AnActionButton button) {
// allow to delete several certificates at once
for (X509Certificate certificate : myTreeBuilder.getSelectedCertificates(true)) {
myCertificates.remove(certificate);
myTreeBuilder.removeCertificate(certificate);
}
if (myCertificates.isEmpty()) {
showCard(EMPTY_PANEL);
} else {
myTreeBuilder.selectFirstCertificate();
}
}
});
myTree.addTreeSelectionListener(
new TreeSelectionListener() {
@Override
public void valueChanged(TreeSelectionEvent e) {
X509Certificate certificate = myTreeBuilder.getFirstSelectedCertificate(true);
if (certificate != null) {
showCard(getCardName(certificate));
}
}
});
myCertificatesListPanel.add(decorator.createPanel(), BorderLayout.CENTER);
}
private void createActions(ToolbarDecorator decorator) {
final Consumer<BaseInjection> consumer =
new Consumer<BaseInjection>() {
public void consume(final BaseInjection injection) {
addInjection(injection);
}
};
final Factory<BaseInjection> producer =
new NullableFactory<BaseInjection>() {
public BaseInjection create() {
final InjInfo info = getSelectedInjection();
return info == null ? null : info.injection;
}
};
for (LanguageInjectionSupport support : InjectorUtils.getActiveInjectionSupports()) {
ContainerUtil.addAll(myAddActions, support.createAddActions(myProject, consumer));
final AnAction action = support.createEditAction(myProject, producer);
myEditActions.put(
support.getId(),
action == null
? AbstractLanguageInjectionSupport.createDefaultEditAction(myProject, producer)
: action);
mySupports.put(support.getId(), support);
}
Collections.sort(
myAddActions,
new Comparator<AnAction>() {
public int compare(final AnAction o1, final AnAction o2) {
return Comparing.compare(
o1.getTemplatePresentation().getText(), o2.getTemplatePresentation().getText());
}
});
decorator.disableUpDownActions();
decorator.setAddActionUpdater(
new AnActionButtonUpdater() {
@Override
public boolean isEnabled(AnActionEvent e) {
return !myAddActions.isEmpty();
}
});
decorator.setAddAction(
new AnActionButtonRunnable() {
@Override
public void run(AnActionButton button) {
performAdd(button);
}
});
decorator.setRemoveActionUpdater(
new AnActionButtonUpdater() {
@Override
public boolean isEnabled(AnActionEvent e) {
boolean enabled = false;
for (InjInfo info : getSelectedInjections()) {
if (!info.bundled) {
enabled = true;
break;
}
}
return enabled;
}
});
decorator.setRemoveAction(
new AnActionButtonRunnable() {
@Override
public void run(AnActionButton button) {
performRemove();
}
});
decorator.setEditActionUpdater(
new AnActionButtonUpdater() {
@Override
public boolean isEnabled(AnActionEvent e) {
AnAction edit = getEditAction();
if (edit != null) edit.update(e);
return edit != null && edit.getTemplatePresentation().isEnabled();
}
});
decorator.setEditAction(
new AnActionButtonRunnable() {
@Override
public void run(AnActionButton button) {
performEditAction();
}
});
decorator.addExtraAction(
new DumbAwareActionButton("Duplicate", "Duplicate", PlatformIcons.COPY_ICON) {
@Override
public boolean isEnabled() {
return getEditAction() != null;
}
@Override
public void actionPerformed(@NotNull AnActionEvent e) {
final InjInfo injection = getSelectedInjection();
if (injection != null) {
addInjection(injection.injection.copy());
// performEditAction(e);
}
}
});
decorator.addExtraAction(
new DumbAwareActionButton(
"Enable Selected Injections",
"Enable Selected Injections",
PlatformIcons.SELECT_ALL_ICON) {
@Override
public void actionPerformed(@NotNull final AnActionEvent e) {
performSelectedInjectionsEnabled(true);
}
});
decorator.addExtraAction(
new DumbAwareActionButton(
"Disable Selected Injections",
"Disable Selected Injections",
PlatformIcons.UNSELECT_ALL_ICON) {
@Override
public void actionPerformed(@NotNull final AnActionEvent e) {
performSelectedInjectionsEnabled(false);
}
});
new DumbAwareAction("Toggle") {
@Override
public void update(@NotNull AnActionEvent e) {
SpeedSearchSupply supply = SpeedSearchSupply.getSupply(myInjectionsTable);
e.getPresentation().setEnabled(supply == null || !supply.isPopupActive());
}
@Override
public void actionPerformed(@NotNull final AnActionEvent e) {
performToggleAction();
}
}.registerCustomShortcutSet(
new CustomShortcutSet(KeyStroke.getKeyStroke(KeyEvent.VK_SPACE, 0)), myInjectionsTable);
if (myInfos.length > 1) {
AnActionButton shareAction =
new DumbAwareActionButton("Move to IDE Scope", null, PlatformIcons.IMPORT_ICON) {
{
addCustomUpdater(
new AnActionButtonUpdater() {
@Override
public boolean isEnabled(AnActionEvent e) {
CfgInfo cfg = getTargetCfgInfo(getSelectedInjections());
e.getPresentation()
.setText(
cfg == getDefaultCfgInfo()
? "Move to IDE Scope"
: "Move to Project Scope");
return cfg != null;
}
});
}
@Override
public void actionPerformed(@NotNull final AnActionEvent e) {
final List<InjInfo> injections = getSelectedInjections();
final CfgInfo cfg = getTargetCfgInfo(injections);
if (cfg == null) return;
for (InjInfo info : injections) {
if (info.cfgInfo == cfg) continue;
if (info.bundled) continue;
info.cfgInfo.injectionInfos.remove(info);
cfg.addInjection(info.injection);
}
final int[] selectedRows = myInjectionsTable.getSelectedRows();
myInjectionsTable.getListTableModel().setItems(getInjInfoList(myInfos));
TableUtil.selectRows(myInjectionsTable, selectedRows);
}
@Nullable
private CfgInfo getTargetCfgInfo(final List<InjInfo> injections) {
CfgInfo cfg = null;
for (InjInfo info : injections) {
if (info.bundled) {
continue;
}
if (cfg == null) cfg = info.cfgInfo;
else if (cfg != info.cfgInfo) return info.cfgInfo;
}
if (cfg == null) return null;
for (CfgInfo info : myInfos) {
if (info != cfg) return info;
}
throw new AssertionError();
}
};
shareAction.setShortcut(
new CustomShortcutSet(
KeyStroke.getKeyStroke(KeyEvent.VK_SPACE, InputEvent.SHIFT_DOWN_MASK)));
decorator.addExtraAction(shareAction);
}
decorator.addExtraAction(
new DumbAwareActionButton("Import", "Import", AllIcons.Actions.Install) {
@Override
public void actionPerformed(@NotNull final AnActionEvent e) {
doImportAction(e.getDataContext());
updateCountLabel();
}
});
decorator.addExtraAction(
new DumbAwareActionButton("Export", "Export", AllIcons.Actions.Export) {
@Override
public void actionPerformed(@NotNull final AnActionEvent e) {
final List<BaseInjection> injections = getInjectionList(getSelectedInjections());
final VirtualFileWrapper wrapper =
FileChooserFactory.getInstance()
.createSaveFileDialog(
new FileSaverDescriptor("Export Selected Injections to File...", "", "xml"),
myProject)
.save(null, null);
if (wrapper == null) return;
final Configuration configuration = new Configuration();
configuration.setInjections(injections);
final Document document = new Document(configuration.getState());
try {
JDOMUtil.writeDocument(document, wrapper.getFile(), "\n");
} catch (IOException ex) {
final String msg = ex.getLocalizedMessage();
Messages.showErrorDialog(
myProject,
msg != null && msg.length() > 0 ? msg : ex.toString(),
"Export Failed");
}
}
@Override
public boolean isEnabled() {
return !getSelectedInjections().isEmpty();
}
});
}
public XWatchesViewImpl(
@NotNull final XDebugSession session, final @NotNull XDebugSessionData sessionData) {
mySession = session;
mySessionData = sessionData;
myTreePanel =
new XDebuggerTreePanel(
session.getProject(),
session.getDebugProcess().getEditorsProvider(),
this,
null,
XDebuggerActions.WATCHES_TREE_POPUP_GROUP,
((XDebugSessionImpl) session).getValueMarkers());
ActionManager actionManager = ActionManager.getInstance();
XDebuggerTree tree = myTreePanel.getTree();
actionManager
.getAction(XDebuggerActions.XNEW_WATCH)
.registerCustomShortcutSet(CommonShortcuts.INSERT, tree);
actionManager
.getAction(XDebuggerActions.XREMOVE_WATCH)
.registerCustomShortcutSet(CommonShortcuts.DELETE, tree);
CustomShortcutSet f2Shortcut = new CustomShortcutSet(KeyStroke.getKeyStroke(KeyEvent.VK_F2, 0));
actionManager
.getAction(XDebuggerActions.XEDIT_WATCH)
.registerCustomShortcutSet(f2Shortcut, tree);
DnDManager.getInstance().registerTarget(this, tree);
myRootNode = new WatchesRootNode(tree, session, this, sessionData.getWatchExpressions());
tree.setRoot(myRootNode, false);
final ToolbarDecorator decorator =
ToolbarDecorator.createDecorator(myTreePanel.getTree()).disableUpDownActions();
decorator.setAddAction(
new AnActionButtonRunnable() {
@Override
public void run(AnActionButton button) {
executeAction(XDebuggerActions.XNEW_WATCH);
}
});
decorator.setRemoveAction(
new AnActionButtonRunnable() {
@Override
public void run(AnActionButton button) {
executeAction(XDebuggerActions.XREMOVE_WATCH);
}
});
CustomLineBorder border =
new CustomLineBorder(
CaptionPanel.CNT_ACTIVE_BORDER_COLOR,
SystemInfo.isMac ? 1 : 0,
0,
SystemInfo.isMac ? 0 : 1,
0);
decorator.setToolbarBorder(border);
myDecoratedPanel = decorator.createPanel();
myDecoratedPanel.setBorder(null);
myTreePanel.getTree().getEmptyText().setText(XDebuggerBundle.message("debugger.no.watches"));
}
BeforeRunStepsPanel(StepsBeforeRunListener listener) {
myListener = listener;
myModel = new CollectionListModel<BeforeRunTask>();
myList = new JBList(myModel);
myList.getEmptyText().setText(ExecutionBundle.message("before.launch.panel.empty"));
myList.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
myList.setCellRenderer(new MyListCellRenderer());
myModel.addListDataListener(
new ListDataListener() {
@Override
public void intervalAdded(ListDataEvent e) {
adjustVisibleRowCount();
updateText();
}
@Override
public void intervalRemoved(ListDataEvent e) {
adjustVisibleRowCount();
updateText();
}
@Override
public void contentsChanged(ListDataEvent e) {}
private void adjustVisibleRowCount() {
myList.setVisibleRowCount(Math.max(4, Math.min(8, myModel.getSize())));
}
});
ToolbarDecorator myDecorator = ToolbarDecorator.createDecorator(myList);
if (!SystemInfo.isMac) {
myDecorator.setAsUsualTopToolbar();
}
myDecorator.setEditAction(
new AnActionButtonRunnable() {
@Override
public void run(AnActionButton button) {
int index = myList.getSelectedIndex();
if (index == -1) return;
Pair<BeforeRunTask, BeforeRunTaskProvider<BeforeRunTask>> selection = getSelection();
if (selection == null) return;
BeforeRunTask task = selection.getFirst();
BeforeRunTaskProvider<BeforeRunTask> provider = selection.getSecond();
if (provider.configureTask(myRunConfiguration, task)) {
myModel.setElementAt(task, index);
}
}
});
myDecorator.setEditActionUpdater(
new AnActionButtonUpdater() {
@Override
public boolean isEnabled(AnActionEvent e) {
Pair<BeforeRunTask, BeforeRunTaskProvider<BeforeRunTask>> selection = getSelection();
return selection != null && selection.getSecond().isConfigurable();
}
});
myDecorator.setAddAction(
new AnActionButtonRunnable() {
@Override
public void run(AnActionButton button) {
doAddAction(button);
}
});
myDecorator.setAddActionUpdater(
new AnActionButtonUpdater() {
@Override
public boolean isEnabled(AnActionEvent e) {
return checkBeforeRunTasksAbility(true);
}
});
myShowSettingsBeforeRunCheckBox =
new JCheckBox(ExecutionBundle.message("configuration.edit.before.run"));
myShowSettingsBeforeRunCheckBox.addActionListener(
new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
updateText();
}
});
myPanel = myDecorator.createPanel();
setLayout(new BorderLayout());
add(myPanel, BorderLayout.CENTER);
add(myShowSettingsBeforeRunCheckBox, BorderLayout.SOUTH);
}
public CreateXmlResourceDialog(
@NotNull Module module,
@NotNull ResourceType resourceType,
@Nullable String predefinedName,
@Nullable String predefinedValue,
boolean chooseName,
@Nullable VirtualFile defaultFile) {
super(module.getProject());
myResourceType = resourceType;
if (predefinedName != null && predefinedName.length() > 0) {
if (!chooseName) {
myNameLabel.setVisible(false);
myNameField.setVisible(false);
}
myNameField.setText(predefinedName);
}
if (predefinedValue != null && predefinedValue.length() > 0) {
myValueLabel.setVisible(false);
myValueField.setVisible(false);
myValueField.setText(predefinedValue);
}
final Set<Module> modulesSet = new HashSet<Module>();
modulesSet.add(module);
for (AndroidFacet depFacet : AndroidUtils.getAllAndroidDependencies(module, true)) {
modulesSet.add(depFacet.getModule());
}
assert modulesSet.size() > 0;
if (modulesSet.size() == 1) {
myModule = module;
myModuleLabel.setVisible(false);
myModuleCombo.setVisible(false);
} else {
myModule = null;
final Module[] modules = modulesSet.toArray(new Module[modulesSet.size()]);
Arrays.sort(
modules,
new Comparator<Module>() {
@Override
public int compare(Module m1, Module m2) {
return m1.getName().compareTo(m2.getName());
}
});
myModuleCombo.setModel(new DefaultComboBoxModel(modules));
myModuleCombo.setSelectedItem(module);
myModuleCombo.setRenderer(new ModuleListCellRendererWrapper(myModuleCombo.getRenderer()));
}
if (defaultFile == null) {
final String defaultFileName = AndroidResourceUtil.getDefaultResourceFileName(resourceType);
if (defaultFileName != null) {
myFileNameCombo.getEditor().setItem(defaultFileName);
}
}
myDirectoriesList = new CheckBoxList();
myDirectoriesLabel.setLabelFor(myDirectoriesList);
final ToolbarDecorator decorator = ToolbarDecorator.createDecorator(myDirectoriesList);
decorator.setEditAction(null);
decorator.disableUpDownActions();
decorator.setAddAction(
new AnActionButtonRunnable() {
@Override
public void run(AnActionButton button) {
doAddNewDirectory();
}
});
decorator.setRemoveAction(
new AnActionButtonRunnable() {
@Override
public void run(AnActionButton button) {
doDeleteDirectory();
}
});
final AnActionButton selectAll =
new AnActionButton("Select All", null, PlatformIcons.SELECT_ALL_ICON) {
@Override
public void actionPerformed(AnActionEvent e) {
doSelectAllDirs();
}
};
decorator.addExtraAction(selectAll);
final AnActionButton unselectAll =
new AnActionButton("Unselect All", null, PlatformIcons.UNSELECT_ALL_ICON) {
@Override
public void actionPerformed(AnActionEvent e) {
doUnselectAllDirs();
}
};
decorator.addExtraAction(unselectAll);
myDirectoriesPanel.add(decorator.createPanel());
updateDirectories(true);
myModuleCombo.addActionListener(
new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
updateDirectories(true);
}
});
final JCheckBox valuesCheckBox = myCheckBoxes.get(SdkConstants.FD_RES_VALUES);
if (valuesCheckBox != null) {
valuesCheckBox.setSelected(true);
}
if (defaultFile != null) {
resetFromFile(defaultFile, module.getProject());
}
init();
}