Uses of Class
edu.umd.cs.piccolo.PNode

Packages that use PNode
edu.umd.cs.piccolo Piccolo is a general-purpose Java-based engine that supports 2D visualizations. 
edu.umd.cs.piccolo.event This package supports Piccolo event handlers. 
edu.umd.cs.piccolo.examples   
edu.umd.cs.piccolo.examples.fisheye   
edu.umd.cs.piccolo.examples.pswing   
edu.umd.cs.piccolo.nodes This package contains nodes that may be useful for Piccolo applications. 
edu.umd.cs.piccolo.tutorial   
edu.umd.cs.piccolo.util This package defines several utility classes that are likely to be useful for Piccolo applications. 
edu.umd.cs.piccolox.event This package provides additional Piccolo event handlers. 
edu.umd.cs.piccolox.handles This package contains handle nodes. 
edu.umd.cs.piccolox.nodes This package contains additional nodes that may be useful for Piccolo applications. 
edu.umd.cs.piccolox.pswing This package contains PSwing nodes and related classes. 
edu.umd.cs.piccolox.swing This package supports using Piccolo with JFC/Swing. 
edu.umd.cs.piccolox.swt This package provides a SWT implementation of the core Piccolo library. 
edu.umd.cs.piccolox.util This package defines additional utility classes that are likely to be useful for Piccolo applications. 
 

Uses of PNode in edu.umd.cs.piccolo
 

Subclasses of PNode in edu.umd.cs.piccolo
 class PCamera
          PCamera represents a viewport onto a list of layer nodes.
 class PLayer
          PLayer is a node that can be viewed directly by multiple camera nodes.
 class PRoot
          PRoot serves as the top node in Piccolo2D's runtime structure.
 

Methods in edu.umd.cs.piccolo that return PNode
 PNode PNode.getChild(int index)
          Return the child node at the specified index.
 PNode PNode.getParent()
          Return the parent of this node.
 PNode PNode.removeChild(int index)
          Remove the child at the specified position of this group node's children.
 PNode PNode.removeChild(PNode child)
          Remove the given child from this node's children list.
 

Methods in edu.umd.cs.piccolo with parameters of type PNode
 void PNode.addChild(int index, PNode child)
          Add a node to be a new child of this node at the specified index.
 void PNode.addChild(PNode child)
          Add a node to be a new child of this node.
 int PNode.indexOfChild(PNode child)
          Return the index where the given child is stored.
 boolean PNode.isAncestorOf(PNode node)
          Return true if this node is an ancestor of the parameter node.
 boolean PNode.isDescendentOf(PNode node)
          Return true if this node is a descendant of the parameter node.
 void PNode.moveInBackOf(PNode sibling)
          Change the order of this node in its parent's children list so that it will draw in back of the specified sibling node.
 void PNode.moveInFrontOf(PNode sibling)
          Change the order of this node in its parent's children list so that it will draw in front of the specified sibling node.
 void PNode.PSceneGraphDelegate.nodeFullBoundsInvalidated(PNode node)
          Called to notify delegate that the node and all it's children need repainting.
 void PNode.PSceneGraphDelegate.nodePaintInvalidated(PNode node)
          Called to notify delegate that the node needs repainting.
 PNode PNode.removeChild(PNode child)
          Remove the given child from this node's children list.
 void PLayer.repaintFrom(PBounds localBounds, PNode repaintSource)
          Override repaints and forward them to the cameras that are viewing this layer.
 void PNode.repaintFrom(PBounds localBounds, PNode childOrThis)
          Pass the given repaint request up the tree, so that any cameras can invalidate that region on their associated canvas.
 void PCamera.repaintFrom(PBounds localBounds, PNode sourceNode)
          Repaint this camera and forward the repaint request to the component for this camera, if it is non-null.
 void PCamera.repaintFromLayer(PBounds viewBounds, PNode repaintedLayer)
          Deprecated. by PCamera.repaintFromLayer(PBounds, PLayer). Will be removed in version 2.0.
 void PNode.reparent(PNode newParent)
          Set the parent of this node, and transform the node in such a way that it doesn't move in global coordinates.
 void PNode.replaceWith(PNode replacementNode)
          Swaps this node out of the scene graph tree, and replaces it with the specified replacement node.
 void PNode.setParent(PNode newParent)
          Set the parent of this node.
 

