/// <summary>
        /// Prepares the layout execution.
        /// </summary>
        public void InitializeLayout()
        {
            // prepare undo/redo
            oldClearRect = clearRect.ToRectD();
            layoutEdit   = Graph.BeginEdit("Clear Area", "Clear Area");

            resetToOriginalGraphStageData = CreateGivenCoordinateStageData();
            executor = CreateDraggingLayoutExecutor();
        }
        /// <summary>
        /// Initializes the layout calculation.
        /// </summary>
        public void InitializeLayout()
        {
            resetToOriginalGraphStageData = CreateGivenCoordinatesStageData(n => !nodes.Contains(n), e => !IsSubgraphEdge(e));

            // hide edge path for any edge between a node in 'nodes' and a node not in 'nodes'
            HideInterEdges();

            executor = GetDragLayoutExecutor();
            state    = GestureState.Dragging;
        }
Esempio n. 3
0
        /// <summary>
        /// Called before the a layout run starts.
        /// </summary>
        private void OnLayoutStarting()
        {
            switch (state)
            {
            case GestureState.Initializing:
                resetToOriginalGraphStageData = CreateGivenCoordinatesStageData(n => true, e => true);
                executor = CreateInitializingLayoutExecutor();

                // highlight the parent of the current subtree and make the connection to the root invisible
                if (subtree.Parent != null)
                {
                    canvasObjectEdge         = graphControl.GraphModelManager.GetCanvasObject(subtree.ParentToRootEdge);
                    canvasObjectEdge.Visible = false;

                    subtree.NewParent = subtree.Parent;
                    UpdateComponents();
                    graphControl.HighlightIndicatorManager.AddHighlight(subtree.NewParent);
                }
                break;

            case GestureState.Cancelling:
                // make root edge visible
                if (canvasObjectEdge != null)
                {
                    canvasObjectEdge.Visible = true;
                }
                // remove highlight
                if (subtree.NewParent != null)
                {
                    graphControl.HighlightIndicatorManager.RemoveHighlight(subtree.NewParent);
                }
                // reset to original graph layout
                executor = CreateCanceledLayoutExecutor();
                break;

            case GestureState.Finishing:
                // before the last run starts, we have to reparent the subtree
                if (ApplyNewParent())
                {
                    canvasObjectEdge         = graphControl.GraphModelManager.GetCanvasObject(subtree.ParentToRootEdge);
                    canvasObjectEdge.Visible = false;
                }

                // last layout run also includes subtree
                executor = CreateFinishedLayoutExecutor();

                // remove highlight
                if (subtree.NewParent != null)
                {
                    graphControl.HighlightIndicatorManager.RemoveHighlight(subtree.NewParent);
                }
                state = GestureState.Finished;
                break;
            }
        }
        /// <summary>
        /// Creates a <see cref="GivenCoordinatesStageData"/> that store the layout of nodes and edges.
        /// </summary>
        /// <returns>The <see cref="GivenCoordinatesStageData"/>.</returns>
        private GivenCoordinatesStageData CreateGivenCoordinateStageData()
        {
            var data = new GivenCoordinatesStageData();

            foreach (var node in Graph.Nodes)
            {
                data.NodeLocations.Mapper[node] = node.Layout.GetTopLeft();
                data.NodeSizes.Mapper[node]     = node.Layout.GetSize();
            }
            foreach (var edge in Graph.Edges)
            {
                data.EdgePaths.Mapper[edge] = edge.GetPathPoints();
            }
            return(data);
        }
Esempio n. 5
0
        /// <summary>
        /// Creates a <see cref="GivenCoordinatesStageData"/> that stores the layout of nodes and edges.
        /// </summary>
        /// <param name="nodePredicate">Determines the nodes to store.</param>
        /// <param name="edgePredicate">Determines the edges to store.</param>
        /// <returns>The <see cref="GivenCoordinatesStageData"/>.</returns>
        private GivenCoordinatesStageData CreateGivenCoordinatesStageData(Predicate <INode> nodePredicate, Predicate <IEdge> edgePredicate)
        {
            var data = new GivenCoordinatesStageData();

            foreach (var node in Graph.Nodes.Where(n => nodePredicate(n)))
            {
                data.NodeLocations.Mapper[node] = node.Layout.GetTopLeft();
                data.NodeSizes.Mapper[node]     = node.Layout.GetSize();
            }
            foreach (var edge in Graph.Edges.Where(e => edgePredicate(e)))
            {
                data.EdgePaths.Mapper[edge] = edge.GetPathPoints();
            }
            return(data);
        }
Esempio n. 6
0
        /// <summary>
        /// Called after the a layout run finished.
        /// </summary>
        private void OnLayoutFinished()
        {
            switch (state)
            {
            case GestureState.Initializing:
                resetToWorkingGraphStageData = CreateGivenCoordinatesStageData(n => !subtree.Nodes.Contains(n), e => !subtree.Edges.Contains(e));
                executor = CreateDraggingLayoutExecutor();
                state    = GestureState.Dragging;
                break;

            case GestureState.Dragging:
                // check for a new parent candidate
                UpdateNewParent();
                break;

            case GestureState.Finished:
                // make root edge visible
                if (subtree.Parent == subtree.NewParent && canvasObjectEdge != null)
                {
                    canvasObjectEdge.Visible = true;
                }
                break;
            }
        }
 /// <summary>
 /// Prepares the layout execution.
 /// </summary>
 public void InitializeLayout()
 {
     layoutEdit = Graph.BeginEdit("Clear Area", "Clear Area");
     resetToOriginalGraphStageData = CreateGivenCoordinateStageData();
     executor = CreateDraggingLayoutExecutor();
 }
Esempio n. 8
0
 /// <summary>
 /// Prepares the layout execution.
 /// </summary>
 public void InitializeLayout()
 {
     resetToOriginalGraphStageData = CreateGivenCoordinateStageData();
     executor = CreateDraggingLayoutExecutor();
 }
 /// <summary>
 /// Run a layout immediately.
 /// </summary>
 public void LayoutImmediately()
 {
     resetToOriginalGraphStageData = CreateGivenCoordinatesStageData(n => false, e => false);
     state = GestureState.Finishing;
     RunLayout();
 }