Uses of Class org.openide.nodes.Node (Nodes API) - NetBeans API Javadoc (Current Development Version)

Overview

Package

Class

Use

Tree

Deprecated

Index

Help

org.openide.nodes 7.0

PREV NEXT

FRAMES NO FRAMES

Uses of Class
org.openide.nodes.Node

Packages that use Node
org.openide.cookies	Cookies are a design pattern used to add behaviors to existing data object and nodes, or to separate implementation from the main object.
org.openide.nodes	NetBeans uses nodes to represent JavaBeans or other property containers, formed into a hierarchical tree.
org.openide.util.actions

Uses of Node in org.openide.cookies

Methods in org.openide.cookies that return Node

Node ConnectionCookie.Event.getNode()
Getter for the node that produced the action.

Methods in org.openide.cookies that return Node
`Node`	`ConnectionCookie.Event.getNode()` Getter for the node that produced the action.

Methods in org.openide.cookies with parameters of type Node

void ConnectionCookie.register(ConnectionCookie.Type type, Node listener)
Deprecated. Attaches new node to listen to events produced by this event.

void ConnectionCookie.unregister(ConnectionCookie.Type type, Node listener)
Deprecated. Unregisters an listener.

Methods in org.openide.cookies with parameters of type Node
`void`	`ConnectionCookie.register(ConnectionCookie.Type type, Node listener)` Deprecated. Attaches new node to listen to events produced by this event.
`void`	`ConnectionCookie.unregister(ConnectionCookie.Type type, Node listener)` Deprecated. Unregisters an listener.

Constructors in org.openide.cookies with parameters of type Node

ConnectionCookie.Event(Node n, ConnectionCookie.Type t)

Constructors in org.openide.cookies with parameters of type Node
`ConnectionCookie.Event(Node n, ConnectionCookie.Type t)`

Uses of Node in org.openide.nodes

Subclasses of Node in org.openide.nodes

class AbstractNode
          A basic implementation of a node.

class BeanNode<T>
          Represents a JavaBeans component as a node.

class FilterNode
          A proxy for another node.

class IndexedNode
          An implementation of a node that has children and supports reordering by providing Index implementor.

Subclasses of Node in org.openide.nodes
`class`	`AbstractNode` A basic implementation of a node.
`class`	`BeanNode<T>` Represents a JavaBeans component as a node.
`class`	`FilterNode` A proxy for another node.
`class`	`IndexedNode` An implementation of a node that has children and supports reordering by providing Index implementor.

Fields in org.openide.nodes declared as Node

static Node Node.EMPTY
An empty leaf node.

protected Node FilterNode.Children.original
Original node.

Fields in org.openide.nodes declared as Node
`static Node`	`Node.EMPTY` An empty leaf node.
`protected Node`	`FilterNode.Children.original` Original node.

Fields in org.openide.nodes with type parameters of type Node

protected Collection<Node> Children.Array.nodes
vector of added children

protected Map<T,Node> Children.Map.nodes
A map to use to store children in.

Fields in org.openide.nodes with type parameters of type Node
`protected Collection<Node>`	`Children.Array.nodes` vector of added children
`protected Map<T,Node>`	`Children.Map.nodes` A map to use to store children in.

Methods in org.openide.nodes that return Node

abstract Node Node.cloneNode()
          Clone the node.

Node FilterNode.cloneNode()
          Create new filter node for the original.

Node AbstractNode.cloneNode()
          Clone the node.

protected Node FilterNode.Children.copyNode(Node node)
          Allows subclasses to override creation of node representants for nodes in the mirrored children list.

Node BeanChildren.Factory.createNode(Object bean)
          Create a node for a child bean.

protected Node[] FilterNode.Children.createNodes(Node key)
          Create nodes representing copies of the original node's children.

protected Node[] BeanChildren.createNodes(Object subbean)
          Creates a node representant for given bean.

protected abstract Node[] Children.Keys.createNodes(T key)
          Create nodes for a given key.

