C# Class UMD.HCIL.Piccolo.PNode

Inheritance: ICloneable, ISerializable, IEnumerable

Mostra file Open project: ME3Explorer/ME3Explorer Class Usage Examples

Public Properties

Property	Type	Description
FullBoundsInvalidated	FullBoundsInvalidatedDelegate
PaintInvalidated	PaintInvalidatedDelegate

Protected Properties

Property	Type	Description
EVENT_KEY_CLICK	object
EVENT_KEY_DOUBLECLICK	object
EVENT_KEY_DRAGDROP	object
EVENT_KEY_DRAGENTER	object
EVENT_KEY_DRAGLEAVE	object
EVENT_KEY_DRAGOVER	object
EVENT_KEY_GOTFOCUS	object
EVENT_KEY_KEYDOWN	object
EVENT_KEY_KEYPRESS	object
EVENT_KEY_KEYUP	object
EVENT_KEY_LOSTFOCUS	object
EVENT_KEY_MOUSEDOWN	object
EVENT_KEY_MOUSEDRAG	object
EVENT_KEY_MOUSEENTER	object
EVENT_KEY_MOUSELEAVE	object
EVENT_KEY_MOUSEMOVE	object
EVENT_KEY_MOUSEUP	object
EVENT_KEY_MOUSEWHEEL	object
PROPERTY_KEY_BOUNDS	object
PROPERTY_KEY_BRUSH	object
PROPERTY_KEY_CHILDREN	object
PROPERTY_KEY_CHILDRENPICKABLE	object
PROPERTY_KEY_FULLBOUNDS	object
PROPERTY_KEY_PARENT	object
PROPERTY_KEY_PICKABLE	object
PROPERTY_KEY_TAG	object
PROPERTY_KEY_TRANSFORM	object
PROPERTY_KEY_VISIBLE	object
bounds	System.Drawing.RectangleF

Public Methods

