public void updateModel(
List<? extends ChangeList> changeLists,
Trinity<List<VirtualFile>, Integer, Integer> unversionedFiles,
final List<LocallyDeletedChange> locallyDeletedFiles,
List<VirtualFile> modifiedWithoutEditing,
MultiMap<String, VirtualFile> switchedFiles,
@Nullable Map<VirtualFile, String> switchedRoots,
@Nullable List<VirtualFile> ignoredFiles,
final List<VirtualFile> lockedFolders,
@Nullable final Map<VirtualFile, LogicalLock> logicallyLockedFiles) {
TreeModelBuilder builder = new TreeModelBuilder(myProject, isShowFlatten());
final DefaultTreeModel model =
builder.buildModel(
changeLists,
unversionedFiles,
locallyDeletedFiles,
modifiedWithoutEditing,
switchedFiles,
switchedRoots,
ignoredFiles,
lockedFolders,
logicallyLockedFiles);
storeState();
DefaultTreeModel oldModel = getModel();
setModel(model);
setCellRenderer(new ChangesBrowserNodeRenderer(myProject, isShowFlatten(), true));
ChangesBrowserNode root = (ChangesBrowserNode) model.getRoot();
expandPath(new TreePath(root.getPath()));
restoreState();
expandDefaultChangeList(oldModel, root);
}
private void collapseTargets() {
DefaultMutableTreeNode root = (DefaultMutableTreeNode) myTreeModel.getRoot();
for (int i = 0; i < root.getChildCount(); i++) {
DefaultMutableTreeNode node = (DefaultMutableTreeNode) root.getChildAt(i);
myTree.collapsePath(new TreePath(node.getPath()));
}
}
public boolean restoreSelection(TreeSelection treeSelection) {
if (treeSelection.isEmpty()) return false;
DefaultMutableTreeNode root = (DefaultMutableTreeNode) myTreeModel.getRoot();
for (int i = 0; i < root.getChildCount(); i++) {
TreeNode node = root.getChildAt(i);
if (node instanceof MessageNode) {
MessageNode messageNode = (MessageNode) node;
String[] text = messageNode.getText();
if (text.length == 0) continue;
if (Comparing.equal(treeSelection.mySelectedTarget, text[0])) {
TreePath pathToSelect = new TreePath(messageNode.getPath());
for (Enumeration enumeration = messageNode.children(); enumeration.hasMoreElements(); ) {
Object o = enumeration.nextElement();
if (o instanceof MessageNode) {
messageNode = (MessageNode) o;
if (Comparing.equal(treeSelection.mySelectedTask, text[0])) {
pathToSelect = new TreePath(messageNode.getPath());
break;
}
}
}
TreeUtil.selectPath(myTree, pathToSelect);
myTree.expandPath(pathToSelect);
return true;
}
}
}
return false;
}
private void addJavacMessageImpl(AntMessage message) {
MutableTreeNode parentNode = (MutableTreeNode) myParentPath.getLastPathComponent();
MessageNode messageNode = new MessageNode(message, myProject, false);
myTreeModel.insertNodeInto(messageNode, parentNode, parentNode.getChildCount());
myMessageItems.add(messageNode);
handleExpansion();
}
public Object addMessage(AntMessage message) {
MessageNode messageNode = createMessageNode(message);
MutableTreeNode parentNode = (MutableTreeNode) myParentPath.getLastPathComponent();
myTreeModel.insertNodeInto(messageNode, parentNode, parentNode.getChildCount());
myMessageItems.add(messageNode);
handleExpansion();
return messageNode;
}
protected void doSort() {
Pair<ElementNode, List<ElementNode>> pair = storeSelection();
Enumeration<ParentNode> children = getRootNodeChildren();
while (children.hasMoreElements()) {
ParentNode classNode = children.nextElement();
sortNode(classNode, myComparator);
myTreeModel.nodeStructureChanged(classNode);
}
restoreSelection(pair);
}
protected void restoreTree() {
Pair<ElementNode, List<ElementNode>> selection = storeSelection();
DefaultMutableTreeNode root = getRootNode();
if (!myShowClasses || myContainerNodes.isEmpty()) {
List<ParentNode> otherObjects = new ArrayList<ParentNode>();
Enumeration<ParentNode> children = getRootNodeChildren();
ParentNode newRoot =
new ParentNode(
null, new MemberChooserObjectBase(getAllContainersNodeName()), new Ref<Integer>(0));
while (children.hasMoreElements()) {
final ParentNode nextElement = children.nextElement();
if (nextElement instanceof ContainerNode) {
final ContainerNode containerNode = (ContainerNode) nextElement;
Enumeration<MemberNode> memberNodes = containerNode.children();
List<MemberNode> memberNodesList = new ArrayList<MemberNode>();
while (memberNodes.hasMoreElements()) {
memberNodesList.add(memberNodes.nextElement());
}
for (MemberNode memberNode : memberNodesList) {
newRoot.add(memberNode);
}
} else {
otherObjects.add(nextElement);
}
}
replaceChildren(root, otherObjects);
sortNode(newRoot, myComparator);
if (newRoot.children().hasMoreElements()) root.add(newRoot);
} else {
Enumeration<ParentNode> children = getRootNodeChildren();
while (children.hasMoreElements()) {
ParentNode allClassesNode = children.nextElement();
Enumeration<MemberNode> memberNodes = allClassesNode.children();
ArrayList<MemberNode> arrayList = new ArrayList<MemberNode>();
while (memberNodes.hasMoreElements()) {
arrayList.add(memberNodes.nextElement());
}
Collections.sort(arrayList, myComparator);
for (MemberNode memberNode : arrayList) {
myNodeToParentMap.get(memberNode).add(memberNode);
}
}
replaceChildren(root, myContainerNodes);
}
myTreeModel.nodeStructureChanged(root);
defaultExpandTree();
restoreSelection(selection);
}
public void addMessages(AntMessage[] messages) {
DefaultMutableTreeNode parentNode =
(DefaultMutableTreeNode) myParentPath.getLastPathComponent();
int[] indices = new int[messages.length];
for (int i = 0; i < messages.length; i++) {
AntMessage message = messages[i];
MessageNode messageNode = createMessageNode(message);
indices[i] = parentNode.getChildCount();
parentNode.insert(messageNode, indices[i]);
myMessageItems.add(messageNode);
}
myTreeModel.nodesWereInserted(parentNode, indices);
handleExpansion();
}
public void addException(AntMessage exception, boolean showFullTrace) {
MessageNode exceptionRootNode = null;
StringTokenizer tokenizer = new StringTokenizer(exception.getText(), "\r\n");
while (tokenizer.hasMoreElements()) {
String line = (String) tokenizer.nextElement();
if (exceptionRootNode == null) {
AntMessage newMessage =
new AntMessage(
exception.getType(),
exception.getPriority(),
line,
exception.getFile(),
exception.getLine(),
exception.getColumn());
exceptionRootNode = new MessageNode(newMessage, myProject, true);
myMessageItems.add(exceptionRootNode);
} else if (showFullTrace) {
if (StringUtil.startsWithChar(line, '\t')) {
line = line.substring(1);
}
HyperlinkUtil.PlaceInfo info = HyperlinkUtil.parseStackLine(myProject, '\t' + line);
VirtualFile file = info != null ? info.getFile() : null;
int lineNumber = info != null ? info.getLine() : 0;
int column = info != null ? info.getColumn() : 1;
AntMessage newMessage =
new AntMessage(
exception.getType(), exception.getPriority(), line, file, lineNumber, column);
MessageNode child = new MessageNode(newMessage, myProject, false);
exceptionRootNode.add(child);
myMessageItems.add(child);
}
}
if (exceptionRootNode == null) return;
MutableTreeNode parentNode = (MutableTreeNode) myParentPath.getLastPathComponent();
myTreeModel.insertNodeInto(exceptionRootNode, parentNode, parentNode.getChildCount());
handleExpansion();
}
private void expandDefaultChangeList(DefaultTreeModel oldModel, ChangesBrowserNode root) {
if (((ChangesBrowserNode) oldModel.getRoot()).getCount() == 0
&& TreeUtil.collectExpandedPaths(this).size() == 1) {
TreeNode toExpand = null;
for (int i = 0; i < root.getChildCount(); i++) {
TreeNode node = root.getChildAt(i);
if (node instanceof ChangesBrowserChangeListNode && node.getChildCount() > 0) {
ChangeList object = ((ChangesBrowserChangeListNode) node).getUserObject();
if (object instanceof LocalChangeList) {
if (((LocalChangeList) object).isDefault()) {
toExpand = node;
break;
}
}
}
}
if (toExpand != null) {
expandPath(new TreePath(new Object[] {root, toExpand}));
}
}
}
protected DefaultMutableTreeNode getRootNode() {
return (DefaultMutableTreeNode) myTreeModel.getRoot();
}
public void scrollToFirstError() {
TreePath path = getFirstErrorPath(new TreePath(myTreeModel.getRoot()));
if (path != null) {
TreeUtil.selectPath(myTree, path);
}
}
public void finishBuild(String messageText) {
collapseTargets();
DefaultMutableTreeNode root = (DefaultMutableTreeNode) myTreeModel.getRoot();
myStatusNode = new DefaultMutableTreeNode(messageText);
myTreeModel.insertNodeInto(myStatusNode, root, root.getChildCount());
}
public void setActionsEnabled(boolean actionsEnabled) {
myActionsEnabled = actionsEnabled;
if (actionsEnabled) {
myTreeModel.reload();
}
}