/// <summary>
/// Initializes a new instance of the PNodeList class that contains nodes copied
/// from the specified list and that has the same initial capacity as the number
/// of nodes copied.
/// </summary>
/// <param name="list">The list whose nodes are copied to the new list.</param>
public PNodeList(PNodeList list)
{
foreach (PNode node in list)
{
List.Add(node);
}
}
public override void Initialize() {
Canvas.RemoveInputEventListener(Canvas.PanEventHandler);
// Create a decorator group that is NOT volatile
DecoratorGroup dg = new DecoratorGroup();
dg.Brush = Brushes.Magenta;
// Put some nodes under the group for it to decorate
PPath p1 = PPath.CreateEllipse(25,25,75,75);
p1.Brush = Brushes.Red;
PPath p2 = PPath.CreateRectangle(125,75,50,50);
p2.Brush = Brushes.Blue;
// Add everything to the Piccolo hierarchy
dg.AddChild(p1);
dg.AddChild(p2);
Canvas.Layer.AddChild(dg);
// Create a decorator group that IS volatile
VolatileDecoratorGroup vdg = new VolatileDecoratorGroup(Canvas.Camera);
vdg.Brush = Brushes.Cyan;
// Put some nodes under the group for it to decorate
PPath p3 = PPath.CreateEllipse(275,175,50,50);
p3.Brush = Brushes.Blue;
PPath p4 = PPath.CreateRectangle(175,175,75,75);
p4.Brush = Brushes.Green;
// Add everything to the Piccolo hierarchy
vdg.AddChild(p3);
vdg.AddChild(p4);
Canvas.Layer.AddChild(vdg);
// Create a selection handler so we can see that the decorator actually works
PNodeList selectableParents = new PNodeList();
selectableParents.Add(dg);
selectableParents.Add(vdg);
PSelectionEventHandler ps = new PSelectionEventHandler(Canvas.Layer,selectableParents);
Canvas.AddInputEventListener(ps);
}
/// <summary>
/// Gets a list containing the subset of this node and all of its descendent nodes
/// that are accepted by the given node filter.
/// </summary>
/// <param name="filter">The filter used to determine the subset.</param>
/// <param name="results">The list used to collect the subset; can be null.</param>
/// <returns>
/// A list containing the subset of this node and all its descendents accepted by
/// the filter.
/// </returns>
/// <remarks>
/// 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.
/// </remarks>
public virtual PNodeList GetAllNodes(PNodeFilter filter, PNodeList results) {
if (results == null) {
results = new PNodeList();
}
if (filter == null || filter.Accept(this)) {
results.Add(this);
}
if (filter == null || filter.AcceptChildrenOf(this)) {
int count = ChildrenCount;
for (int i = 0; i < count; i++) {
children[i].GetAllNodes(filter, results);
}
}
return results;
}
/// <summary>
/// Remove all the children from this node.
/// </summary>
/// <remarks>
/// Note this method is more efficient then removing each child individually.
/// </remarks>
public virtual void RemoveAllChildren() {
if (children != null) {
int count = ChildrenCount;
for (int i = 0; i < count; i++) {
children[i].Parent = null;
}
children = null;
InvalidatePaint();
InvalidateFullBounds();
FirePropertyChangedEvent(PROPERTY_KEY_CHILDREN, PROPERTY_CODE_CHILDREN, null, children);
}
}
/// <summary>
/// Remove all the children in the given list from this node’s list
/// of children.
/// </summary>
/// <param name="childrenNodes">The list of children to remove.</param>
/// <remarks>All removed nodes will have their parent set to null.</remarks>
public virtual void RemoveChildren(PNodeList childrenNodes) {
RemoveChildren((ICollection)childrenNodes);
}
/// <summary>
/// Remove the child at the specified position from this node's children.
/// </summary>
/// <param name="index">The index of the child to remove.</param>
/// <remarks >
/// Any subsequent children are shifted to the left (one is subtracted
/// from their indices). The removed child’s parent is set to null.
/// </remarks>
/// <returns>The removed child.</returns>
public virtual PNode RemoveChild(int index) {
PNode child = children[index];
children.RemoveAt(index);
if (children.Count == 0) {
children = null;
}
child.Repaint();
child.Parent = null;
InvalidateFullBounds();
FirePropertyChangedEvent(PROPERTY_KEY_CHILDREN, PROPERTY_CODE_CHILDREN, null, children);
return child;
}
/// <summary>
/// Adds the nodes of the given list to the end of this list.
/// </summary>
/// <param name="list">
/// The list whose nodes should be added to the end of this list.
/// </param>
public void AddRange(PNodeList list)
{
InnerList.AddRange(list);
}
/// <summary>
/// Constructs a new PSelectionEventHandler that will handle selection for the
/// children of the given selectable parent node.
/// </summary>
/// <param name="marqueeParent">
/// The node to which the event handler dynamically adds a marquee (temporarily)
/// to represent the area being selected.
/// </param>
/// <param name="selectableParent">
/// The node whose children will be selected by this event handler.
/// </param>
public PSelectionEventHandler(PNode marqueeParent, PNode selectableParent) {
this.marqueeParent = marqueeParent;
selectableParents = new PNodeList();
selectableParents.Add(selectableParent);
Init();
}
/// <summary>
/// Unselects each node in the list, if the node is currently selected.
/// </summary>
/// <param name="items">The list of items to unselect.</param>
/// <remarks>
/// This method will remove the handles from the selected nodes in the
/// list and post a SELECTION_CHANGED_NOTIFICATION if the selection has
/// changed.
/// </remarks>
public virtual void Unselect(PNodeList items) {
Unselect((ICollection)items);
}
/// <summary>
/// Initializes a new instance of the PNodeList class that contains nodes copied
/// from the specified list and that has the same initial capacity as the number
/// of nodes copied.
/// </summary>
/// <param name="list">The list whose nodes are copied to the new list.</param>
public PNodeList(PNodeList list) {
foreach(PNode node in list) {
List.Add(node);
}
}
/// <summary>
/// Adds the nodes of the given list to the end of this list.
/// </summary>
/// <param name="list">
/// The list whose nodes should be added to the end of this list.
/// </param>
public void AddRange(PNodeList list) {
InnerList.AddRange(list);
}
/// <summary>
/// Sorts the given list of nodes by their distance from the given point. Nodes
/// closest to the point will be placed first in the list.
/// </summary>
/// <param name="aNodesList">The list to sort.</param>
/// <param name="aPoint">The point to use for the comparison.</param>
public virtual void SortNodesByDistanceFromPoint(PNodeList aNodesList, PointF aPoint) {
aNodesList.Sort(new DistanceFromPointComparer(aPoint));
}
/// <summary>
/// Get a list of all neighbors (parent, siblings and children).
/// </summary>
/// <returns>A list of all neighbors.</returns>
public virtual PNodeList GetNeighbors() {
PNodeList result = new PNodeList();
if (focusNode == null) return result;
if (focusNode.Parent == null) return result;
PNode focusParent = focusNode.Parent;
PNodeList focusParentChildren = focusParent.ChildrenReference;
foreach (PNode each in focusParentChildren) {
if (each != focusNode && each.Pickable) {
result.Add(each);
}
}
result.Add(focusParent);
PNodeList focusChildren = focusNode.ChildrenReference;
foreach(PNode each in focusChildren) {
result.Add(each);
}
return result;
}
protected PNode currentPosition; // Visual indicator of current position
#endregion
#region Initialization
/// <summary>
/// Constructs a new slideviewer control.
/// </summary>
public SlideViewer() {
// This call is required by the Windows.Forms Form Designer.
InitializeComponent();
slides = new PNodeList();
slideBar = new PNode();
slideBar.Brush = Brushes.DarkGray;
slideBar.Bounds = new RectangleF(0, 0, Width, SLIDE_BAR_HEIGHT);
// Add the navigation event handlers and set the keyboard focus.
Camera.MouseDown += new PInputEventHandler(Camera_MouseDown);
Camera.KeyDown += new PInputEventHandler(Camera_KeyDown);
Camera.MouseMove += new PInputEventHandler(Camera_MouseMove);
Root.DefaultInputManager.KeyboardFocus = Camera.ToPickPath();
// Remove the default zoom and pan event handlers.
ZoomEventHandler = null;
PanEventHandler = null;
this.HandleCreated += new EventHandler(SlideViewer_HandleCreated);
}
/// <summary>
/// Constructs a new PSelectionEventHandler that will handle selection for the
/// children of the given list of selectable parent nodes.
/// </summary>
/// <param name="marqueeParent">
/// The node to which the event handler dynamically adds a marquee (temporarily)
/// to represent the area being selected.
/// </param>
/// <param name="selectableParents">
/// A list of nodes whose children will be selected by this event handler.
/// </param>
public PSelectionEventHandler(PNode marqueeParent, PNodeList selectableParents) {
this.marqueeParent = marqueeParent;
this.selectableParents = selectableParents;
Init();
}
/// <summary>
/// Called by the constructors to perform some common initialization tasks.
/// </summary>
protected virtual void Init() {
float[] dash = { DASH_WIDTH, DASH_WIDTH };
pens = new Pen[NUM_PENS];
for (int i = 0; i < NUM_PENS; i++) {
pens[i] = new Pen(Color.Black, 1);
pens[i].DashPattern = dash;
pens[i].DashOffset = i;
}
selection = new Hashtable();
allItems = new Hashtable();
unselectList = new PNodeList();
marqueeMap = new Hashtable();
}
/// <summary>
/// Removes bounds handles from the given node.
/// </summary>
/// <param name="aNode">The node to remove the bounds handles from.</param>
public static void RemoveBoundsHandlesFrom(PNode aNode) {
PNodeList handles = new PNodeList();
PNodeList children = aNode.ChildrenReference;
foreach (PNode each in children) {
if (each is PBoundsHandle) {
handles.Add(each);
}
}
aNode.RemoveChildren(handles);
}
/// <summary>
/// Update the marquee bounds based on the given event data.
/// </summary>
/// <param name="e">A PInputEventArgs that contains the event data.</param>
protected virtual void UpdateMarquee(PInputEventArgs e) {
RectangleF r = RectangleF.Empty;
if (marqueeParent is PCamera) {
r = PUtil.AddPointToRect(r, canvasPressPt);
r = PUtil.AddPointToRect(r, e.CanvasPosition);
}
else {
r = PUtil.AddPointToRect(r, presspt);
r = PUtil.AddPointToRect(r, e.Position);
}
r = marquee.GlobalToLocal(r);
marquee.Reset();
SetSafeMarqueePen(r.Width, r.Height);
marquee.AddRectangle(r.X, r.Y, r.Width, r.Height);
r = RectangleF.Empty;
r = PUtil.AddPointToRect(r, presspt);
r = PUtil.AddPointToRect(r, e.Position);
allItems.Clear();
PNodeFilter filter = CreateNodeFilter(r);
foreach (PNode parent in selectableParents) {
PNodeList items;
if (parent is PCamera) {
items = new PNodeList();
PCamera cameraParent = (PCamera)parent;
for(int i=0; i<cameraParent.LayerCount; i++) {
cameraParent.GetLayer(i).GetAllNodes(filter,items);
}
}
else {
items = parent.GetAllNodes(filter, null);
}
foreach (PNode node in items) {
allItems.Add(node, true);
}
}
}
/// <summary>
/// Checks this node and it's descendents for intersection with the given bounds
/// and adds any intersecting nodes to the given list.
/// </summary>
/// <param name="fullBounds">
/// The bounds to check for intersection, in parent coordinates.
/// </param>
/// <param name="results">
/// The resulting list of nodes.
/// </param>
public void FindIntersectingNodes(RectangleF fullBounds, PNodeList results) {
if (FullIntersects(fullBounds)) {
RectangleF bounds = ParentToLocal(fullBounds);
if (Intersects(bounds)) {
results.Add(this);
}
int count = ChildrenCount;
for (int i = count - 1; i >= 0; i--) {
PNode each = children[i];
each.FindIntersectingNodes(bounds, results);
}
}
}
/// <summary>
/// Add a list of nodes to be children of this node.
/// </summary>
/// <param name="nodes">A list of nodes to be added to this node.</param>
/// <remarks>
/// If these nodes already have parents they will first be removed from
/// those parents.
/// </remarks>
public virtual void AddChildren(PNodeList nodes) {
AddChildren((ICollection)nodes);
}
/// <summary>
/// This method paints the bounds and full bounds of nodes when the appropriate debug
/// flags are set.
/// </summary>
/// <param name="paintContext">
/// The paint context to use for painting debug information.
/// </param>
/// <remarks>
/// Setting debugBounds and/or debugFullBounds flags is useful for visual debugging.
/// </remarks>
protected virtual void PaintDebugInfo(PPaintContext paintContext) {
if (PDebug.DebugBounds || PDebug.DebugFullBounds) {
PNodeList nodes = new PNodeList();
RectangleF nodeBounds = RectangleF.Empty;
for (int i = 0; i < LayerCount; i++) {
GetLayer(i).GetAllNodes(null, nodes);
}
GetAllNodes(null, nodes);
foreach (PNode each in nodes) {
if (PDebug.DebugBounds) {
nodeBounds = each.Bounds;
if (!nodeBounds.IsEmpty) {
nodeBounds = each.LocalToGlobal(nodeBounds);
nodeBounds = GlobalToLocal(nodeBounds);
if (each == this || each.IsDescendentOf(this)) {
nodeBounds = LocalToView(nodeBounds);
}
PaintDebugBounds(paintContext, boundsPen, nodeBounds);
}
}
if (PDebug.DebugFullBounds) {
nodeBounds = each.FullBounds;
if (!nodeBounds.IsEmpty) {
if (each.Parent != null) {
nodeBounds = each.Parent.LocalToGlobal(nodeBounds);
}
nodeBounds = GlobalToLocal(nodeBounds);
if (each == this || each.IsDescendentOf(this)) {
nodeBounds = LocalToView(nodeBounds);
}
PaintDebugFullBounds(paintContext, fullBoundsBrush, nodeBounds);
}
}
}
}
}
