Uses of Class
org.openide.nodes.Node

Packages that use Node

org.openide	Jumping-off points for all the rest of the IDE's functionality.
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.view	The Explorer is really an abstraction that needs a view to actually display the nodes.
org.openide.loaders	DataSystems are the logical layer between a filesystem and the regular functions of the IDE.
org.openide.modules	The IDE is capable of being extended by pluggable modules providing additional functionality.
org.openide.nodes	The IDE uses nodes to represent JavaBeans or other property containers, formed into a hierarchical tree.
org.openide.src.nodes	Source elements can be represented by default element nodes.
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

Methods in org.openide that return Node

abstract Node[]	TopManager.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[]	TopManager.NodeOperation.select(String title, String rootTitle, Node root, NodeAcceptor acceptor) Open a modal Explorer without any extra dialog component.
Node	TopManager.NodeOperation.select(String title, String rootTitle, Node root) Open a modal Explorer accepting only a single node.
Node	Places.Nodes.repository() Get the Repository node.
Node	Places.Nodes.repository(DataFilter f) Get a Repository node with a given data filter.
Node	Places.Nodes.packages(DataFilter f) Get a root of packages with a given data filter.
Node	Places.Nodes.loaderPool() Get a node with all installed loaders.
Node	Places.Nodes.controlPanel() Deprecated. Typically no longer meaningful.
Node	Places.Nodes.project() Deprecated. Typically no longer meaningful.
Node	Places.Nodes.environment() Get the environment node.
Node	Places.Nodes.session() Deprecated. Typically no longer meaningful.
Node	Places.Nodes.workspaces() Get a node with all workspaces.
Node	Places.Nodes.repositorySettings() Get the Repository settings node.
Node	Places.Nodes.projectDesktop() Get the Desktop node for the current project.
Node[]	Places.Nodes.roots() Get all root nodes.

Methods in org.openide with parameters of type Node

abstract boolean	TopManager.NodeOperation.customize(Node n) Tries to open a customization dialog for the specified node.
abstract void	TopManager.NodeOperation.explore(Node n) Explore a node (and its subhierarchy).
abstract void	TopManager.NodeOperation.showProperties(Node n) Open a modal Property Sheet on a node.
abstract void	TopManager.NodeOperation.showProperties(Node[] n) Open a modal Property Sheet on a set of nodes.
abstract Node[]	TopManager.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[]	TopManager.NodeOperation.select(String title, String rootTitle, Node root, NodeAcceptor acceptor) Open a modal Explorer without any extra dialog component.
Node	TopManager.NodeOperation.select(String title, String rootTitle, Node root) Open a modal Explorer accepting only a single node.

Uses of Node in org.openide.actions

Methods in org.openide.actions that return Node

static Node

NewTemplateAction.getTemplateRoot() Create a hierarchy of templates.

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

