private bool HandleSetReplicationGuideText(GraphCommand command)
        {
            uint   nodeId           = (uint)command.GetArgument(0);
            int    replicationIndex = (int)command.GetArgument(1);
            string text             = ((string)command.GetArgument(2));

            VisualNode node = GetVisualNode(nodeId);

            if (node.VisualType != NodeType.Function)
            {
                throw new InvalidOperationException("Node must be FunctionNode");
            }

            DeltaNodes  deltaNodes = new DeltaNodes();
            IVisualNode iNode      = this.GetVisualNode(nodeId);

            deltaNodes.AppendToModifiedNodes(iNode);

            FunctionNode fNode = node as FunctionNode;

            undoRedoRecorder.BeginGroup();
            undoRedoRecorder.RecordNodeModificationForUndo(deltaNodes.ModifiedNodes);
            undoRedoRecorder.EndGroup();
            fNode.SetReplicationText(replicationIndex, text);
            //if(!fNode.SetReplicationText(replicationIndex,text))
            //    undoRedoRecorder.PopRecordFromUndoStorage();
            node.DisableEdit();
            node.Dirty = true;
            node.Compose();
            this.SynchronizeToLiveRunner(deltaNodes);
            return(true);
        }
        public void PreviewSelectComponent(uint componentId, ModifierKeys modifiers)
        {
            IVisualNode selectedNode = null;

            nodeCollection.TryGetValue(componentId, out selectedNode);

            if (selectedNode != null)
            {
                VisualNode node = (VisualNode)selectedNode;

                if (modifiers.HasFlag(ModifierKeys.Control))//toggle
                {
                    node.PreviewSelected = !node.PreviewSelected;
                }
                else
                {
                    node.PreviewSelected = true;
                }

                node.Compose(); // Optionally redraw the node.
            }
            else
            {
                edgeController.PreviewSelectComponent(componentId, modifiers);
            }
        }
        private void OnWarningTimeOut(object sender, EventArgs e)
        {
            VisualNode node = graphController.GetVisualNode(this.OwnerId);

            //Terminate DispatcherTimer
            this.timer.Stop();
            this.timer = null;

            //Clear state
            this.content = null;
            this.ErrType = ErrorType.None;

            //Redraw
            node.Dirty = true;
            node.Compose();
        }
        public void ClearPreviewSelection(uint componentId)
        {
            IVisualNode selectedNode = null;

            nodeCollection.TryGetValue(componentId, out selectedNode);
            VisualNode node = selectedNode as VisualNode;

            if (node != null)
            {
                node.PreviewSelected = node.Selected;
                node.Compose(); // Optionally redraw the node.
            }
            else
            {
                edgeController.ClearPreviewSelection(componentId);
            }
        }
        private bool HandleEndDrag(GraphCommand command)
        {
            MouseButton  button    = ((MouseButton)command.GetArgument(0));
            uint         compId    = ((uint)command.GetArgument(1));
            NodePart     nodePart  = ((NodePart)command.GetArgument(2));
            int          slotIndex = ((int)command.GetArgument(3));
            ModifierKeys modifiers = ((ModifierKeys)command.GetArgument(4));
            double       mouseX    = ((double)command.GetArgument(5));
            double       mouseY    = ((double)command.GetArgument(6));

            switch (currentDragState)
            {
            case DragState.NodeRepositioning:
                foreach (DraggedNode draggedNode in dragSet)
                {
                    ((VisualNode)draggedNode.node).X = mouseX - draggedNode.DeltaX;
                    ((VisualNode)draggedNode.node).Y = mouseY - draggedNode.DeltaY;
                }

                // both node that the edge is connected to should be bring to back
                //
                foreach (VisualNode connectingNode in edgeController.GetNodesFromSelectedEdges())
                {
                    if (!connectingNode.Selected)
                    {
                        RearrangeNodeAndBubbleVisual(connectingNode, false);
                    }
                }

                dragSet.Clear();
                edgeController.ResetAllEdges();
                break;

            case DragState.CurveDrawing:
            case DragState.EdgeReconnection:
                edgeConnection = EdgeConnectionFlag.None;

                VisualNode node = GetVisualNode(edgeController.GetConnectNodeId());
                if (null != node)
                {
                    node.PreviewSelected = node.Selected;
                    node.Compose();     // Optionally redraw the node.
                }
                node = GetVisualNode(edgeController.GetCurrentlySelectedNodeId());
                if (null != node)
                {
                    node.Selected = false;
                    node.Compose();     // reset highlighted node
                }

                node = GetVisualNode(compId);
                List <IVisualNode> modifiedNodes = null;
                edgeConnection = edgeController.AttemptConnectEdge(node, nodePart, slotIndex, out modifiedNodes);

                DeltaNodes deltaNodes = new DeltaNodes();
                deltaNodes.AppendToModifiedNodes(modifiedNodes.Distinct().ToList());

                //reset highlighted node
                foreach (IVisualNode visualNode in deltaNodes.ModifiedNodes)
                {
                    ((VisualNode)visualNode).Selected = false;
                }

                // Start tracking variables being undefined in this process.
                {
                    RuntimeStates runtimeStates = graphProperties.RuntimeStates;
                    runtimeStates.BeginDefinitionMonitor();

                    undoRedoRecorder.BeginGroup();
                    undoRedoRecorder.RecordRuntimeStatesForUndo(runtimeStates);
                    undoRedoRecorder.RecordNodeModificationForUndo(deltaNodes.ModifiedNodes);
                    edgeController.CreateEdge();

                    modifiedNodes.Clear();
                    this.EstablishImplicitConnections(modifiedNodes);
                    undoRedoRecorder.EndGroup();

                    Dictionary <uint, List <string> > undefinedVariables = null;
                    runtimeStates.EndDefinitionMonitor(out undefinedVariables);
                    deltaNodes.AppendUndefinedVariables(undefinedVariables);
                }

                deltaNodes.AppendToModifiedNodes(modifiedNodes);
                if (deltaNodes.ModifiedNodes.Count > 0)      //modification have been done
                {
                    SynchronizeToLiveRunner(deltaNodes);
                }
                else
                {
                    undoRedoRecorder.PopRecordFromUndoStorage();
                }

                edgeController.ResetParameters();
                edgeController.ResetAllEdges();
                currentDragState = DragState.None;
                edgeConnection   = EdgeConnectionFlag.None;
                break;

            case DragState.RegionSelection:
                if (visualHost != null)
                {
                    visualHost.EndDragSelection();
                }
                break;
            }
            //currentDragState = DragState.None;
            selectionBox.UpdateSelectionBox(GetSelectedNodes());
            return(true);
        }
        private bool HandleMouseDown(GraphCommand command)
        {
            MouseButton  button    = ((MouseButton)command.GetArgument(0));
            uint         compId    = ((uint)command.GetArgument(1));
            NodePart     nodePart  = ((NodePart)command.GetArgument(2));
            int          slotIndex = ((int)command.GetArgument(3));
            ModifierKeys modifiers = ((ModifierKeys)command.GetArgument(4));

            if (nodePart != NodePart.None)
            {
                if (IdGenerator.GetType(compId) != ComponentType.Node)
                {
                    throw new InvalidOperationException("Component type mismatch!");
                }
                IVisualNode node = null;
                nodeCollection.TryGetValue(compId, out node);
                if (null == node)
                {
                    throw new ArgumentException("Invalid argument!", "compId");
                }
                VisualNode visualNode = node as VisualNode;

                switch (nodePart)
                {
                case NodePart.North:
                case NodePart.South:
                case NodePart.NorthEast:
                case NodePart.NorthWest:
                case NodePart.PreviewNorthEast:
                case NodePart.Preview:
                    ClearSelectionInternal();
                    RearrangeNodeAndBubbleVisual(visualNode, true);
                    visualNode.Selected = true;
                    break;

                case NodePart.Caption:
                case NodePart.Text:
                case NodePart.ReplicationGuide:
                case NodePart.InputLabel:
                    if (visualNode.Selected)
                    {
                        if (modifiers.HasFlag(ModifierKeys.Control))     //remove the selected node and update the edge
                        {
                            visualNode.Selected = false;
                        }
                    }
                    else
                    {
                        if (!modifiers.HasFlag(ModifierKeys.Control) && !modifiers.HasFlag(ModifierKeys.Shift))
                        {
                            ClearSelectionInternal();
                        }
                        RearrangeNodeAndBubbleVisual(visualNode, true);
                        visualNode.Selected = true;
                    }
                    break;

                case NodePart.InputSlot:
                case NodePart.OutputSlot:
                    break;
                }

                if (null != visualNode)
                {
                    visualNode.Compose(); // Redraw for selection change.
                }
            }

            selectionBox.UpdateSelectionBox(GetSelectedNodes());
            return(true);
        }
        public void SetMouseCursor(uint nodeId, NodePart nodePart, int index, ModifierKeys modifiers, bool isMouseButtonDown, double x, double y)
        {
            if (0 == nodeId)
            {
                // When the UI calls this method, we are only expecting two possible
                // value ranges for 'nodeId': a "uint.MaxValue" when the 'nodeId' is
                // invalid, or a positive number. This should not be zero, if it is,
                // do let me know. - Ben.
                throw new ArgumentException("121B20BE: Invalid argument!", "nodeId");
            }

            if (currentDragState == DragState.NodeRepositioning)
            {
                if (!isMouseButtonDown)
                {
                    return;
                }

                foreach (DraggedNode draggedNode in dragSet)
                {
                    if (visualHost != null)
                    {
                        VisualNode         node      = (VisualNode)draggedNode.node;
                        DrawingVisual      visual    = visualHost.GetDrawingVisualForNode(node.NodeId);
                        TranslateTransform transform = visual.Transform as TranslateTransform;

                        transform.X = x - draggedNode.DeltaX;
                        transform.Y = y - draggedNode.DeltaY;

                        node.X = transform.X;
                        node.Y = transform.Y;

                        this.TransformBubble(node, transform);
                    }
                }
                edgeController.UpdateSelectedEdges();

                selectionBox.UpdateSelectionBox(x, y);
            }
            else if ((currentDragState == DragState.CurveDrawing) || (currentDragState == DragState.EdgeReconnection))
            {
                if (nodePart != NodePart.None && nodeId == uint.MaxValue)
                {
                    throw new InvalidOperationException("Nodepard and NodeId are not in consistent (914C54A64BFD)");
                }

                VisualNode node = null;
                edgeConnection = EdgeConnectionFlag.None;

                if (nodePart != NodePart.None)
                {
                    node = GetVisualNode(nodeId);
                }
                else
                {
                    if (lastHoveredNodeId != uint.MaxValue && lastHoveredNodeId != edgeController.GetCurrentlySelectedNodeId())
                    {
                        node = GetVisualNode(lastHoveredNodeId);
                        node.PreviewSelected = node.Selected;//reset the original state of the node
                        RearrangeNodeAndBubbleVisual(node, false);
                    }
                }
                //verification
                List <IVisualNode> nodeToModify;
                edgeConnection = edgeController.AttemptConnectEdge(node, nodePart, index, out nodeToModify);

                if (nodePart != NodePart.None)
                {
                    if ((edgeConnection == EdgeConnectionFlag.NewEdge || edgeConnection == EdgeConnectionFlag.ReconnectEdge) &&
                        (nodePart == NodePart.InputSlot || nodePart == NodePart.InputLabel || nodePart == NodePart.ReplicationGuide))
                    {
                        node.SetHoveredIndex(index);
                    }

                    node.PreviewSelected = true;
                    RearrangeNodeAndBubbleVisual(node, true);
                }

                if (edgeConnection != EdgeConnectionFlag.None && edgeConnection != EdgeConnectionFlag.Illegal)
                {
                    edgeController.DrawConnectingEdgeTo();
                }
                else
                {
                    edgeController.DrawConnectingEdgeTo(new Point(x, y));
                }

                lastHoveredNodeId = nodeId;
                if (null != node)
                {
                    node.Compose(); // Optionally redraw the node.
                }
            }
        }
        private void CreateNodeInternal(VisualNode node, double x, double y)
        {
            if (null == node)
                throw new ArgumentNullException("node");

            if (CoreComponent.Instance.StudioSettings.SuppressPreview)
                node.SetNodeState(States.PreviewHidden);

            node.X = x;
            node.Y = y;
            node.Compose(); // Just to compute the dimension.

            DeltaNodes deltaNodes = new DeltaNodes();
            deltaNodes.AppendToAddedNodes(node);

            if (node.VisualType != NodeType.CodeBlock)
            {
                bool visualOnlyNode = (node.VisualType == NodeType.Condensed ||
                    (node.VisualType == NodeType.Render));

                this.undoRedoRecorder.BeginGroup();
                this.undoRedoRecorder.RecordRuntimeStatesForUndo(this.graphProperties.RuntimeStates);
                this.undoRedoRecorder.RecordNodeCreationForUndo(deltaNodes.AddedNodes);
                this.graphProperties.RuntimeStates.AddVariablesDefinedInNode(node, false);

                if (false == visualOnlyNode)
                {
                    List<IVisualNode> modifiedNodes = new List<IVisualNode>();
                    EstablishImplicitConnections(modifiedNodes);
                    deltaNodes.AppendToModifiedNodes(modifiedNodes);
                }

                this.undoRedoRecorder.EndGroup();

                if (false == visualOnlyNode)
                    this.SynchronizeToLiveRunner(deltaNodes);
            }

            this.UpdateDirtyNodes();
            node.PositionAtCenter(node.NodeId);
        }