Java Code Examples for org.openide.nodes.Node#isLeaf()

private static void representationOf(Children c, StringBuilder b) {
    boolean first = true;
    for (Node n : c.getNodes(true)) {
        if (first) {
            first = false;
        } else {
            b.append(", ");
        }
        b.append(n.getDisplayName());
        if (!n.isLeaf()) {
            b.append('[');
            representationOf(n.getChildren(), b);
            b.append(']');
        }
    }
}
 

private int getNextRow(int row) {
    row = row + 1;
    Outline outline = tablePanel.treeView.getOutline();
    if(row < 0 || row >= outline.getRowCount()) {
        return -1;
    }
    TreePath path = outline.getOutlineModel().getLayout().getPathForRow(row);
    Node node = Visualizer.findNode(path.getLastPathComponent());
    if(node.isLeaf()) {
        if(node instanceof RevisionNode || node instanceof RevisionNode.FileNode) {
            return row;
        } else {
            return -1;
        }
    } else {
        TreePathSupport support = outline.getOutlineModel().getTreePathSupport();
        if(support.isExpanded(path)) {
            return getPrevRow(row);
        } else {
            support.expandPath(path);
            return row + 1;
        }
    }
}
 

protected Node copyNode (Node node) {
    boolean filter = false;
    try {
        DataObject d = (DataObject) node.getCookie (DataObject.class);
        if (d != null) {
            InstanceCookie.Of inst = (InstanceCookie.Of)d.getCookie(InstanceCookie.Of.class);
            if (inst != null && (inst.instanceOf(Node.class) || inst.instanceOf(Node.Handle.class))) {
                // This is just a node, not a real setting. E.g. ModuleNode, LoaderPoolNode. As such,
                // it itself should not display any origin information, it would make no sense. However
                // its children might have a legitimate DataObject cookie from the SFS.
                d = null;
            }
        }
        DataFolder folder = (DataFolder) node.getCookie (DataFolder.class);
        FileSystem fs = d == null || folder != null ? null : d.getPrimaryFile ().getFileSystem ();
        filter = fs == null ? false : fs.isDefault();
    } catch (FileStateInvalidException e) {
        // ignore
    }

    return filter ? new SettingFilterNode (node) : 
        node.isLeaf() ? node.cloneNode() : new TrivialFilterNode(node);
}
 

private int getPrevRow(int row) {
    row = row - 1;
    Outline outline = tablePanel.treeView.getOutline();
    if(row < 0 || row >= outline.getRowCount()) {
        return -1;
    }
    TreePath path = outline.getOutlineModel().getLayout().getPathForRow(row);
    Node node = Visualizer.findNode(path.getLastPathComponent());
    if(node.isLeaf()) {
        if(node instanceof RevisionNode || node instanceof RevisionNode.FileNode) {
            return row;
        } else {
            return -1;
        }
    } else {
        TreePathSupport support = outline.getOutlineModel().getTreePathSupport();
        if(support.isExpanded(path)) {
            return getPrevRow(row);
        } else {
            support.expandPath(path);
            return row + node.getChildren().getNodesCount();
        }
    }
}
 

public int getIndexOfChild(java.lang.Object parent, java.lang.Object child) {
    int superCnt = super.getChildCount(parent);
    int myCnt = 0;

    for (int i = 0; i < superCnt; i++) {
        Object origChild = super.getChild(parent, i);

        if (child.equals(origChild)) {
            return myCnt;
        }

        Node n = Visualizer.findNode(origChild);

        if (!n.isLeaf()) {
            myCnt++;
        }
    }

    return -1;
}
 

private Node findObjectNode(Node topNode, OpenSimObject openSimObject) {
    if (topNode instanceof OpenSimObjectNode){
        if (((OpenSimObjectNode)topNode).getOpenSimObject().equals(openSimObject))
            return topNode;
    }
    if (topNode instanceof ExperimentalDataNode){
        ExperimentalDataNode edn = (ExperimentalDataNode) topNode;
        if (openSimObject.equals(edn.getDataObject()))
            return topNode;
    }
    if (topNode.isLeaf()) return null;
    boolean found = false;
    Children chden= topNode.getChildren();
    Node fndNode=null;
    for(int ch=0; ch < chden.getNodesCount() && !found; ch++){
        fndNode = findObjectNode(chden.getNodeAt(ch), openSimObject);
        found = (fndNode != null);
    }
    return fndNode;
}
 