Method	Description
AddActivity ( UMD.HCIL.Piccolo.Activities.PActivity activity ) : bool	Schedule the given activity with the root. Note that only scheduled activities will be stepped. If the activity is successfully added true is returned, else false.
AddChild ( PNode child ) : void	Add a node to be a new child of this node. The new node is added to the end of the list of this node's children. If child was previously a child of another node, it is removed from that node first.
AddChild ( int index, PNode child ) : void	Add a node to be a new child of this node at the specified index. If child was previously a child of another node, it is removed from that node first.
AddChildren ( UMD.HCIL.Piccolo.Util.PNodeList nodes ) : void	Add a list of nodes to be children of this node. If these nodes already have parents they will first be removed from those parents.
AddInputEventListener ( PInputEventListener listener ) : void	Adds the specified input event listener to receive input events from this node.
AnimateMatrixToBounds ( float x, float y, float width, float height, long duration ) : UMD.HCIL.Piccolo.Activities.PTransformActivity	Animate this node from it's current matrix when the activity starts a new matrix that will fit the node into the given bounds. If this node descends from the root then the activity will be scheduled, else the returned activity should be scheduled manually. If two different transform activities are scheduled for the same node at the same time, they will both be applied to the node, but the last one scheduled will be applied last on each frame, so it will appear to have replaced the original. Generally you will not want to do that. Note this method animates the node's matrix, but does not directly change the node's bounds rectangle. Use AnimateToBounds to animate the node's bounds rectangle instead.
AnimateToBounds ( float x, float y, float width, float height, long duration ) : UMD.HCIL.Piccolo.Activities.PInterpolatingActivity	Animate this node's bounds from their current location when the activity starts to the specified bounds. If this node descends from the root then the activity will be scheduled, else the returned activity should be scheduled manually. If two different transform activities are scheduled for the same node at the same time, they will both be applied to the node, but the last one scheduled will be applied last on each frame, so it will appear to have replaced the original. Generally you will not want to do that. Note this method animates the node's bounds, but does not change the node's matrix. Use AnimateMatrixToBounds to animate the node's matrix instead.
AnimateToColor ( Color destColor, long duration ) : PColorActivity	Animate this node's color from its current value to the new value specified. This method assumes that this nodes Brush property is of type SolidBrush. If this node descends from the root then the activity will be scheduled, else the returned activity should be scheduled manually. If two different color activities are scheduled for the same node at the same time, they will both be applied to the node, but the last one scheduled will be applied last on each frame, so it will appear to have replaced the original. Generally you will not want to do that.
AnimateToMatrix ( UMD.HCIL.Piccolo.Util.PMatrix destMatrix, long duration ) : UMD.HCIL.Piccolo.Activities.PTransformActivity	Animate this node's matrix from its current values when the activity starts to the new values specified in the given matrix. If this node descends from the root then the activity will be scheduled, else the returned activity should be scheduled manually. If two different transform activities are scheduled for the same node at the same time, they will both be applied to the node, but the last one scheduled will be applied last on each frame, so it will appear to have replaced the original. Generally you will not want to do that.
AnimateToPositionScaleRotation ( float x, float y, float scale, float theta, long duration ) : UMD.HCIL.Piccolo.Activities.PTransformActivity	Animate this node's matrix from its current location when the activity starts to the specified location, scale, and rotation. If this node descends from the root then the activity will be scheduled, else the returned activity should be scheduled manually. If two different transform activities are scheduled for the same node at the same time, they will both be applied to the node, but the last one scheduled will be applied last on each frame, so it will appear to have replaced the original. Generally you will not want to do that.
CenterBoundsOnPoint ( float x, float y ) : bool	Adjust the bounds of this node so that they are centered on the given point specified in the local coordinate system of this node. Note that this method will modify the node's bounds, while CenterFullBoundsOnPoint will modify the node's matrix.
CenterFullBoundsOnPoint ( float x, float y ) : void	Adjust the full bounds of this node so that they are centered on the given point specified in the local coordinates of this node's parent. Note that this meathod will modify the node's matrix, while CenterBoundsOnPoint will modify the node's bounds.
Clone ( ) : Object	The copy method copies this node and all of its descendents. Note that copying is implemented in terms of c# serialization. See the serialization notes for more information.
ComputeFullBounds ( ) : RectangleF	Compute and return the full bounds of this node.
EndResizeBounds ( ) : void	Notify this node that you have finished a resize bounds sequence. A call to `StartResizeBounds` should precede a call to `EndResizeBounds`.
FindIntersectingNodes ( RectangleF fullBounds, UMD.HCIL.Piccolo.Util.PNodeList results ) : void	Checks this node and it's descendents for intersection with the given bounds and adds any intersecting nodes to the given list.
FullIntersects ( RectangleF bounds ) : bool	Return true if the full bounds of this node intersect with the specified bounds.
FullPaint ( UMD.HCIL.Piccolo.Util.PPaintContext paintContext ) : void	Paint this node and all of its descendents. Notes to Inheritors: Most subclasses do not need to override this method, they should override `paint` or `paintAfterChildren` instead.
FullPick ( UMD.HCIL.Piccolo.Util.PPickPath pickPath ) : bool	Try to pick this node and all of its descendents. Notes to Inheritors: Most subclasses should not need to override this method. Instead they should override `Pick` or `PickAfterChildren`.
GetAllNodes ( PNodeFilter filter, UMD.HCIL.Piccolo.Util.PNodeList results ) : UMD.HCIL.Piccolo.Util.PNodeList	Gets a list containing the subset of this node and all of its descendent nodes that are accepted by the given node filter. If the filter is null then all nodes will be accepted. If the results parameter is not null then it will be used to store this subset instead of creating a new list.
GetChild ( int index ) : PNode	Return the child node at the specified index.
GetEnumerator ( ) : IEnumerator	Return an enumerator for this node’s direct descendent children. This method allows you to use the foreach loop to iterate over a node's children. For example, you could do the following: `foreach(PNode node in aNode) { node.DoSomething(); }` Typically, you will not need to call this method directly. Instead use the ChildrenEnumerator property.
GetObjectData ( SerializationInfo info, StreamingContext context ) : void	Write this node and all of its descendent nodes to the given SerializationInfo. This node's parent is written out conditionally, that is it will only be written out if someone else writes it out unconditionally.
GlobalToLocal ( PointF point ) : PointF	Transform the given point from global coordinates to this node's local coordinate system.
GlobalToLocal ( RectangleF rectangle ) : RectangleF	Transform the given rectangle from global coordinates to this node's local coordinate system.
GlobalToLocal ( SizeF size ) : SizeF	Transform the given size from global coordinates to this node's local coordinate system.
IndexOfChild ( PNode child ) : int	Return the index where the given child is stored.
Intersects ( RectangleF bounds ) : bool	Return true if this node intersects the given rectangle specified in local bounds. If the geometry of this node is complex, this method can become expensive. It is therefore recommended that `FullIntersects` is used for quick rejects before calling this method.
InvalidateFullBounds ( ) : void	Invalidates the full bounds of this node, and sets the child bounds invalid flag on each of this node's ancestors.
InvalidateLayout ( ) : void	Invalidate this node's layout, so that later `LayoutChildren` will get called.
InvalidatePaint ( ) : void	Invalidate this node's paint, and mark all of its ancestors as having a node with invalid paint.
IsAncestorOf ( PNode node ) : bool	Return true if this node is an ancestor of the parameter node.
IsDescendentOf ( PNode node ) : bool	Return true if this node is a descendent of the parameter node.
IsDescendentOfRoot ( ) : bool	Return true if this node is a descendent of the Root.
IsOpaque ( RectangleF boundary ) : bool
LayoutChildren ( ) : void	Nodes that apply layout constraints to their children should override this method and do the layout there. This method gets called whenever Piccolo determines that this node's children may need to be re-layed out. This occurs when the bounds of this node or a descendent node change. This method may also be invoked indirectly when LayoutChildren is called on an ancestor node, since typically you will modify the bounds of the children there.
Lerp ( float t, float a, float b ) : float	Linearly interpolates between a and b, based on t. Specifically, it computes Lerp(a, b, t) = a + t*(b - a). This produces a result that changes from a (when t = 0) to b (when t = 1).
LocalToGlobal ( PointF point ) : PointF	Transform the given point from this node's local coordinate system to the global coordinate system.
LocalToGlobal ( RectangleF rectangle ) : RectangleF	Transform the given rectangle from this node's local coordinate system to the global coordinate system.
LocalToGlobal ( SizeF size ) : SizeF	Transform the given size from this node's local coordinate system to the global coordinate system.
LocalToParent ( PointF point ) : PointF	Transform the given point from this node's local coordinate system to its parent's local coordinate system.
LocalToParent ( RectangleF rectangle ) : RectangleF	Transform the given rectangle from this node's local coordinate system to its parent's local coordinate system.
LocalToParent ( SizeF size ) : SizeF	Transform the given size from this node's local coordinate system to its parent's local coordinate system.
MoveInBackOf ( PNode sibling ) : void	Change the order of this node in its parent's children list so that it will draw before the given sibling node.
MoveInFrontOf ( PNode sibling ) : void	Change the order of this node in its parent's children list so that it will draw after the given sibling node.
MoveToBack ( ) : void	Change the order of this node in its parent's children list so that it will draw in back of all of its other sibling nodes.
MoveToFront ( ) : void	Change the order of this node in its parent's children list so that it will draw in front of all of its other sibling nodes.
OffsetBy ( float dx, float dy ) : void	Offset this node relative to the parent's coordinate system. This is NOT affected by this node's current scale or rotation. This is implemented by directly adding dx to the dx position and dy to the dy position of the matrix.
OnClick ( PInputEventArgs e ) : void	Raises the Click event. Raising an event invokes the event handler through a delegate. The OnClick method also allows derived classes to handle the event without attaching a delegate. This is the preferred technique for handling the event in a derived class. Notes to Inheritors: When overriding OnClick in a derived class, be sure to call the base class's OnClick method so that registered delegates receive the event.
OnDoubleClick ( PInputEventArgs e ) : void	Raises the DoubleClick event. Raising an event invokes the event handler through a delegate. The OnDoubleClick method also allows derived classes to handle the event without attaching a delegate. This is the preferred technique for handling the event in a derived class. Notes to Inheritors: When overriding OnDoubleClick in a derived class, be sure to call the base class's OnDOubleClick method so that registered delegates receive the event.
OnDragDrop ( PInputEventArgs e ) : void	Raises the DragDrop event. Raising an event invokes the event handler through a delegate. The OnDragDrop method also allows derived classes to handle the event without attaching a delegate. This is the preferred technique for handling the event in a derived class. Notes to Inheritors: When overriding OnDragDrop in a derived class, be sure to call the base class's OnDragDrop method so that registered delegates receive the event.
OnDragEnter ( PInputEventArgs e ) : void	Raises the DragEnter event. Raising an event invokes the event handler through a delegate. The OnDragEnter method also allows derived classes to handle the event without attaching a delegate. This is the preferred technique for handling the event in a derived class. Notes to Inheritors: When overriding OnDragEnter in a derived class, be sure to call the base class's OnDragEnter method so that registered delegates receive the event.
OnDragLeave ( PInputEventArgs e ) : void	Raises the DragLeave event. Raising an event invokes the event handler through a delegate. The OnDragLeave method also allows derived classes to handle the event without attaching a delegate. This is the preferred technique for handling the event in a derived class. Notes to Inheritors: When overriding OnDragLeave in a derived class, be sure to call the base class's OnDragLeave method so that registered delegates receive the event.
OnDragOver ( PInputEventArgs e ) : void	Raises the DragOver event. Raising an event invokes the event handler through a delegate. The OnDragOver method also allows derived classes to handle the event without attaching a delegate. This is the preferred technique for handling the event in a derived class. Notes to Inheritors: When overriding OnDragOver in a derived class, be sure to call the base class's OnDragOver method so that registered delegates receive the event.
OnGotFocus ( PInputEventArgs e ) : void	Raises the GotFocus event. Raising an event invokes the event handler through a delegate. The OnGotFocus method also allows derived classes to handle the event without attaching a delegate. This is the preferred technique for handling the event in a derived class. Notes to Inheritors: When overriding OnGotFocus in a derived class, be sure to call the base class's OnGotFocus method so that registered delegates receive the event.
OnKeyDown ( PInputEventArgs e ) : void	Raises the KeyDown event. Raising an event invokes the event handler through a delegate. The OnKeyDown method also allows derived classes to handle the event without attaching a delegate. This is the preferred technique for handling the event in a derived class. Notes to Inheritors: When overriding OnKeyDown in a derived class, be sure to call the base class's OnKeyDown method so that registered delegates receive the event.
OnKeyPress ( PInputEventArgs e ) : void	Raises the KeyPress event. Raising an event invokes the event handler through a delegate. The OnKeyPress method also allows derived classes to handle the event without attaching a delegate. This is the preferred technique for handling the event in a derived class. Notes to Inheritors: When overriding OnKeyPress in a derived class, be sure to call the base class's OnKeyPress method so that registered delegates receive the event.
OnKeyUp ( PInputEventArgs e ) : void	Raises the KeyUp event. Raising an event invokes the event handler through a delegate. The OnKeyUp method also allows derived classes to handle the event without attaching a delegate. This is the preferred technique for handling the event in a derived class. Notes to Inheritors: When overriding OnKeyUp in a derived class, be sure to call the base class's OnKeyUp method so that registered delegates receive the event.
OnLostFocus ( PInputEventArgs e ) : void	Raises the LostFocus event. Raising an event invokes the event handler through a delegate. The OnLostFocus method also allows derived classes to handle the event without attaching a delegate. This is the preferred technique for handling the event in a derived class. Notes to Inheritors: When overriding OnLostFocus in a derived class, be sure to call the base class's OnLostFocus method so that registered delegates receive the event.
OnMouseDown ( PInputEventArgs e ) : void	Raises the MouseDown event. Raising an event invokes the event handler through a delegate. The OnMouseDown method also allows derived classes to handle the event without attaching a delegate. This is the preferred technique for handling the event in a derived class. Notes to Inheritors: When overriding OnMouseDown in a derived class, be sure to call the base class's OnMouseDown method so that registered delegates receive the event.
OnMouseDrag ( PInputEventArgs e ) : void	Raises the MouseDrag event. Raising an event invokes the event handler through a delegate. The OnMouseDrag method also allows derived classes to handle the event without attaching a delegate. This is the preferred technique for handling the event in a derived class. Notes to Inheritors: When overriding OnMouseDrag in a derived class, be sure to call the base class's OnMouseDrag method so that registered delegates receive the event.
OnMouseEnter ( PInputEventArgs e ) : void	Raises the MouseEnter event. Raising an event invokes the event handler through a delegate. The OnMouseEnter method also allows derived classes to handle the event without attaching a delegate. This is the preferred technique for handling the event in a derived class. Notes to Inheritors: When overriding OnMouseEnter in a derived class, be sure to call the base class's OnMouseEnter method so that registered delegates receive the event.
OnMouseLeave ( PInputEventArgs e ) : void	Raises the MouseLeave event. Raising an event invokes the event handler through a delegate. The OnMouseLeave method also allows derived classes to handle the event without attaching a delegate. This is the preferred technique for handling the event in a derived class. Notes to Inheritors: When overriding OnMouseLeave in a derived class, be sure to call the base class's OnMouseLeave method so that registered delegates receive the event.
OnMouseMove ( PInputEventArgs e ) : void	Raises the MouseMove event. Raising an event invokes the event handler through a delegate. The OnMouseMove method also allows derived classes to handle the event without attaching a delegate. This is the preferred technique for handling the event in a derived class. Notes to Inheritors: When overriding OnMouseMove in a derived class, be sure to call the base class's OnMouseMove method so that registered delegates receive the event.
OnMouseUp ( PInputEventArgs e ) : void	Raises the MouseUp event. Raising an event invokes the event handler through a delegate. The OnMouseUp method also allows derived classes to handle the event without attaching a delegate. This is the preferred technique for handling the event in a derived class. Notes to Inheritors: When overriding OnMouseUp in a derived class, be sure to call the base class's OnMouseUp method so that registered delegates receive the event.
OnMouseWheel ( PInputEventArgs e ) : void	Raises the MouseWheel event. Raising an event invokes the event handler through a delegate. The OnMouseWheel method also allows derived classes to handle the event without attaching a delegate. This is the preferred technique for handling the event in a derived class. Notes to Inheritors: When overriding OnMouseWheel in a derived class, be sure to call the base class's OnMouseWheel method so that registered delegates receive the event.
PNode ( ) : System	Constructs a new PNode.
ParentBoundsChanged ( ) : void	A notification that the bounds of this node's parent have changed.
ParentToLocal ( PointF point ) : PointF	Transform the given point from this node's parent's local coordinate system to the local coordinate system of this node.
ParentToLocal ( RectangleF rectangle ) : RectangleF	Transform the given rectangle from this node's parent's local coordinate system to the local coordinate system of this node.
ParentToLocal ( SizeF size ) : SizeF	Transform the given size from this node's parent's local coordinate system to the local coordinate system of this node.
Position ( PointF srcPt, PointF destPt, RectangleF destBounds, int millis ) : void	Animate this node's matrix to one that will make this node appear at the specified position relative to the specified bounding box. The source point specifies a point in the unit square (0, 0) - (1, 1) that represents an anchor point on the corresponding node to this matrox. The destination point specifies an anchor point on the reference node. The position method then computes the matrix that results in transforming this node so that the source anchor point coincides with the reference anchor point. This can be useful for layout algorithms as it is straightforward to position one object relative to another. For example, If you have two nodes, A and B, and you call `PointF srcPt = new PointF(1.0f, 0.0f); PointF destPt = new PointF(0.0f, 0.0f); A.Position(srcPt, destPt, B.GlobalBounds, 750);` The result is that A will move so that its upper-right corner is at the same place as the upper-left corner of B, and the transition will be smoothly animated over a period of 750 milliseconds.
Print ( ) : void	Constructs a new PrintDocument, allows the user to select which printer to print to, and then prints the node.
RemoveAllChildren ( ) : void	Remove all the children from this node. Note this method is more efficient then removing each child individually.
RemoveChild ( PNode child ) : PNode	Remove the given child from this node's children list. Any subsequent children are shifted to the left (one is subtracted from their indices). The removed child’s parent is set to null.
RemoveChild ( int index ) : PNode	Remove the child at the specified position from this node's children. Any subsequent children are shifted to the left (one is subtracted from their indices). The removed child’s parent is set to null.
RemoveChildren ( UMD.HCIL.Piccolo.Util.PNodeList childrenNodes ) : void	Remove all the children in the given list from this node’s list of children. All removed nodes will have their parent set to null.
RemoveFromParent ( ) : void	Delete this node by removing it from its parent’s list of children.
RemoveInputEventListener ( PInputEventListener listener ) : void	Removes the specified input event listener so that it no longer receives input events from this node.
Repaint ( ) : void	Mark the area on the screen represented by this node's full bounds as needing a repaint.
RepaintFrom ( RectangleF bounds, PNode childOrThis ) : void	Pass the given repaint request up the tree, so that any cameras can invalidate that region on their associated canvas.
Reparent ( PNode newParent ) : void	Set the parent of this node, and transform the node in such a way that it doesn't move in global coordinates.
ReplaceWith ( PNode replacementNode ) : void	Swaps this node out of the scene graph tree, and replaces it with the specified replacement node. This node is left dangling, and it is up to the caller to manage it. The replacement node will be added to this node's parent in the same position as this node was located. That is, if this was the 3rd child of its parent, then after calling `ReplaceWith`, the replacement node will also be the 3rd child of its parent. If this node has no parent when `ReplaceWith` is called, then nothing will be done at all.
ResetBounds ( ) : void	Set the bounds of this node back to an empty rectangle.
RotateBy ( float theta ) : void	Rotates this node by theta (in degrees) about the 0,0 point. This will affect this node and all its descendents.
RotateBy ( float theta, PointF point ) : void	Rotates this node by theta (in degrees) about the given point. This will affect this node and all its descendents.
RotateBy ( float theta, float x, float y ) : void	Rotates this node by theta (in degrees) about the given point.
RotateInPlace ( float theta ) : void	Rotates this node by theta (in degrees), and then translates the node so that the x, y position of its fullBounds stays constant.
ScaleBy ( float scale ) : void	Scale this node's matrix by the given amount. This will affect this node and all of its descendents.
ScaleBy ( float scale, PointF point ) : void	Scale this node's matrix by the given amount about the specified point. This will affect this node and all of its descendents.
ScaleBy ( float scale, float x, float y ) : void	Scale this node's matrix by the given amount about the specified point.
SetBounds ( float x, float y, float width, float height ) : bool	Set the bounds of this node to the given values. These bounds are stored in the local coordinate system of this node.
SetOffset ( PointF p ) : void	Sets the offset applied to this node by it's matrix. The offset affects this node and all of its descendents and is specified in the parent coordinate system. This directly sets the values that are in the dx and dy positions of the matrix. Unlike `PNode.TranslateBy()`, this is not affected by the scale value of the matrix.
SetOffset ( float x, float y ) : void	Sets the offset applied to this node by it's matrix. The offset affects this node and all of its descendents and is specified in the parent coordinate system. This directly sets the values that are in the dx and dy positions of the matrix. Unlike `PNode.TranslateBy()`, this is not affected by the scale value of the matrix.
SignalBoundsChanged ( ) : void	This method should be called when the bounds of this node are changed. This method invalidates the full bounds of this node, and also notifies each of this node's children that their parent's bounds have changed. As a result of this method getting called this node's `LayoutChildren` will be called.
StartResizeBounds ( ) : void	Notify this node that you will begin to repeatedly call `SetBounds`. After a call to `StartResizeBounds`, `EndResizeBounds` should eventually be called to notify the node of the end of the sequence of `SetBounds` calls.
ToImage ( ) : Image	Return a new Image representing this node and all of its children. The image size will be equal to the size of this node's full bounds.
ToImage ( Image image, Brush backgroundBrush ) : Image	Paint a representation of this node into the specified image. If backgroundBrush is null, then the image will not be filled with a color prior to rendering.
ToImage ( int width, int height, Brush backgroundBrush ) : Image	Return a new Image of the requested size representing this node and all of its children. If backgroundBrush is null, then the image will not be filled with a color prior to rendering.
ToPickPath ( ) : UMD.HCIL.Piccolo.Util.PPickPath	Creates a pick path with a null camera and empty pickbounds and adds this node. This method is useful if you want to dispatch events directly to a single node. For an example, see PSelectionExample, where the KeyboardFocus is set using this approach.
ToPickPath ( UMD.HCIL.Piccolo.PCamera aCamera, RectangleF pickBounds ) : UMD.HCIL.Piccolo.Util.PPickPath	Creates a pick path with the given Camera and pickbounds and adds this node.
ToString ( ) : string	Returns a string representation of this object for debugging purposes.
TransformBy ( UMD.HCIL.Piccolo.Util.PMatrix matrix ) : void	Transform this node's matrix by the given matrix.
TranslateBy ( float dx, float dy ) : void	Translate this node's matrix by the given amount, using the standard matrix `Translate` method. This translation affects this node and all of its descendents.
ValidateFullPaint ( ) : void	Repaint this node and any of its descendents if they have invalid paint.
this ( int index ) : PNode	Allows a PNode to be indexed directly to access it's children. This provides a shortcut to indexing a node's children. For example, `aNode.GetChild(i)` is equivalent to `aNode[i]`. Note that using the indexor to set a child will remove the child currently at that index.

