@Override public void excludeUsages(@NotNull Usage[] usages) { for (Usage usage : usages) { final UsageNode node = myUsageNodes.get(usage); if (node != NULL_NODE && node != null) { node.setUsageExcluded(true); } } updateImmediately(); }
@NotNull private Set<Usage> getReadOnlyUsages() { final Set<Usage> result = new THashSet<Usage>(); final Set<Map.Entry<Usage, UsageNode>> usages = myUsageNodes.entrySet(); for (Map.Entry<Usage, UsageNode> entry : usages) { Usage usage = entry.getKey(); UsageNode node = entry.getValue(); if (node != null && node != NULL_NODE && !node.isExcluded() && usage.isReadOnly()) { result.add(usage); } } return result; }
@Override public void selectUsages(@NotNull Usage[] usages) { List<TreePath> paths = new LinkedList<TreePath>(); for (Usage usage : usages) { final UsageNode node = myUsageNodes.get(usage); if (node != NULL_NODE && node != null) { paths.add(new TreePath(node.getPath())); } } myTree.setSelectionPaths(paths.toArray(new TreePath[paths.size()])); if (!paths.isEmpty()) myTree.scrollPathToVisible(paths.get(0)); }
@Override public void removeUsage(@NotNull Usage usage) { final UsageNode node = myUsageNodes.remove(usage); if (node != NULL_NODE && node != null && !myPresentation.isDetachedMode()) { UIUtil.invokeLaterIfNeeded( new Runnable() { @Override public void run() { if (isDisposed) return; TreeModel treeModel = myTree.getModel(); ((DefaultTreeModel) treeModel).removeNodeFromParent(node); ((GroupNode) myTree.getModel().getRoot()).removeUsage(node); } }); } }
public UsageNode doAppendUsage(@NotNull Usage usage) { // invoke in ReadAction to be be sure that usages are not invalidated while the tree is being // built ApplicationManager.getApplication().assertReadAccessAllowed(); if (!usage.isValid()) { // because the view is built incrementally, the usage may be already invalid, so need to // filter such cases return null; } UsageNode node = myBuilder.appendUsage(usage); myUsageNodes.put(usage, node == null ? NULL_NODE : node); if (!myIsFirstVisibleUsageFound && node != null) { // first visible usage found; myIsFirstVisibleUsageFound = true; showNode(node); } return node; }
@Override @NotNull public Set<Usage> getExcludedUsages() { Set<Usage> result = new THashSet<Usage>(); for (Map.Entry<Usage, UsageNode> entry : myUsageNodes.entrySet()) { UsageNode node = entry.getValue(); Usage usage = entry.getKey(); if (node == NULL_NODE || node == null) { continue; } if (node.isExcluded()) { result.add(usage); } } return result; }
private void reset() { ApplicationManager.getApplication().assertIsDispatchThread(); myUsageNodes.clear(); myIsFirstVisibleUsageFound = false; myModel.reset(); if (!myPresentation.isDetachedMode()) { SwingUtilities.invokeLater( new Runnable() { @Override public void run() { if (isDisposed) return; TreeUtil.expand(myTree, 2); } }); } }
private void rulesChanged() { ApplicationManager.getApplication().assertIsDispatchThread(); final ArrayList<UsageState> states = new ArrayList<UsageState>(); captureUsagesExpandState(new TreePath(myTree.getModel().getRoot()), states); final List<Usage> allUsages = new ArrayList<Usage>(myUsageNodes.keySet()); Collections.sort(allUsages, USAGE_COMPARATOR); final Set<Usage> excludedUsages = getExcludedUsages(); reset(); myBuilder.setGroupingRules(getActiveGroupingRules(myProject)); myBuilder.setFilteringRules(getActiveFilteringRules(myProject)); ApplicationManager.getApplication() .runReadAction( new Runnable() { @Override public void run() { for (Usage usage : allUsages) { if (!usage.isValid()) { continue; } if (usage instanceof MergeableUsage) { ((MergeableUsage) usage).reset(); } appendUsage(usage); } } }); excludeUsages(excludedUsages.toArray(new Usage[excludedUsages.size()])); if (myCentralPanel != null) { setupCentralPanel(); } SwingUtilities.invokeLater( new Runnable() { @Override public void run() { if (isDisposed) return; restoreUsageExpandState(states); updateImmediately(); } }); }
private String getRenamedTitle(String fieldOrGroupName, String defaultName) { String result = myRenamedFields.get(fieldOrGroupName); return result == null ? defaultName : result; }
protected TreeTable createOptionsTree(CodeStyleSettings settings) { DefaultMutableTreeNode rootNode = new DefaultMutableTreeNode(); Map<String, DefaultMutableTreeNode> groupsMap = new THashMap<String, DefaultMutableTreeNode>(); List<Option> sorted = sortOptions(ContainerUtil.concat(myOptions, myCustomOptions)); for (Option each : sorted) { if (!(myCustomOptions.contains(each) || myAllowedOptions.contains(each.field.getName()) || myShowAllStandardOptions)) continue; String group = each.groupName; MyTreeNode newNode = new MyTreeNode(each, each.title, settings); DefaultMutableTreeNode groupNode = groupsMap.get(group); if (groupNode != null) { groupNode.add(newNode); } else { String groupName; if (group == null) { groupName = each.title; groupNode = newNode; } else { groupName = group; groupNode = new DefaultMutableTreeNode(groupName); groupNode.add(newNode); } groupsMap.put(groupName, groupNode); rootNode.add(groupNode); } } ListTreeTableModel model = new ListTreeTableModel(rootNode, COLUMNS); TreeTable treeTable = new TreeTable(model) { @Override public TreeTableCellRenderer createTableRenderer(TreeTableModel treeTableModel) { TreeTableCellRenderer tableRenderer = super.createTableRenderer(treeTableModel); UIUtil.setLineStyleAngled(tableRenderer); tableRenderer.setRootVisible(false); tableRenderer.setShowsRootHandles(true); return tableRenderer; } @Override public TableCellRenderer getCellRenderer(int row, int column) { TreePath treePath = getTree().getPathForRow(row); if (treePath == null) return super.getCellRenderer(row, column); Object node = treePath.getLastPathComponent(); @SuppressWarnings("unchecked") TableCellRenderer renderer = COLUMNS[column].getRenderer(node); return renderer == null ? super.getCellRenderer(row, column) : renderer; } @Override public TableCellEditor getCellEditor(int row, int column) { TreePath treePath = getTree().getPathForRow(row); if (treePath == null) return super.getCellEditor(row, column); Object node = treePath.getLastPathComponent(); @SuppressWarnings("unchecked") TableCellEditor editor = COLUMNS[column].getEditor(node); return editor == null ? super.getCellEditor(row, column) : editor; } }; new TreeTableSpeedSearch(treeTable).setComparator(new SpeedSearchComparator(false)); treeTable.setRootVisible(false); final JTree tree = treeTable.getTree(); tree.setCellRenderer(myTitleRenderer); tree.setShowsRootHandles(true); // myTreeTable.setRowHeight(new JComboBox(new String[]{"Sample // Text"}).getPreferredSize().height); treeTable.setSelectionMode(ListSelectionModel.SINGLE_SELECTION); treeTable.setTableHeader(null); expandTree(tree); treeTable.getColumnModel().getSelectionModel().setAnchorSelectionIndex(1); treeTable.getColumnModel().getSelectionModel().setLeadSelectionIndex(1); int maxWidth = tree.getPreferredScrollableViewportSize().width + 10; final TableColumn titleColumn = treeTable.getColumnModel().getColumn(0); titleColumn.setPreferredWidth(maxWidth); titleColumn.setMinWidth(maxWidth); titleColumn.setMaxWidth(maxWidth); titleColumn.setResizable(false); // final TableColumn levelColumn = treeTable.getColumnModel().getColumn(1); // TODO[max]: better preffered size... // TODO[kb]: Did I fixed it by making the last column floating? // levelColumn.setPreferredWidth(valueSize.width); // levelColumn.setMaxWidth(valueSize.width); // levelColumn.setMinWidth(valueSize.width); // levelColumn.setResizable(false); final Dimension valueSize = new JLabel(ApplicationBundle.message("option.table.sizing.text")).getPreferredSize(); treeTable.setPreferredScrollableViewportSize( new Dimension(maxWidth + valueSize.width + 10, 20)); return treeTable; }
@Override public void renameStandardOption(String fieldName, String newTitle) { myRenamedFields.put(fieldName, newTitle); }
@Override protected void resetDefaultNames() { myRenamedFields.clear(); }
public void setColumnClass(String name, Object obj) { ColumnClass.put(name, obj); }
public Class getColumnClass(int column) { if (column == 0) return TreeTableModel.class; Object obj = ColumnClass.get(colIndex[column]); if (obj != null) return (Class) obj; return Object.class; }
@Override public int getUsagesCount() { return myUsageNodes.size(); }
@Override @NotNull public Set<Usage> getUsages() { return myUsageNodes.keySet(); }