Uses of Class org.openide.nodes.Node (NetBeans Nodes API) - NetBeans API Javadoc 5.5.1

Overview

Package

Class

Use

Tree

Deprecated

Index

Help

org.openide.nodes 6.7.31

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	The IDE 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
          Represents one JavaBean in the nodes hierarchy.

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` Represents one JavaBean in the nodes hierarchy.
`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.

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(Object key)
          Create nodes representing copies of the original node's children.

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

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

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 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(Object key)` Create nodes representing copies of the original node's children.
`protected abstract Node[]`	`Children.Keys.createNodes(Object key)` Create nodes for a given key.
`protected Node[]`	`BeanChildren.createNodes(Object subbean)` Creates a node representant for given bean.
`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 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 with parameters of type Node

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

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


abstract boolean Children.add(Node[] nodes)
          Add nodes this container.

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


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

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


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.

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 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(Object key, Node node)
          Add one key and one node to the list.

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


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)


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)`
`abstract boolean`	`Children.add(Node[] nodes)` Add nodes this container.
`boolean`	`Children.Array.add(Node[] arr)`
`boolean`	`Children.Map.add(Node[] arr)` Does nothing.
`boolean`	`Children.Keys.add(Node[] arr)`
`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.
`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 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(Object key, Node node)` Add one key and one node to the list.
`boolean`	`FilterNode.Children.remove(Node[] arr)`
`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)`
`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.

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.

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.