Protected Methods

Method	Description
AddChildren ( ICollection nodes ) : void	Add a collection of nodes to be children of this node. This method allows you to pass in any ICollection, rather than a PNodeList. This can be useful if you are using an ArrayList or some other collection type to store PNodes. Note, however, that this list still must contain only objects that extend PNode otherwise you will get a runtime error. To protect against problems of this type, use the AddChildren(PNodeList) method instead. If these nodes already have parents they will first be removed from those parents.
FireChildPropertyChangedEvent ( UMD.HCIL.Piccolo.Event.PPropertyEventArgs e, object propertyKey, int propertyCode ) : void	Called by child node to forward property change events up the node tree so that property change listeners registered with this node will be notified of property changes of its children nodes. For performance reason only propertyCodes listed in the propertyChangeParentMask are forwarded.
FirePropertyChangedEvent ( object propertyKey, int propertyCode, Object oldValue, Object newValue ) : void	Raise the given property change event.
GetPropertyHandlers ( object propertyKey ) : PPropertyEventHandler	Gets all property event handlers for this node, that are associated with the specified property key.
HandleEvent ( PInputEventArgs e, PInputEventHandler handler ) : void	Raise the given input event. If an event has been set as handled, and the delegate is not a member of a listener class, then the event is consumed. If the delegate is a member of a listener class the decision of consumption is left up to the filter associated with that class.
InternalUpdateBounds ( float x, float y, float width, float height ) : void	Gives nodes a chance to update their internal structure before bounds changed notifications are sent. When this message is received, the node's bounds field will contain the new value.
OnFullBoundsInvalidated ( ) : void	Raises the FullBoundsInvalidated event.
OnPaintInvalidated ( ) : void	Raises the PaintInvalidated event.
PNode ( SerializationInfo info, StreamingContext context ) : System	Read this node and all of its descendent nodes from the given SerializationInfo. This constructor is required for Deserialization.
Paint ( UMD.HCIL.Piccolo.Util.PPaintContext paintContext ) : void	Paint this node behind any of its children nodes. Notes to Inheritors: Subclasses that define a different appearance should override this method and paint themselves there.
PaintAfterChildren ( UMD.HCIL.Piccolo.Util.PPaintContext paintContext ) : void	Subclasses that wish to do additional painting after their children are painted should override this method and do that painting here.
Pick ( UMD.HCIL.Piccolo.Util.PPickPath pickPath ) : bool	Try to pick this node before its children have had a chance to be picked. Nodes that paint on top of their children may want to override this method to see if the pick path intersects that paint.
PickAfterChildren ( UMD.HCIL.Piccolo.Util.PPickPath pickPath ) : bool	Try to pick this node after its children have had a chance to be picked. Notes to Inheritors: Most subclasses that define a different geometry will need to override this method.
RemoveChildren ( ICollection childrenNodes ) : void	Remove all the children in the given collection from this node’s list of children. This method allows you to pass in any ICollection, rather than a PNodeList. This can be useful if you are using an ArrayList or some other collection type to store PNodes. Note, however, that this list still must contain only objects that extend PNode otherwise you will get a runtime error. To protect against problems of this type, use the RemoveChildren(PNodeList) method instead. All removed nodes will have their parent set to null.
ScaleAndDraw ( Graphics g, RectangleF displayRect ) : void	Scale the Graphics so that this node's full bounds fit in displayRect and then render into the given Graphics context.
ValidateFullBounds ( ) : bool	This method is called to validate the bounds of this node and all of its descendents. This method returns true if this node's bounds or the bounds of any of its descendents are marked as volatile.
printDocument_PrintPage ( object sender, System.Drawing.Printing.PrintPageEventArgs e ) : void	Prints the node into the given Graphics context.

