C# 클래스 UMD.HCIL.Piccolo.PNode

상속: ICloneable, ISerializable, IEnumerable

파일 보기 프로젝트 열기: ME3Explorer/ME3Explorer 1 사용 예제들

공개 프로퍼티들

프로퍼티	타입	설명
FullBoundsInvalidated	FullBoundsInvalidatedDelegate
PaintInvalidated	PaintInvalidatedDelegate

보호된 프로퍼티들

프로퍼티	타입	설명
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

공개 메소드들

메소드	설명
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.

보호된 메소드들

메소드	설명
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.

메소드 상세

AddActivity() 공개 메소드

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.
리턴	bool

AddChild() 공개 메소드

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.
리턴	void

AddChild() 공개 메소드

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.
리턴	void

AddChildren() 보호된 메소드

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. ///
리턴	void

AddChildren() 공개 메소드

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.
리턴	void

AddInputEventListener() 공개 메소드

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

public AddInputEventListener ( PInputEventListener listener ) : void
listener	PInputEventListener	The new input listener
리턴	void

AnimateMatrixToBounds() 공개 메소드

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.
리턴	UMD.HCIL.Piccolo.Activities.PTransformActivity

AnimateToBounds() 공개 메소드

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.
리턴	UMD.HCIL.Piccolo.Activities.PInterpolatingActivity

AnimateToColor() 공개 메소드

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.
리턴	UMD.HCIL.Piccolo.Activities.PColorActivity

AnimateToMatrix() 공개 메소드

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.
리턴	UMD.HCIL.Piccolo.Activities.PTransformActivity

AnimateToPositionScaleRotation() 공개 메소드

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.
리턴	UMD.HCIL.Piccolo.Activities.PTransformActivity

CenterBoundsOnPoint() 공개 메소드

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. ///
리턴	bool

CenterFullBoundsOnPoint() 공개 메소드

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. ///
리턴	void

Clone() 공개 메소드

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
리턴	Object

ComputeFullBounds() 공개 메소드

Compute and return the full bounds of this node.

public ComputeFullBounds ( ) : RectangleF
리턴	System.Drawing.RectangleF

EndResizeBounds() 공개 메소드

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

A call to StartResizeBounds should precede a call to EndResizeBounds.

public EndResizeBounds ( ) : void
리턴	void

FindIntersectingNodes() 공개 메소드

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. ///
리턴	void

FireChildPropertyChangedEvent() 보호된 메소드

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.
리턴	void

FirePropertyChangedEvent() 보호된 메소드

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.
리턴	void

FullIntersects() 공개 메소드

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). ///
리턴	bool

FullPaint() 공개 메소드

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.
리턴	void

FullPick() 공개 메소드

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.
리턴	bool

GetAllNodes() 공개 메소드

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.
리턴	UMD.HCIL.Piccolo.Util.PNodeList

GetChild() 공개 메소드

Return the child node at the specified index.

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

GetEnumerator() 공개 메소드

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
리턴	IEnumerator

GetObjectData() 공개 메소드

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.
리턴	void

GetPropertyHandlers() 보호된 메소드

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.
리턴	PPropertyEventHandler

GlobalToLocal() 공개 메소드

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.
리턴	System.Drawing.PointF

GlobalToLocal() 공개 메소드

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.
리턴	System.Drawing.RectangleF

GlobalToLocal() 공개 메소드

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.
리턴	System.Drawing.SizeF

HandleEvent() 보호된 메소드

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.
리턴	void

IndexOfChild() 공개 메소드

Return the index where the given child is stored.

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

InternalUpdateBounds() 보호된 메소드

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.
리턴	void

Intersects() 공개 메소드

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.
리턴	bool

InvalidateFullBounds() 공개 메소드

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

public InvalidateFullBounds ( ) : void
리턴	void

InvalidateLayout() 공개 메소드

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

public InvalidateLayout ( ) : void
리턴	void

InvalidatePaint() 공개 메소드

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

