@Nullable
public VcsCommittedViewAuxiliary createActions(
final DecoratorManager manager, @Nullable final RepositoryLocation location) {
final RootsAndBranches rootsAndBranches = new RootsAndBranches(myProject, manager, location);
refreshMergeInfo(rootsAndBranches);
final DefaultActionGroup popup = new DefaultActionGroup(myVcs.getDisplayName(), true);
popup.add(rootsAndBranches.getIntegrateAction());
popup.add(rootsAndBranches.getUndoIntegrateAction());
popup.add(new ConfigureBranchesAction());
final ShowHideMergePanel action =
new ShowHideMergePanel(manager, rootsAndBranches.getStrategy());
return new VcsCommittedViewAuxiliary(
Collections.<AnAction>singletonList(popup),
new Runnable() {
public void run() {
if (myMergeInfoUpdatesListener != null) {
myMergeInfoUpdatesListener.removePanel(rootsAndBranches);
rootsAndBranches.dispose();
}
}
},
Collections.<AnAction>singletonList(action));
}
protected void addActionsTo(DefaultActionGroup group) {
group.add(new MyGroupByPackagesAction());
group.add(new GroupByChangeListAction());
group.add(ActionManager.getInstance().getAction(IdeActions.ACTION_EXPAND_ALL));
group.add(ActionManager.getInstance().getAction(IdeActions.ACTION_COLLAPSE_ALL));
group.add(ActionManager.getInstance().getAction("Diff.UpdatedFiles"));
}
@Override
protected List<AnAction> fillToolBarActions(
final DefaultActionGroup toolbarActions,
final Executor defaultExecutor,
final RunContentDescriptor contentDescriptor) {
AnAction backspaceHandlingAction = createBackspaceHandlingAction();
// toolbarActions.add(backspaceHandlingAction);
AnAction interruptAction = createInterruptAction();
AnAction rerunAction = createRerunAction();
toolbarActions.add(rerunAction);
List<AnAction> actions =
super.fillToolBarActions(toolbarActions, defaultExecutor, contentDescriptor);
actions.add(0, rerunAction);
actions.add(backspaceHandlingAction);
actions.add(interruptAction);
actions.add(createSplitLineAction());
AnAction showVarsAction = new ShowVarsAction();
toolbarActions.add(showVarsAction);
toolbarActions.add(myHistoryController.getBrowseHistory());
toolbarActions.add(new ConnectDebuggerAction());
return actions;
}
private JPanel createToolbarPanel(Collection<AnAction> actions) {
final DefaultActionGroup group = new DefaultActionGroup();
for (AnAction action : actions) {
group.add(action);
}
final ActionToolbar actionToolBar =
ActionManager.getInstance().createActionToolbar(ActionPlaces.UNKNOWN, group, false);
final JPanel panel = new JPanel(new BorderLayout());
panel.add(actionToolBar.getComponent(), BorderLayout.CENTER);
return panel;
}
protected void initTree() {
((DefaultTreeModel) myTree.getModel()).setRoot(myRoot);
myTree.setRootVisible(false);
myTree.setShowsRootHandles(true);
UIUtil.setLineStyleAngled(myTree);
TreeUtil.installActions(myTree);
myTree.setCellRenderer(
new ColoredTreeCellRenderer() {
public void customizeCellRenderer(
JTree tree,
Object value,
boolean selected,
boolean expanded,
boolean leaf,
int row,
boolean hasFocus) {
if (value instanceof MyNode) {
final MyNode node = ((MyNode) value);
setIcon(node.getIcon(expanded));
final Font font = UIUtil.getTreeFont();
if (node.isDisplayInBold()) {
setFont(font.deriveFont(Font.BOLD));
} else {
setFont(font.deriveFont(Font.PLAIN));
}
append(
node.getDisplayName(),
node.isDisplayInBold()
? SimpleTextAttributes.REGULAR_BOLD_ATTRIBUTES
: SimpleTextAttributes.REGULAR_ATTRIBUTES);
}
}
});
initToolbar();
ArrayList<AnAction> actions = createActions(true);
if (actions != null) {
final DefaultActionGroup group = new DefaultActionGroup();
for (AnAction action : actions) {
group.add(action);
}
actions = getAdditionalActions();
if (actions != null) {
group.addSeparator();
for (AnAction action : actions) {
group.add(action);
}
}
PopupHandler.installPopupHandler(
myTree,
group,
ActionPlaces.UNKNOWN,
ActionManager.getInstance()); // popup should follow the selection
}
}
@Override
@NotNull
protected final DefaultActionGroup createPopupActionGroup(final JComponent button) {
final DefaultActionGroup group = new DefaultActionGroup();
for (String name : getValidScopeNames()) {
group.add(new MenuAction(name));
}
group.add(new ConfigureScopesAction());
return group;
}
private DefaultActionGroup createFilteringActionsGroup() {
final DefaultActionGroup group = new DefaultActionGroup();
final AnAction[] groupingActions = createGroupingActions();
for (AnAction groupingAction : groupingActions) {
group.add(groupingAction);
}
addFilteringActions(group);
group.add(new PreviewUsageAction(this));
group.add(new SortMembersAlphabeticallyAction(this));
return group;
}
public Editor addCommitLog(String title, Editor commitLog) {
boolean notExist = !_commitLogs.contains(commitLog);
LOG.assertTrue(notExist);
//noinspection ConstantConditions
if (notExist) {
DefaultActionGroup actions = new DefaultActionGroup();
actions.add(new CopyContentAction(commitLog));
addTab(
title, commitLog.getComponent(), true, false, false, true, actions, COMMIT_LOG_HELP_ID);
_commitLogs.add(commitLog);
}
return commitLog;
}
protected DefaultActionGroup createToolbarActionGroup() {
final ArrayList<AnAction> actions = createActions(false);
if (actions != null) {
final DefaultActionGroup group = new DefaultActionGroup();
for (AnAction action : actions) {
if (action instanceof ActionGroupWithPreselection) {
group.add(new MyActionGroupWrapper((ActionGroupWithPreselection) action));
} else {
group.add(action);
}
}
return group;
}
return null;
}
public void addFilteringActions(DefaultActionGroup group) {
final JComponent component = getComponent();
final MergeDupLines mergeDupLines = new MergeDupLines();
mergeDupLines.registerCustomShortcutSet(mergeDupLines.getShortcutSet(), component, this);
group.add(mergeDupLines);
final UsageFilteringRuleProvider[] providers =
Extensions.getExtensions(UsageFilteringRuleProvider.EP_NAME);
for (UsageFilteringRuleProvider provider : providers) {
AnAction[] actions = provider.createFilteringActions(this);
for (AnAction action : actions) {
group.add(action);
}
}
}
private void addChangeLibraryLevelAction(DefaultActionGroup actionGroup, String tableLevel) {
final LibraryTablePresentation presentation =
LibraryEditingUtil.getLibraryTablePresentation(getProject(), tableLevel);
actionGroup.add(
new ChangeLibraryLevelInClasspathAction(
this, presentation.getDisplayName(true), tableLevel));
}
@NotNull
protected DefaultActionGroup createPopupActionGroup(final JComponent button) {
final DefaultActionGroup group = new DefaultActionGroup();
for (final PatternDialectProvider provider :
Extensions.getExtensions(PatternDialectProvider.EP_NAME)) {
group.add(
new AnAction(provider.getDisplayName()) {
public void actionPerformed(final AnActionEvent e) {
mySettings.SCOPE_TYPE = provider.getShortName();
DependencyUISettings.getInstance().SCOPE_TYPE = provider.getShortName();
rebuild();
}
});
}
return group;
}
@Override
protected JComponent createCenterPanel() {
JPanel panel = new JPanel(new BorderLayout());
// Toolbar
DefaultActionGroup group = new DefaultActionGroup();
fillToolbarActions(group);
group.addSeparator();
ExpandAllAction expandAllAction = new ExpandAllAction();
expandAllAction.registerCustomShortcutSet(
new CustomShortcutSet(
KeymapManager.getInstance()
.getActiveKeymap()
.getShortcuts(IdeActions.ACTION_EXPAND_ALL)),
myTree);
group.add(expandAllAction);
CollapseAllAction collapseAllAction = new CollapseAllAction();
collapseAllAction.registerCustomShortcutSet(
new CustomShortcutSet(
KeymapManager.getInstance()
.getActiveKeymap()
.getShortcuts(IdeActions.ACTION_COLLAPSE_ALL)),
myTree);
group.add(collapseAllAction);
panel.add(
ActionManager.getInstance()
.createActionToolbar(ActionPlaces.UNKNOWN, group, true)
.getComponent(),
BorderLayout.NORTH);
// Tree
expandFirst();
defaultExpandTree();
installSpeedSearch();
JScrollPane scrollPane = ScrollPaneFactory.createScrollPane(myTree);
scrollPane.setPreferredSize(new Dimension(350, 450));
panel.add(scrollPane, BorderLayout.CENTER);
return panel;
}
@Override
protected void buildToolBar(final DefaultActionGroup toolBarGroup) {
super.buildToolBar(toolBarGroup);
EmptyAction.registerWithShortcutSet(
IdeActions.MOVE_TO_ANOTHER_CHANGE_LIST, CommonShortcuts.getMove(), myViewer);
toolBarGroup.add(ActionManager.getInstance().getAction(IdeActions.MOVE_TO_ANOTHER_CHANGE_LIST));
}
protected void fillToolbarActions(DefaultActionGroup group) {
final boolean alphabeticallySorted = PropertiesComponent.getInstance().isTrueValue(PROP_SORTED);
if (alphabeticallySorted) {
setSortComparator(new OrderComparator());
}
myAlphabeticallySorted = alphabeticallySorted;
group.add(mySortAction);
if (!supportsNestedContainers()) {
ShowContainersAction showContainersAction = getShowContainersAction();
showContainersAction.registerCustomShortcutSet(
new CustomShortcutSet(KeyStroke.getKeyStroke(KeyEvent.VK_C, InputEvent.ALT_MASK)),
myTree);
setShowClasses(PropertiesComponent.getInstance().isTrueValue(PROP_SHOWCLASSES));
group.add(showContainersAction);
}
}
private ActionToolbar createToolbar() {
DefaultActionGroup group = new DefaultActionGroup();
final DumbAwareAction refreshActionAction =
new DumbAwareAction("Refresh", "Refresh changes list", AllIcons.Actions.Refresh) {
@Override
public void actionPerformed(AnActionEvent anActionEvent) {
final Project project = anActionEvent.getData(PlatformDataKeys.PROJECT);
reloadChanges(project, true);
}
};
group.add(refreshActionAction);
group.add(new SettingsAction());
return ActionManager.getInstance().createActionToolbar(ActionPlaces.UNKNOWN, group, false);
}
private void popupInvoked(Component component, int x, int y) {
final TreePath path = myTree.getLeadSelectionPath();
if (path == null) return;
final DefaultActionGroup actions = new DefaultActionGroup();
final ActionManager actionManager = ActionManager.getInstance();
actions.add(actionManager.getAction(IdeActions.ACTION_EDIT_SOURCE));
actions.add(actionManager.getAction(IdeActions.ACTION_FIND_USAGES));
actions.add(myIncludeAction);
actions.add(myExcludeAction);
actions.addSeparator();
final InspectionToolWrapper toolWrapper = myTree.getSelectedToolWrapper();
if (toolWrapper != null) {
final QuickFixAction[] quickFixes = myProvider.getQuickFixes(toolWrapper, myTree);
if (quickFixes != null) {
for (QuickFixAction quickFixe : quickFixes) {
actions.add(quickFixe);
}
}
final HighlightDisplayKey key = HighlightDisplayKey.find(toolWrapper.getShortName());
if (key == null) return; // e.g. DummyEntryPointsTool
// options
actions.addSeparator();
actions.add(new EditSettingsAction());
final List<AnAction> options = new InspectionsOptionsToolbarAction(this).createActions();
for (AnAction action : options) {
actions.add(action);
}
}
actions.addSeparator();
actions.add(actionManager.getAction(IdeActions.GROUP_VERSION_CONTROLS));
final ActionPopupMenu menu =
actionManager.createActionPopupMenu(ActionPlaces.CODE_INSPECTION, actions);
menu.getComponent().show(component, x, y);
}
private ActiveComponent createPinButton(
final UsageInfoToUsageConverter.TargetElementsDescriptor descriptor,
final UsageViewImpl usageView,
final FindUsagesOptions options,
final JBPopup[] popup,
DefaultActionGroup pinGroup) {
final AnAction pinAction =
new AnAction(
"Open Find Usages Toolwindow",
"Show all usages in a separate toolwindow",
AllIcons.General.AutohideOff) {
{
AnAction action = ActionManager.getInstance().getAction(IdeActions.ACTION_FIND_USAGES);
setShortcutSet(action.getShortcutSet());
}
@Override
public void actionPerformed(AnActionEvent e) {
hideHints();
popup[0].cancel();
FindUsagesManager findUsagesManager =
((FindManagerImpl) FindManager.getInstance(usageView.getProject()))
.getFindUsagesManager();
FindUsagesManager.SearchData data = new FindUsagesManager.SearchData();
data.myOptions = options;
List<SmartPsiElementPointer<PsiElement>> plist = descriptor.getAllElementPointers();
data.myElements = plist.toArray(new SmartPsiElementPointer[plist.size()]);
findUsagesManager.rerunAndRecallFromHistory(data);
}
};
pinGroup.add(pinAction);
final ActionToolbar pinToolbar =
ActionManager.getInstance()
.createActionToolbar(ActionPlaces.USAGE_VIEW_TOOLBAR, pinGroup, true);
pinToolbar.setReservePlaceAutoPopupIcon(false);
final JComponent pinToolBar = pinToolbar.getComponent();
pinToolBar.setBorder(null);
pinToolBar.setOpaque(false);
return new ActiveComponent() {
@Override
public void setActive(boolean active) {}
@Override
public JComponent getComponent() {
return pinToolBar;
}
};
}
private JComponent createActionsToolbar() {
DefaultActionGroup group =
new DefaultActionGroup() {
@Override
public void update(AnActionEvent e) {
super.update(e);
myButtonPanel.update();
}
@Override
public boolean isDumbAware() {
return true;
}
};
AnAction[] actions = createActions();
for (final AnAction action : actions) {
if (action != null) {
group.add(action);
}
}
return toUsageViewToolbar(group);
}
public void buildUi() {
myTopPanel = new JPanel(new BorderLayout());
final JPanel wrapper = new JPanel();
// final BoxLayout boxLayout = new BoxLayout(wrapper, BoxLayout.X_AXIS);
wrapper.setLayout(new BorderLayout());
myTitleLabel.setBorder(BorderFactory.createEmptyBorder(1, 2, 0, 0));
wrapper.add(myTitleLabel, BorderLayout.WEST);
DefaultActionGroup dag = new DefaultActionGroup();
myPreviousDiff.copyShortcutFrom(ActionManager.getInstance().getAction("PreviousDiff"));
myNextDiff.copyShortcutFrom(ActionManager.getInstance().getAction("NextDiff"));
dag.add(new MyChangeContextAction());
dag.add(myPreviousDiff);
dag.add(myNextDiff);
myPreviousDiff.registerCustomShortcutSet(myPreviousDiff.getShortcutSet(), myPanel);
myNextDiff.registerCustomShortcutSet(myNextDiff.getShortcutSet(), myPanel);
dag.add(new PopupAction());
ActionToolbar toolbar =
ActionManager.getInstance().createActionToolbar(ActionPlaces.UNKNOWN, dag, true);
wrapper.add(toolbar.getComponent(), BorderLayout.EAST);
myTopPanel.add(wrapper, BorderLayout.CENTER);
final JPanel wrapperDiffs = new JPanel(new GridBagLayout());
final JPanel oneMore = new JPanel(new BorderLayout());
oneMore.add(wrapperDiffs, BorderLayout.NORTH);
myCurrentHorizontal = myConfiguration.SHORT_DIFF_HORISONTALLY;
myHorizontal = createPanel(true);
myVertical = createPanel(false);
myPanel.add(myTopPanel, BorderLayout.NORTH);
myPanel.add(getCurrentPanel().getComponent(), BorderLayout.CENTER);
myPreviousDiff.registerCustomShortcutSet(myPreviousDiff.getShortcutSet(), myParent);
myNextDiff.registerCustomShortcutSet(myNextDiff.getShortcutSet(), myParent);
}
protected void buildToolBar(final DefaultActionGroup toolBarGroup) {
myDiffAction =
new DumbAwareAction() {
public void update(AnActionEvent e) {
e.getPresentation().setEnabled(canShowDiff());
}
public void actionPerformed(AnActionEvent e) {
showDiff();
}
};
ActionUtil.copyFrom(myDiffAction, "ChangesView.Diff");
myDiffAction.registerCustomShortcutSet(myViewer, null);
toolBarGroup.add(myDiffAction);
}
@Override
public void actionPerformed(AnActionEvent e) {
final DefaultActionGroup dag = new DefaultActionGroup();
dag.add(myUsual);
dag.add(myNumbered);
dag.add(mySoftWrapsAction);
final ListPopup popup =
JBPopupFactory.getInstance()
.createActionGroupPopup(
null,
dag,
e.getDataContext(),
JBPopupFactory.ActionSelectionAid.SPEEDSEARCH,
false);
if (e.getInputEvent() instanceof MouseEvent) {
popup.show(new RelativePoint((MouseEvent) e.getInputEvent()));
} else {
// todo correct
/*final Dimension dimension = popup.getContent().getPreferredSize();
final Point at = new Point(-dimension.width / 2, 0);
popup.show(new RelativePoint(myParent, at));*/
popup.showInBestPositionFor(e.getDataContext());
}
}
private ActionGroup createTreePopupActions(boolean isRightTree) {
DefaultActionGroup group = new DefaultActionGroup();
final ActionManager actionManager = ActionManager.getInstance();
group.add(actionManager.getAction(IdeActions.ACTION_EDIT_SOURCE));
group.add(actionManager.getAction(IdeActions.GROUP_VERSION_CONTROLS));
if (isRightTree) {
group.add(actionManager.getAction(IdeActions.GROUP_ANALYZE));
group.add(new AddToScopeAction());
group.add(new SelectInLeftTreeAction());
group.add(new ShowDetailedInformationAction());
} else {
group.add(new RemoveFromScopeAction());
}
return group;
}
private JComponent createLeftActionsToolbar() {
final CommonActionsManager actionsManager = CommonActionsManager.getInstance();
DefaultActionGroup group = new DefaultActionGroup();
group.add(new RerunAction(this));
group.add(new CloseAction());
final TreeExpander treeExpander =
new TreeExpander() {
@Override
public void expandAll() {
TreeUtil.expandAll(myTree);
}
@Override
public boolean canExpand() {
return true;
}
@Override
public void collapseAll() {
TreeUtil.collapseAll(myTree, 0);
}
@Override
public boolean canCollapse() {
return true;
}
};
group.add(actionsManager.createExpandAllAction(treeExpander, myTree));
group.add(actionsManager.createCollapseAllAction(treeExpander, myTree));
group.add(actionsManager.createPrevOccurenceAction(getOccurenceNavigator()));
group.add(actionsManager.createNextOccurenceAction(getOccurenceNavigator()));
group.add(myGlobalInspectionContext.createToggleAutoscrollAction());
group.add(new ExportHTMLAction(this));
group.add(new ContextHelpAction(HELP_ID));
return createToolbar(group);
}
@NotNull
protected JComponent createToolbar() {
DefaultActionGroup toolbarGroups = new DefaultActionGroup();
myToolBarGroup = new DefaultActionGroup();
toolbarGroups.add(myToolBarGroup);
buildToolBar(myToolBarGroup);
toolbarGroups.addSeparator();
DefaultActionGroup treeActionsGroup = new DefaultActionGroup();
toolbarGroups.add(treeActionsGroup);
for (AnAction action : myViewer.getTreeActions()) {
treeActionsGroup.add(action);
}
ActionToolbar toolbar =
ActionManager.getInstance().createActionToolbar(ActionPlaces.TOOLBAR, toolbarGroups, true);
toolbar.setTargetComponent(this);
return toolbar.getComponent();
}
@NotNull
private JBPopup createUsagePopup(
@NotNull final List<Usage> usages,
@NotNull final UsageInfoToUsageConverter.TargetElementsDescriptor descriptor,
@NotNull Set<UsageNode> visibleNodes,
@NotNull final FindUsagesHandler handler,
final Editor editor,
@NotNull final RelativePoint popupPosition,
final int maxUsages,
@NotNull final UsageViewImpl usageView,
@NotNull final FindUsagesOptions options,
@NotNull final JTable table,
@NotNull final UsageViewPresentation presentation,
@NotNull final AsyncProcessIcon processIcon,
boolean hadMoreSeparator) {
table.setRowHeight(PlatformIcons.CLASS_ICON.getIconHeight() + 2);
table.setShowGrid(false);
table.setShowVerticalLines(false);
table.setShowHorizontalLines(false);
table.setTableHeader(null);
table.setAutoResizeMode(JTable.AUTO_RESIZE_LAST_COLUMN);
table.setIntercellSpacing(new Dimension(0, 0));
PopupChooserBuilder builder = new PopupChooserBuilder(table);
final String title = presentation.getTabText();
if (title != null) {
String result = getFullTitle(usages, title, hadMoreSeparator, visibleNodes.size() - 1, true);
builder.setTitle(result);
builder.setAdText(getSecondInvocationTitle(options, handler));
}
builder.setMovable(true).setResizable(true);
builder.setItemChoosenCallback(
new Runnable() {
@Override
public void run() {
int[] selected = table.getSelectedRows();
for (int i : selected) {
Object value = table.getValueAt(i, 0);
if (value instanceof UsageNode) {
Usage usage = ((UsageNode) value).getUsage();
if (usage == MORE_USAGES_SEPARATOR) {
appendMoreUsages(editor, popupPosition, handler, maxUsages);
return;
}
navigateAndHint(usage, null, handler, popupPosition, maxUsages, options);
}
}
}
});
final JBPopup[] popup = new JBPopup[1];
KeyboardShortcut shortcut = UsageViewImpl.getShowUsagesWithSettingsShortcut();
if (shortcut != null) {
new DumbAwareAction() {
@Override
public void actionPerformed(AnActionEvent e) {
popup[0].cancel();
showDialogAndFindUsages(handler, popupPosition, editor, maxUsages);
}
}.registerCustomShortcutSet(new CustomShortcutSet(shortcut.getFirstKeyStroke()), table);
}
shortcut = getShowUsagesShortcut();
if (shortcut != null) {
new DumbAwareAction() {
@Override
public void actionPerformed(AnActionEvent e) {
popup[0].cancel();
searchEverywhere(options, handler, editor, popupPosition, maxUsages);
}
}.registerCustomShortcutSet(new CustomShortcutSet(shortcut.getFirstKeyStroke()), table);
}
InplaceButton settingsButton =
createSettingsButton(
handler,
popupPosition,
editor,
maxUsages,
new Runnable() {
@Override
public void run() {
popup[0].cancel();
}
});
ActiveComponent spinningProgress =
new ActiveComponent() {
@Override
public void setActive(boolean active) {}
@Override
public JComponent getComponent() {
return processIcon;
}
};
builder.setCommandButton(new CompositeActiveComponent(spinningProgress, settingsButton));
DefaultActionGroup toolbar = new DefaultActionGroup();
usageView.addFilteringActions(toolbar);
toolbar.add(UsageGroupingRuleProviderImpl.createGroupByFileStructureAction(usageView));
toolbar.add(
new AnAction(
"Open Find Usages Toolwindow",
"Show all usages in a separate toolwindow",
AllIcons.Toolwindows.ToolWindowFind) {
{
AnAction action = ActionManager.getInstance().getAction(IdeActions.ACTION_FIND_USAGES);
setShortcutSet(action.getShortcutSet());
}
@Override
public void actionPerformed(AnActionEvent e) {
hideHints();
popup[0].cancel();
FindUsagesManager findUsagesManager =
((FindManagerImpl) FindManager.getInstance(usageView.getProject()))
.getFindUsagesManager();
findUsagesManager.findUsages(
handler.getPrimaryElements(),
handler.getSecondaryElements(),
handler,
options,
FindSettings.getInstance().isSkipResultsWithOneUsage());
}
});
ActionToolbar actionToolbar =
ActionManager.getInstance()
.createActionToolbar(ActionPlaces.USAGE_VIEW_TOOLBAR, toolbar, true);
actionToolbar.setReservePlaceAutoPopupIcon(false);
final JComponent toolBar = actionToolbar.getComponent();
toolBar.setOpaque(false);
builder.setSettingButton(toolBar);
popup[0] = builder.createPopup();
JComponent content = popup[0].getContent();
myWidth =
(int)
(toolBar.getPreferredSize().getWidth()
+ new JLabel(
getFullTitle(
usages, title, hadMoreSeparator, visibleNodes.size() - 1, true))
.getPreferredSize()
.getWidth()
+ settingsButton.getPreferredSize().getWidth());
myWidth = -1;
for (AnAction action : toolbar.getChildren(null)) {
action.unregisterCustomShortcutSet(usageView.getComponent());
action.registerCustomShortcutSet(action.getShortcutSet(), content);
}
return popup[0];
}
public ClasspathPanelImpl(ModuleConfigurationState state) {
super(new BorderLayout());
myState = state;
myModel = new ClasspathTableModel(state, getStructureConfigurableContext());
myEntryTable =
new JBTable(myModel) {
@Override
protected TableRowSorter<TableModel> createRowSorter(TableModel model) {
return new DefaultColumnInfoBasedRowSorter(model) {
@Override
public void toggleSortOrder(int column) {
if (isSortable(column)) {
SortKey oldKey = ContainerUtil.getFirstItem(getSortKeys());
SortOrder oldOrder;
if (oldKey == null || oldKey.getColumn() != column) {
oldOrder = SortOrder.UNSORTED;
} else {
oldOrder = oldKey.getSortOrder();
}
setSortKeys(
Collections.singletonList(new SortKey(column, getNextSortOrder(oldOrder))));
}
}
};
}
};
myEntryTable.setShowGrid(false);
myEntryTable.setDragEnabled(false);
myEntryTable.setIntercellSpacing(new Dimension(0, 0));
myEntryTable.setDefaultRenderer(
ClasspathTableItem.class, new TableItemRenderer(getStructureConfigurableContext()));
myEntryTable.setDefaultRenderer(
Boolean.class, new ExportFlagRenderer(myEntryTable.getDefaultRenderer(Boolean.class)));
JComboBox scopeEditor =
new ComboBox(new EnumComboBoxModel<DependencyScope>(DependencyScope.class));
myEntryTable.setDefaultEditor(DependencyScope.class, new DefaultCellEditor(scopeEditor));
myEntryTable.setDefaultRenderer(
DependencyScope.class,
new ComboBoxTableRenderer<DependencyScope>(DependencyScope.values()) {
@Override
protected String getTextFor(@NotNull final DependencyScope value) {
return value.getDisplayName();
}
});
myEntryTable.setTransferHandler(
new TransferHandler() {
@Nullable
@Override
protected Transferable createTransferable(JComponent c) {
OrderEntry entry = getSelectedEntry();
if (entry == null) return null;
String text = entry.getPresentableName();
return new TextTransferable(text);
}
@Override
public int getSourceActions(JComponent c) {
return COPY;
}
});
myEntryTable
.getSelectionModel()
.setSelectionMode(ListSelectionModel.MULTIPLE_INTERVAL_SELECTION);
new SpeedSearchBase<JBTable>(myEntryTable) {
@Override
public int getSelectedIndex() {
return myEntryTable.getSelectedRow();
}
@Override
protected int convertIndexToModel(int viewIndex) {
return myEntryTable.convertRowIndexToModel(viewIndex);
}
@Override
public Object[] getAllElements() {
final int count = myModel.getRowCount();
Object[] elements = new Object[count];
for (int idx = 0; idx < count; idx++) {
elements[idx] = myModel.getItem(idx);
}
return elements;
}
@Override
public String getElementText(Object element) {
return getCellAppearance(
(ClasspathTableItem<?>) element, getStructureConfigurableContext(), false)
.getText();
}
@Override
public void selectElement(Object element, String selectedText) {
final int count = myModel.getRowCount();
for (int row = 0; row < count; row++) {
if (element.equals(myModel.getItem(row))) {
final int viewRow = myEntryTable.convertRowIndexToView(row);
myEntryTable.getSelectionModel().setSelectionInterval(viewRow, viewRow);
TableUtil.scrollSelectionToVisible(myEntryTable);
break;
}
}
}
};
setFixedColumnWidth(ClasspathTableModel.EXPORT_COLUMN);
setFixedColumnWidth(ClasspathTableModel.SCOPE_COLUMN); // leave space for combobox border
myEntryTable.registerKeyboardAction(
new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
final int[] selectedRows = myEntryTable.getSelectedRows();
boolean currentlyMarked = true;
for (final int selectedRow : selectedRows) {
final ClasspathTableItem<?> item = getItemAt(selectedRow);
if (selectedRow < 0 || !item.isExportable()) {
return;
}
currentlyMarked &= item.isExported();
}
for (final int selectedRow : selectedRows) {
getItemAt(selectedRow).setExported(!currentlyMarked);
}
myModel.fireTableDataChanged();
TableUtil.selectRows(myEntryTable, selectedRows);
}
},
KeyStroke.getKeyStroke(KeyEvent.VK_SPACE, 0),
WHEN_FOCUSED);
myEditButton =
new AnActionButton(
ProjectBundle.message("module.classpath.button.edit"), null, IconUtil.getEditIcon()) {
@Override
public void actionPerformed(@NotNull AnActionEvent e) {
doEdit();
}
@Override
public boolean isEnabled() {
ClasspathTableItem<?> selectedItem = getSelectedItem();
return selectedItem != null && selectedItem.isEditable();
}
@Override
public boolean isDumbAware() {
return true;
}
};
add(createTableWithButtons(), BorderLayout.CENTER);
if (myEntryTable.getRowCount() > 0) {
myEntryTable.getSelectionModel().setSelectionInterval(0, 0);
}
new DoubleClickListener() {
@Override
protected boolean onDoubleClick(MouseEvent e) {
navigate(true);
return true;
}
}.installOn(myEntryTable);
DefaultActionGroup actionGroup = new DefaultActionGroup();
final AnAction navigateAction =
new AnAction(ProjectBundle.message("classpath.panel.navigate.action.text")) {
@Override
public void actionPerformed(@NotNull AnActionEvent e) {
navigate(false);
}
@Override
public void update(@NotNull AnActionEvent e) {
final Presentation presentation = e.getPresentation();
presentation.setEnabled(false);
final OrderEntry entry = getSelectedEntry();
if (entry != null && entry.isValid()) {
if (!(entry instanceof ModuleSourceOrderEntry)) {
presentation.setEnabled(true);
}
}
}
};
navigateAction.registerCustomShortcutSet(
ActionManager.getInstance().getAction(IdeActions.ACTION_EDIT_SOURCE).getShortcutSet(),
myEntryTable);
actionGroup.add(myEditButton);
actionGroup.add(myRemoveButton);
actionGroup.add(navigateAction);
actionGroup.add(new InlineModuleDependencyAction(this));
actionGroup.add(new MyFindUsagesAction());
actionGroup.add(new AnalyzeDependencyAction());
addChangeLibraryLevelAction(actionGroup, LibraryTablesRegistrar.PROJECT_LEVEL);
addChangeLibraryLevelAction(actionGroup, LibraryTablesRegistrar.APPLICATION_LEVEL);
addChangeLibraryLevelAction(actionGroup, LibraryTableImplUtil.MODULE_LEVEL);
PopupHandler.installPopupHandler(
myEntryTable, actionGroup, ActionPlaces.UNKNOWN, ActionManager.getInstance());
}
public RegistryUi() {
myContent.setLayout(new BorderLayout(UIUtil.DEFAULT_HGAP, UIUtil.DEFAULT_VGAP));
myModel = new MyTableModel();
myTable = new JBTable(myModel);
myTable.setCellSelectionEnabled(true);
myTable.setEnableAntialiasing(true);
final MyRenderer r = new MyRenderer();
final TableColumn c0 = myTable.getColumnModel().getColumn(0);
c0.setCellRenderer(r);
c0.setMaxWidth(RESTART_ICON.getIconWidth() + 12);
c0.setMinWidth(RESTART_ICON.getIconWidth() + 12);
c0.setHeaderValue(null);
final TableColumn c1 = myTable.getColumnModel().getColumn(1);
c1.setCellRenderer(r);
c1.setHeaderValue("Key");
final TableColumn c2 = myTable.getColumnModel().getColumn(2);
c2.setCellRenderer(r);
c2.setHeaderValue("Value");
c2.setCellEditor(new MyEditor());
myTable.setStriped(true);
myDescriptionLabel = new JTextArea(3, 50);
myDescriptionLabel.setEditable(false);
final JScrollPane label = ScrollPaneFactory.createScrollPane(myDescriptionLabel);
final JPanel descriptionPanel = new JPanel(new BorderLayout());
descriptionPanel.add(label, BorderLayout.CENTER);
descriptionPanel.setBorder(
IdeBorderFactory.createTitledBorder("Description", false, false, true));
myContent.add(ScrollPaneFactory.createScrollPane(myTable), BorderLayout.CENTER);
myContent.add(descriptionPanel, BorderLayout.SOUTH);
myTable
.getSelectionModel()
.addListSelectionListener(
new ListSelectionListener() {
public void valueChanged(ListSelectionEvent e) {
if (e.getValueIsAdjusting()) return;
final int selected = myTable.getSelectedRow();
if (selected != -1) {
final RegistryValue value = myModel.getRegistryValue(selected);
String desc = value.getDescription();
if (value.isRestartRequired()) {
String required = "Requires IDE restart.";
if (desc.endsWith(".")) {
desc += required;
} else {
desc += (". " + required);
}
}
myDescriptionLabel.setText(desc);
} else {
myDescriptionLabel.setText(null);
}
}
});
myRestoreDefaultsAction = new RestoreDefaultsAction();
final DefaultActionGroup tbGroup = new DefaultActionGroup();
tbGroup.add(new EditAction());
tbGroup.add(new RevertAction());
final ActionToolbar tb =
ActionManager.getInstance().createActionToolbar(ActionPlaces.UNKNOWN, tbGroup, true);
tb.setTargetComponent(myTable);
myContent.add(tb.getComponent(), BorderLayout.NORTH);
new TableSpeedSearch(myTable).setComparator(new SpeedSearchComparator(false));
}
private JComponent createToolbar() {
DefaultActionGroup group = new DefaultActionGroup();
group.add(new CloseAction());
group.add(new RerunAction(this));
group.add(new FlattenPackagesAction());
group.add(new ShowFilesAction());
if (ModuleManager.getInstance(myProject).getModules().length > 1) {
group.add(new ShowModulesAction());
group.add(new ShowModuleGroupsAction());
}
group.add(new GroupByScopeTypeAction());
// group.add(new GroupByFilesAction());
group.add(new FilterLegalsAction());
group.add(new MarkAsIllegalAction());
group.add(new ChooseScopeTypeAction());
group.add(new EditDependencyRulesAction());
group.add(
CommonActionsManager.getInstance()
.createExportToTextFileAction(new DependenciesExporterToTextFile()));
group.add(new ContextHelpAction("dependency.viewer.tool.window"));
ActionToolbar toolbar =
ActionManager.getInstance().createActionToolbar(ActionPlaces.UNKNOWN, group, true);
return toolbar.getComponent();
}
@SuppressWarnings({"NonStaticInitializer"})
private JComponent createRightActionsToolbar() {
myIncludeAction =
new AnAction(InspectionsBundle.message("inspections.result.view.include.action.text")) {
{
registerCustomShortcutSet(CommonShortcuts.INSERT, myTree);
}
@Override
public void actionPerformed(AnActionEvent e) {
final TreePath[] paths = myTree.getSelectionPaths();
if (paths != null) {
for (TreePath path : paths) {
((InspectionTreeNode) path.getLastPathComponent()).amnesty();
}
}
updateView(false);
}
@Override
public void update(final AnActionEvent e) {
final TreePath[] paths = myTree.getSelectionPaths();
e.getPresentation()
.setEnabled(
paths != null
&& paths.length > 0
&& !myGlobalInspectionContext.getUIOptions().FILTER_RESOLVED_ITEMS);
}
};
myExcludeAction =
new AnAction(InspectionsBundle.message("inspections.result.view.exclude.action.text")) {
{
registerCustomShortcutSet(CommonShortcuts.getDelete(), myTree);
}
@Override
public void actionPerformed(final AnActionEvent e) {
final TreePath[] paths = myTree.getSelectionPaths();
if (paths != null) {
for (TreePath path : paths) {
((InspectionTreeNode) path.getLastPathComponent()).ignoreElement();
}
}
updateView(false);
}
@Override
public void update(final AnActionEvent e) {
final TreePath[] path = myTree.getSelectionPaths();
e.getPresentation().setEnabled(path != null && path.length > 0);
}
};
DefaultActionGroup specialGroup = new DefaultActionGroup();
specialGroup.add(myGlobalInspectionContext.getUIOptions().createGroupBySeverityAction(this));
specialGroup.add(myGlobalInspectionContext.getUIOptions().createGroupByDirectoryAction(this));
specialGroup.add(
myGlobalInspectionContext.getUIOptions().createFilterResolvedItemsAction(this));
specialGroup.add(
myGlobalInspectionContext.getUIOptions().createShowOutdatedProblemsAction(this));
specialGroup.add(myGlobalInspectionContext.getUIOptions().createShowDiffOnlyAction(this));
specialGroup.add(new EditSettingsAction());
specialGroup.add(new InvokeQuickFixAction(this));
specialGroup.add(new InspectionsOptionsToolbarAction(this));
return createToolbar(specialGroup);
}