private static Children createChildren(FileObject fo) {
    if (fo != null) {
        try {
            Node n = DataObject.find(fo).getNodeDelegate();
            if (!n.isLeaf()) { // using n.cloneNode().getChildren() does not work; someone caches cloneNode??
                return new FilterNode.Children(n);
            }
        } catch (DataObjectNotFoundException x) {
            Exceptions.printStackTrace(x);
        }
    }
    return Children.LEAF;
}
 

private static void writeChildren(ZipOutputStream str, FileObject projectDirectory, FileObject siteRoot, Children children) throws IOException {
    for (Node node : children.getNodes(true)) {
        FileObject fo = node.getLookup().lookup(FileObject.class);
        InputStream is = null;
        if (!fo.isFolder()) {
            is = fo.getInputStream();
        }
        try {
            Checkable ch = node.getLookup().lookup(Checkable.class);
            if (!Boolean.TRUE.equals(ch.isSelected())) {
                continue;
            }
            String relPath = getRelativePath(projectDirectory, siteRoot, fo);
            if (fo.isFolder()) {
                relPath += "/"; //NOI18N
            }
            ZipEntry ze = new ZipEntry(relPath);
            str.putNextEntry(ze);
            if (is != null) {
                FileUtil.copy(fo.getInputStream(), str);
            }
        } finally {
            if (is != null) {
                is.close();
            }
        }
        if (!node.isLeaf()) {
            writeChildren(str, projectDirectory, siteRoot, node.getChildren());
        }
    }
}
 

public int getChildCount(java.lang.Object parent) {
    int superCnt = super.getChildCount(parent);
    int myCnt = 0;

    for (int i = 0; i < superCnt; i++) {
        Node n = Visualizer.findNode(super.getChild(parent, i));

        if (!n.isLeaf()) {
            myCnt++;
        }
    }

    return myCnt;
}
 

@Override
public boolean isRelevantNode(Node node) {
    if (node == null) {
        return false;
    } else {
        Node parent = node.getParentNode();
        return node.isLeaf() && parent != null
                && parent.getParentNode() != null;
    }
}
 

FilteredNode(Node original, String displayName, Filter filter) {
    super(original, original.isLeaf() ? Children.LEAF : new FilteredChildren(original, filter));
    if (displayName != null) {
        disableDelegation(DELEGATE_GET_DISPLAY_NAME | DELEGATE_SET_DISPLAY_NAME);
        setDisplayName(displayName);
    }
}
 

private static String printTree(Node n) {
    String name = n.getDisplayName();
    if (n.isLeaf()) {
        return name;
    } else {
        List<String> kidNames = new ArrayList<String>();
        for (Node kid : n.getChildren().getNodes(true)) {
            kidNames.add(printTree(kid));
        }
        return name + kidNames;
    }
}
 

/** This method is called when user double-clicks on some object or
* presses Enter key.
* @param index Index of object in current explored context
*/
final void performObjectAt(int index, int modifiers) {
    if ((index < 0) || (index >= model.getSize())) {
        return;
    }

    VisualizerNode v = (VisualizerNode) model.getElementAt(index);
    Node node = v.node;

    // if DefaultProcessor is set, the default action is notified to it overriding the default action on nodes
    if (defaultProcessor != null) {
        defaultProcessor.actionPerformed(new ActionEvent(node, 0, null, modifiers));

        return;
    }

    if (showParentNode && NodeListModel.findVisualizerDepth(model, v) == -1) {
        try {
            manager.setExploredContextAndSelection(node.getParentNode(), new Node[] { node });
        } catch (PropertyVetoException ex) {
            // OK, let it be
        }
        return;
    }

    // on double click - invoke default action, if there is any
    // (unless user holds CTRL key what means that we should always dive into the context)
    Action a = node.getPreferredAction();

    if ((a != null) && ((modifiers & InputEvent.CTRL_MASK) == 0)) {
        a = TreeView.takeAction(a, node);

        if (a.isEnabled()) {
            a.actionPerformed(new ActionEvent(node, ActionEvent.ACTION_PERFORMED, "")); // NOI18N
        } else {
            Utilities.disabledActionBeep();
        }
    }
    // otherwise dive into the context
    else if (traversalAllowed && (!node.isLeaf())) {
        manager.setExploredContext(node, manager.getSelectedNodes());
    }
}
 