Uses of PNode in edu.umd.cs.piccolo.event
 

Methods in edu.umd.cs.piccolo.event that return PNode
protected  PNode PDragEventHandler.getDraggedNode()
          Returns the node that is currently being dragged, or null if none.
 PNode PInputEvent.getPickedNode()
          Return the bottom node on the current pickpath, that is the picked node furthest from the root node.
 

Methods in edu.umd.cs.piccolo.event with parameters of type PNode
 PDimension PInputEvent.getDeltaRelativeTo(PNode nodeOnPath)
          Return the delta between the last and current mouse positions relative to a given node on the pick path.
 Point2D PInputEvent.getPositionRelativeTo(PNode nodeOnPath)
          Return the mouse position relative to a given node on the pick path.
protected  void PDragEventHandler.setDraggedNode(PNode draggedNode)
          Set's the node that is currently being dragged.
 

Uses of PNode in edu.umd.cs.piccolo.examples
 

Subclasses of PNode in edu.umd.cs.piccolo.examples
static class AngleNodeExample.AngleNode
           
(package private)  class DecoratorGroup
          This is the non-volatile implementation of a decorator group that paints a background rectangle based on the bounds of its children.
static class SwingLayoutExample.MyPPath
           
(package private)  class VolatileDecoratorGroup
          This is the volatile implementation of a decorator group that paints a background rectangle based on the bounds of its children.
 

Fields in edu.umd.cs.piccolo.examples declared as PNode
(package private)  PNode BirdsEyeViewExample.BirdsEyeView.areaVisiblePNode
          This is the node that shows the viewed area.
(package private)  PNode NodeLinkExample.node1
           
(package private)  PNode NodeLinkExample.node2
           
 

Methods in edu.umd.cs.piccolo.examples that return PNode
 PNode HierarchyZoomExample.createHierarchy(int level)
           
 

Uses of PNode in edu.umd.cs.piccolo.examples.fisheye
 

Subclasses of PNode in edu.umd.cs.piccolo.examples.fisheye
(package private)  class CalendarNode
           
(package private)  class DayNode
           
 

Uses of PNode in edu.umd.cs.piccolo.examples.pswing
 

Subclasses of PNode in edu.umd.cs.piccolo.examples.pswing
static class PSwingExample2.ZVisualLeaf
           
(package private)  class PSwingExample3.ExampleGrid
           
(package private)  class PSwingExample3.ExampleList
           
(package private)  class PSwingExample3.ExampleList.ExampleNode
           
 

Methods in edu.umd.cs.piccolo.examples.pswing with parameters of type PNode
 void PSwingExample3.ExampleList.addExample(String name, PNode example)
           
 

Constructors in edu.umd.cs.piccolo.examples.pswing with parameters of type PNode
PSwingExample2.ZVisualLeaf(PNode node)
           
PSwingExample3.ExampleList.ExampleNode(String name, PNode example)
           
 

Uses of PNode in edu.umd.cs.piccolo.nodes
 

Subclasses of PNode in edu.umd.cs.piccolo.nodes
 class PHtmlView
          PHtmlView is a Piccolo node for rendering HTML text.
 class PImage
          PImage is a wrapper around a java.awt.Image.
 class PPath
          PPath is a wrapper around a java.awt.geom.GeneralPath.
 class PText
          PText is a multi-line text node.
 

Uses of PNode in edu.umd.cs.piccolo.tutorial
 

Subclasses of PNode in edu.umd.cs.piccolo.tutorial
(package private)  class InterfaceFrame.ToggleShape
           
 

Fields in edu.umd.cs.piccolo.tutorial declared as PNode
protected  PNode PiccoloPresentation.currentSlide
           
protected  PNode PiccoloPresentation.slideBar
           
 