Method Details

AddActivity() public method

Schedule the given activity with the root.

Note that only scheduled activities will be stepped. If the activity is successfully added true is returned, else false.

public AddActivity ( UMD.HCIL.Piccolo.Activities.PActivity activity ) : bool
activity	UMD.HCIL.Piccolo.Activities.PActivity	The new activity to schedule.
return	bool

AddChild() public method

Add a node to be a new child of this node.

The new node is added to the end of the list of this node's children. If child was previously a child of another node, it is removed from that node first.

public AddChild ( PNode child ) : void
child	PNode	The new child to add to this node.
return	void

AddChild() public method

Add a node to be a new child of this node at the specified index.

If child was previously a child of another node, it is removed from that node first.

public AddChild ( int index, PNode child ) : void
index	int	The index at which to add the new child.
child	PNode	The new child to add to this node.
return	void

AddChildren() protected method

Add a collection of nodes to be children of this node.

This method allows you to pass in any ICollection, rather than a PNodeList. This can be useful if you are using an ArrayList or some other collection type to store PNodes. Note, however, that this list still must contain only objects that extend PNode otherwise you will get a runtime error. To protect against problems of this type, use the AddChildren(PNodeList) method instead.

If these nodes already have parents they will first be removed from those parents.

protected AddChildren ( ICollection nodes ) : void
nodes	ICollection	/// A collection of nodes to be added to this node. ///
return	void

AddChildren() public method

Add a list of nodes to be children of this node.

If these nodes already have parents they will first be removed from those parents.

public AddChildren ( UMD.HCIL.Piccolo.Util.PNodeList nodes ) : void
nodes	UMD.HCIL.Piccolo.Util.PNodeList	A list of nodes to be added to this node.
return	void

AddInputEventListener() public method

Adds the specified input event listener to receive input events from this node.

public AddInputEventListener ( PInputEventListener listener ) : void
listener	PInputEventListener	The new input listener
return	void

AnimateMatrixToBounds() public method

Animate this node from it's current matrix when the activity starts a new matrix that will fit the node into the given bounds.

If this node descends from the root then the activity will be scheduled, else the returned activity should be scheduled manually. If two different transform activities are scheduled for the same node at the same time, they will both be applied to the node, but the last one scheduled will be applied last on each frame, so it will appear to have replaced the original. Generally you will not want to do that. Note this method animates the node's matrix, but does not directly change the node's bounds rectangle. Use AnimateToBounds to animate the node's bounds rectangle instead.

public AnimateMatrixToBounds ( float x, float y, float width, float height, long duration ) : UMD.HCIL.Piccolo.Activities.PTransformActivity
x	float	The x coordinate of the target bounds.
y	float	The y coordinate of the target bounds.
width	float	The width of the target bounds.
height	float	The height of the target bounds.
duration	long	The amount of time that the animation should take.
return	UMD.HCIL.Piccolo.Activities.PTransformActivity

AnimateToBounds() public method

Animate this node's bounds from their current location when the activity starts to the specified bounds.

If this node descends from the root then the activity will be scheduled, else the returned activity should be scheduled manually. If two different transform activities are scheduled for the same node at the same time, they will both be applied to the node, but the last one scheduled will be applied last on each frame, so it will appear to have replaced the original. Generally you will not want to do that. Note this method animates the node's bounds, but does not change the node's matrix. Use AnimateMatrixToBounds to animate the node's matrix instead.

public AnimateToBounds ( float x, float y, float width, float height, long duration ) : UMD.HCIL.Piccolo.Activities.PInterpolatingActivity
x	float	The x coordinate of the target bounds.
y	float	The y coordinate of the target bounds.
width	float	The width of the target bounds.
height	float	The height of the target bounds.
duration	long	The amount of time that the animation should take.
return	UMD.HCIL.Piccolo.Activities.PInterpolatingActivity

AnimateToColor() public method

Animate this node's color from its current value to the new value specified.

This method assumes that this nodes Brush property is of type SolidBrush. If this node descends from the root then the activity will be scheduled, else the returned activity should be scheduled manually. If two different color activities are scheduled for the same node at the same time, they will both be applied to the node, but the last one scheduled will be applied last on each frame, so it will appear to have replaced the original. Generally you will not want to do that.

public AnimateToColor ( Color destColor, long duration ) : PColorActivity
destColor	Color	The final color value.
duration	long	The amount of time that the animation should take.
return	UMD.HCIL.Piccolo.Activities.PColorActivity

AnimateToMatrix() public method

Animate this node's matrix from its current values when the activity starts to the new values specified in the given matrix.

public AnimateToMatrix ( UMD.HCIL.Piccolo.Util.PMatrix destMatrix, long duration ) : UMD.HCIL.Piccolo.Activities.PTransformActivity
destMatrix	UMD.HCIL.Piccolo.Util.PMatrix	The final matrix value.
duration	long	The amount of time that the animation should take.
return	UMD.HCIL.Piccolo.Activities.PTransformActivity

AnimateToPositionScaleRotation() public method

Animate this node's matrix from its current location when the activity starts to the specified location, scale, and rotation.

public AnimateToPositionScaleRotation ( float x, float y, float scale, float theta, long duration ) : UMD.HCIL.Piccolo.Activities.PTransformActivity
x	float	The x coordinate of the target location.
y	float	The y coordinate of the target location
scale	float	The scale of the target matrix
theta	float	The rotation of the target matrix
duration	long	The amount of time that the animation should take.
return	UMD.HCIL.Piccolo.Activities.PTransformActivity

CenterBoundsOnPoint() public method

Adjust the bounds of this node so that they are centered on the given point specified in the local coordinate system of this node.

Note that this method will modify the node's bounds, while CenterFullBoundsOnPoint will modify the node's matrix.

public CenterBoundsOnPoint ( float x, float y ) : bool
x	float	/// The x coordinate of the point on which to center the bounds, in local coordinates. ///
y	float	/// The y coordinate of the point on which to center the bounds, in local coordinates. ///
return	bool

CenterFullBoundsOnPoint() public method

Adjust the full bounds of this node so that they are centered on the given point specified in the local coordinates of this node's parent.

Note that this meathod will modify the node's matrix, while CenterBoundsOnPoint will modify the node's bounds.

public CenterFullBoundsOnPoint ( float x, float y ) : void
x	float	/// The x coordinate of the point on which to center the bounds, in parent coordinates. ///
y	float	/// The y coordinate of the point on which to center the bounds, in parent coordinates. ///
return	void

Clone() public method

The copy method copies this node and all of its descendents.

Note that copying is implemented in terms of c# serialization. See the serialization notes for more information.

public Clone ( ) : Object
return	Object

ComputeFullBounds() public method

Compute and return the full bounds of this node.

public ComputeFullBounds ( ) : RectangleF
return	System.Drawing.RectangleF

EndResizeBounds() public method

Notify this node that you have finished a resize bounds sequence.

A call to StartResizeBounds should precede a call to EndResizeBounds.

public EndResizeBounds ( ) : void
return	void

FindIntersectingNodes() public method

Checks this node and it's descendents for intersection with the given bounds and adds any intersecting nodes to the given list.

public FindIntersectingNodes ( RectangleF fullBounds, UMD.HCIL.Piccolo.Util.PNodeList results ) : void
fullBounds	System.Drawing.RectangleF	/// The bounds to check for intersection, in parent coordinates. ///
results	UMD.HCIL.Piccolo.Util.PNodeList	/// The resulting list of nodes. ///
return	void

FireChildPropertyChangedEvent() protected method

Called by child node to forward property change events up the node tree so that property change listeners registered with this node will be notified of property changes of its children nodes.

For performance reason only propertyCodes listed in the propertyChangeParentMask are forwarded.

protected FireChildPropertyChangedEvent ( UMD.HCIL.Piccolo.Event.PPropertyEventArgs e, object propertyKey, int propertyCode ) : void
e	UMD.HCIL.Piccolo.Event.PPropertyEventArgs	The property change event to forward.
propertyKey	object	The key associated with the property that changed.
propertyCode	int	The code that identifies the property that changed.
return	void

FirePropertyChangedEvent() protected method

Raise the given property change event.

protected FirePropertyChangedEvent ( object propertyKey, int propertyCode, Object oldValue, Object newValue ) : void
propertyKey	object	The key associated with the property that changed.
propertyCode	int	The code that identifies the property that changed.
oldValue	Object	The old value of the property.
newValue	Object	The new value of the property.
return	void

FullIntersects() public method

Return true if the full bounds of this node intersect with the specified bounds.

public FullIntersects ( RectangleF bounds ) : bool
bounds	System.Drawing.RectangleF	/// The bounds to test for intersection (specified in the parent's coordinate system). ///
return	bool

FullPaint() public method

Paint this node and all of its descendents.

Notes to Inheritors: Most subclasses do not need to override this method, they should override paint or paintAfterChildren instead.

public FullPaint ( UMD.HCIL.Piccolo.Util.PPaintContext paintContext ) : void
paintContext	UMD.HCIL.Piccolo.Util.PPaintContext	The paint context to use for painting this node.
return	void

FullPick() public method

Try to pick this node and all of its descendents.

Notes to Inheritors: Most subclasses should not need to override this method. Instead they should override Pick or PickAfterChildren.

public FullPick ( UMD.HCIL.Piccolo.Util.PPickPath pickPath ) : bool
pickPath	UMD.HCIL.Piccolo.Util.PPickPath	The pick path to add the node to if its picked.
return	bool

GetAllNodes() public method

