@Override protected void onNodeStateChanged(CheckedTreeNode node) { super.onNodeStateChanged(node); Resources.Template template = ((TemplateTreeNode) node).getTemplate(); if (node.isChecked()) { checked.add(template); } else { checked.remove(template); } } };
private void setNodesChecked(@NotNull CheckedTreeNode node) { if (!node.isRoot() && !node.isLeaf()) { if (hasAnyCheckedLeaf(node)) { node.setChecked(true); } else { node.setChecked(false); } } int childCount = node.getChildCount(); for (int i = 0; i < childCount; i++) { setNodesChecked(((CheckedTreeNode) node.getChildAt(i))); } }
public Tree createTree(java.util.List<String> literals) { final CheckedTreeNode rootNode = new CheckedTreeNode("all literals not defined"); for (String literal : literals) { CheckedTreeNode child = new CheckedTreeNode(new LiteralChooserObject(literal, Icons.LEXER_RULE)); child.setChecked(true); rootNode.add(child); } DefaultTreeModel treeModel = new DefaultTreeModel(rootNode); selectedElements.addAll(literals); // all are "on" by default Tree tree = new Tree(treeModel); tree.setRootVisible(false); tree.setCellRenderer(new LiteralChooserRenderer()); tree.addTreeSelectionListener(new MyTreeSelectionListener()); return tree; }
@Nullable private ConfigCheckedTreeNode maybeInsertOrFind(CheckedTreeNode parent, @NotNull List<MethodConfig> methodConfigs, @NotNull MethodConfig methodConfig, TreeNodeType nodeType) { String name = getName(methodConfig, nodeType); if (name.compareTo(parent.getChildAt(0).toString()) < 0) { return insertBefore(parent, parent.getChildAt(0), methodConfigs, methodConfig, nodeType); } for (int i = 0; i < parent.getChildCount(); i++) { ConfigCheckedTreeNode child = (ConfigCheckedTreeNode) parent.getChildAt(i); TreeNode nextNode = parent.getChildAfter(child); if (nextNode != null) { if (name.compareTo(child.toString()) > 0 && name.compareTo(nextNode.toString()) < 0) { return insertBefore(parent, nextNode, methodConfigs, methodConfig, nodeType); } } if (Objects.equals(child.toString(), name)) { return child; } } return null; }
public void valueChanged(TreeSelectionEvent e) { // System.out.println("select event ----------"); TreePath[] paths = e.getPaths(); if (paths == null) return; for (int i = 0; i < paths.length; i++) { Object node = paths[i].getLastPathComponent(); if (node instanceof CheckedTreeNode) { Object userObject = ((DefaultMutableTreeNode) node).getUserObject(); if (userObject instanceof LiteralChooserObject) { LiteralChooserObject literalObject = (LiteralChooserObject) userObject; String text = literalObject.getText(); // System.out.println("selected " + text); if ( e.isAddedPath(paths[i]) ) { if ( selectedElements.contains(text) ) { selectedElements.remove(text); } else { selectedElements.add(text); } // System.out.println("added path: "+text); CheckedTreeNode checkedNode = (CheckedTreeNode) node; checkedNode.setChecked(!checkedNode.isChecked()); // toggle } } } } } }
@NotNull private ConfigCheckedTreeNode insertBefore(CheckedTreeNode parent, TreeNode child, @NotNull List<MethodConfig> methodConfigs, @NotNull MethodConfig methodConfig, TreeNodeType nodeType) { ConfigCheckedTreeNode newNode = createNode(methodConfigs, methodConfig, nodeType); for (int i = 0; i < parent.getChildCount(); i++) { if (Objects.equals(parent.getChildAt(i).toString(), child.toString())) { model.insertNodeInto(newNode, parent, i); return newNode; } } throw new RuntimeException("Cannot insert new node"); }
@Override public void setChecked(boolean checked) { super.setChecked(checked); }
public void removeNode(@NotNull ConfigCheckedTreeNode treeNode) { CheckedTreeNode parent = (CheckedTreeNode) treeNode.getParent(); if (parent == null) { return; } model.removeNodeFromParent(treeNode); while (parent != root && parent.getChildCount() == 0) { CheckedTreeNode child = parent; parent = ((CheckedTreeNode) parent.getParent()); model.removeNodeFromParent(child); } methodFormManager.showChooseConfig(); TreeUtil.expandAll(this); }
}, new CheckedTreeNode(null)); methodFormManager = new MethodFormManager(cardPanel, excludedMethodForm, saveReturnValueCheckBox, methodConfigs, this);
private ConfigCheckedTreeNode appendNode(CheckedTreeNode parent, @NotNull MethodConfig methodConfig, TreeNodeType nodeType, List<MethodConfig> methodConfigs) { ConfigCheckedTreeNode node = createNode(methodConfigs, methodConfig, nodeType); model.insertNodeInto(node, parent, parent.getChildCount()); return node; }
@Override public void customizeRenderer(JTree tree, Object value, boolean selected, boolean expanded, boolean leaf, int row, boolean hasFocus) { if (!(value instanceof ConfigCheckedTreeNode)) { return; } ConfigCheckedTreeNode node = ((ConfigCheckedTreeNode) value); if (node.isRoot()) { return; } if (((CheckedTreeNode) node.getParent()).isRoot()) { this.getTextRenderer().setIcon(AllIcons.Nodes.Package); } else if (leaf) { this.getTextRenderer().setIcon(AllIcons.Nodes.Method); } else { this.getTextRenderer().setIcon(AllIcons.Nodes.Class); } this.getTextRenderer().append(value.toString(), SimpleTextAttributes.SIMPLE_CELL_ATTRIBUTES); } }, new CheckedTreeNode(null));
@NotNull private ConfigCheckedTreeNode insertNode(CheckedTreeNode parent, @NotNull List<MethodConfig> methodConfigs, @NotNull MethodConfig methodConfig, TreeNodeType nodeType) { if (parent.getChildCount() == 0) { return appendNode(parent, methodConfig, nodeType, methodConfigs); } String name = getName(methodConfig, nodeType); if (name.compareTo(parent.getChildAt(0).toString()) < 0) { return insertBefore(parent, parent.getChildAt(0), methodConfigs, methodConfig, nodeType); } for (int i = 0; i < parent.getChildCount(); i++) { ConfigCheckedTreeNode child = (ConfigCheckedTreeNode) parent.getChildAt(i); TreeNode nextNode = parent.getChildAfter(child); if (nextNode != null) { if (name.compareTo(child.toString()) > 0 && name.compareTo(nextNode.toString()) < 0) { return insertBefore(parent, nextNode, methodConfigs, methodConfig, nodeType); } } } return appendNode(parent, methodConfig, nodeType, methodConfigs); }
private boolean hasAnyCheckedLeaf(@NotNull CheckedTreeNode node) { if (node instanceof MethodTreeNode) { MethodConfig methodConfig = ((MethodTreeNode) node).getMethodConfig(); return methodConfig.isEnabled(); } int childCount = node.getChildCount(); for (int i = 0; i < childCount; i++) { if (hasAnyCheckedLeaf(((CheckedTreeNode) node.getChildAt(i)))) { return true; } } return false; }
private ConfigCheckedTreeNode createChildIfNotPresent(CheckedTreeNode parent, @NotNull List<MethodConfig> methodConfigs, @NotNull MethodConfig methodConfig, TreeNodeType nodeType) { if (parent.getChildCount() == 0) { return appendNode(parent, methodConfig, nodeType, methodConfigs); } else { ConfigCheckedTreeNode node = maybeInsertOrFind(parent, methodConfigs, methodConfig, nodeType); if (node != null) { return node; } } return appendNode(parent, methodConfig, nodeType, methodConfigs); }
private MethodTreeNode findNodeRecursively(@NotNull CheckedTreeNode node, MethodConfig methodConfig) { int len = node.getChildCount(); if (node instanceof MethodTreeNode) { if (Objects.equals(((MethodTreeNode) node).getMethodConfig().toString(), methodConfig.toString())) { return ((MethodTreeNode) node); } } for (int i = 0; i < len; i++) { MethodTreeNode res = findNodeRecursively((CheckedTreeNode) node.getChildAt(i), methodConfig); if (res != null) { return res; } } return null; }