Methods in edu.umd.cs.piccolo.tutorial with parameters of type PNode
 void PiccoloPresentation.goToSlide(PNode slide)
           
 

Uses of PNode in edu.umd.cs.piccolo.util
 

Methods in edu.umd.cs.piccolo.util that return PNode
 PNode PPickPath.getPickedNode()
          Get the bottom node on the pick path node stack.
 PNode PPickPath.nextPickedNode()
          Return the next node that will be picked after the current picked node.
 

Methods in edu.umd.cs.piccolo.util with parameters of type PNode
 boolean PNodeFilter.accept(PNode aNode)
          Return true if the filter should accept the given node.
 boolean PNodeFilter.acceptChildrenOf(PNode aNode)
          Return true if the filter should test the children of the given node for acceptance.
 boolean PPickPath.acceptsNode(PNode node)
          Determines if the passed node has been excluded from being a member of the pickpath.
 Dimension2D PPickPath.canvasToLocal(Dimension2D canvasDimension, PNode nodeOnPath)
          Convert the given dimension from the canvas coordinates, down through the pick path (and through any camera view transforms applied to the path) to the local coordinates of the given node.
 Point2D PPickPath.canvasToLocal(Point2D canvasPoint, PNode nodeOnPath)
          Convert the given point from the canvas coordinates, down through the pick path (and through any camera view transforms applied to the path) to the local coordinates of the given node.
 Rectangle2D PPickPath.canvasToLocal(Rectangle2D canvasRectangle, PNode nodeOnPath)
          Convert the given rectangle from the canvas coordinates, down through the pick path (and through any camera view transforms applied to the path) to the local coordinates of the given node.
 PAffineTransform PPickPath.getPathTransformTo(PNode nodeOnPath)
          Calculates the context at which the given node is being interacted with.
 void PPickPath.popNode(PNode node)
          Removes the topmost node from the node stack.
 void PPickPath.pushNode(PNode node)
          Pushes the provided node to the top of the pick path.
 

Uses of PNode in edu.umd.cs.piccolox.event
 

Methods in edu.umd.cs.piccolox.event that return PNode
 PNode PNavigationEventHandler.getNeighborInDirection(int direction)
          Returns the nearest node in the given direction.
 

Methods in edu.umd.cs.piccolox.event with parameters of type PNode
 boolean PSelectionEventHandler.BoundsFilter.accept(PNode node)
          Returns true if the node is an acceptable selection.
 boolean PSelectionEventHandler.BoundsFilter.acceptChildrenOf(PNode node)
          Returns whether this filter should accept all children of a node.
 void PSelectionEventHandler.addSelectableParent(PNode node)
          Flags the node provided as a selectable parent.
 void PSelectionEventHandler.decorateSelectedNode(PNode node)
          Adds bound handles to the provided node.
 PActivity PNavigationEventHandler.directCameraViewToFocus(PCamera camera, PNode newFocus, int duration)
          Animates the Camera's view so that it contains the new focus node.
 boolean PSelectionEventHandler.BoundsFilter.isCameraLayer(PNode node)
          Tests a node to see if it's a layer that has an attached camera.
protected  boolean PSelectionEventHandler.isSelectable(PNode node)
          Determine if the specified node can be selected (i.e., if it is a child of the one the list of nodes that can be selected).
 boolean PSelectionEventHandler.isSelected(PNode node)
          Returns true is provided node is selected.
 boolean PNavigationEventHandler.nodeIsNeighborInDirection(PNode node, int direction)
          Returns true if the given node is a neighbor in the given direction relative to the current focus.
 void PSelectionEventHandler.removeSelectableParent(PNode node)
          Removes the node provided from the set of selectable parents.
 void PSelectionEventHandler.select(PNode node)
          Selected the provided node if not already selected.
 void PSelectionEventHandler.setSelectableParent(PNode node)
          Sets the node provided as the *only* selectable parent.
 void PSelectionEventHandler.undecorateSelectedNode(PNode node)
          Removes bounds handles from node.
 void PSelectionEventHandler.unselect(PNode node)
          Removes node from selection.
 