Gets a list containing the subset of this node and all of its descendent nodes that are accepted by the given node filter.

If the filter is null then all nodes will be accepted. If the results parameter is not null then it will be used to store this subset instead of creating a new list.

public GetAllNodes ( PNodeFilter filter, UMD.HCIL.Piccolo.Util.PNodeList results ) : UMD.HCIL.Piccolo.Util.PNodeList
filter	PNodeFilter	The filter used to determine the subset.
results	UMD.HCIL.Piccolo.Util.PNodeList	The list used to collect the subset; can be null.
return	UMD.HCIL.Piccolo.Util.PNodeList

GetChild() public method

Return the child node at the specified index.

public GetChild ( int index ) : PNode
index	int	The index of the desired child.
return	PNode

GetEnumerator() public method

Return an enumerator for this node’s direct descendent children.

This method allows you to use the foreach loop to iterate over a node's children. For example, you could do the following: foreach(PNode node in aNode) { node.DoSomething(); } Typically, you will not need to call this method directly. Instead use the ChildrenEnumerator property.

public GetEnumerator ( ) : IEnumerator
return	IEnumerator

GetObjectData() public method

Write this node and all of its descendent nodes to the given SerializationInfo.

This node's parent is written out conditionally, that is it will only be written out if someone else writes it out unconditionally.

public GetObjectData ( SerializationInfo info, StreamingContext context ) : void
info	System.Runtime.Serialization.SerializationInfo	The SerializationInfo to write to.
context	System.Runtime.Serialization.StreamingContext	The streaming context of this serialization operation.
return	void

GetPropertyHandlers() protected method

Gets all property event handlers for this node, that are associated with the specified property key.

protected GetPropertyHandlers ( object propertyKey ) : PPropertyEventHandler
propertyKey	object	The key for which to find associated handlers.
return	PPropertyEventHandler

GlobalToLocal() public method

Transform the given point from global coordinates to this node's local coordinate system.

public GlobalToLocal ( PointF point ) : PointF
point	System.Drawing.PointF	The point in global coordinates to be transformed.
return	System.Drawing.PointF

GlobalToLocal() public method

Transform the given rectangle from global coordinates to this node's local coordinate system.

public GlobalToLocal ( RectangleF rectangle ) : RectangleF
rectangle	System.Drawing.RectangleF	The rectangle in global coordinates to be transformed.
return	System.Drawing.RectangleF

GlobalToLocal() public method

Transform the given size from global coordinates to this node's local coordinate system.

public GlobalToLocal ( SizeF size ) : SizeF
size	System.Drawing.SizeF	The size in global coordinates to be transformed.
return	System.Drawing.SizeF

HandleEvent() protected method

Raise the given input event.

If an event has been set as handled, and the delegate is not a member of a listener class, then the event is consumed. If the delegate is a member of a listener class the decision of consumption is left up to the filter associated with that class.

protected HandleEvent ( PInputEventArgs e, PInputEventHandler handler ) : void
e	UMD.HCIL.Piccolo.Event.PInputEventArgs	The arguments for this input event.
handler	PInputEventHandler	The delegate to dispatch this event to.
return	void

IndexOfChild() public method

Return the index where the given child is stored.

public IndexOfChild ( PNode child ) : int
child	PNode	The child whose index is desired.
return	int

InternalUpdateBounds() protected method

Gives nodes a chance to update their internal structure before bounds changed notifications are sent. When this message is received, the node's bounds field will contain the new value.

protected InternalUpdateBounds ( float x, float y, float width, float height ) : void
x	float	The new x coordinate of the bounds.
y	float	The new y coordinate of the bounds.
width	float	The new width of the bounds.
height	float	The new height of the bounds.
return	void

Intersects() public method

Return true if this node intersects the given rectangle specified in local bounds.

If the geometry of this node is complex, this method can become expensive. It is therefore recommended that FullIntersects is used for quick rejects before calling this method.

public Intersects ( RectangleF bounds ) : bool
bounds	System.Drawing.RectangleF	The bounds to test for intersection.
return	bool

InvalidateFullBounds() public method

Invalidates the full bounds of this node, and sets the child bounds invalid flag on each of this node's ancestors.

public InvalidateFullBounds ( ) : void
return	void

InvalidateLayout() public method

Invalidate this node's layout, so that later LayoutChildren will get called.

public InvalidateLayout ( ) : void
return	void

InvalidatePaint() public method

Invalidate this node's paint, and mark all of its ancestors as having a node with invalid paint.

public InvalidatePaint ( ) : void
return	void

IsAncestorOf() public method

Return true if this node is an ancestor of the parameter node.

public IsAncestorOf ( PNode node ) : bool
node	PNode	A possible descendent node.
return	bool

IsDescendentOf() public method

Return true if this node is a descendent of the parameter node.

public IsDescendentOf ( PNode node ) : bool
node	PNode	A possible descendent node.
return	bool

IsDescendentOfRoot() public method

Return true if this node is a descendent of the Root.

public IsDescendentOfRoot ( ) : bool
return	bool

IsOpaque() public method

public IsOpaque ( RectangleF boundary ) : bool
boundary	System.Drawing.RectangleF
return	bool

LayoutChildren() public method

Nodes that apply layout constraints to their children should override this method and do the layout there.

This method gets called whenever Piccolo determines that this node's children may need to be re-layed out. This occurs when the bounds of this node or a descendent node change. This method may also be invoked indirectly when LayoutChildren is called on an ancestor node, since typically you will modify the bounds of the children there.

public LayoutChildren ( ) : void
return	void

Lerp() static public method

Linearly interpolates between a and b, based on t. Specifically, it computes Lerp(a, b, t) = a + t*(b - a). This produces a result that changes from a (when t = 0) to b (when t = 1).

static public Lerp ( float t, float a, float b ) : float
t	float	The variable 'time' parameter.
a	float	The starting value.
b	float	The ending value.
return	float

LocalToGlobal() public method

Transform the given point from this node's local coordinate system to the global coordinate system.

public LocalToGlobal ( PointF point ) : PointF
point	System.Drawing.PointF	The point in local coordinate system to be transformed.
return	System.Drawing.PointF

LocalToGlobal() public method

Transform the given rectangle from this node's local coordinate system to the global coordinate system.

public LocalToGlobal ( RectangleF rectangle ) : RectangleF
rectangle	System.Drawing.RectangleF	The rectangle in local coordinate system to be transformed.
return	System.Drawing.RectangleF

LocalToGlobal() public method

Transform the given size from this node's local coordinate system to the global coordinate system.

public LocalToGlobal ( SizeF size ) : SizeF
size	System.Drawing.SizeF	The size in local coordinate system to be transformed.
return	System.Drawing.SizeF

LocalToParent() public method

Transform the given point from this node's local coordinate system to its parent's local coordinate system.

public LocalToParent ( PointF point ) : PointF
point	System.Drawing.PointF	The point in local coordinate system to be transformed.
return	System.Drawing.PointF

LocalToParent() public method

Transform the given rectangle from this node's local coordinate system to its parent's local coordinate system.

public LocalToParent ( RectangleF rectangle ) : RectangleF
rectangle	System.Drawing.RectangleF	The rectangle in local coordinate system to be transformed.
return	System.Drawing.RectangleF

LocalToParent() public method

Transform the given size from this node's local coordinate system to its parent's local coordinate system.

public LocalToParent ( SizeF size ) : SizeF
size	System.Drawing.SizeF	The size in local coordinate system to be transformed.
return	System.Drawing.SizeF

MoveInBackOf() public method

Change the order of this node in its parent's children list so that it will draw before the given sibling node.

public MoveInBackOf ( PNode sibling ) : void
sibling	PNode	The sibling to move behind.
return	void

MoveInFrontOf() public method

Change the order of this node in its parent's children list so that it will draw after the given sibling node.

public MoveInFrontOf ( PNode sibling ) : void
sibling	PNode	The sibling to move in front of.
return	void

MoveToBack() public method

Change the order of this node in its parent's children list so that it will draw in back of all of its other sibling nodes.

public MoveToBack ( ) : void
return	void

MoveToFront() public method

Change the order of this node in its parent's children list so that it will draw in front of all of its other sibling nodes.

public MoveToFront ( ) : void
return	void

OffsetBy() public method

Offset this node relative to the parent's coordinate system. This is NOT affected by this node's current scale or rotation.

This is implemented by directly adding dx to the dx position and dy to the dy position of the matrix.

public OffsetBy ( float dx, float dy ) : void
dx	float	The amount to add to the x-offset for this node.
dy	float	The amount to add to the y-offset for this node.
return	void

OnClick() public method

Raises the Click event.

Raising an event invokes the event handler through a delegate.

The OnClick method also allows derived classes to handle the event without attaching a delegate. This is the preferred technique for handling the event in a derived class.

Notes to Inheritors: When overriding OnClick in a derived class, be sure to call the base class's OnClick method so that registered delegates receive the event.

public OnClick ( PInputEventArgs e ) : void
e	UMD.HCIL.Piccolo.Event.PInputEventArgs	A PInputEventArgs that contains the event data
return	void

OnDoubleClick() public method

Raises the DoubleClick event.

Raising an event invokes the event handler through a delegate.

The OnDoubleClick method also allows derived classes to handle the event without attaching a delegate. This is the preferred technique for handling the event in a derived class.

Notes to Inheritors: When overriding OnDoubleClick in a derived class, be sure to call the base class's OnDOubleClick method so that registered delegates receive the event.

public OnDoubleClick ( PInputEventArgs e ) : void
e	UMD.HCIL.Piccolo.Event.PInputEventArgs	A PInputEventArgs that contains the event data
return	void

OnDragDrop() public method

Raises the DragDrop event.