static Node NodeOp.findChild(Node node, String name)
          Look for a node child of given name.

Node FilterNode.Children.findChild(String name)


Node Children.findChild(String name)
          Find a child node by name.

static Node NodeOp.findPath(Node start, Enumeration<String> names)
          Traverse a path from a parent node down, by an enumeration of names.

static Node NodeOp.findPath(Node start, String[] names)
          Traverse a path from a parent node down, by an enumeration of names.

static Node NodeOp.findRoot(Node node)
          Find the root for a given node.

static Node[] NodeOp.fromHandles(Node.Handle[] handles)
          Takes array of handles and creates array of nodes.

Node NodeNotFoundException.getClosestNode()
          Get the closest node to the target that was able to be found.

Node[] NodeMemberEvent.getDelta()
          Get a list of children that changed.

Node NodeEvent.getNode()
          Get the node where the change occurred.

Node Node.Handle.getNode()
          Reconstitute the node for this handle.

Node DefaultHandle.getNode()
          Find the node.

protected Node Children.getNode()
          Get the parent node of these children.

Node[] Index.getNodes()
          Get the child nodes.

abstract Node[] Index.Support.getNodes()
          Get the nodes; should be overridden if needed.

Node[] Children.getNodes()
          Get a (sorted) array of nodes in this list.

Node[] FilterNode.Children.getNodes(boolean optimalResult)
          Implementation that ensures the original node is fully initialized if optimal result is requested.

Node[] Children.getNodes(boolean optimalResult)
          Get a (sorted) array of nodes in this list.

protected Node FilterNode.getOriginal()
          Get the original node.

Node Node.getParentNode()
          Get the parent node.

static Node NodeTransfer.node(Transferable t, int action)
          Obtain a node from a transferable.

static Node[] NodeTransfer.nodes(Transferable t, int action)
          Obtain a list of nodes from a transferable.

Node NodeOperation.select(String title, String rootTitle, Node root)
          Open a modal Explorer accepting only a single node.

Node[] NodeOperation.select(String title, String rootTitle, Node root, NodeAcceptor acceptor)
          Open a modal Explorer without any extra dialog component.

abstract Node[] NodeOperation.select(String title, String rootTitle, Node root, NodeAcceptor acceptor, Component top)
          Open a modal Explorer on a root node, permitting a node selection to be returned.

Methods in org.openide.nodes that return Node
`abstract Node`	`Node.cloneNode()` Clone the node.
`Node`	`FilterNode.cloneNode()` Create new filter node for the original.
`Node`	`AbstractNode.cloneNode()` Clone the node.
`protected Node`	`FilterNode.Children.copyNode(Node node)` Allows subclasses to override creation of node representants for nodes in the mirrored children list.
`Node`	`BeanChildren.Factory.createNode(Object bean)` Create a node for a child bean.
`protected Node[]`	`FilterNode.Children.createNodes(Node key)` Create nodes representing copies of the original node's children.
`protected Node[]`	`BeanChildren.createNodes(Object subbean)` Creates a node representant for given bean.
`protected abstract Node[]`	`Children.Keys.createNodes(T key)` Create nodes for a given key.
`static Node`	`NodeOp.findChild(Node node, String name)` Look for a node child of given name.
`Node`	`FilterNode.Children.findChild(String name)`
`Node`	`Children.findChild(String name)` Find a child node by name.
`static Node`	`NodeOp.findPath(Node start, Enumeration<String> names)` Traverse a path from a parent node down, by an enumeration of names.
`static Node`	`NodeOp.findPath(Node start, String[] names)` Traverse a path from a parent node down, by an enumeration of names.
`static Node`	`NodeOp.findRoot(Node node)` Find the root for a given node.
`static Node[]`	`NodeOp.fromHandles(Node.Handle[] handles)` Takes array of handles and creates array of nodes.
`Node`	`NodeNotFoundException.getClosestNode()` Get the closest node to the target that was able to be found.
`Node[]`	`NodeMemberEvent.getDelta()` Get a list of children that changed.
`Node`	`NodeEvent.getNode()` Get the node where the change occurred.
`Node`	`Node.Handle.getNode()` Reconstitute the node for this handle.
`Node`	`DefaultHandle.getNode()` Find the node.
`protected Node`	`Children.getNode()` Get the parent node of these children.
`Node[]`	`Index.getNodes()` Get the child nodes.
`abstract Node[]`	`Index.Support.getNodes()` Get the nodes; should be overridden if needed.
`Node[]`	`Children.getNodes()` Get a (sorted) array of nodes in this list.
`Node[]`	`FilterNode.Children.getNodes(boolean optimalResult)` Implementation that ensures the original node is fully initialized if optimal result is requested.
`Node[]`	`Children.getNodes(boolean optimalResult)` Get a (sorted) array of nodes in this list.
`protected Node`	`FilterNode.getOriginal()` Get the original node.
`Node`	`Node.getParentNode()` Get the parent node.
`static Node`	`NodeTransfer.node(Transferable t, int action)` Obtain a node from a transferable.
`static Node[]`	`NodeTransfer.nodes(Transferable t, int action)` Obtain a list of nodes from a transferable.
`Node`	`NodeOperation.select(String title, String rootTitle, Node root)` Open a modal Explorer accepting only a single node.
`Node[]`	`NodeOperation.select(String title, String rootTitle, Node root, NodeAcceptor acceptor)` Open a modal Explorer without any extra dialog component.
`abstract Node[]`	`NodeOperation.select(String title, String rootTitle, Node root, NodeAcceptor acceptor, Component top)` Open a modal Explorer on a root node, permitting a node selection to be returned.

