public void setSelected(AnActionEvent e, boolean state) {
configuration.setShowMembers(state);
if (state) {
((TreeItemModel) tree.getModel()).removeFilter(filter);
} else {
((TreeItemModel) tree.getModel()).addFilter(filter);
}
tree.updateUI();
}
private static void printImpl(
JTree tree,
Object root,
Collection<String> strings,
int level,
boolean withSelection,
@Nullable Condition<String> nodePrintCondition) {
DefaultMutableTreeNode defaultMutableTreeNode = (DefaultMutableTreeNode) root;
final Object userObject = defaultMutableTreeNode.getUserObject();
String nodeText;
if (userObject != null) {
nodeText = toString(userObject, null);
} else {
nodeText = "null";
}
if (nodePrintCondition != null && !nodePrintCondition.value(nodeText)) return;
final StringBuilder buff = new StringBuilder();
StringUtil.repeatSymbol(buff, ' ', level);
final boolean expanded = tree.isExpanded(new TreePath(defaultMutableTreeNode.getPath()));
if (!defaultMutableTreeNode.isLeaf()) {
buff.append(expanded ? "-" : "+");
}
final boolean selected =
tree.getSelectionModel().isPathSelected(new TreePath(defaultMutableTreeNode.getPath()));
if (withSelection && selected) {
buff.append("[");
}
buff.append(nodeText);
if (withSelection && selected) {
buff.append("]");
}
strings.add(buff.toString());
int childCount = tree.getModel().getChildCount(root);
if (expanded) {
for (int i = 0; i < childCount; i++) {
printImpl(
tree,
tree.getModel().getChild(root, i),
strings,
level + 1,
withSelection,
nodePrintCondition);
}
}
}
// reorder the nodes
private void reorder(Vector nodes) {
debug("reorder nodes");
// remove all the children of topNode (they'll be added back later)
topNode.removeAllChildren();
// Create an array of the elements for sorting & copy the elements
// into the array.
DefaultMutableTreeNode[] array = new DefaultMutableTreeNode[nodes.size()];
nodes.copyInto(array);
// Sort the array (Quick Sort)
quickSort(array, 0, array.length - 1);
// Reload the topNode. Everthing is in order now.
for (int i = 0; i < array.length; i++) {
topNode.add((DefaultMutableTreeNode) array[i]);
}
// Tell the tree to repaint itself
((DefaultTreeModel) tree.getModel()).reload();
tree.invalidate();
tree.repaint();
}
public static List<TreePath> collectExpandedPaths(final JTree tree, TreePath path) {
final ArrayList<TreePath> result = new ArrayList<TreePath>();
if (!tree.isExpanded(path)) return result;
final Object lastPathComponent = path.getLastPathComponent();
final TreeModel model = tree.getModel();
if (model.isLeaf(lastPathComponent)) {
result.add(path);
} else {
boolean pathWasAdded = false;
for (int i = model.getChildCount(lastPathComponent) - 1; i >= 0; i--) {
final TreePath childPath = path.pathByAddingChild(model.getChild(lastPathComponent, i));
if (model.isLeaf(lastPathComponent)) {
if (!pathWasAdded) {
result.add(path);
pathWasAdded = true;
}
} else if (tree.isExpanded(childPath)) {
result.addAll(collectExpandedPaths(tree, childPath));
} else {
if (!pathWasAdded) {
result.add(path);
pathWasAdded = true;
}
}
}
}
return result;
}
public void reset() {
mySelectedSchema = new CustomActionsSchema();
mySelectedSchema.copyFrom(CustomActionsSchema.getInstance());
patchActionsTreeCorrespondingToSchema(
(DefaultMutableTreeNode) myActionsTree.getModel().getRoot());
myRestoreAllDefaultButton.setEnabled(mySelectedSchema.isModified(new CustomActionsSchema()));
}
public static List<TreePath> collectExpandedPaths(@NotNull final JTree tree) {
final ArrayList<TreePath> result = new ArrayList<TreePath>();
final Object root = tree.getModel().getRoot();
final TreePath rootPath = new TreePath(root);
result.addAll(collectExpandedPaths(tree, rootPath));
return result;
}
public static Collection<String> printAsList(
JTree tree, boolean withSelection, @Nullable Condition<String> nodePrintCondition) {
Collection<String> strings = new ArrayList<String>();
Object root = tree.getModel().getRoot();
printImpl(tree, root, strings, 0, withSelection, nodePrintCondition);
return strings;
}
private void updateImmediately() {
if (myProject.isDisposed()) return;
checkNodeValidity((DefaultMutableTreeNode) myTree.getModel().getRoot());
if (myUsagePreviewPanel != null) {
myUsagePreviewPanel.updateLayout(getSelectedUsageInfos());
}
}
public Component getTreeCellRendererComponent(
JTree tree,
Object value,
boolean selected,
boolean expanded,
boolean leaf,
int row,
boolean hasFocus) {
Component renderer =
delegate.getTreeCellRendererComponent(tree, value, selected, expanded, leaf, row, hasFocus);
if (!showRootNodeCheckBox && tree.getModel().getRoot() == value) return renderer;
TreePath path = tree.getPathForRow(row);
if (path != null) {
if (checkBoxCustomer != null && !checkBoxCustomer.showCheckBox(path)) return renderer;
if (selectionModel.isPathSelected(path, selectionModel.isDigged()))
checkBox.getTristateModel().setState(TristateState.SELECTED);
else
checkBox
.getTristateModel()
.setState(
selectionModel.isDigged() && selectionModel.isPartiallySelected(path)
? TristateState.INDETERMINATE
: TristateState.DESELECTED);
}
removeAll();
add(checkBox, BorderLayout.WEST);
add(renderer, BorderLayout.CENTER);
return this;
}
public SlicePanel(
@NotNull final Project project,
boolean dataFlowToThis,
@NotNull SliceNode rootNode,
boolean splitByLeafExpressions,
@NotNull final ToolWindow toolWindow) {
super(new BorderLayout());
myToolWindow = toolWindow;
final ToolWindowManagerListener listener =
new ToolWindowManagerListener() {
ToolWindowAnchor myAnchor = toolWindow.getAnchor();
@Override
public void toolWindowRegistered(@NotNull String id) {}
@Override
public void stateChanged() {
if (!project.isOpen()) return;
if (toolWindow.getAnchor() != myAnchor) {
myAnchor = myToolWindow.getAnchor();
layoutPanel();
}
}
};
ToolWindowManagerEx.getInstanceEx(project).addToolWindowManagerListener(listener, this);
ApplicationManager.getApplication().assertIsDispatchThread();
myProject = project;
myTree = createTree();
myBuilder =
new SliceTreeBuilder(myTree, project, dataFlowToThis, rootNode, splitByLeafExpressions);
myBuilder.setCanYieldUpdate(!ApplicationManager.getApplication().isUnitTestMode());
Disposer.register(this, myBuilder);
myBuilder.addSubtreeToUpdate(
(DefaultMutableTreeNode) myTree.getModel().getRoot(),
new Runnable() {
@Override
public void run() {
if (isDisposed || myBuilder.isDisposed() || myProject.isDisposed()) return;
final SliceNode rootNode = myBuilder.getRootSliceNode();
myBuilder.expand(
rootNode,
new Runnable() {
@Override
public void run() {
if (isDisposed || myBuilder.isDisposed() || myProject.isDisposed()) return;
myBuilder.select(
rootNode.myCachedChildren.get(0)); // first there is ony one child
}
});
treeSelectionChanged();
}
});
layoutPanel();
}
/**
* Constructor.
*
* @param tree a JTree
*/
public CheckTreeManager(JTree tree) {
this.tree = tree;
selectionModel = new CheckTreeSelectionModel(tree.getModel());
tree.setCellRenderer(new CheckTreeCellRenderer(tree.getCellRenderer(), selectionModel));
tree.addMouseListener(this);
tree.addMouseMotionListener(this);
selectionModel.addTreeSelectionListener(this);
}
/**
* @param tree JTree to collect expanded paths from.
* @param paths output parameter.
*/
public static void collectExpandedPaths(
@NotNull final JTree tree, @NotNull final List<TreePath> paths) {
final TreeModel model = tree.getModel();
final Object root = model.getRoot();
LOG.assertTrue(root != null);
collectExpandedPathsImpl(tree, paths, new TreePath(root));
}
public static ActionCallback selectFirstNode(final JTree tree) {
final TreeModel model = tree.getModel();
final Object root = model.getRoot();
TreePath selectionPath = new TreePath(root);
if (!tree.isRootVisible() && model.getChildCount(root) > 0)
selectionPath = selectionPath.pathByAddingChild(model.getChild(root, 0));
return selectPath(tree, selectionPath);
}
public ViewerTreeBuilder(Project project, JTree tree) {
super(
tree,
(DefaultTreeModel) tree.getModel(),
new ViewerTreeStructure(project),
IndexComparator.INSTANCE);
initRootNode();
}
// If expanded, return only paths of nodes that are expanded.
public TreePath[] getPaths(JTree tree, boolean expanded) {
TreeNode root = (TreeNode) tree.getModel().getRoot();
List list = new ArrayList();
// Traverse tree from root adding treepaths for all nodes to list
getPaths(tree, new TreePath(root), expanded, list);
// Convert list to array
return (TreePath[]) list.toArray(new TreePath[list.size()]);
}
public void addSelectionPathTo(final Object element) {
DefaultMutableTreeNode node = myAbstractTreeBuilder.getNodeForElement(element);
if (node != null) {
final JTree tree = getTree();
final TreePath path = new TreePath(node.getPath());
if (node == tree.getModel().getRoot() && !tree.isExpanded(path)) tree.expandPath(path);
tree.addSelectionPath(path);
}
}
Main() {
FuncClass RootClass =
new FuncClass(System.getProperty("user.dir") + "\\root", "Mathematica Input Assistant");
JTree tree = new JTree(RootClass.getTreeNode());
final DefaultTreeModel treeModel = (DefaultTreeModel) tree.getModel();
new MainFrame(tree, RootClass, "Mathematica Input Assistant");
}
@Override
public void adoptElement(SceneElement elem) {
if (!(elem instanceof NenyaImageSceneElement
|| elem instanceof NenyaTileSceneElement
|| elem instanceof NenyaComponentSceneElement)) {
enableEditor(false);
return;
}
DefaultComboBoxModel dcm = (DefaultComboBoxModel) itemList.getModel();
// Important: Work on a copy, not on the original. Otherwise we mess up the undomanager
sceneElement = elem.copy();
if ((sceneElement instanceof NenyaImageSceneElement) && !locked) {
dcm.removeAllElements();
String[] tmp = ((NenyaImageSceneElement) sceneElement).getPath();
dcm.addElement(tmp[tmp.length - 1]);
}
if ((sceneElement instanceof NenyaTileSceneElement) && !locked) {
dcm.removeAllElements();
dcm.addElement(((NenyaTileSceneElement) sceneElement).getTileName());
}
if ((sceneElement instanceof NenyaComponentSceneElement) && !locked) {
dcm.removeAllElements();
NenyaComponentItem[] ni = ((NenyaComponentSceneElement) sceneElement).getComponents();
for (NenyaComponentItem element : ni) {
dcm.addElement(element);
}
}
try {
ClassedItem[] cols = null;
if (elem instanceof NenyaTileSceneElement)
cols = ((NenyaTileSceneElement) elem).getColorList();
if (elem instanceof NenyaImageSceneElement)
cols = ((NenyaImageSceneElement) elem).getColorList();
if (elem instanceof NenyaComponentSceneElement) {
NenyaComponentItem nci = (NenyaComponentItem) dcm.getSelectedItem();
cols = nci.getColorList();
}
Vector<TreePath> collect = new Vector<TreePath>();
TreeNode root = (TreeNode) colors.getModel().getRoot();
for (ClassedItem col : cols) {
String[] tmp = {root.toString(), col.getClassName(), col.getItemName()};
collect.add(TreeUtil.findPath(root, tmp));
}
TreePath[] path = collect.toArray(new TreePath[0]);
colors.getSelectionModel().setSelectionPaths(path);
} catch (Exception e) {
// Either the tree is filtered away or the selected item is not colorized.
}
enableEditor(true);
itemList.setEnabled(elem instanceof NenyaComponentSceneElement);
}
private void patchActionsTreeCorrespondingToSchema(DefaultMutableTreeNode root) {
root.removeAllChildren();
if (mySelectedSchema != null) {
mySelectedSchema.fillActionGroups(root);
for (final ActionUrl actionUrl : mySelectedSchema.getActions()) {
ActionUrl.changePathInActionsTree(myActionsTree, actionUrl);
}
}
((DefaultTreeModel) myActionsTree.getModel()).reload();
}
public static void moveSelectedRow(final JTree tree, final int direction) {
final TreePath selectionPath = tree.getSelectionPath();
final DefaultMutableTreeNode treeNode =
(DefaultMutableTreeNode) selectionPath.getLastPathComponent();
final DefaultMutableTreeNode parent = (DefaultMutableTreeNode) treeNode.getParent();
final int idx = parent.getIndex(treeNode);
parent.remove(treeNode);
parent.insert(treeNode, idx + direction);
((DefaultTreeModel) tree.getModel()).reload(parent);
selectNode(tree, treeNode);
}
public UpdaterTreeState(AbstractTreeUi ui, boolean isEmpty) {
myUi = ui;
if (!isEmpty) {
final JTree tree = myUi.getTree();
putAll(addPaths(tree.getSelectionPaths()), myToSelect);
putAll(
addPaths(tree.getExpandedDescendants(new TreePath(tree.getModel().getRoot()))),
myToExpand);
}
}
public static void expandAll(final JTree tree) {
tree.expandPath(new TreePath(tree.getModel().getRoot()));
int oldRowCount = 0;
do {
int rowCount = tree.getRowCount();
if (rowCount == oldRowCount) break;
oldRowCount = rowCount;
for (int i = 0; i < rowCount; i++) {
tree.expandRow(i);
}
} while (true);
}
public ShowMembersToggleAction(JTree tree) {
super(
APIComparatorBundle.message("comparator.toolbar.actions.showmembers.text"),
APIComparatorBundle.message("comparator.toolbar.actions.showmembers.description"),
IconLoader.getIcon("/objectBrowser/showMembers.png"));
this.tree = tree;
if (!configuration.isShowMembers()) {
((TreeItemModel) tree.getModel()).addFilter(filter);
}
}
@Nullable
private DefaultMutableTreeNode getNodeForPath(String path) {
Enumeration enumeration =
((DefaultMutableTreeNode) myTree.getModel().getRoot()).preorderEnumeration();
while (enumeration.hasMoreElements()) {
DefaultMutableTreeNode node = (DefaultMutableTreeNode) enumeration.nextElement();
if (Comparing.equal(getPath(node), path)) {
return node;
}
}
return null;
}
private void applySelected(final JTree tree, final DefaultMutableTreeNode node) {
TreeUtil.unselect(tree, node);
List<TreePath> selectionPaths = new ArrayList<TreePath>();
for (List<PathElement> pathElements : mySelectedPaths) {
applySelectedTo(pathElements, tree.getModel().getRoot(), tree, selectionPaths);
}
if (selectionPaths.size() > 1) {
for (TreePath path : selectionPaths) {
tree.addSelectionPath(path);
}
}
}
@Nullable
private DefaultMutableTreeNode findNodeOnToolbar(String actionId) {
final TreeNode toolbar =
((DefaultMutableTreeNode) myActionsTree.getModel().getRoot()).getChildAt(1);
for (int i = 0; i < toolbar.getChildCount(); i++) {
final DefaultMutableTreeNode child = (DefaultMutableTreeNode) toolbar.getChildAt(i);
final String childId = getActionId(child);
if (childId != null && childId.equals(actionId)) {
return child;
}
}
return null;
}
private ArrayList<DefaultMutableTreeNode> getNodesByPaths(ArrayList<String> paths) {
final ArrayList<DefaultMutableTreeNode> result = new ArrayList<DefaultMutableTreeNode>();
Enumeration enumeration =
((DefaultMutableTreeNode) myTree.getModel().getRoot()).preorderEnumeration();
while (enumeration.hasMoreElements()) {
DefaultMutableTreeNode node = (DefaultMutableTreeNode) enumeration.nextElement();
final String path = getPath(node);
if (paths.contains(path)) {
result.add(node);
}
}
return result;
}
private void restoreUsageExpandState(final Collection<UsageState> states) {
// always expand the last level group
final DefaultMutableTreeNode root = (DefaultMutableTreeNode) myTree.getModel().getRoot();
for (int i = root.getChildCount() - 1; i >= 0; i--) {
final DefaultMutableTreeNode child = (DefaultMutableTreeNode) root.getChildAt(i);
if (child instanceof GroupNode) {
final TreePath treePath = new TreePath(child.getPath());
myTree.expandPath(treePath);
}
}
myTree.getSelectionModel().clearSelection();
for (final UsageState usageState : states) {
usageState.restore();
}
}
private void setStructureViewSelection(@NotNull final String propertyName) {
if (myStructureViewComponent.isDisposed()) {
return;
}
JTree tree = myStructureViewComponent.getTree();
if (tree == null) {
return;
}
Object root = tree.getModel().getRoot();
if (AbstractTreeUi.isLoadingChildrenFor(root)) {
mySelectionChangeAlarm.cancelAllRequests();
mySelectionChangeAlarm.addRequest(
new Runnable() {
@Override
public void run() {
mySelectionChangeAlarm.cancelAllRequests();
setStructureViewSelection(propertyName);
}
},
500);
return;
}
Stack<TreeElement> toCheck = ContainerUtilRt.newStack();
toCheck.push(myStructureViewComponent.getTreeModel().getRoot());
while (!toCheck.isEmpty()) {
TreeElement element = toCheck.pop();
PsiElement value =
element instanceof ResourceBundlePropertyStructureViewElement
? ((ResourceBundlePropertyStructureViewElement) element).getValue()
: null;
if (value instanceof IProperty
&& propertyName.equals(((IProperty) value).getUnescapedKey())) {
myStructureViewComponent.select(value, true);
selectionChanged();
return;
} else {
for (TreeElement treeElement : element.getChildren()) {
toCheck.push(treeElement);
}
}
}
}
public void populateTree() {
DefaultTreeModel model = (DefaultTreeModel) JTree.getModel();
ArrayList<Network> networkList = system.getNetworkList();
ArrayList<Enterprise> enterpriseList;
ArrayList<Organization> organizationList;
Network network;
Enterprise enterprise;
Organization organization;
DefaultMutableTreeNode networks = new DefaultMutableTreeNode("Networks");
DefaultMutableTreeNode root = (DefaultMutableTreeNode) model.getRoot();
root.removeAllChildren();
root.insert(networks, 0);
DefaultMutableTreeNode networkNode;
DefaultMutableTreeNode enterpriseNode;
DefaultMutableTreeNode organizationNode;
for (int i = 0; i < networkList.size(); i++) {
network = networkList.get(i);
networkNode = new DefaultMutableTreeNode(network.getName());
networks.insert(networkNode, i);
enterpriseList = network.getEnterpriseDirectory().getEnterpriseList();
for (int j = 0; j < enterpriseList.size(); j++) {
enterprise = enterpriseList.get(j);
enterpriseNode = new DefaultMutableTreeNode(enterprise.getName());
networkNode.insert(enterpriseNode, j);
organizationList = enterprise.getOrganizationDirectory().getOrganizationList();
for (int k = 0; k < organizationList.size(); k++) {
organization = organizationList.get(k);
organizationNode = new DefaultMutableTreeNode(organization.getName());
enterpriseNode.insert(organizationNode, k);
}
}
}
model.reload();
}