public InvalidatePaint ( ) : void
리턴	void

IsAncestorOf() 공개 메소드

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

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

IsDescendentOf() 공개 메소드

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

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

IsDescendentOfRoot() 공개 메소드

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

public IsDescendentOfRoot ( ) : bool
리턴	bool

IsOpaque() 공개 메소드

public IsOpaque ( RectangleF boundary ) : bool
boundary	System.Drawing.RectangleF
리턴	bool

LayoutChildren() 공개 메소드

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
리턴	void

Lerp() 정적인 공개 메소드

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.
리턴	float

LocalToGlobal() 공개 메소드

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.
리턴	System.Drawing.PointF

LocalToGlobal() 공개 메소드

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.
리턴	System.Drawing.RectangleF

LocalToGlobal() 공개 메소드

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.
리턴	System.Drawing.SizeF

LocalToParent() 공개 메소드

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.
리턴	System.Drawing.PointF

LocalToParent() 공개 메소드

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.
리턴	System.Drawing.RectangleF

LocalToParent() 공개 메소드

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.
리턴	System.Drawing.SizeF

MoveInBackOf() 공개 메소드

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.
리턴	void

MoveInFrontOf() 공개 메소드

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.
리턴	void

MoveToBack() 공개 메소드

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
리턴	void

MoveToFront() 공개 메소드

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
리턴	void

OffsetBy() 공개 메소드

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.
리턴	void

OnClick() 공개 메소드

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
리턴	void

OnDoubleClick() 공개 메소드

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
리턴	void

OnDragDrop() 공개 메소드

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
리턴	void

OnDragEnter() 공개 메소드

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
리턴	void

OnDragLeave() 공개 메소드

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
리턴	void

OnDragOver() 공개 메소드

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
리턴	void

OnFullBoundsInvalidated() 보호된 메소드

Raises the FullBoundsInvalidated event.

protected OnFullBoundsInvalidated ( ) : void
리턴	void

OnGotFocus() 공개 메소드

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
리턴	void

OnKeyDown() 공개 메소드

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
리턴	void

OnKeyPress() 공개 메소드

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
리턴	void

OnKeyUp() 공개 메소드

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
리턴	void

OnLostFocus() 공개 메소드

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
리턴	void

OnMouseDown() 공개 메소드

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
리턴	void

OnMouseDrag() 공개 메소드

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
리턴	void

OnMouseEnter() 공개 메소드

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
리턴	void

OnMouseLeave() 공개 메소드

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
리턴	void

OnMouseMove() 공개 메소드

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
리턴	void

OnMouseUp() 공개 메소드

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
리턴	void

OnMouseWheel() 공개 메소드

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
리턴	void

OnPaintInvalidated() 보호된 메소드

Raises the PaintInvalidated event.

protected OnPaintInvalidated ( ) : void
리턴	void

PNode() 공개 메소드

Constructs a new PNode.

public PNode ( ) : System
리턴	System

PNode() 보호된 메소드

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.
리턴	System

Paint() 보호된 메소드

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.
리턴	void

PaintAfterChildren() 보호된 메소드

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. ///
리턴	void

ParentBoundsChanged() 공개 메소드

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

public ParentBoundsChanged ( ) : void
리턴	void

ParentToLocal() 공개 메소드

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.
리턴	System.Drawing.PointF

ParentToLocal() 공개 메소드

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.
리턴	System.Drawing.RectangleF

ParentToLocal() 공개 메소드

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.
리턴	System.Drawing.SizeF

Pick() 보호된 메소드

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.
리턴	bool

PickAfterChildren() 보호된 메소드

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.
리턴	bool

Position() 공개 메소드

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
리턴	void

Print() 공개 메소드

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

public Print ( ) : void
리턴	void

RemoveAllChildren() 공개 메소드

Remove all the children from this node.

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

public RemoveAllChildren ( ) : void
리턴	void

RemoveChild() 공개 메소드

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.
리턴	PNode