Raising an event invokes the event handler through a delegate.

The OnDragDrop method also allows derived classes to handle the event without attaching a delegate. This is the preferred technique for handling the event in a derived class.

Notes to Inheritors: When overriding OnDragDrop in a derived class, be sure to call the base class's OnDragDrop method so that registered delegates receive the event.

public OnDragDrop ( PInputEventArgs e ) : void
e	UMD.HCIL.Piccolo.Event.PInputEventArgs	A PInputEventArgs that contains the event data
return	void

OnDragEnter() public method

Raises the DragEnter event.

Raising an event invokes the event handler through a delegate.

The OnDragEnter method also allows derived classes to handle the event without attaching a delegate. This is the preferred technique for handling the event in a derived class.

Notes to Inheritors: When overriding OnDragEnter in a derived class, be sure to call the base class's OnDragEnter method so that registered delegates receive the event.

public OnDragEnter ( PInputEventArgs e ) : void
e	UMD.HCIL.Piccolo.Event.PInputEventArgs	A PInputEventArgs that contains the event data
return	void

OnDragLeave() public method

Raises the DragLeave event.

Raising an event invokes the event handler through a delegate.

The OnDragLeave method also allows derived classes to handle the event without attaching a delegate. This is the preferred technique for handling the event in a derived class.

Notes to Inheritors: When overriding OnDragLeave in a derived class, be sure to call the base class's OnDragLeave method so that registered delegates receive the event.

public OnDragLeave ( PInputEventArgs e ) : void
e	UMD.HCIL.Piccolo.Event.PInputEventArgs	A PInputEventArgs that contains the event data
return	void

OnDragOver() public method

Raises the DragOver event.

Raising an event invokes the event handler through a delegate.

The OnDragOver method also allows derived classes to handle the event without attaching a delegate. This is the preferred technique for handling the event in a derived class.

Notes to Inheritors: When overriding OnDragOver in a derived class, be sure to call the base class's OnDragOver method so that registered delegates receive the event.

public OnDragOver ( PInputEventArgs e ) : void
e	UMD.HCIL.Piccolo.Event.PInputEventArgs	A PInputEventArgs that contains the event data
return	void

OnFullBoundsInvalidated() protected method

Raises the FullBoundsInvalidated event.

protected OnFullBoundsInvalidated ( ) : void
return	void

OnGotFocus() public method

Raises the GotFocus event.

Raising an event invokes the event handler through a delegate.

The OnGotFocus method also allows derived classes to handle the event without attaching a delegate. This is the preferred technique for handling the event in a derived class.

Notes to Inheritors: When overriding OnGotFocus in a derived class, be sure to call the base class's OnGotFocus method so that registered delegates receive the event.

public OnGotFocus ( PInputEventArgs e ) : void
e	UMD.HCIL.Piccolo.Event.PInputEventArgs	A PInputEventArgs that contains the event data
return	void

OnKeyDown() public method

Raises the KeyDown event.

Raising an event invokes the event handler through a delegate.

The OnKeyDown method also allows derived classes to handle the event without attaching a delegate. This is the preferred technique for handling the event in a derived class.

Notes to Inheritors: When overriding OnKeyDown in a derived class, be sure to call the base class's OnKeyDown method so that registered delegates receive the event.

public OnKeyDown ( PInputEventArgs e ) : void
e	UMD.HCIL.Piccolo.Event.PInputEventArgs	A PInputEventArgs that contains the event data
return	void

OnKeyPress() public method

Raises the KeyPress event.

Raising an event invokes the event handler through a delegate.

The OnKeyPress method also allows derived classes to handle the event without attaching a delegate. This is the preferred technique for handling the event in a derived class.

Notes to Inheritors: When overriding OnKeyPress in a derived class, be sure to call the base class's OnKeyPress method so that registered delegates receive the event.

public OnKeyPress ( PInputEventArgs e ) : void
e	UMD.HCIL.Piccolo.Event.PInputEventArgs	A PInputEventArgs that contains the event data
return	void

OnKeyUp() public method

Raises the KeyUp event.

Raising an event invokes the event handler through a delegate.

The OnKeyUp method also allows derived classes to handle the event without attaching a delegate. This is the preferred technique for handling the event in a derived class.

Notes to Inheritors: When overriding OnKeyUp in a derived class, be sure to call the base class's OnKeyUp method so that registered delegates receive the event.

public OnKeyUp ( PInputEventArgs e ) : void
e	UMD.HCIL.Piccolo.Event.PInputEventArgs	A PInputEventArgs that contains the event data
return	void

OnLostFocus() public method

Raises the LostFocus event.

Raising an event invokes the event handler through a delegate.

The OnLostFocus method also allows derived classes to handle the event without attaching a delegate. This is the preferred technique for handling the event in a derived class.

Notes to Inheritors: When overriding OnLostFocus in a derived class, be sure to call the base class's OnLostFocus method so that registered delegates receive the event.

public OnLostFocus ( PInputEventArgs e ) : void
e	UMD.HCIL.Piccolo.Event.PInputEventArgs	A PInputEventArgs that contains the event data
return	void

OnMouseDown() public method

Raises the MouseDown event.

Raising an event invokes the event handler through a delegate.

The OnMouseDown method also allows derived classes to handle the event without attaching a delegate. This is the preferred technique for handling the event in a derived class.

Notes to Inheritors: When overriding OnMouseDown in a derived class, be sure to call the base class's OnMouseDown method so that registered delegates receive the event.

public OnMouseDown ( PInputEventArgs e ) : void
e	UMD.HCIL.Piccolo.Event.PInputEventArgs	A PInputEventArgs that contains the event data
return	void

OnMouseDrag() public method

Raises the MouseDrag event.

Raising an event invokes the event handler through a delegate.

The OnMouseDrag method also allows derived classes to handle the event without attaching a delegate. This is the preferred technique for handling the event in a derived class.

Notes to Inheritors: When overriding OnMouseDrag in a derived class, be sure to call the base class's OnMouseDrag method so that registered delegates receive the event.

public OnMouseDrag ( PInputEventArgs e ) : void
e	UMD.HCIL.Piccolo.Event.PInputEventArgs	A PInputEventArgs that contains the event data
return	void

OnMouseEnter() public method

Raises the MouseEnter event.

Raising an event invokes the event handler through a delegate.

The OnMouseEnter method also allows derived classes to handle the event without attaching a delegate. This is the preferred technique for handling the event in a derived class.

Notes to Inheritors: When overriding OnMouseEnter in a derived class, be sure to call the base class's OnMouseEnter method so that registered delegates receive the event.

public OnMouseEnter ( PInputEventArgs e ) : void
e	UMD.HCIL.Piccolo.Event.PInputEventArgs	A PInputEventArgs that contains the event data
return	void

OnMouseLeave() public method

Raises the MouseLeave event.

Raising an event invokes the event handler through a delegate.

The OnMouseLeave method also allows derived classes to handle the event without attaching a delegate. This is the preferred technique for handling the event in a derived class.

Notes to Inheritors: When overriding OnMouseLeave in a derived class, be sure to call the base class's OnMouseLeave method so that registered delegates receive the event.

public OnMouseLeave ( PInputEventArgs e ) : void
e	UMD.HCIL.Piccolo.Event.PInputEventArgs	A PInputEventArgs that contains the event data
return	void

OnMouseMove() public method

Raises the MouseMove event.

Raising an event invokes the event handler through a delegate.

The OnMouseMove method also allows derived classes to handle the event without attaching a delegate. This is the preferred technique for handling the event in a derived class.

Notes to Inheritors: When overriding OnMouseMove in a derived class, be sure to call the base class's OnMouseMove method so that registered delegates receive the event.

public OnMouseMove ( PInputEventArgs e ) : void
e	UMD.HCIL.Piccolo.Event.PInputEventArgs	A PInputEventArgs that contains the event data
return	void

OnMouseUp() public method

Raises the MouseUp event.

Raising an event invokes the event handler through a delegate.

The OnMouseUp method also allows derived classes to handle the event without attaching a delegate. This is the preferred technique for handling the event in a derived class.

Notes to Inheritors: When overriding OnMouseUp in a derived class, be sure to call the base class's OnMouseUp method so that registered delegates receive the event.

public OnMouseUp ( PInputEventArgs e ) : void
e	UMD.HCIL.Piccolo.Event.PInputEventArgs	A PInputEventArgs that contains the event data
return	void

OnMouseWheel() public method

Raises the MouseWheel event.

Raising an event invokes the event handler through a delegate.

The OnMouseWheel method also allows derived classes to handle the event without attaching a delegate. This is the preferred technique for handling the event in a derived class.

Notes to Inheritors: When overriding OnMouseWheel in a derived class, be sure to call the base class's OnMouseWheel method so that registered delegates receive the event.

public OnMouseWheel ( PInputEventArgs e ) : void
e	UMD.HCIL.Piccolo.Event.PInputEventArgs	A PInputEventArgs that contains the event data
return	void

OnPaintInvalidated() protected method

Raises the PaintInvalidated event.

protected OnPaintInvalidated ( ) : void
return	void

PNode() public method

Constructs a new PNode.

public PNode ( ) : System
return	System

PNode() protected method

Read this node and all of its descendent nodes from the given SerializationInfo.

This constructor is required for Deserialization.

protected PNode ( SerializationInfo info, StreamingContext context ) : System
info	System.Runtime.Serialization.SerializationInfo	The SerializationInfo to read from.
context	System.Runtime.Serialization.StreamingContext	The StreamingContext of this serialization operation.
return	System

Paint() protected method

Paint this node behind any of its children nodes.

Notes to Inheritors: Subclasses that define a different appearance should override this method and paint themselves there.