protected void	StartDebuggerAction.performAction(Node[] activatedNodes)
protected boolean	StartDebuggerAction.enable(Node[] activatedNodes)
protected void	GoAction.performAction(Node[] activatedNodes)
protected boolean	GoAction.enable(Node[] activatedNodes)
void	TraceIntoAction.performAction(Node[] activatedNodes)
protected boolean	TraceIntoAction.enable(Node[] activatedNodes)
protected void	PrintAction.performAction(Node[] activatedNodes)
protected void	AbstractCompileAction.performAction(Node[] activatedNodes)
protected boolean	AbstractCompileAction.enable(Node[] arr) Checks whether the depth is supported.
protected void	SaveAction.performAction(Node[] activatedNodes)
protected boolean	RenameAction.enable(Node[] activatedNodes)
protected void	RenameAction.performAction(Node[] activatedNodes)
protected void	DebugProjectAction.performAction(Node project)
protected boolean	DebugProjectAction.enable(Node project)
protected void	NewAction.performAction(Node[] activatedNodes)
protected boolean	NewAction.enable(Node[] activatedNodes)
protected void	BuildProjectAction.performAction(Node projectDesktop)
protected boolean	BuildProjectAction.enable(Node projectDesktop) Test whether the action is currently enabled.
protected boolean	InstantiateAction.enable(Node[] activatedNodes)
protected void	InstantiateAction.performAction(Node[] activatedNodes)
void	ExecuteProjectAction.performAction(Node projectDesktop)
boolean	ExecuteProjectAction.enable(Node projectDesktop) Test whether the action is currently enabled.
protected void	ReorderAction.performAction(Node[] activatedNodes)
void	CompileProjectAction.performAction(Node projectDesktop)
boolean	CompileProjectAction.enable(Node projectDesktop) Test whether the action is currently enabled.
void	SaveProjectAction.performAction(Node projectDesktop) Performs the action
boolean	SaveProjectAction.enable(Node projectDesktop) Enabled if the project desktop supports save cookie
protected void	MoveDownAction.performAction(Node[] activatedNodes)
protected boolean	MoveDownAction.enable(Node[] activatedNodes)
protected void	OpenAction.performAction(Node[] activatedNodes)
protected void	ViewAction.performAction(Node[] activatedNodes)
protected void	CustomizeAction.performAction(Node[] activatedNodes)
protected boolean	CustomizeAction.enable(Node[] activatedNodes)
protected void	EditAction.performAction(Node[] activatedNodes)
protected void	MoveUpAction.performAction(Node[] activatedNodes)
protected boolean	MoveUpAction.enable(Node[] activatedNodes)
protected void	CustomizeBeanAction.performAction(Node[] activatedNodes)
static boolean	CustomizeBeanAction.compileNodes(Node[] nodes) Execute some data objects.
protected boolean	SaveAsTemplateAction.enable(Node[] activatedNodes)
protected void	SaveAsTemplateAction.performAction(Node[] activatedNodes)
protected void	NewTemplateAction.performAction(Node[] activatedNodes)
protected boolean	NewTemplateAction.enable(Node[] activatedNodes)
protected boolean	GoToCursorAction.enable(Node[] activatedNodes)
protected void	GoToCursorAction.performAction(Node[] activatedNodes)
protected void	OpenLocalExplorerAction.performAction(Node[] activatedNodes)
protected boolean	OpenLocalExplorerAction.enable(Node[] activatedNodes)
protected void	PropertiesAction.performAction(Node[] activatedNodes)
protected boolean	PropertiesAction.enable(Node[] activatedNodes)
protected void	ExecuteAction.performAction(Node[] activatedNodes)
static boolean	ExecuteAction.execute(Node[] nodes, boolean compileBefore) Execute some nodes.

Uses of Node in org.openide.cookies

Methods in org.openide.cookies that return Node

Node	ProjectCookie.projectDesktop() Get the "Project Desktop" node.
Node	ConnectionCookie.Event.getNode() Getter for the node that produced the action.
Node	ElementCookie.getElementsParent() Get the alternate node representation.

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

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.
static HelpCtx	ExplorerPanel.getHelpCtx(Node[] sel, HelpCtx def) Utility method to get context help from a node selection.

Uses of Node in org.openide.explorer.propertysheet

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

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

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

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.
static TreeNode	Visualizer.findVisualizer(Node node) Methods that create a tree node for given node.
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.
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.
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)
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.
void	NodeListModel.setNode(Node root) Changes the root of the model.

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

NodeTreeModel(Node root)
Creates new NodeTreeModel

MenuView.Menu(Node node)
Constuctor that assigns the node a default action, e.g.

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.

NodeListModel(Node root)
Creates new NodeTreeModel

Uses of Node in org.openide.loaders

Subclasses of Node in org.openide.loaders

class	DataFolder.FolderNode Node for a folder.
class	DataNode Standard node representing a data object.
protected static class	DataShadow.ShadowNode Node for a shadow object.

Methods in org.openide.loaders that return Node

Node	DataObject.getNodeDelegate() Get the node delegate.
protected Node	DataObject.createNodeDelegate() Provides node that should represent this data object.
protected Node	MultiDataObject.createNodeDelegate() Provides node that should represent this data object.
protected Node	DataFolder.createNodeDelegate() Create node representative for this folder.
Node[]	DataFolder.Index.getNodes()
protected Node	DataShadow.createNodeDelegate()
Node	DataShadow.ShadowNode.cloneNode()
protected Node	InstanceDataObject.createNodeDelegate()
protected Node	XMLDataObject.createNodeDelegate() If the Info associated with this data object (if any) provides a subclass of Node, then this object is created to represent the XML data object, otherwise DataNode is created.
protected Node[]	DataObjectFilter.createNodes(Object key) Create children for a data-object key.

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

int	DataFolder.Index.indexOf(Node node)
void	ConnectionSupport.register(ConnectionCookie.Type type, Node listener) Attaches new node to listen to events produced by this event.
void	ConnectionSupport.unregister(ConnectionCookie.Type type, Node listener) Unregisters an listener.

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

DataFolder.Index(DataFolder df, Node node)
Create an index cookie associated with a data folder.

Uses of Node in org.openide.modules