RemoveChild() 공개 메소드

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.
리턴	PNode

RemoveChildren() 보호된 메소드

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. ///
리턴	void

RemoveChildren() 공개 메소드

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.
리턴	void

RemoveFromParent() 공개 메소드

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

public RemoveFromParent ( ) : void
리턴	void

RemoveInputEventListener() 공개 메소드

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.
리턴	void

Repaint() 공개 메소드

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

public Repaint ( ) : void
리턴	void

RepaintFrom() 공개 메소드

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. ///
리턴	void

Reparent() 공개 메소드

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.
리턴	void

ReplaceWith() 공개 메소드

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. ///
리턴	void

ResetBounds() 공개 메소드

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

public ResetBounds ( ) : void
리턴	void

RotateBy() 공개 메소드

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.
리턴	void

RotateBy() 공개 메소드

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.
리턴	void

RotateBy() 공개 메소드

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.
리턴	void

RotateInPlace() 공개 메소드

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.
리턴	void

ScaleAndDraw() 보호된 메소드

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.
리턴	void

ScaleBy() 공개 메소드

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.
리턴	void

ScaleBy() 공개 메소드

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.
리턴	void

ScaleBy() 공개 메소드

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.
리턴	void

SetBounds() 공개 메소드

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.
리턴	bool

SetOffset() 공개 메소드

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. ///
리턴	void

SetOffset() 공개 메소드

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. ///
리턴	void

SignalBoundsChanged() 공개 메소드

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
리턴	void

StartResizeBounds() 공개 메소드

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
리턴	void

ToImage() 공개 메소드

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
리턴	Image

ToImage() 공개 메소드

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. ///
리턴	Image

ToImage() 공개 메소드

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. ///
리턴	Image

ToPickPath() 공개 메소드

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
리턴	UMD.HCIL.Piccolo.Util.PPickPath

ToPickPath() 공개 메소드

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.
리턴	UMD.HCIL.Piccolo.Util.PPickPath

ToString() 공개 메소드

Returns a string representation of this object for debugging purposes.

public ToString ( ) : string
리턴	string

TransformBy() 공개 메소드

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.
리턴	void

TranslateBy() 공개 메소드

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.
리턴	void

ValidateFullBounds() 보호된 메소드

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
리턴	bool

ValidateFullPaint() 공개 메소드

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

public ValidateFullPaint ( ) : void
리턴	void

printDocument_PrintPage() 보호된 메소드

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.
리턴	void

this() 공개 메소드

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
리턴	PNode

프로퍼티 상세

EVENT_KEY_CLICK 보호되어 있는 정적으로 프로퍼티

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

protected static object EVENT_KEY_CLICK
리턴	object

EVENT_KEY_DOUBLECLICK 보호되어 있는 정적으로 프로퍼티

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

protected static object EVENT_KEY_DOUBLECLICK
리턴	object

EVENT_KEY_DRAGDROP 보호되어 있는 정적으로 프로퍼티

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

protected static object EVENT_KEY_DRAGDROP
리턴	object

EVENT_KEY_DRAGENTER 보호되어 있는 정적으로 프로퍼티

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

protected static object EVENT_KEY_DRAGENTER
리턴	object

EVENT_KEY_DRAGLEAVE 보호되어 있는 정적으로 프로퍼티

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

protected static object EVENT_KEY_DRAGLEAVE
리턴	object

EVENT_KEY_DRAGOVER 보호되어 있는 정적으로 프로퍼티

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

protected static object EVENT_KEY_DRAGOVER
리턴	object

EVENT_KEY_GOTFOCUS 보호되어 있는 정적으로 프로퍼티

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

protected static object EVENT_KEY_GOTFOCUS
리턴	object

EVENT_KEY_KEYDOWN 보호되어 있는 정적으로 프로퍼티

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

protected static object EVENT_KEY_KEYDOWN
리턴	object

EVENT_KEY_KEYPRESS 보호되어 있는 정적으로 프로퍼티

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

