org.openide.nodes 7.2.1

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 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<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 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
 Node AbstractNode.cloneNode()
          Clone the node.
abstract  Node Node.cloneNode()
          Clone the node.
 Node FilterNode.cloneNode()
          Create new filter node for the original.
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 ChildFactory.createNodeForKey(T key)
          Create a Node for a given key that was put into the list passed into createKeys().
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.
protected  Node[] ChildFactory.createNodesForKey(T key)
          Create Nodes for a given key object (one from the List passed to createKeys(List )).
protected  Node ChildFactory.createWaitNode()
          Create the Node that should be shown while the keys are being computed on a background thread.
static Node NodeOp.findChild(Node node, String name)
          Look for a node child of given name.
 Node Children.findChild(String name)
          Find a child node by name.
 Node FilterNode.Children.findChild(String 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.
protected  Node Children.getNode()
          Get the parent node of these children.
 Node DefaultHandle.getNode()
          Find the 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[] 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.
 Node[] FilterNode.Children.getNodes(boolean optimalResult)
          Implementation that ensures the original node is fully initialized if optimal result is requested.
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 with parameters of type Node
 boolean NodeAcceptor.acceptNodes(Node[] nodes)
          Is the set of nodes acceptable?
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.
 boolean FilterNode.Children.add(Node[] arr)
          Deprecated. 
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.
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.
 boolean FilterNode.Children.remove(Node[] arr)
          Deprecated. 
 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.
 

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.
 

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  boolean CookieAction.enable(Node[] activatedNodes)
          Test for enablement based on the cookies of selected nodes.
protected abstract  boolean NodeAction.enable(Node[] activatedNodes)
          Test whether the action should be enabled based on the currently activated nodes.
protected abstract  void NodeAction.performAction(Node[] activatedNodes)
          Perform the action based on the currently activated nodes.
 


org.openide.nodes 7.2.1

Built on January 29 2008.  |  Portions Copyright 1997-2007 Sun Microsystems, Inc. All rights reserved.