Methods in org.openide.modules that return Node

Node	ManifestSection.NodeSection.getNode() Get the environment node.

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

Node[]	Index.getNodes() Get the child nodes.
abstract Node[]	Index.Support.getNodes() Get the nodes; should be overridden if needed.
abstract Node	Node.cloneNode() Clone the node.
Node	Node.getParentNode() Get the parent node.
Node	AbstractNode.cloneNode() Clone the node.
Node	FilterNode.cloneNode() Create new filter node for the original.
protected Node	FilterNode.getOriginal() Get the original 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.
protected abstract Node[]	Children.Keys.createNodes(Object key) Create nodes for a given key.
Node	NodeEvent.getNode() Get the node where the change occurred.
Node	DefaultHandle.getNode() Find the node.
Node	NodeNotFoundException.getClosestNode() Get the closest node to the target that was able to be found.
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.
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[]	NodeMemberEvent.getDelta() Get a list of children that changed.
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.
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	Node.Handle.getNode() Reconstitute the node for this handle.

Methods in org.openide.nodes with parameters of type 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.
protected void	FilterNode.changeOriginal(Node original, boolean changeChildren) Changes the original node for this 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)
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.
boolean	NodeAcceptor.acceptNodes(Node[] nodes) Is the set of nodes acceptable?
static DefaultHandle	DefaultHandle.createHandle(Node node) Create a handle for a given 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 JPopupMenu	NodeOp.findContextMenu(Node[] nodes) Compute common menu for specified nodes.
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.
int	Index.ArrayChildren.indexOf(Node node)
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.
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(Node original)
Create proxy.

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

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.

FilterNode.Children(Node or)
Create children.

Uses of Node in org.openide.src.nodes

Subclasses of Node in org.openide.src.nodes

class	ClassElementNode Node representing a Java class.
class	ConstructorElementNode Node representing a constructor.
class	ElementNode Superclass of nodes representing elements in the source hierarchy.
class	FieldElementNode Node representing a field (variable).
class	InitializerElementNode Node representing an initializer (static or nonstatic).
class	MemberElementNode Node representing some type of member element.
class	MethodElementNode Node for a method element.

Methods in org.openide.src.nodes that return Node

protected Node[]	SourceChildren.createNodes(Object key)
Node	SourceChildren.findChild(String name)
Node	FilterFactory.createConstructorNode(ConstructorElement element) Make a node representing a constructor.
Node	FilterFactory.createMethodNode(MethodElement element) Make a node representing a method.
Node	FilterFactory.createFieldNode(FieldElement element) Make a node representing a field.
Node	FilterFactory.createInitializerNode(InitializerElement element) Make a node representing an initializer.
Node	FilterFactory.createClassNode(ClassElement element) Make a node representing a class.
Node	FilterFactory.createWaitNode() Make a node indicating that the creation of children is still under way.
Node	FilterFactory.createErrorNode() Make a node indicating that there was an error creating the element children.
Node	DefaultFactory.createMethodNode(MethodElement element)
Node	DefaultFactory.createConstructorNode(ConstructorElement element)
Node	DefaultFactory.createFieldNode(FieldElement element)
Node	DefaultFactory.createInitializerNode(InitializerElement element)
Node	DefaultFactory.createClassNode(ClassElement element)
Node	DefaultFactory.createWaitNode()
Node	DefaultFactory.createErrorNode()
Node	ElementNodeFactory.createConstructorNode(ConstructorElement element) Make a node representing a constructor.
Node	ElementNodeFactory.createMethodNode(MethodElement element) Make a node representing a method.
Node	ElementNodeFactory.createFieldNode(FieldElement element) Make a node representing a field.
Node	ElementNodeFactory.createInitializerNode(InitializerElement element) Make a node representing an initializer.
Node	ElementNodeFactory.createClassNode(ClassElement element) Make a node representing a class.
Node	ElementNodeFactory.createWaitNode() Make a node indicating that the creation of children is still under way.
Node	ElementNodeFactory.createErrorNode() Make a node indicating that there was an error creating the element children.
protected Node[]	ClassChildren.createNodes(Object key)

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.
protected abstract void	ProjectSensitiveAction.performAction(Node project) Performs the action on the current project desktop node.
protected abstract boolean	ProjectSensitiveAction.enable(Node project) Performs the action on the current project desktop node.

Uses of Node in org.openide.windows

Methods in org.openide.windows that return Node

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.
Node[]	WindowManager.Component.getActivatedNodes() Get the set of activated nodes.

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

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