protected Paint ( UMD.HCIL.Piccolo.Util.PPaintContext paintContext ) : void
paintContext	UMD.HCIL.Piccolo.Util.PPaintContext	The paint context to use for painting this node.
return	void

PaintAfterChildren() protected method

Subclasses that wish to do additional painting after their children are painted should override this method and do that painting here.

protected PaintAfterChildren ( UMD.HCIL.Piccolo.Util.PPaintContext paintContext ) : void
paintContext	UMD.HCIL.Piccolo.Util.PPaintContext	/// The paint context to use for painting after the children are painted. ///
return	void

ParentBoundsChanged() public method

A notification that the bounds of this node's parent have changed.

public ParentBoundsChanged ( ) : void
return	void

ParentToLocal() public method

Transform the given point from this node's parent's local coordinate system to the local coordinate system of this node.

public ParentToLocal ( PointF point ) : PointF
point	System.Drawing.PointF	The point in parent's coordinate system to be transformed.
return	System.Drawing.PointF

ParentToLocal() public method

Transform the given rectangle from this node's parent's local coordinate system to the local coordinate system of this node.

public ParentToLocal ( RectangleF rectangle ) : RectangleF
rectangle	System.Drawing.RectangleF	The rectangle in parent's coordinate system to be transformed.
return	System.Drawing.RectangleF

ParentToLocal() public method

Transform the given size from this node's parent's local coordinate system to the local coordinate system of this node.

public ParentToLocal ( SizeF size ) : SizeF
size	System.Drawing.SizeF	The size in parent's coordinate system to be transformed.
return	System.Drawing.SizeF

Pick() protected method

Try to pick this node before its children have had a chance to be picked.

Nodes that paint on top of their children may want to override this method to see if the pick path intersects that paint.

protected Pick ( UMD.HCIL.Piccolo.Util.PPickPath pickPath ) : bool
pickPath	UMD.HCIL.Piccolo.Util.PPickPath	The pick path used for the pick operation.
return	bool

PickAfterChildren() protected method

Try to pick this node after its children have had a chance to be picked.

Notes to Inheritors: Most subclasses that define a different geometry will need to override this method.

protected PickAfterChildren ( UMD.HCIL.Piccolo.Util.PPickPath pickPath ) : bool
pickPath	UMD.HCIL.Piccolo.Util.PPickPath	The pick path used for the pick operation.
return	bool

Position() public method

Animate this node's matrix to one that will make this node appear at the specified position relative to the specified bounding box.

The source point specifies a point in the unit square (0, 0) - (1, 1) that represents an anchor point on the corresponding node to this matrox. The destination point specifies an anchor point on the reference node. The position method then computes the matrix that results in transforming this node so that the source anchor point coincides with the reference anchor point. This can be useful for layout algorithms as it is straightforward to position one object relative to another.

For example, If you have two nodes, A and B, and you call PointF srcPt = new PointF(1.0f, 0.0f); PointF destPt = new PointF(0.0f, 0.0f); A.Position(srcPt, destPt, B.GlobalBounds, 750); The result is that A will move so that its upper-right corner is at the same place as the upper-left corner of B, and the transition will be smoothly animated over a period of 750 milliseconds.

public Position ( PointF srcPt, PointF destPt, RectangleF destBounds, int millis ) : void
srcPt	System.Drawing.PointF
destPt	System.Drawing.PointF
destBounds	System.Drawing.RectangleF
millis	int
return	void

Print() public method

Constructs a new PrintDocument, allows the user to select which printer to print to, and then prints the node.

public Print ( ) : void
return	void

RemoveAllChildren() public method

Remove all the children from this node.

Note this method is more efficient then removing each child individually.

public RemoveAllChildren ( ) : void
return	void

RemoveChild() public method

Remove the given child from this node's children list.

Any subsequent children are shifted to the left (one is subtracted from their indices). The removed child’s parent is set to null.

public RemoveChild ( PNode child ) : PNode
child	PNode	The child to remove.
return	PNode

RemoveChild() public method

Remove the child at the specified position from this node's children.

Any subsequent children are shifted to the left (one is subtracted from their indices). The removed child’s parent is set to null.

public RemoveChild ( int index ) : PNode
index	int	The index of the child to remove.
return	PNode

RemoveChildren() protected method

Remove all the children in the given collection from this node’s list of children.

All removed nodes will have their parent set to null.

protected RemoveChildren ( ICollection childrenNodes ) : void
childrenNodes	ICollection	/// The collection of children to remove. ///
return	void

RemoveChildren() public method

Remove all the children in the given list from this node’s list of children.

All removed nodes will have their parent set to null.

public RemoveChildren ( UMD.HCIL.Piccolo.Util.PNodeList childrenNodes ) : void
childrenNodes	UMD.HCIL.Piccolo.Util.PNodeList	The list of children to remove.
return	void

RemoveFromParent() public method

Delete this node by removing it from its parent’s list of children.

public RemoveFromParent ( ) : void
return	void

RemoveInputEventListener() public method

Removes the specified input event listener so that it no longer receives input events from this node.

public RemoveInputEventListener ( PInputEventListener listener ) : void
listener	PInputEventListener	The input listener to remove.
return	void

Repaint() public method

Mark the area on the screen represented by this node's full bounds as needing a repaint.

public Repaint ( ) : void
return	void

RepaintFrom() public method

Pass the given repaint request up the tree, so that any cameras can invalidate that region on their associated canvas.

public RepaintFrom ( RectangleF bounds, PNode childOrThis ) : void
bounds	System.Drawing.RectangleF	/// The bounds to repaint, specified in the local coordinate system. ///
childOrThis	PNode	/// If childOrThis does not equal this then this node's matrix will /// be applied to the bounds paramater. ///
return	void

Reparent() public method

Set the parent of this node, and transform the node in such a way that it doesn't move in global coordinates.

public Reparent ( PNode newParent ) : void
newParent	PNode	The new parent of this node.
return	void

ReplaceWith() public method

Swaps this node out of the scene graph tree, and replaces it with the specified replacement node.

This node is left dangling, and it is up to the caller to manage it. The replacement node will be added to this node's parent in the same position as this node was located. That is, if this was the 3rd child of its parent, then after calling ReplaceWith, the replacement node will also be the 3rd child of its parent. If this node has no parent when ReplaceWith is called, then nothing will be done at all.

public ReplaceWith ( PNode replacementNode ) : void
replacementNode	PNode	/// The new node that replaces the current node in the scene graph tree. ///
return	void

ResetBounds() public method

Set the bounds of this node back to an empty rectangle.

public ResetBounds ( ) : void
return	void

RotateBy() public method

Rotates this node by theta (in degrees) about the 0,0 point.

This will affect this node and all its descendents.

public RotateBy ( float theta ) : void
theta	float	The rotation in degrees.
return	void

RotateBy() public method

Rotates this node by theta (in degrees) about the given point.

This will affect this node and all its descendents.

public RotateBy ( float theta, PointF point ) : void
theta	float	The amount to rotate by in degrees.
point	System.Drawing.PointF	The point to rotate about.
return	void

RotateBy() public method

Rotates this node by theta (in degrees) about the given point.

public RotateBy ( float theta, float x, float y ) : void
theta	float	The amount to rotate by in degrees
x	float	The x-coordinate of the point to rotate about.
y	float	The y-coordinate of the point to rotate about.
return	void

RotateInPlace() public method

Rotates this node by theta (in degrees), and then translates the node so that the x, y position of its fullBounds stays constant.

public RotateInPlace ( float theta ) : void
theta	float	The amount to rotate by in degrees.
return	void

ScaleAndDraw() protected method

Scale the Graphics so that this node's full bounds fit in displayRect and then render into the given Graphics context.

protected ScaleAndDraw ( Graphics g, RectangleF displayRect ) : void
g	System.Drawing.Graphics	The Graphics context to use when rendering the node.
displayRect	System.Drawing.RectangleF	The imageable area.
return	void

ScaleBy() public method

Scale this node's matrix by the given amount.

This will affect this node and all of its descendents.

public ScaleBy ( float scale ) : void
scale	float	The amount to scale by.
return	void

ScaleBy() public method

Scale this node's matrix by the given amount about the specified point.

This will affect this node and all of its descendents.

public ScaleBy ( float scale, PointF point ) : void
scale	float	The amount to scale by.
point	System.Drawing.PointF	The point to scale about.
return	void

ScaleBy() public method

Scale this node's matrix by the given amount about the specified point.

public ScaleBy ( float scale, float x, float y ) : void
scale	float	The amount to scale by.
x	float	The x-coordinate of the point to scale about.
y	float	The y-coordinate of the point to scale about.
return	void

SetBounds() public method

Set the bounds of this node to the given values.

These bounds are stored in the local coordinate system of this node.

public SetBounds ( float x, float y, float width, float height ) : bool
x	float	The new x coordinate of the bounds.
y	float	The new y coordinate of the bounds.
width	float	The new width of the bounds.
height	float	The new height of the bounds.
return	bool

SetOffset() public method

Sets the offset applied to this node by it's matrix.

The offset affects this node and all of its descendents and is specified in the parent coordinate system. This directly sets the values that are in the dx and dy positions of the matrix. Unlike PNode.TranslateBy(), this is not affected by the scale value of the matrix.

public SetOffset ( PointF p ) : void
p	System.Drawing.PointF	/// The offset, specified in the parent coordinate system. ///
return	void

SetOffset() public method

Sets the offset applied to this node by it's matrix.

public SetOffset ( float x, float y ) : void
x	float	/// The x amount of the offset, specified in the parent coordinate system. ///
y	float	/// The y amount of the offset, specified in the parent coordinate system. ///
return	void

SignalBoundsChanged() public method

This method should be called when the bounds of this node are changed.