protected static object EVENT_KEY_KEYPRESS
리턴	object

EVENT_KEY_KEYUP 보호되어 있는 정적으로 프로퍼티

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

protected static object EVENT_KEY_KEYUP
리턴	object

EVENT_KEY_LOSTFOCUS 보호되어 있는 정적으로 프로퍼티

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

protected static object EVENT_KEY_LOSTFOCUS
리턴	object

EVENT_KEY_MOUSEDOWN 보호되어 있는 정적으로 프로퍼티

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

protected static object EVENT_KEY_MOUSEDOWN
리턴	object

EVENT_KEY_MOUSEDRAG 보호되어 있는 정적으로 프로퍼티

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

protected static object EVENT_KEY_MOUSEDRAG
리턴	object

EVENT_KEY_MOUSEENTER 보호되어 있는 정적으로 프로퍼티

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

protected static object EVENT_KEY_MOUSEENTER
리턴	object

EVENT_KEY_MOUSELEAVE 보호되어 있는 정적으로 프로퍼티

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

protected static object EVENT_KEY_MOUSELEAVE
리턴	object

EVENT_KEY_MOUSEMOVE 보호되어 있는 정적으로 프로퍼티

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

protected static object EVENT_KEY_MOUSEMOVE
리턴	object

EVENT_KEY_MOUSEUP 보호되어 있는 정적으로 프로퍼티

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

protected static object EVENT_KEY_MOUSEUP
리턴	object

EVENT_KEY_MOUSEWHEEL 보호되어 있는 정적으로 프로퍼티

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

protected static object EVENT_KEY_MOUSEWHEEL
리턴	object

FullBoundsInvalidated 공개적으로 프로퍼티

Used to recieve low level full bounds invalidated events.

public FullBoundsInvalidatedDelegate FullBoundsInvalidated
리턴	FullBoundsInvalidatedDelegate

PROPERTY_KEY_BOUNDS 보호되어 있는 정적으로 프로퍼티

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

protected static object PROPERTY_KEY_BOUNDS
리턴	object

PROPERTY_KEY_BRUSH 보호되어 있는 정적으로 프로퍼티

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

protected static object PROPERTY_KEY_BRUSH
리턴	object

PROPERTY_KEY_CHILDREN 보호되어 있는 정적으로 프로퍼티

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

protected static object PROPERTY_KEY_CHILDREN
리턴	object

PROPERTY_KEY_CHILDRENPICKABLE 보호되어 있는 정적으로 프로퍼티

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

protected static object PROPERTY_KEY_CHILDRENPICKABLE
리턴	object

PROPERTY_KEY_FULLBOUNDS 보호되어 있는 정적으로 프로퍼티

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

protected static object PROPERTY_KEY_FULLBOUNDS
리턴	object

PROPERTY_KEY_PARENT 보호되어 있는 정적으로 프로퍼티

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

protected static object PROPERTY_KEY_PARENT
리턴	object

PROPERTY_KEY_PICKABLE 보호되어 있는 정적으로 프로퍼티

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

protected static object PROPERTY_KEY_PICKABLE
리턴	object

PROPERTY_KEY_TAG 보호되어 있는 정적으로 프로퍼티

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

protected static object PROPERTY_KEY_TAG
리턴	object

PROPERTY_KEY_TRANSFORM 보호되어 있는 정적으로 프로퍼티

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

protected static object PROPERTY_KEY_TRANSFORM
리턴	object

PROPERTY_KEY_VISIBLE 보호되어 있는 정적으로 프로퍼티

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

protected static object PROPERTY_KEY_VISIBLE
리턴	object

PaintInvalidated 공개적으로 프로퍼티

Used to recieve low level paint invalidated events.

public PaintInvalidatedDelegate PaintInvalidated
리턴	PaintInvalidatedDelegate

bounds 보호되어 있는 프로퍼티

The bounds of this node, stored in local coordinates.

protected RectangleF,System.Drawing bounds
리턴	System.Drawing.RectangleF