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.
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.
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.
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.
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.
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.

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.
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 ( 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