private void createNodesGroupedByDirectory(
CheckedTreeNode root, final List<? extends DetectedFrameworkDescription> frameworks) {
Map<VirtualFile, FrameworkDirectoryNode> nodes = new HashMap<>();
List<DetectedFrameworkNode> externalNodes = new ArrayList<>();
for (DetectedFrameworkDescription framework : frameworks) {
VirtualFile parent = VfsUtil.getCommonAncestor(framework.getRelatedFiles());
if (parent != null && !parent.isDirectory()) {
parent = parent.getParent();
}
final DetectedFrameworkNode frameworkNode = new DetectedFrameworkNode(framework, myContext);
if (parent != null) {
createDirectoryNodes(parent, nodes).add(frameworkNode);
} else {
externalNodes.add(frameworkNode);
}
}
List<FrameworkDirectoryNode> rootDirs = new ArrayList<>();
for (FrameworkDirectoryNode directoryNode : nodes.values()) {
if (directoryNode.getParent() == null) {
rootDirs.add(directoryNode);
}
}
for (FrameworkDirectoryNode dir : rootDirs) {
root.add(collapseDirectoryNode(dir));
}
for (DetectedFrameworkNode node : externalNodes) {
root.add(node);
}
}
private CheckedTreeNode insertNewTool(final CheckedTreeNode groupNode, final Tool toolCopy) {
CheckedTreeNode toolNode = new CheckedTreeNode(toolCopy);
toolNode.setChecked(toolCopy.isEnabled());
((ToolsGroup) groupNode.getUserObject()).addElement(toolCopy);
groupNode.add(toolNode);
nodeWasInserted(toolNode);
return toolNode;
}
/**
* @param parentDescriptor a descriptor of the childNode (possibly not existing) to attach to
* @param childNode the childNode to be attached
* @return either parent node if it has just been created or null, if the node has been attached
* to already existing childNode
*/
private CheckedTreeNode attachNodeToParent(
final TreeDescriptor parentDescriptor, final CheckedTreeNode childNode) {
CheckedTreeNode parentNode = myDescriptorToNodeMap.get(parentDescriptor);
try {
if (parentNode != null) {
parentNode.add(childNode);
return null; // added to already existing, so stop iteration over appenders
}
parentNode = createNode(parentDescriptor);
parentNode.add(childNode);
return parentNode;
} finally {
if (parentNode != null && parentNode.getChildCount() == 1) {
expandPath(new TreePath(parentNode.getPath()));
}
}
}
private CheckedTreeNode insertNewGroup(final ToolsGroup groupCopy) {
CheckedTreeNode root = getTreeRoot();
CheckedTreeNode groupNode = new CheckedTreeNode(groupCopy);
root.add(groupNode);
for (Tool tool : groupCopy.getElements()) {
insertNewTool(groupNode, tool);
}
return groupNode;
}
/**
* Update the tree according to the list of loaded roots
*
* @param roots the list of roots to add to the tree
* @param uncheckedCommits the map from vcs root to commit identifiers that should be
* uncheckedCommits
*/
private void updateTree(List<Root> roots, Map<VirtualFile, Set<String>> uncheckedCommits) {
myTreeRoot.removeAllChildren();
if (roots == null) {
roots = Collections.emptyList();
}
for (Root r : roots) {
CheckedTreeNode rootNode = new CheckedTreeNode(r);
Status status = new Status();
status.root = r;
rootNode.add(new DefaultMutableTreeNode(status, false));
Set<String> unchecked =
uncheckedCommits != null && uncheckedCommits.containsKey(r.root)
? uncheckedCommits.get(r.root)
: Collections.<String>emptySet();
for (Commit c : r.commits) {
CheckedTreeNode child = new CheckedTreeNode(c);
rootNode.add(child);
child.setChecked(r.remoteName != null && !unchecked.contains(c.commitId()));
}
myTreeRoot.add(rootNode);
}
}
private void createNodesGroupedByType(
CheckedTreeNode root, final List<? extends DetectedFrameworkDescription> frameworks) {
Map<FrameworkType, FrameworkTypeNode> groupNodes = new HashMap<>();
for (DetectedFrameworkDescription framework : frameworks) {
final FrameworkType type = framework.getDetector().getFrameworkType();
FrameworkTypeNode group = groupNodes.get(type);
if (group == null) {
group = new FrameworkTypeNode(type);
groupNodes.put(type, group);
root.add(group);
}
group.add(new DetectedFrameworkNode(framework, myContext));
}
}
private void rebuildTree() {
final TreeStateSnapshot treeStateSnapshot = new TreeStateSnapshot(this);
myRootNode.removeAllChildren();
myDescriptorToNodeMap.clear();
myDescriptorToNodeMap.put((TreeDescriptor) myRootNode.getUserObject(), myRootNode);
// build tree
for (final Breakpoint breakpoint : myBreakpoints) {
CheckedTreeNode node = createNode(new BreakpointDescriptor(breakpoint));
node.setChecked(breakpoint.ENABLED);
addNode(node);
}
// remove all package nodes with one child
final int count = myRootNode.getChildCount();
final List<CheckedTreeNode> children = new ArrayList<CheckedTreeNode>();
for (int idx = 0; idx < count; idx++) {
CheckedTreeNode child = (CheckedTreeNode) myRootNode.getChildAt(idx);
if (!(child.getUserObject() instanceof PackageDescriptor)) {
children.add(child);
continue;
}
while (child.getUserObject() instanceof PackageDescriptor && child.getChildCount() <= 1) {
child = (CheckedTreeNode) child.getChildAt(0);
}
if (!(child.getUserObject() instanceof PackageDescriptor)) {
child = (CheckedTreeNode) child.getParent();
}
for (CheckedTreeNode childToRemove = (CheckedTreeNode) child.getParent();
!childToRemove.equals(myRootNode);
childToRemove = (CheckedTreeNode) childToRemove.getParent()) {
myDescriptorToNodeMap.remove(childToRemove.getUserObject());
}
children.add(child);
}
for (final CheckedTreeNode aChildren : children) {
aChildren.removeFromParent();
}
myRootNode.removeAllChildren();
for (final CheckedTreeNode child : children) {
myRootNode.add(child);
}
sortChildren(myRootNode);
((DefaultTreeModel) getModel()).nodeStructureChanged(myRootNode);
treeStateSnapshot.restore(this);
expandPath(new TreePath(myRootNode));
}
private void sortChildren(CheckedTreeNode node) {
final int childCount = node.getChildCount();
if (childCount == 0) {
return;
}
final List<CheckedTreeNode> children = new ArrayList<CheckedTreeNode>(childCount);
for (int idx = 0; idx < childCount; idx++) {
children.add((CheckedTreeNode) node.getChildAt(idx));
}
for (CheckedTreeNode child : children) {
sortChildren(child);
child.removeFromParent();
}
Collections.sort(children, myNodeComparator);
for (CheckedTreeNode child : children) {
node.add(child);
}
}