Constructors in edu.umd.cs.piccolox.event with parameters of type PNode
PSelectionEventHandler(PNode marqueeParent, List selectableParents)
          Creates a selection event handler.
PSelectionEventHandler(PNode marqueeParent, PNode selectableParent)
          Creates a selection event handler.
 

Uses of PNode in edu.umd.cs.piccolox.handles
 

Subclasses of PNode in edu.umd.cs.piccolox.handles
 class PBoundsHandle
          PBoundsHandle a handle for resizing the bounds of another node.
 class PHandle
          PHandle is used to modify some aspect of Piccolo when it is dragged.
 class PStickyHandleManager
          This class relays adjustments to its bounds to its target.
 

Methods in edu.umd.cs.piccolox.handles with parameters of type PNode
static void PBoundsHandle.addBoundsHandlesTo(PNode node)
          Adds bounds handles to the corners and edges of the provided node.
static void PBoundsHandle.addStickyBoundsHandlesTo(PNode node, PCamera camera)
          Adds stick handles (always visible regardless of scale since they are attached to the camera) to the node provided.
static void PBoundsHandle.removeBoundsHandlesFrom(PNode node)
          Removes all bounds from the node provided.
 void PStickyHandleManager.setCameraTarget(PCamera newCamera, PNode newTarget)
          Changes the node and camera on which this manager is operating.
 void PHandle.setParent(PNode newParent)
          Set's this handle's parent.
 

Constructors in edu.umd.cs.piccolox.handles with parameters of type PNode
PStickyHandleManager(PCamera newCamera, PNode newTarget)
          Constructs a sticky handle manager responsible for updating the position of its associated node on the camera provided.
 

Uses of PNode in edu.umd.cs.piccolox.nodes
 

Subclasses of PNode in edu.umd.cs.piccolox.nodes
 class P3DRect
          This is a simple node that draws a "3D" rectangle within the bounds of the node.
 class PCacheCamera
          An extension to PCamera that provides a fast image based animationToCenterBounds method.
 class PClip
          PClip is a simple node that applies a clip before rendering or picking its children.
 class PComposite
          PComposite is a simple node that makes a group of nodes appear to be a single node when picking and interacting.
 class PLens
          PLens is a simple default lens implementation for Piccolo2D.
 class PLine
          PLine a class for drawing multisegment lines.
 class PNodeCache
          PNodeCache caches a visual representation of it's children into an image and uses this cached image for painting instead of painting it's children directly.
 class PShadow
          Shadow node.
 class PStyledText
           
 

Methods in edu.umd.cs.piccolox.nodes with parameters of type PNode
 void PNodeCache.repaintFrom(PBounds localBounds, PNode childOrThis)
          Handles a repaint event issued from a node in this node's tree.
 void PClip.repaintFrom(PBounds localBounds, PNode childOrThis)
          Callback that receives notification of repaint requests from nodes in this node's tree.
 

Uses of PNode in edu.umd.cs.piccolox.pswing
 

Subclasses of PNode in edu.umd.cs.piccolox.pswing
 class PSwing
          PSwing is used to add Swing Components to a Piccolo2D canvas.
 

Methods in edu.umd.cs.piccolox.pswing that return PNode
 PNode PSwingMouseWheelEvent.getCurrentNode()
          Get the current node that is under the cursor.
 PNode PSwingMouseEvent.getCurrentNode()
          Get the current node that is under the cursor.
 PNode PSwingEvent.getCurrentNode()
          Get the current node that is under the cursor.
 PNode PSwingMouseWheelEvent.getGrabNode()
          Determine the node the event originated at.
 PNode PSwingMouseEvent.getGrabNode()
          Determine the node the event originated at.
 PNode PSwingEvent.getGrabNode()
          Determine the node the event originated at.
 PNode PSwingMouseWheelEvent.getNode()
          Determine the node the event originated at.
 PNode PSwingMouseEvent.getNode()
          Determine the node the event originated at.
 PNode PSwingEvent.getNode()
          Determine the node the event originated at.
 