Methods in org.openide.nodes that return types with arguments of type Node

Comparator<? super Node> Children.SortedArray.getComparator()
          Get the current comparator.

Comparator<? super Node> Children.SortedMap.getComparator()
          Get the current comparator.

protected List<Node> Index.ArrayChildren.initCollection()
          If default constructor is used, then this method is called to lazily create the collection.

protected Collection<Node> Children.Array.initCollection()
          Allow subclasses to create a collection, the first time the children are used.

protected Map<T,Node> Children.Map.initMap()
          Initialize some nodes.

Enumeration<Node> Children.nodes()
          Get the nodes as an enumeration.

Methods in org.openide.nodes that return types with arguments of type Node
`Comparator<? super Node>`	`Children.SortedArray.getComparator()` Get the current comparator.
`Comparator<? super Node>`	`Children.SortedMap.getComparator()` Get the current comparator.
`protected List<Node>`	`Index.ArrayChildren.initCollection()` If default constructor is used, then this method is called to lazily create the collection.
`protected Collection<Node>`	`Children.Array.initCollection()` Allow subclasses to create a collection, the first time the children are used.
`protected Map<T,Node>`	`Children.Map.initMap()` Initialize some nodes.
`Enumeration<Node>`	`Children.nodes()` Get the nodes as an enumeration.

Methods in org.openide.nodes with parameters of type Node

boolean NodeAcceptor.acceptNodes(Node[] nodes)
          Is the set of nodes acceptable?

boolean FilterNode.Children.add(Node[] arr)
          Deprecated.

abstract boolean Children.add(Node[] nodes)
          Add nodes to this container but do not call this method.

boolean Children.Array.add(Node[] arr)


boolean Children.Map.add(Node[] arr)
          Does nothing.

boolean Children.Keys.add(Node[] arr)
          Deprecated. Do not use! Just call Children.Keys.setKeys(Collection) with a larger set.

protected void FilterNode.Children.changeOriginal(Node original)
          Sets the original children for this children.

protected void FilterNode.changeOriginal(Node original, boolean changeChildren)
          Changes the original node for this node.

static int[] NodeOp.computePermutation(Node[] arr1, Node[] arr2)
          Compute a permutation between two arrays of nodes.

static int[] NodeOp.computePermutation(Node[] arr1, Node[] arr2)
          Compute a permutation between two arrays of nodes.

