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

Overview

Package

Class

Use

Tree

Deprecated

Index

Help

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 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)

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.

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

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.

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.

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

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

static Node NodeOp.findChild(Node node, String name)
          Look for a node child of given 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.

abstract Node Node.cloneNode()
          Clone the node.

Node Node.getParentNode()
          Get the parent node.

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

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

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

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

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

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

Node FilterNode.Children.findChild(String name)


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

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

Node DefaultHandle.getNode()
          Find the node.

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

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

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

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

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.

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

Node AbstractNode.cloneNode()
          Clone the node.

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

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.

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

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

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.

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.

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

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

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

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

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

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

static Node NodeOp.findChild(Node node, String name)
          Look for a node child of given 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 int[] NodeOp.computePermutation(Node[] arr1, Node[] arr2)
          Compute a permutation between two arrays of nodes.

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

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

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)


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

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

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

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


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


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

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

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

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


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


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

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

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

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


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


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

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

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.

NodeEvent(Node n)
          Create a new event.

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.

FilterNode.Children(Node or)
          Create children.

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 with parameters of type Node

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

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.