Constructors in edu.umd.cs.piccolox.pswing with parameters of type PNode
PSwingEventHandler(PSwingCanvas canvas, PNode listenNode)
          Constructs a new PSwingEventHandler for the given canvas, and a node that will receive the mouse events.
 

Uses of PNode in edu.umd.cs.piccolox.swing
 

Subclasses of PNode in edu.umd.cs.piccolox.swing
 class SwingLayoutNode
          Uses Swing layout managers to position PNodes.
 

Methods in edu.umd.cs.piccolox.swing that return PNode
 PNode SwingLayoutNode.removeChild(int index)
          Removes a node at a specified index.
 

Methods in edu.umd.cs.piccolox.swing with parameters of type PNode
 void SwingLayoutNode.addChild(int index, PNode child)
          Add a node to be a new child of this node at the specified index.
 void SwingLayoutNode.addChild(int index, PNode child, Object constraints)
          Adds a child at the specified index.
 void SwingLayoutNode.addChild(int index, PNode child, Object constraints, SwingLayoutNode.Anchor childAnchor)
          Adds a child at the specified index.
 void SwingLayoutNode.addChild(int index, PNode child, SwingLayoutNode.Anchor anchor)
          Adds a child at the specified index.
 void SwingLayoutNode.addChild(PNode child)
          Adds a child to the end of the node list.
 void SwingLayoutNode.addChild(PNode child, Object constraints)
          Adds a child to the end of the node list and specifies the given constraints.
 void SwingLayoutNode.addChild(PNode child, Object constraints, SwingLayoutNode.Anchor anchor)
          Adds a child to the end of the node list.
 void SwingLayoutNode.addChild(PNode child, SwingLayoutNode.Anchor anchor)
          Adds a child to the end of the node list.
protected static double SwingLayoutNode.Anchor.AbstractAnchor.centerX(PNode node, double x, double width)
          Returns the x at which the given node would need to be placed so that its center was in the middle of the horizontal segment defined by x and width.
protected static double SwingLayoutNode.Anchor.AbstractAnchor.centerY(PNode node, double y, double height)
          Returns the y at which the given node would need to be placed so that its center was in the middle of the vertical segment defined by y and h.
protected static double SwingLayoutNode.Anchor.AbstractAnchor.east(PNode node, double x, double width)
          Returns the x at which the given node would need to be placed so that its right side was against the right side of the horizontal range defined.
protected static double SwingLayoutNode.Anchor.AbstractAnchor.north(PNode node, double y, double height)
          Returns the y at which the given node would need to be placed so that its top was against the top of the vertical segment defined.
 void SwingLayoutNode.Anchor.positionNode(PNode node, double x, double y, double width, double height)
          Positions the node in the bounds defined.
protected static double SwingLayoutNode.Anchor.AbstractAnchor.south(PNode node, double y, double height)
          Returns the y at which the given node would need to be placed so that its bottom was against the bottom of the vertical range defined.
protected static double SwingLayoutNode.Anchor.AbstractAnchor.west(PNode node, double x, double width)
          Returns the x at which the given node would need to be placed so that its left side was against the left side of the horizontal range defined.
 

Uses of PNode in edu.umd.cs.piccolox.swt
 

Subclasses of PNode in edu.umd.cs.piccolox.swt
 class PSWTBoundsHandle
          PSWTBoundsHandle a handle for resizing the bounds of another node.
 class PSWTHandle
          PSWTHandle is used to modify some aspect of Piccolo when it is dragged.
 class PSWTImage
          PSWTImage is a wrapper around a org.eclipse.swt.graphics.Image.
 class PSWTPath
          PSWTPath is a wrapper around a java.awt.geom.GeneralPath, with workarounds for drawing shapes in SWT where necessary.
 class PSWTRoot
          PSWTRoot is a subclass of PRoot that is designed to work in the SWT environment.
 class PSWTStickyHandleManager
          A class for managing the position of a sticky handle.
 class PSWTText
          PSWTText creates a visual component to support text.
 

