public void selectElements(ClassMember[] elements) {
ArrayList<TreePath> selectionPaths = new ArrayList<TreePath>();
for (ClassMember element : elements) {
MemberNode treeNode = myElementToNodeMap.get(element);
if (treeNode != null) {
selectionPaths.add(new TreePath(((DefaultMutableTreeNode) treeNode).getPath()));
}
}
myTree.setSelectionPaths(selectionPaths.toArray(new TreePath[selectionPaths.size()]));
}
private static void sortNode(ParentNode node, final Comparator<ElementNode> sortComparator) {
ArrayList<MemberNode> arrayList = new ArrayList<MemberNode>();
Enumeration<MemberNode> children = node.children();
while (children.hasMoreElements()) {
arrayList.add(children.nextElement());
}
Collections.sort(arrayList, sortComparator);
replaceChildren(node, arrayList);
}
@SuppressWarnings("unchecked")
public void resetElements(
T[] elements,
final @Nullable Comparator<T> sortComparator,
final boolean restoreSelectedElements) {
final List<T> selectedElements =
restoreSelectedElements && mySelectedElements != null
? new ArrayList<T>(mySelectedElements)
: null;
myElements = elements;
if (sortComparator != null) {
myComparator = new ElementNodeComparatorWrapper(sortComparator);
}
mySelectedNodes.clear();
myNodeToParentMap.clear();
myElementToNodeMap.clear();
myContainerNodes.clear();
ApplicationManager.getApplication()
.runReadAction(
new Runnable() {
@Override
public void run() {
myTreeModel = buildModel();
}
});
myTree.setModel(myTreeModel);
myTree.setRootVisible(false);
restoreTree();
if (myOptionControls == null) {
myCopyJavadocCheckbox = new NonFocusableCheckBox(IdeBundle.message("checkbox.copy.javadoc"));
if (myIsInsertOverrideVisible) {
myInsertOverrideAnnotationCheckbox =
new NonFocusableCheckBox(IdeBundle.message("checkbox.insert.at.override"));
myOptionControls =
new JCheckBox[] {myCopyJavadocCheckbox, myInsertOverrideAnnotationCheckbox};
} else {
myOptionControls = new JCheckBox[] {myCopyJavadocCheckbox};
}
}
myTree.doLayout();
setOKActionEnabled(myElements != null && myElements.length > 0);
if (selectedElements != null) {
selectElements(selectedElements.toArray(new ClassMember[selectedElements.size()]));
}
if (mySelectedElements == null || mySelectedElements.isEmpty()) {
expandFirst();
}
}
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);
}
private void restoreSelection(Pair<ElementNode, List<ElementNode>> pair) {
List<ElementNode> selectedNodes = pair.second;
DefaultMutableTreeNode root = getRootNode();
ArrayList<TreePath> toSelect = new ArrayList<TreePath>();
for (ElementNode node : selectedNodes) {
DefaultMutableTreeNode treeNode = (DefaultMutableTreeNode) node;
if (root.isNodeDescendant(treeNode)) {
toSelect.add(new TreePath(treeNode.getPath()));
}
}
if (!toSelect.isEmpty()) {
myTree.setSelectionPaths(toSelect.toArray(new TreePath[toSelect.size()]));
}
ElementNode leadNode = pair.first;
if (leadNode != null) {
myTree.setLeadSelectionPath(new TreePath(((DefaultMutableTreeNode) leadNode).getPath()));
}
}
@Override
public void dispose() {
PropertiesComponent instance = PropertiesComponent.getInstance();
instance.setValue(PROP_SORTED, Boolean.toString(isAlphabeticallySorted()));
instance.setValue(PROP_SHOWCLASSES, Boolean.toString(myShowClasses));
if (myCopyJavadocCheckbox != null) {
instance.setValue(PROP_COPYJAVADOC, Boolean.toString(myCopyJavadocCheckbox.isSelected()));
}
final Container contentPane = getContentPane();
if (contentPane != null) {
contentPane.removeAll();
}
mySelectedNodes.clear();
myElements = null;
super.dispose();
}