public override void Undo()
                {
                    int                      i, j;
                    DGEdge                   edge;
                    List <DGEdge>            edges;
                    Digraph <DGNode, DGEdge> dg
                        = this.mNode.mState.DecisionGraph;

                    this.mSliceList.AddRange(this.mSlices);
                    Array.Copy(this.mAPs, 0, this.mNode.mSliceAnchors, 0,
                               this.mAPs.Length);
                    this.mNode.mSliceCount = this.mAPs.Length;
                    for (i = this.mAPs.Length - 1; i >= 0; i--)
                    {
                        this.mAPs[i].SetParent(this.mNode);
                    }
                    this.mNode.UpdateVisualization();

                    foreach (IEdgeAction action in this.mActions)
                    {
                        action.Undo();
                    }
                    for (i = this.mAPs.Length - 1; i >= 0; i--)
                    {
                        edges = this.mAPs[i].Edges;
                        for (j = edges.Count - 1; j >= 0; j--)
                        {
                            edge = edges[j];
                            edge.SetParent(this.mNode.mState);
                            dg.AddEdge(edge);
                        }
                    }
                    this.mNode.mState.RemoveRootDGEdges();

                    StateNode fState = this.mNode.mScene.FocusedState;

                    if (fState != null && fState.Equals(this.mNode.mState))
                    {
                        for (i = this.mSelectedEdges.Count - 1; i >= 0; i--)
                        {
                            edge = this.mSelectedEdges[i];
                            this.mNode.mScene.SelectDGEdge(edge, false);
                        }
                    }
                }
                public override bool Execute()
                {
                    int                      i, j;
                    DGEdge                   edge;
                    List <DGEdge>            edges;
                    Digraph <DGNode, DGEdge> dg
                        = this.mNode.mState.DecisionGraph;
                    StateNode fState = this.mNode.mScene.FocusedState;

                    if (fState != null && fState.Equals(this.mNode.mState))
                    {
                        for (i = this.mSelectedEdges.Count - 1; i >= 0; i--)
                        {
                            edge = this.mSelectedEdges[i];
                            this.mNode.mScene.SelectDGEdge(edge, false);
                        }
                    }

                    for (i = this.mAPs.Length - 1; i >= 0; i--)
                    {
                        edges = this.mAPs[i].Edges;
                        for (j = edges.Count - 1; j >= 0; j--)
                        {
                            edge = edges[j];
                            dg.RemoveEdge(edge.SrcNode, edge.DstNode);
                            edge.SetParent(null);
                        }
                    }
                    foreach (IEdgeAction action in this.mActions)
                    {
                        action.Redo();
                    }
                    this.mNode.mState.AddRootDGEdges();

                    this.mSliceList.Clear();
                    Array.Clear(this.mNode.mSliceAnchors, 0,
                                this.mNode.mSliceCount);
                    this.mNode.mSliceCount = 0;
                    for (i = this.mAPs.Length - 1; i >= 0; i--)
                    {
                        this.mAPs[i].SetParent(null);
                    }
                    this.mNode.UpdateVisualization();
                    return(true);
                }
                public override void Undo()
                {
                    int    i;
                    DGEdge edge;
                    Digraph <DGNode, DGEdge> dg
                        = this.mNode.mState.DecisionGraph;

                    this.mSliceList.Insert(this.mIndex, this.mSlice);
                    Array.Copy(
                        this.mNode.mSliceAnchors, this.mIndex,
                        this.mNode.mSliceAnchors, this.mIndex + 1,
                        this.mNode.mSliceCount - this.mIndex);
                    this.mNode.mSliceAnchors[this.mIndex] = this.mAP;
                    this.mNode.mSliceCount++;
                    this.mAP.SetParent(this.mNode);
                    this.mNode.UpdateVisualization();

                    for (i = 0; i < this.mCount; i++)
                    {
                        this.mActions[i].Undo();
                    }
                    for (i = this.mAP.Edges.Count - 1; i >= 0; i--)
                    {
                        edge = this.mAP.Edges[i];
                        edge.SetParent(this.mNode.mState);
                        dg.AddEdge(edge);
                    }
                    this.mNode.mState.RemoveRootDGEdges();

                    StateNode fState = this.mNode.mScene.FocusedState;

                    if (fState != null && fState.Equals(this.mNode.mState))
                    {
                        for (i = this.mSelectedEdges.Count - 1; i >= 0; i--)
                        {
                            edge = this.mSelectedEdges[i];
                            this.mNode.mScene.SelectDGEdge(edge, false);
                        }
                    }
                }
                public override bool Execute()
                {
                    int       i;
                    DGEdge    edge;
                    StateNode fState = this.mNode.mScene.FocusedState;

                    if (fState != null && fState.Equals(this.mNode.mState))
                    {
                        for (i = this.mSelectedEdges.Count - 1; i >= 0; i--)
                        {
                            edge = this.mSelectedEdges[i];
                            this.mNode.mScene.SelectDGEdge(edge, false);
                        }
                    }
                    Digraph <DGNode, DGEdge> dg
                        = this.mNode.mState.DecisionGraph;

                    for (i = this.mAP.Edges.Count - 1; i >= 0; i--)
                    {
                        edge = this.mAP.Edges[i];
                        dg.RemoveEdge(edge.SrcNode, edge.DstNode);
                        edge.SetParent(null);
                    }
                    for (i = 0; i < this.mCount; i++)
                    {
                        this.mActions[i].Redo();
                    }
                    this.mNode.mState.AddRootDGEdges();

                    this.mSliceList.RemoveAt(this.mIndex);
                    this.mNode.mSliceCount--;
                    Array.Copy(
                        this.mNode.mSliceAnchors, this.mIndex + 1,
                        this.mNode.mSliceAnchors, this.mIndex,
                        this.mNode.mSliceCount - this.mIndex);
                    this.mAP.SetParent(null);
                    this.mNode.UpdateVisualization();
                    return(true);
                }