Fields in edu.umd.cs.piccolox.swt declared as PNode
(package private)  PNode PSWTSelectionEventHandler.marqueeParent
           
 

Methods in edu.umd.cs.piccolox.swt with parameters of type PNode
static void PSWTBoundsHandle.addBoundsHandlesTo(PNode node)
          Adds bounds handles to all corners and edges of the provided node.
static void PSWTBoundsHandle.addStickyBoundsHandlesTo(PNode node, PCamera camera)
          Adds sticky bounds handles to all corners and edges of the provided node and for display on the provided camera.
 void PSWTSelectionEventHandler.decorateSelectedNode(PNode node)
          Modifies the provided node so that it is displayed as selected.
static void PSWTBoundsHandle.removeBoundsHandlesFrom(PNode node)
          Removes all bounds handles from the specified node.
 void PSWTStickyHandleManager.setCameraTarget(PCamera newCamera, PNode newTarget)
          Changes the associated camera and target for this sticky handle.
 void PSWTHandle.setParent(PNode newParent)
          Set the parent of this node.
 void PSWTSelectionEventHandler.undecorateSelectedNode(PNode node)
          Undoes any modifications to the provided node so that it is not displayed as selected.
 

Constructors in edu.umd.cs.piccolox.swt with parameters of type PNode
PSWTSelectionEventHandler(PNode marqueeParent, List selectableParents)
          Creates a selection event handler.
PSWTSelectionEventHandler(PNode marqueeParent, PNode selectableParent)
          Creates a selection event handler.
PSWTStickyHandleManager(PCamera camera, PNode target)
          Creates a sticky handle that will be displayed on the given camera and will update the provided target.
 

Uses of PNode in edu.umd.cs.piccolox.util
 

Fields in edu.umd.cs.piccolox.util declared as PNode
protected  PNode PNodeLocator.node
          Node being located by this locator.
 

Methods in edu.umd.cs.piccolox.util that return PNode
 PNode PNodeLocator.getNode()
          Returns the node being located by this locator.
 

Methods in edu.umd.cs.piccolox.util with parameters of type PNode
static PBoundsLocator PBoundsLocator.createEastLocator(PNode node)
          Creates a locator for tracking the east side of the provided node.
static PBoundsLocator PBoundsLocator.createNorthEastLocator(PNode node)
          Creates a locator for tracking the north east corner of the provided node.
static PBoundsLocator PBoundsLocator.createNorthLocator(PNode node)
          Creates a locator for tracking the north side of the provided node.
static PBoundsLocator PBoundsLocator.createNorthWestLocator(PNode node)
          Creates a locator for tracking the north west corner of the provided node.
static PBoundsLocator PBoundsLocator.createSouthEastLocator(PNode node)
          Creates a locator for tracking the south east corner of the provided node.
static PBoundsLocator PBoundsLocator.createSouthLocator(PNode node)
          Creates a locator for tracking the south side of the provided node.
static PBoundsLocator PBoundsLocator.createSouthWestLocator(PNode node)
          Creates a locator for tracking the south west corner of the provided node.
static PBoundsLocator PBoundsLocator.createWestLocator(PNode node)
          Creates a locator for tracking the west side of the provided node.
 void POcclusionDetection.detectOcclusions(PNode node, PPickPath pickPath)
          Traverse the pick path determining which parent nodes are occluded by their children nodes.
 void POcclusionDetection.detectOccusions(PNode n, PBounds parentBounds)
          Traverse from the bottom right of the scene graph (top visible node) up the tree determining which parent nodes are occluded by their children nodes.
 void PNodeLocator.setNode(PNode node)
          Changes the node being located by this locator.
 

Constructors in edu.umd.cs.piccolox.util with parameters of type PNode
PBoundsLocator(PNode node, int aSide)
          Constructs a locator for tracking the position on the node provided.
PNodeLocator(PNode node)
          Constructs a locator responsible for locating the given node.
 



Copyright © 1995-2011 Piccolo2D. All Rights Reserved.