This method invalidates the full bounds of this node, and also notifies each of this node's children that their parent's bounds have changed. As a result of this method getting called this node's LayoutChildren will be called.

public SignalBoundsChanged ( ) : void
return	void

StartResizeBounds() public method

Notify this node that you will begin to repeatedly call SetBounds.

After a call to StartResizeBounds, EndResizeBounds should eventually be called to notify the node of the end of the sequence of SetBounds calls.

public StartResizeBounds ( ) : void
return	void

ToImage() public method

Return a new Image representing this node and all of its children.

The image size will be equal to the size of this node's full bounds.

public ToImage ( ) : Image
return	Image

ToImage() public method

Paint a representation of this node into the specified image. If backgroundBrush is null, then the image will not be filled with a color prior to rendering.

public ToImage ( Image image, Brush backgroundBrush ) : Image
image	Image	The image to render this node into.
backgroundBrush	System.Drawing.Brush	/// The brush used to render the background of the image. ///
return	Image

ToImage() public method

Return a new Image of the requested size representing this node and all of its children.

If backgroundBrush is null, then the image will not be filled with a color prior to rendering.

public ToImage ( int width, int height, Brush backgroundBrush ) : Image
width	int	The desired width of the image, in pixels.
height	int	The desired height of the image, in pixels.
backgroundBrush	System.Drawing.Brush	/// The brush used to render the background of the image. ///
return	Image

ToPickPath() public method

Creates a pick path with a null camera and empty pickbounds and adds this node.

This method is useful if you want to dispatch events directly to a single node. For an example, see PSelectionExample, where the KeyboardFocus is set using this approach.

public ToPickPath ( ) : UMD.HCIL.Piccolo.Util.PPickPath
return	UMD.HCIL.Piccolo.Util.PPickPath

ToPickPath() public method

Creates a pick path with the given Camera and pickbounds and adds this node.

public ToPickPath ( UMD.HCIL.Piccolo.PCamera aCamera, RectangleF pickBounds ) : UMD.HCIL.Piccolo.Util.PPickPath
aCamera	UMD.HCIL.Piccolo.PCamera	The camera to use when creating the pick path.
pickBounds	System.Drawing.RectangleF	The pick bounds to use when creating the pick path.
return	UMD.HCIL.Piccolo.Util.PPickPath

ToString() public method

Returns a string representation of this object for debugging purposes.

public ToString ( ) : string
return	string

TransformBy() public method

Transform this node's matrix by the given matrix.

public TransformBy ( UMD.HCIL.Piccolo.Util.PMatrix matrix ) : void
matrix	UMD.HCIL.Piccolo.Util.PMatrix	The transform to apply.
return	void

TranslateBy() public method

Translate this node's matrix by the given amount, using the standard matrix Translate method.

This translation affects this node and all of its descendents.

public TranslateBy ( float dx, float dy ) : void
dx	float	The amount to translate in the x direction.
dy	float	The amount to translate in the y direction.
return	void

ValidateFullBounds() protected method

This method is called to validate the bounds of this node and all of its descendents.

This method returns true if this node's bounds or the bounds of any of its descendents are marked as volatile.

protected ValidateFullBounds ( ) : bool
return	bool

ValidateFullPaint() public method

Repaint this node and any of its descendents if they have invalid paint.

public ValidateFullPaint ( ) : void
return	void

printDocument_PrintPage() protected method

Prints the node into the given Graphics context.

protected printDocument_PrintPage ( object sender, System.Drawing.Printing.PrintPageEventArgs e ) : void
sender	object	The source of the PrintPage event.
e	System.Drawing.Printing.PrintPageEventArgs	The PrintPageEventArgs.
return	void

this() public method

Allows a PNode to be indexed directly to access it's children.

This provides a shortcut to indexing a node's children. For example, aNode.GetChild(i) is equivalent to aNode[i]. Note that using the indexor to set a child will remove the child currently at that index.

public this ( int index ) : PNode
index	int
return	PNode

Property Details

EVENT_KEY_CLICK protected_oe static_oe property

The key that identifies Click events in a node's event handler list.

protected static object EVENT_KEY_CLICK
return	object

EVENT_KEY_DOUBLECLICK protected_oe static_oe property

The key that identifies DoubleClick events in a node's event handler list.

protected static object EVENT_KEY_DOUBLECLICK
return	object

EVENT_KEY_DRAGDROP protected_oe static_oe property

The key that identifies DragDrop events in a node's event handler list.

protected static object EVENT_KEY_DRAGDROP
return	object

EVENT_KEY_DRAGENTER protected_oe static_oe property

The key that identifies DragEnter events in a node's event handler list.

protected static object EVENT_KEY_DRAGENTER
return	object

EVENT_KEY_DRAGLEAVE protected_oe static_oe property

The key that identifies DragLeave events in a node's event handler list.

protected static object EVENT_KEY_DRAGLEAVE
return	object

EVENT_KEY_DRAGOVER protected_oe static_oe property

The key that identifies DragOver events in a node's event handler list.

protected static object EVENT_KEY_DRAGOVER
return	object

EVENT_KEY_GOTFOCUS protected_oe static_oe property

The key that identifies GotFocus events in a node's event handler list.

protected static object EVENT_KEY_GOTFOCUS
return	object

EVENT_KEY_KEYDOWN protected_oe static_oe property

The key that identifies KeyDown events in a node's event handler list.

protected static object EVENT_KEY_KEYDOWN
return	object

EVENT_KEY_KEYPRESS protected_oe static_oe property

The key that identifies KeyPress events in a node's event handler list.

protected static object EVENT_KEY_KEYPRESS
return	object

EVENT_KEY_KEYUP protected_oe static_oe property

The key that identifies KeyUp events in a node's event handler list.

protected static object EVENT_KEY_KEYUP
return	object

EVENT_KEY_LOSTFOCUS protected_oe static_oe property

The key that identifies LostFocus events in a node's event handler list.

protected static object EVENT_KEY_LOSTFOCUS
return	object

EVENT_KEY_MOUSEDOWN protected_oe static_oe property

The key that identifies MouseDown events in a node's event handler list.

protected static object EVENT_KEY_MOUSEDOWN
return	object

EVENT_KEY_MOUSEDRAG protected_oe static_oe property

The key that identifies MouseDrag events in a node's event handler list.

protected static object EVENT_KEY_MOUSEDRAG
return	object

EVENT_KEY_MOUSEENTER protected_oe static_oe property

The key that identifies MouseEnter events in a node's event handler list.

protected static object EVENT_KEY_MOUSEENTER
return	object

EVENT_KEY_MOUSELEAVE protected_oe static_oe property

The key that identifies MouseLeave events in a node's event handler list.

protected static object EVENT_KEY_MOUSELEAVE
return	object

EVENT_KEY_MOUSEMOVE protected_oe static_oe property

The key that identifies MouseMove events in a node's event handler list.

protected static object EVENT_KEY_MOUSEMOVE
return	object

EVENT_KEY_MOUSEUP protected_oe static_oe property

The key that identifies MouseUp events in a node's event handler list.

protected static object EVENT_KEY_MOUSEUP
return	object

EVENT_KEY_MOUSEWHEEL protected_oe static_oe property

The key that identifies MouseWheel events in a node's event handler list.

protected static object EVENT_KEY_MOUSEWHEEL
return	object

FullBoundsInvalidated public_oe property

Used to recieve low level full bounds invalidated events.

public FullBoundsInvalidatedDelegate FullBoundsInvalidated
return	FullBoundsInvalidatedDelegate

PROPERTY_KEY_BOUNDS protected_oe static_oe property

The key that identifies BoundsChanged events in a node's event handler list.

protected static object PROPERTY_KEY_BOUNDS
return	object

PROPERTY_KEY_BRUSH protected_oe static_oe property

The key that identifies BrushChanged events in a node's event handler list.

protected static object PROPERTY_KEY_BRUSH
return	object

PROPERTY_KEY_CHILDREN protected_oe static_oe property

The key that identifies ChildrenChanged events in a node's event handler list.

protected static object PROPERTY_KEY_CHILDREN
return	object

PROPERTY_KEY_CHILDRENPICKABLE protected_oe static_oe property

The key that identifies ChildrenPickableChanged events in a node's event handler list.

protected static object PROPERTY_KEY_CHILDRENPICKABLE
return	object

PROPERTY_KEY_FULLBOUNDS protected_oe static_oe property

The key that identifies FullBoundsChanged events in a node's event handler list.

protected static object PROPERTY_KEY_FULLBOUNDS
return	object

PROPERTY_KEY_PARENT protected_oe static_oe property

The key that identifies ParentChanged events in a node's event handler list.

protected static object PROPERTY_KEY_PARENT
return	object

PROPERTY_KEY_PICKABLE protected_oe static_oe property

The key that identifies PickableChanged events in a node's event handler list.

protected static object PROPERTY_KEY_PICKABLE
return	object

PROPERTY_KEY_TAG protected_oe static_oe property

The key that identifies TagChanged events in a node's event handler list.

protected static object PROPERTY_KEY_TAG
return	object

PROPERTY_KEY_TRANSFORM protected_oe static_oe property

The key that identifies TransformChanged events in a node's event handler list.

protected static object PROPERTY_KEY_TRANSFORM
return	object

PROPERTY_KEY_VISIBLE protected_oe static_oe property

The key that identifies VisibleChanged events in a node's event handler list.

protected static object PROPERTY_KEY_VISIBLE
return	object

PaintInvalidated public_oe property

Used to recieve low level paint invalidated events.

public PaintInvalidatedDelegate PaintInvalidated
return	PaintInvalidatedDelegate

bounds protected_oe property

The bounds of this node, stored in local coordinates.

protected RectangleF,System.Drawing bounds
return	System.Drawing.RectangleF