public void customizeCellRenderer(
final ColoredTreeCellRenderer targetRenderer,
CheckedTreeNode node,
boolean selected,
final boolean checked,
boolean expanded,
boolean leaf,
boolean hasFocus) {
targetRenderer.setIcon(PlatformIcons.PACKAGE_ICON);
final String displayName;
final CheckedTreeNode parent = (CheckedTreeNode) node.getParent();
if (parent != null && parent.getUserObject() instanceof PackageDescriptor) {
final String parentPackageInTree =
((PackageDescriptor) parent.getUserObject()).getPackageName() + ".";
displayName =
myPackageName.startsWith(parentPackageInTree)
? myPackageName.substring(parentPackageInTree.length())
: myPackageName;
} else {
displayName = myPackageName;
}
targetRenderer.append(
displayName,
checked
? SimpleTextAttributes.SIMPLE_CELL_ATTRIBUTES
: SimpleTextAttributes.GRAYED_ATTRIBUTES);
}
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;
}
private void moveNode(final CheckedTreeNode toolNode, Direction dir) {
CheckedTreeNode parentNode = (CheckedTreeNode) toolNode.getParent();
int index = parentNode.getIndex(toolNode);
removeNodeFromParent(toolNode);
int newIndex = dir.newIndex(index);
parentNode.insert(toolNode, newIndex);
getModel().nodesWereInserted(parentNode, new int[] {newIndex});
}
private CheckedTreeNode findGroupNode(final String group) {
for (int i = 0; i < getTreeRoot().getChildCount(); i++) {
CheckedTreeNode node = (CheckedTreeNode) getTreeRoot().getChildAt(i);
ToolsGroup g = (ToolsGroup) node.getUserObject();
if (Comparing.equal(group, g.getName())) return node;
}
return null;
}
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;
}
private static List<TreePath> getPaths(BreakpointTree tree, final Object[] userObjects) {
final List<TreePath> paths = new ArrayList<TreePath>(userObjects.length);
for (Object descriptor : userObjects) {
final CheckedTreeNode node = tree.myDescriptorToNodeMap.get(descriptor);
if (node != null) {
paths.add(new TreePath(node.getPath()));
}
}
return paths;
}
public int compare(CheckedTreeNode o1, CheckedTreeNode o2) {
final int w1 = getWeight(o1);
final int w2 = getWeight(o2);
if (w1 != w2) {
return w1 - w2;
}
final TreeDescriptor d1 = (TreeDescriptor) o1.getUserObject();
final TreeDescriptor d2 = (TreeDescriptor) o2.getUserObject();
if (d1 instanceof BreakpointDescriptor && d2 instanceof BreakpointDescriptor) {
return 0;
}
return d1.getDisplayString().compareTo(d2.getDisplayString());
}
public void selectBreakpoints(Breakpoint[] breakpoints) {
final List<CheckedTreeNode> nodes = new ArrayList<CheckedTreeNode>(breakpoints.length);
for (Breakpoint breakpoint : breakpoints) {
final CheckedTreeNode node = myDescriptorToNodeMap.get(new BreakpointDescriptor(breakpoint));
if (node != null) {
nodes.add(node);
}
}
clearSelection();
for (CheckedTreeNode node : nodes) {
addSelectionPath(new TreePath(node.getPath()));
}
}
private void insertNewTool(final Tool newTool, boolean setSelection) {
CheckedTreeNode groupNode = findGroupNode(newTool.getGroup());
if (groupNode == null) {
groupNode = insertNewGroup(new ToolsGroup(newTool.getGroup()));
nodeWasInserted(groupNode);
}
CheckedTreeNode tool = insertNewTool(groupNode, newTool);
if (setSelection) {
TreePath treePath = new TreePath(tool.getPath());
myTree.expandPath(treePath);
myTree.getSelectionModel().setSelectionPath(treePath);
}
myIsModified = true;
}
private void removeSelected() {
CheckedTreeNode node = getSelectedToolNode();
if (node != null) {
int result =
Messages.showYesNoDialog(
this,
ToolsBundle.message("tools.delete.confirmation"),
CommonBundle.getWarningTitle(),
Messages.getWarningIcon());
if (result != 0) {
return;
}
myIsModified = true;
if (node.getUserObject() instanceof Tool) {
Tool tool = (Tool) node.getUserObject();
CheckedTreeNode parentNode = (CheckedTreeNode) node.getParent();
((ToolsGroup) parentNode.getUserObject()).removeElement(tool);
removeNodeFromParent(node);
if (parentNode.getChildCount() == 0) {
removeNodeFromParent(parentNode);
}
} else if (node.getUserObject() instanceof ToolsGroup) {
removeNodeFromParent(node);
}
update();
myTree.requestFocus();
}
}
private Breakpoint getSibling(Breakpoint breakpoint, boolean nextSibling) {
final CheckedTreeNode node = myDescriptorToNodeMap.get(new BreakpointDescriptor(breakpoint));
if (node == null) {
return null;
}
final CheckedTreeNode sibling =
(CheckedTreeNode) (nextSibling ? node.getNextSibling() : node.getPreviousSibling());
if (sibling == null) {
return null;
}
final TreeDescriptor descriptor = (TreeDescriptor) sibling.getUserObject();
return descriptor instanceof BreakpointDescriptor
? ((BreakpointDescriptor) descriptor).getBreakpoint()
: null;
}
private int getWeight(CheckedTreeNode node) {
if (node.getUserObject() instanceof BreakpointDescriptor) {
return 100;
}
if (node.getUserObject() instanceof MethodDescriptor) {
return 90;
}
if (node.getUserObject() instanceof PackageDescriptor) {
return 80;
}
if (node.getUserObject() instanceof ClassDescriptor) {
return 70;
}
return 50;
}
@Override
protected void onNodeStateChanged(final CheckedTreeNode node) {
final Object descriptor = node.getUserObject();
final Breakpoint breakpoint;
if (descriptor instanceof BreakpointDescriptor) {
breakpoint = ((BreakpointDescriptor) descriptor).getBreakpoint();
if (myBreakpointManager.findMasterBreakpoint(breakpoint) != null) {
return;
}
} else {
breakpoint = null;
}
if (breakpoint != null) {
myBreakpointManager.setBreakpointEnabled(breakpoint, node.isChecked());
}
}
/**
* @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 void moveNode(final Direction direction) {
CheckedTreeNode node = getSelectedNode();
if (node != null) {
if (isMovingAvailable(node, direction)) {
moveNode(node, direction);
if (node.getUserObject() instanceof Tool) {
ToolsGroup group = (ToolsGroup) (((CheckedTreeNode) node.getParent()).getUserObject());
Tool tool = (Tool) node.getUserObject();
moveElementInsideGroup(tool, group, direction);
}
TreePath path = new TreePath(node.getPath());
myTree.getSelectionModel().setSelectionPath(path);
myTree.expandPath(path);
myTree.requestFocus();
}
}
}
private void editSelected() {
CheckedTreeNode node = getSelectedToolNode();
if (node != null && node.getUserObject() instanceof Tool) {
Tool selected = (Tool) node.getUserObject();
if (selected != null) {
String oldGroupName = selected.getGroup();
ToolEditorDialog dlg = new ToolEditorDialog(this);
dlg.setData(selected, getGroups());
dlg.show();
if (dlg.isOK()) {
selected.copyFrom(dlg.getData());
String newGroupName = selected.getGroup();
if (!Comparing.equal(oldGroupName, newGroupName)) {
CheckedTreeNode oldGroupNode = (CheckedTreeNode) node.getParent();
removeNodeFromParent(node);
((ToolsGroup) oldGroupNode.getUserObject()).removeElement(selected);
if (oldGroupNode.getChildCount() == 0) {
removeNodeFromParent(oldGroupNode);
}
insertNewTool(selected, true);
} else {
(getModel()).nodeChanged(node);
}
myIsModified = true;
update();
}
}
}
}
public void customizeRenderer(
JTree tree,
Object value,
boolean selected,
boolean expanded,
boolean leaf,
int row,
boolean hasFocus) {
if (value instanceof CheckedTreeNode) {
final CheckedTreeNode node = (CheckedTreeNode) value;
final TreeDescriptor descriptor = getDescriptor(node);
descriptor.customizeCellRenderer(
getTextRenderer(), node, selected, node.isChecked(), expanded, leaf, hasFocus);
if (descriptor instanceof BreakpointDescriptor) {
myCheckbox.setEnabled(node.isEnabled() && !((BreakpointDescriptor) descriptor).isSlave());
}
}
}
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);
}
}
public BreakpointTree(final Project project) {
super(new BreakpointTreeCellRenderer(), new CheckedTreeNode(new RootDescriptor()));
myRootNode = (CheckedTreeNode) getModel().getRoot();
myDescriptorToNodeMap.put((TreeDescriptor) myRootNode.getUserObject(), myRootNode);
myBreakpointManager = DebuggerManagerEx.getInstanceEx(project).getBreakpointManager();
myNodeUpdateListener =
new BreakpointManagerListener() {
public void breakpointsChanged() {
repaint();
}
};
myBreakpointManager.addBreakpointManagerListener(myNodeUpdateListener);
getEmptyText().setText(XDebuggerBundle.message("debugger.no.breakpoints"));
}
private ToolsGroup[] getGroupList() {
ArrayList<ToolsGroup> result = new ArrayList<ToolsGroup>();
MutableTreeNode root = (MutableTreeNode) myTree.getModel().getRoot();
for (int i = 0; i < root.getChildCount(); i++) {
final CheckedTreeNode node = (CheckedTreeNode) root.getChildAt(i);
for (int j = 0; j < node.getChildCount(); j++) {
final CheckedTreeNode toolNode = (CheckedTreeNode) node.getChildAt(j);
((Tool) toolNode.getUserObject()).setEnabled(toolNode.isChecked());
}
result.add((ToolsGroup) node.getUserObject());
}
return result.toArray(new ToolsGroup[result.size()]);
}
private static TreeDescriptor getDescriptor(final CheckedTreeNode node) {
return (TreeDescriptor) node.getUserObject();
}
@Nullable
private ToolsGroup getSelectedToolGroup() {
CheckedTreeNode node = getSelectedToolNode();
if (node == null) return null;
return node.getUserObject() instanceof ToolsGroup ? (ToolsGroup) node.getUserObject() : null;
}
private void nodeWasInserted(final CheckedTreeNode groupNode) {
(getModel())
.nodesWereInserted(
groupNode.getParent(), new int[] {groupNode.getParent().getChildCount() - 1});
}
private boolean isMovingAvailable(final CheckedTreeNode toolNode, Direction dir) {
TreeNode parent = toolNode.getParent();
int index = parent.getIndex(toolNode);
return dir.isAvailable(index, parent.getChildCount());
}
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));
}