protected Node FilterNode.Children.copyNode(Node node)
          Allows subclasses to override creation of node representants for nodes in the mirrored children list.

static DefaultHandle DefaultHandle.createHandle(Node node)
          Create a handle for a given node.

protected Node[] FilterNode.Children.createNodes(Node key)
          Create nodes representing copies of the original node's children.

static String[] NodeOp.createPath(Node node, Node parent)
          Find a path (by name) from one node to the root or a parent.

abstract boolean NodeOperation.customize(Node n)
          Tries to open a customization dialog for the specified node.

protected void Children.Keys.destroyNodes(Node[] arr)
          Called when the nodes have been removed from the children.

abstract void NodeOperation.explore(Node n)
          Explore a node (and its subhierarchy).

static Action[] NodeOp.findActions(Node[] nodes)
          Asks the provided nodes for their actions and those that are common, to all of them returns.

static Node NodeOp.findChild(Node node, String name)
          Look for a node child of given name.

static JPopupMenu NodeOp.findContextMenu(Node[] nodes)
          Compute common menu for specified nodes.

static Node NodeOp.findPath(Node start, Enumeration<String> names)
          Traverse a path from a parent node down, by an enumeration of names.

static Node NodeOp.findPath(Node start, String[] names)
          Traverse a path from a parent node down, by an enumeration of names.

static Node NodeOp.findRoot(Node node)
          Find the root for a given node.

int Index.indexOf(Node node)
          Get the index of a given node.

int Index.Support.indexOf(Node node)
          Get the index of a node.

int Index.ArrayChildren.indexOf(Node node)


static boolean NodeOp.isSon(Node parent, Node son)
          Test whether the second node is a (direct) child of the first one.

protected void Children.Map.put(T key, Node node)
          Add one key and one node to the list.

boolean FilterNode.Children.remove(Node[] arr)
          Deprecated.

abstract boolean Children.remove(Node[] nodes)
          Remove nodes from the list.

boolean Children.Array.remove(Node[] arr)


boolean Children.Map.remove(Node[] arr)
          Does nothing.

boolean Children.Keys.remove(Node[] arr)
          Deprecated. Do not use! Just call Children.Keys.setKeys(Collection) with a smaller set.

Node NodeOperation.select(String title, String rootTitle, Node root)
          Open a modal Explorer accepting only a single node.

Node[] NodeOperation.select(String title, String rootTitle, Node root, NodeAcceptor acceptor)
          Open a modal Explorer without any extra dialog component.

abstract Node[] NodeOperation.select(String title, String rootTitle, Node root, NodeAcceptor acceptor, Component top)
          Open a modal Explorer on a root node, permitting a node selection to be returned.

abstract void NodeOperation.showProperties(Node n)
          Open a modal Property Sheet on a node.

abstract void NodeOperation.showProperties(Node[] n)
          Open a modal Property Sheet on a set of nodes.

static Node.Handle[] NodeOp.toHandles(Node[] nodes)
          Takes array of nodes and creates array of handles.

static ExTransferable.Single NodeTransfer.transferable(Node n, int actions)
          Creates transferable that represents a node operation, such as cut-to-clipboard.

PasteType[] NodeTransfer.Paste.types(Node target)
          Method that checks the type of target node and can decide which paste types it supports.

