Uses of Class org.openide.nodes.Node (NetBeans APIs) - NetBeans API Javadoc 4.1.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.actions	There are a number of standard system actions available for use in the IDE.
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.explorer	Many different UI components of the IDE are actually Explorer views of nodes.
org.openide.explorer.propertysheet	The exact properties of a node may be displayed and edited with the Property Sheet.
org.openide.explorer.propertysheet.editors
org.openide.explorer.view	The Explorer is really an abstraction that needs a view to actually display the nodes.
org.openide.nodes	The IDE uses nodes to represent JavaBeans or other property containers, formed into a hierarchical tree.
org.openide.util.actions	There are several types of standard actions that should be used for many user interactions with the IDE.
org.openide.windows	Most parts of the IDE do not manipulate windows directly, but use special top components.

Uses of Node in org.openide.actions

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

protected void ViewAction.performAction(Node[] activatedNodes)


protected void SaveAction.performAction(Node[] activatedNodes)


protected void ReorderAction.performAction(Node[] activatedNodes)


protected boolean RenameAction.enable(Node[] activatedNodes)


protected void RenameAction.performAction(Node[] activatedNodes)


protected void PropertiesAction.performAction(Node[] activatedNodes)


protected boolean PropertiesAction.enable(Node[] activatedNodes)


protected void PrintAction.performAction(Node[] activatedNodes)


protected void OpenLocalExplorerAction.performAction(Node[] activatedNodes)


protected boolean OpenLocalExplorerAction.enable(Node[] activatedNodes)


protected void OpenAction.performAction(Node[] activatedNodes)


protected void NewAction.performAction(Node[] activatedNodes)


protected boolean NewAction.enable(Node[] activatedNodes)


protected void MoveUpAction.performAction(Node[] activatedNodes)


protected boolean MoveUpAction.enable(Node[] activatedNodes)


protected void MoveDownAction.performAction(Node[] activatedNodes)


protected boolean MoveDownAction.enable(Node[] activatedNodes)


protected void EditAction.performAction(Node[] activatedNodes)


protected void CustomizeAction.performAction(Node[] activatedNodes)


protected boolean CustomizeAction.enable(Node[] activatedNodes)

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)
Attaches new node to listen to events produced by this event.

void ConnectionCookie.unregister(ConnectionCookie.Type type, Node listener)
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.explorer

Methods in org.openide.explorer that return Node

Node[] ExplorerManager.getSelectedNodes()
          Get the set of selected nodes.

Node ExplorerManager.getExploredContext()
          Get the explored context.

Node ExplorerManager.getRootContext()
          Get the root context.

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

static HelpCtx ExplorerUtils.getHelpCtx(Node[] sel, HelpCtx def)
          Utility method to get context help from a node selection.

static HelpCtx ExplorerPanel.getHelpCtx(Node[] sel, HelpCtx def)
          Deprecated. Utility method to get context help from a node selection.

void ExplorerManager.setSelectedNodes(Node[] value)
          Set the set of selected nodes.

void ExplorerManager.setExploredContext(Node value)
          Set the explored context.

void ExplorerManager.setExploredContext(Node value, Node[] selection)
          Set the explored context.

void ExplorerManager.setExploredContextAndSelection(Node value, Node[] selection)
          Set the explored context and selected nodes.

void ExplorerManager.setRootContext(Node value)
          Set the root context.

Uses of Node in org.openide.explorer.propertysheet

Methods in org.openide.explorer.propertysheet with parameters of type Node

void PropertySheet.setNodes(Node[] nodes)
Set the nodes explored by this property sheet.

Uses of Node in org.openide.explorer.propertysheet.editors

Methods in org.openide.explorer.propertysheet.editors with parameters of type Node

void NodePropertyEditor.attach(Node[] nodes)
Deprecated. Informs the editor that the property that it is displaying belongs to following nodes.

void NodeCustomizer.attach(Node n)
Deprecated. Informs this customizer, that it has been connected to a node.

Uses of Node in org.openide.explorer.view

Fields in org.openide.explorer.view declared as Node

protected Node MenuView.Menu.node
The node represented.

protected Node MenuView.MenuItem.node
The node represented.

Methods in org.openide.explorer.view that return Node

static Node Visualizer.findNode(Object visualizer)
Converts visualizer object back to its node representant.

Methods in org.openide.explorer.view with parameters of type Node