public ProjectIconNode(Node orig, boolean root) {
    super(orig, orig.isLeaf() ? Children.LEAF : new ProjectBadgingChildren(orig));
    this.root = root;
    setValue("VCS_PHYSICAL", Boolean.TRUE); //#159543 
    addNodeListener(this);
}
 

Leaf (Node node, DataObject data, Node parent) {
    super(node, ((data instanceof XMLDataObject) || node.isLeaf()) ? Children.LEAF : new FilterNode.Children(node));
    this.data = data;
    this.parent = parent;
}
 

public EQReplannedNode(Node n) {
    super(n, n.isLeaf() ? Children.LEAF : new EQReplannedChildren(n));
}
 

/**
 * Initializes the tree view.
 */
private void initTreeView() {
    treeView = new BeanTreeView() {
        {
            MouseAdapter listener = createTreeMouseListener();
            tree.addMouseListener(listener);
            tree.addMouseMotionListener(listener);
            tree.setCellRenderer(createTreeCellRenderer(tree.getCellRenderer()));
        }

        @Override
        public void expandAll() {
            // The original expandAll() doesn't work for us as it doesn't
            // seem to wait for the calculation of sub-nodes.
            Node root = manager.getRootContext();
            expandAll(root);
            // The view attempts to scroll to the expanded node
            // and it does it with a delay. Hence, simple calls like
            // tree.scrollRowToVisible(0) have no effect (are overriden
            // later) => the dummy collapse and expansion attempts
            // to work around that and keep the root node visible.
            collapseNode(root);
            expandNode(root);
        }
        /**
         * Expands the whole sub-tree under the specified node.
         *
         * @param node root node of the sub-tree that should be expanded.
         */
        private void expandAll(Node node) {
            treeView.expandNode(node);
            for (Node subNode : node.getChildren().getNodes(true)) {
                if (!subNode.isLeaf()) {
                    expandAll(subNode);
                }
            }
        }
    };
    treeView.setAllowedDragActions(DnDConstants.ACTION_NONE);
    treeView.setAllowedDropActions(DnDConstants.ACTION_NONE);
    treeView.setRootVisible(false);
    add(treeView, BorderLayout.CENTER);
}
 

public FolderFilterNode(ClientSideProject project, BasicNodes nodeType, Node folderNode, List<File> ignoreList) {
    super(folderNode, folderNode.isLeaf() ? Children.LEAF :
            new FolderFilterChildren(project, folderNode, ignoreList));
    this.nodeType = nodeType;
    delegate = folderNode;
}
 

private ActionFilterNode(Node original, int mode) {
    super(original, original.isLeaf() ? Children.LEAF : new ActionFilterChildren(original, mode, null));
    this.mode = mode;
}
 

/**
 * Initializes the tree view.
 */
private void initTreeView() {
    treeView = new BeanTreeView() {
        {
            tree.setCellRenderer(createTreeCellRenderer(tree.getCellRenderer()));
        }

        @Override
        public void expandAll() {
            // The original expandAll() doesn't work for us as it doesn't
            // seem to wait for the calculation of sub-nodes.
            Node root = manager.getRootContext();
            expandAll(root);
            // The view attempts to scroll to the expanded node
            // and it does it with a delay. Hence, simple calls like
            // tree.scrollRowToVisible(0) have no effect (are overriden
            // later) => the dummy collapse and expansion attempts
            // to work around that and keep the root node visible.
            collapseNode(root);
            expandNode(root);
        }

        /**
         * Expands the whole sub-tree under the specified node.
         *
         * @param node root node of the sub-tree that should be expanded.
         */
        private void expandAll(Node node) {
            treeView.expandNode(node);
            for (Node subNode : node.getChildren().getNodes(true)) {
                if (!subNode.isLeaf()) {
                    expandAll(subNode);
                }
            }
        }
    };
    treeView.setAllowedDragActions(DnDConstants.ACTION_NONE);
    treeView.setAllowedDropActions(DnDConstants.ACTION_NONE);
    treeView.setRootVisible(false);
    add(treeView, BorderLayout.CENTER);
}