Methods in org.openide.nodes with parameters of type Node
`boolean`	`NodeAcceptor.acceptNodes(Node[] nodes)` Is the set of nodes acceptable?
`boolean`	`FilterNode.Children.add(Node[] arr)` Deprecated.
`abstract boolean`	`Children.add(Node[] nodes)` Add nodes to this container but do not call this method.
`boolean`	`Children.Array.add(Node[] arr)`
`boolean`	`Children.Map.add(Node[] arr)` Does nothing.
`boolean`	`Children.Keys.add(Node[] arr)` Deprecated. Do not use! Just call `Children.Keys.setKeys(Collection)` with a larger set.
`protected void`	`FilterNode.Children.changeOriginal(Node original)` Sets the original children for this children.
`protected void`	`FilterNode.changeOriginal(Node original, boolean changeChildren)` Changes the original node for this node.
`static int[]`	`NodeOp.computePermutation(Node[] arr1, Node[] arr2)` Compute a permutation between two arrays of nodes.
`static int[]`	`NodeOp.computePermutation(Node[] arr1, Node[] arr2)` Compute a permutation between two arrays of nodes.
`protected Node`	`FilterNode.Children.copyNode(Node node)` Allows subclasses to override creation of node representants for nodes in the mirrored children list.
`static DefaultHandle`	`DefaultHandle.createHandle(Node node)` Create a handle for a given node.
`protected Node[]`	`FilterNode.Children.createNodes(Node key)` Create nodes representing copies of the original node's children.
`static String[]`	`NodeOp.createPath(Node node, Node parent)` Find a path (by name) from one node to the root or a parent.
`abstract boolean`	`NodeOperation.customize(Node n)` Tries to open a customization dialog for the specified node.
`protected void`	`Children.Keys.destroyNodes(Node[] arr)` Called when the nodes have been removed from the children.
`abstract void`	`NodeOperation.explore(Node n)` Explore a node (and its subhierarchy).
`static Action[]`	`NodeOp.findActions(Node[] nodes)` Asks the provided nodes for their actions and those that are common, to all of them returns.
`static Node`	`NodeOp.findChild(Node node, String name)` Look for a node child of given name.
`static JPopupMenu`	`NodeOp.findContextMenu(Node[] nodes)` Compute common menu for specified nodes.
`static Node`	`NodeOp.findPath(Node start, Enumeration<String> names)` Traverse a path from a parent node down, by an enumeration of names.
`static Node`	`NodeOp.findPath(Node start, String[] names)` Traverse a path from a parent node down, by an enumeration of names.
`static Node`	`NodeOp.findRoot(Node node)` Find the root for a given node.
`int`	`Index.indexOf(Node node)` Get the index of a given node.
`int`	`Index.Support.indexOf(Node node)` Get the index of a node.
`int`	`Index.ArrayChildren.indexOf(Node node)`
`static boolean`	`NodeOp.isSon(Node parent, Node son)` Test whether the second node is a (direct) child of the first one.
`protected void`	`Children.Map.put(T key, Node node)` Add one key and one node to the list.
`boolean`	`FilterNode.Children.remove(Node[] arr)` Deprecated.
`abstract boolean`	`Children.remove(Node[] nodes)` Remove nodes from the list.
`boolean`	`Children.Array.remove(Node[] arr)`
`boolean`	`Children.Map.remove(Node[] arr)` Does nothing.
`boolean`	`Children.Keys.remove(Node[] arr)` Deprecated. Do not use! Just call `Children.Keys.setKeys(Collection)` with a smaller set.
`Node`	`NodeOperation.select(String title, String rootTitle, Node root)` Open a modal Explorer accepting only a single node.
`Node[]`	`NodeOperation.select(String title, String rootTitle, Node root, NodeAcceptor acceptor)` Open a modal Explorer without any extra dialog component.
`abstract Node[]`	`NodeOperation.select(String title, String rootTitle, Node root, NodeAcceptor acceptor, Component top)` Open a modal Explorer on a root node, permitting a node selection to be returned.
`abstract void`	`NodeOperation.showProperties(Node n)` Open a modal Property Sheet on a node.
`abstract void`	`NodeOperation.showProperties(Node[] n)` Open a modal Property Sheet on a set of nodes.
`static Node.Handle[]`	`NodeOp.toHandles(Node[] nodes)` Takes array of nodes and creates array of handles.
`static ExTransferable.Single`	`NodeTransfer.transferable(Node n, int actions)` Creates transferable that represents a node operation, such as cut-to-clipboard.
`PasteType[]`	`NodeTransfer.Paste.types(Node target)` Method that checks the type of target node and can decide which paste types it supports.