static TreeNode Visualizer.findVisualizer(Node node)
          Methods that create a tree node for given node.

void TreeView.collapseNode(Node n)
          Collapses the tree under given node.

void TreeView.expandNode(Node n)
          Expandes the node in the tree.

boolean TreeView.isExpanded(Node n)
          Test whether a node is expanded in the tree or not

protected abstract void TreeView.selectionChanged(Node[] nodes, ExplorerManager em)
          Called to allow subclasses to define the behaviour when a node(s) are selected in the tree.

protected abstract boolean TreeView.selectionAccept(Node[] nodes)
          Called when explorer manager is about to change the current selection.

void NodeTreeModel.setNode(Node root)
          Changes the root of the model.

void NodeTableModel.setNodes(Node[] nodes)
          Set rows.

protected Node.Property NodeTableModel.getPropertyFor(Node node, Node.Property prop)
          Returns node property if found in nodes property sets.

void NodeListModel.setNode(Node root)
          Changes the root of the model.

protected JMenuItem MenuView.Menu.createMenuItem(Node n)
          Create a menu element for a node.

boolean MenuView.Acceptor.accept(Node n)
          Deprecated. whole interface is obsoleted, use NodeAcceptor.acceptNodes(org.openide.nodes.Node[]) instead.

protected void ListView.selectionChanged(Node[] nodes, ExplorerManager em)
          Called when the list changed selection and the explorer manager should be updated.

protected boolean ListView.selectionAccept(Node[] nodes)
          Called when explorer manager is about to change the current selection.

protected boolean ContextTreeView.selectionAccept(Node[] nodes)


protected void ContextTreeView.selectionChanged(Node[] nodes, ExplorerManager man)


protected boolean BeanTreeView.selectionAccept(Node[] nodes)
          Can select any nodes.

protected void BeanTreeView.selectionChanged(Node[] nodes, ExplorerManager em)

Constructors in org.openide.explorer.view with parameters of type Node

NodeTreeModel(Node root)
          Creates new NodeTreeModel

NodeListModel(Node root)
          Creates new NodeTreeModel

MenuView.Menu(Node node)
          Constructor that assigns the node a default action.

MenuView.Menu(Node node, NodeAcceptor action)
          Constructor that permits specification of the action on the node.

MenuView.Menu(Node node, MenuView.Acceptor action)
          Deprecated. use MenuView.Menu.MenuView.Menu(Node, NodeAcceptor)

MenuView.Menu(Node node, MenuView.Acceptor action, boolean setName)
          Deprecated. use MenuView.Menu.MenuView.Menu(Node, NodeAcceptor, boolean)

MenuView.Menu(Node node, NodeAcceptor action, boolean setName)
          Constructor that permits specification of the action on the node, and permits overriding the name and icon of the menu.

MenuView.MenuItem(Node node)
          Construct item for given node with the node's default action.

MenuView.MenuItem(Node node, NodeAcceptor l)
          Construct item for given node, specifying an action.

MenuView.MenuItem(Node node, MenuView.Acceptor action)
          Deprecated. Use proper constructor with (@link NodeAcceptor).

MenuView.MenuItem(Node node, MenuView.Acceptor action, boolean setName)
          Deprecated. Use proper constructor with (@link NodeAcceptor).

MenuView.MenuItem(Node node, NodeAcceptor l, boolean setName)
          Construct item for given node, specifying the action and whether to create the icon and name automatically.

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.

Uses of Node in org.openide.windows

Methods in org.openide.windows that return Node

Node[] WindowManager.Component.getActivatedNodes()
          Deprecated. Get the set of activated nodes.

Node[] TopComponent.getActivatedNodes()
          Get the set of activated nodes in this component.

Node[] TopComponent.Registry.getCurrentNodes()
          Getter for the currently selected nodes.

Node[] TopComponent.Registry.getActivatedNodes()
          Getter for the lastly activated nodes.

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

protected abstract void WindowManager.topComponentActivatedNodesChanged(TopComponent tc, Node[] activatedNodes)
          Informs about change of activated nodes of specified TopComponent.

void WindowManager.Component.setActivatedNodes(Node[] nodes)
          Deprecated. Set the set of activated nodes for this component.

void TopComponent.setActivatedNodes(Node[] activatedNodes)
          Set the set of activated nodes in this component.

static void TopComponent.NodeName.connect(TopComponent top, Node n)
          Connects a top component and a node.