Method parameters in org.openide.nodes with type arguments of type Node

protected void Children.Map.putAll(Map<? extends T,? extends Node> map)
          Add a collection of new key/value pairs into the map.

void Children.SortedArray.setComparator(Comparator<? super Node> c)
          Set the comparator.

void Children.SortedMap.setComparator(Comparator<? super Node> c)
          Set the comparator.

Method parameters in org.openide.nodes with type arguments of type Node
`protected void`	`Children.Map.putAll(Map<? extends T,? extends Node> map)` Add a collection of new key/value pairs into the map.
`void`	`Children.SortedArray.setComparator(Comparator<? super Node> c)` Set the comparator.
`void`	`Children.SortedMap.setComparator(Comparator<? super Node> c)` Set the comparator.

Constructors in org.openide.nodes with parameters of type Node

FilterNode.Children(Node or)
          Create children.

FilterNode(Node original)
          Create proxy.

FilterNode(Node original, Children children)
          Create proxy with a different set of children.

FilterNode(Node original, Children children, Lookup lookup)
          Constructs new filter node with a provided children and lookup.

NodeEvent(Node n)
          Create a new event.

PropertySupport.Name(Node node)
          Create the name property for a node with the standard name and hint.

PropertySupport.Name(Node node, String propName, String hint)
          Create the name property for a node.

Constructors in org.openide.nodes with parameters of type Node
`FilterNode.Children(Node or)` Create children.
`FilterNode(Node original)` Create proxy.
`FilterNode(Node original, Children children)` Create proxy with a different set of children.
`FilterNode(Node original, Children children, Lookup lookup)` Constructs new filter node with a provided children and lookup.
`NodeEvent(Node n)` Create a new event.
`PropertySupport.Name(Node node)` Create the name property for a node with the standard name and hint.
`PropertySupport.Name(Node node, String propName, String hint)` Create the name property for a node.

Constructor parameters in org.openide.nodes with type arguments of type Node

Children.Array(Collection<Node> c)
          Constructs a new list and allows a subclass to provide its own implementation of Collection to store data in.

Children.Map(Map<T,Node> m)
          Constructs a new list with a supplied map object.

Children.SortedArray(Collection<Node> c)
          Create an empty list with a specified storage method.

Children.SortedMap(Map<T,Node> map)
          Create an empty list with a specific storage method.

Constructor parameters in org.openide.nodes with type arguments of type Node
`Children.Array(Collection<Node> c)` Constructs a new list and allows a subclass to provide its own implementation of `Collection` to store data in.
`Children.Map(Map<T,Node> m)` Constructs a new list with a supplied map object.
`Children.SortedArray(Collection<Node> c)` Create an empty list with a specified storage method.
`Children.SortedMap(Map<T,Node> map)` Create an empty list with a specific storage method.

Uses of Node in org.openide.util.actions

Methods in org.openide.util.actions that return Node

Node[] NodeAction.getActivatedNodes()
Get the currently activated nodes.

Methods in org.openide.util.actions that return Node
`Node[]`	`NodeAction.getActivatedNodes()` Get the currently activated nodes.

Methods in org.openide.util.actions with parameters of type Node

protected abstract boolean NodeAction.enable(Node[] activatedNodes)
          Test whether the action should be enabled based on the currently activated nodes.

protected boolean CookieAction.enable(Node[] activatedNodes)
          Test for enablement based on the cookies of selected nodes.

protected abstract void NodeAction.performAction(Node[] activatedNodes)
          Perform the action based on the currently activated nodes.

Methods in org.openide.util.actions with parameters of type Node
`protected abstract boolean`	`NodeAction.enable(Node[] activatedNodes)` Test whether the action should be enabled based on the currently activated nodes.
`protected boolean`	`CookieAction.enable(Node[] activatedNodes)` Test for enablement based on the cookies of selected nodes.
`protected abstract void`	`NodeAction.performAction(Node[] activatedNodes)` Perform the action based on the currently activated nodes.