/// <summary>
        /// Default command handler.
        /// </summary>
        /// <param name="graphToolState">The state.</param>
        /// <param name="command">The command.</param>
        public static void DefaultCommandHandler(GraphToolState graphToolState, ItemizeNodeCommand command)
        {
            bool undoPushed = false;

            using (var graphUpdater = graphToolState.GraphViewState.UpdateScope)
            {
                var graphModel = graphToolState.GraphViewState.GraphModel;
                foreach (var model in command.Models.Where(m => m is IVariableNodeModel || m is IConstantNodeModel))
                {
                    var edges = graphModel.GetEdgesConnections(model.OutputPort).ToList();

                    for (var i = 1; i < edges.Count; i++)
                    {
                        if (!undoPushed)
                        {
                            undoPushed = true;
                            graphToolState.PushUndo(command);
                        }

                        var newModel = (ISingleOutputPortNodeModel)graphModel.DuplicateNode(model, i * 50 * Vector2.up);
                        graphUpdater.MarkNew(newModel);
                        var edge          = edges[i];
                        var newEdge       = graphModel.CreateEdge(edge.ToPort, newModel.OutputPort);
                        var deletedModels = graphModel.DeleteEdge(edge);
                        graphUpdater.MarkNew(newEdge);
                        graphUpdater.MarkDeleted(deletedModels);
                    }
                }
            }
        }
        public void ClearSelectionWorks()
        {
            var node1 = new NodeModel();
            var node2 = new NodeModel();

            var viewGuid1 = SerializableGUID.Generate();
            var state     = new GraphToolState(viewGuid1, null);

            using (var selectionUpdater = state.SelectionState.UpdateScope)
            {
                selectionUpdater.ClearSelection(state.WindowState.GraphModel);
                selectionUpdater.SelectElements(new[] { node1, node2 }, true);
            }

            Assert.IsTrue(state.SelectionState.IsSelected(node1));
            Assert.IsTrue(state.SelectionState.IsSelected(node2));

            using (var selectionUpdater = state.SelectionState.UpdateScope)
            {
                selectionUpdater.ClearSelection(state.WindowState.GraphModel);
            }

            Assert.IsFalse(state.SelectionState.IsSelected(node1));
            Assert.IsFalse(state.SelectionState.IsSelected(node2));
        }
        public TracingTimeline(GraphView graphView, GraphToolState windowGraphToolState)
        {
            m_GraphView            = graphView;
            m_WindowGraphToolState = windowGraphToolState;
            m_TimeArea             = new TimeArea();
            m_Overlay = new AnimEditorOverlay()
            {
                PlayHeadColor = new Color(0.2117647F, 0.6039216F, 0.8F)
            };
            m_State         = new TimelineState(m_TimeArea);
            m_Overlay.state = m_State;

            var         debugger = ((Stencil)m_WindowGraphToolState?.WindowState.GraphModel?.Stencil)?.Debugger;
            IGraphTrace trace    = debugger?.GetGraphTrace(m_WindowGraphToolState?.WindowState.GraphModel,
                                                           m_WindowGraphToolState.TracingControlState.CurrentTracingTarget);

            if (trace?.AllFrames != null && trace.AllFrames.Count > 0)
            {
                int firstFrame = trace.AllFrames[0].Frame;
                int lastFrame  = trace.AllFrames[trace.AllFrames.Count - 1].Frame;
                m_TimeArea.SetShownRange(
                    firstFrame - k_MinTimeVisibleOnTheRight,
                    lastFrame + k_MinTimeVisibleOnTheRight);
            }
        }
 public static void DefaultCommandHandler(GraphToolState graphToolState, CommandThatRebuildsAll command)
 {
     using (var updater = graphToolState.GraphViewState.UpdateScope)
     {
         updater.ForceCompleteUpdate();
     }
 }
 public static void DefaultCommandHandler(GraphToolState graphToolState, CommandThatMarksNew command)
 {
     using (var graphUpdater = graphToolState.GraphViewState.UpdateScope)
     {
         var placematModel = graphToolState.GraphViewState.GraphModel.CreatePlacemat(Rect.zero);
         graphUpdater.MarkNew(placematModel);
     }
 }
        public void Setup()
        {
            var prefs = Preferences.CreatePreferences(nameof(SearcherSizeTests));

            m_State = new GraphToolState(new Hash128(), prefs);
            m_State.ResetSearcherSizes();
            m_State.SetInitialSearcherSize(null, k_DefaultSize, k_DefaultRatio);
            m_State.SetInitialSearcherSize(SearcherService.Usage.k_CreateNode, k_CreateNodeDefaultSize, k_CreateNodeDefaultRatio);
        }
 public static void DefaultCommandHandler(GraphToolState graphToolState, CommandThatMarksChanged command)
 {
     using (var graphUpdater = graphToolState.GraphViewState.UpdateScope)
     {
         var placemat = graphToolState.GraphViewState.GraphModel.PlacematModels.FirstOrDefault();
         Debug.Assert(placemat != null);
         graphUpdater.MarkChanged(placemat);
     }
 }
示例#8
0
        public static void DefaultHandler(GraphToolState state, SetTemperatureCommand command)
        {
            state.PushUndo(command);

            using (var graphUpdater = state.GraphViewState.UpdateScope)
            {
                foreach (var nodeModel in command.Models)
                {
                    nodeModel.Temperature = command.Value;
                    graphUpdater.MarkChanged(nodeModel);
                }
            }
        }
示例#9
0
        public static void DefaultHandler(GraphToolState state, RemovePortCommand command)
        {
            state.PushUndo(command);

            using (var graphUpdater = state.GraphViewState.UpdateScope)
            {
                foreach (var nodeModel in command.Models)
                {
                    nodeModel.RemoveIngredientPort();
                    graphUpdater.MarkChanged(nodeModel);
                }
            }
        }
        public void EmptyChangeSetsDoNotDirtyAsset()
        {
            var viewGuid1         = SerializableGUID.Generate();
            var state             = new GraphToolState(viewGuid1, null);
            var initialDirtyCount = EditorUtility.GetDirtyCount(m_Asset1 as Object);

            using (var graphUpdater = state.GraphViewState.UpdateScope)
            {
                graphUpdater.MarkNew(Enumerable.Empty <IGraphElementModel>());
                graphUpdater.MarkChanged(Enumerable.Empty <IGraphElementModel>());
                graphUpdater.MarkDeleted(Enumerable.Empty <IGraphElementModel>());
            }

            Assert.AreEqual(initialDirtyCount, EditorUtility.GetDirtyCount(m_Asset1 as Object));
        }
        public void AllStateComponentsReturnsAllStateComponents()
        {
            var viewGuid1       = SerializableGUID.Generate();
            var state           = new GraphToolState(viewGuid1, null);
            var sc              = new HashSet <IStateComponent>(state.AllStateComponents);
            var foundComponents = new HashSet <IStateComponent>();

            foreach (var fieldInfo in typeof(GraphToolState)
                     .GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)
                     .Where(fi => typeof(IStateComponent).IsAssignableFrom(fi.FieldType))
                     )
            {
                foundComponents.Add(fieldInfo.GetValue(state) as IStateComponent);
                Assert.IsTrue(sc.Contains(fieldInfo.GetValue(state) as IStateComponent), fieldInfo.Name + " is not included in AllStateComponents");
            }

            Assert.AreEqual(sc, foundComponents);
        }
示例#12
0
        public static void DefaultHandler(GraphToolState state, AddPortCommand command)
        {
            if (!command.Models.Any() || command.m_PortDirection == PortDirection.None)
            {
                return;
            }

            state.PushUndo(command);

            using (var updater = state.GraphViewState.UpdateScope)
            {
                foreach (var nodeModel in command.Models)
                {
                    nodeModel.AddPort(command.m_PortOrientation, command.m_PortDirection);
                }

                updater.MarkChanged(command.Models);
            }
        }
        /// <summary>
        /// Default command handler.
        /// </summary>
        /// <param name="graphToolState">The state.</param>
        /// <param name="command">The command.</param>
        public static void DefaultCommandHandler(GraphToolState graphToolState, LockConstantNodeCommand command)
        {
            if (!command.Models.Any())
            {
                return;
            }

            graphToolState.PushUndo(command);

            using (var graphUpdater = graphToolState.GraphViewState.UpdateScope)
            {
                foreach (var constantNodeModel in command.Models)
                {
                    constantNodeModel.IsLocked = command.Value;
                }

                graphUpdater.MarkChanged(command.Models);
            }
        }
        void ClearHighlights(GraphToolState state)
        {
            var currentGraphModel = state?.WindowState.GraphModel;

            currentGraphModel?.DeleteBadgesOfType <DebuggingErrorBadgeModel>();
            currentGraphModel?.DeleteBadgesOfType <DebuggingValueBadgeModel>();

            foreach (Node x in m_GraphView.Nodes.ToList())
            {
                x.RemoveFromClassList(k_TraceHighlight);
                x.RemoveFromClassList(k_TraceSecondaryHighlight);
                x.RemoveFromClassList(k_ExceptionHighlight);

                x.Query <DebuggingPort>().ForEach(p =>
                {
                    p.ExecutionPortActive = false;
                });
            }
        }
示例#15
0
        public static void DefaultCommandHandler(GraphToolState graphToolState, SetNumberOfInputPortCommand command)
        {
            if (!command.Models.Any())
            {
                return;
            }

            graphToolState.PushUndo(command);

            using (var graphUpdater = graphToolState.GraphViewState.UpdateScope)
            {
                foreach (var nodeModel in command.Models)
                {
                    nodeModel.InputPortCount = command.Value;
                    nodeModel.DefineNode();
                }
                graphUpdater.MarkChanged(command.Models);
            }
        }
        public void SelectionStateIsTiedToAssetAndView()
        {
            var node = new NodeModel();

            var viewGuid1 = SerializableGUID.Generate();
            var state     = new GraphToolState(viewGuid1, null);

            state.LoadGraphAsset(m_Asset1, null);
            Assert.IsNotNull(state.SelectionState);
            using (var selectionUpdater = state.SelectionState.UpdateScope)
            {
                selectionUpdater.SelectElements(new[] { node }, true);
            }
            Assert.IsTrue(state.SelectionState.IsSelected(node));

            // Load another asset in the same view: node is not selected anymore.
            var state2 = new GraphToolState(viewGuid1, null);

            state2.LoadGraphAsset(m_Asset2, null);
            var selectionState2 = state2.SelectionState;

            Assert.IsNotNull(selectionState2);
            Assert.IsFalse(selectionState2.IsSelected(node));

            // Load the same asset in the another view: node is not selected anymore.
            var viewGuid2 = SerializableGUID.Generate();

            state2 = new GraphToolState(viewGuid2, null);
            state2.LoadGraphAsset(m_Asset1, null);
            selectionState2 = state2.SelectionState;
            Assert.IsNotNull(selectionState2);
            Assert.IsFalse(selectionState2.IsSelected(node));

            // Reload the same asset in the original view: node is still selected.
            state2 = new GraphToolState(viewGuid1, null);
            state2.LoadGraphAsset(m_Asset1, null);
            selectionState2 = state2.SelectionState;
            Assert.IsNotNull(selectionState2);
            Assert.IsTrue(selectionState2.IsSelected(node));
        }
        /// <summary>
        /// Default command handler.
        /// </summary>
        /// <param name="graphToolState">The state.</param>
        /// <param name="command">The command.</param>
        public static void DefaultCommandHandler(GraphToolState graphToolState, ChangeVariableDeclarationCommand command)
        {
            if (!command.Models.Any())
            {
                return;
            }

            graphToolState.PushUndo(command);

            using (var graphUpdater = graphToolState.GraphViewState.UpdateScope)
            {
                foreach (var model in command.Models)
                {
                    model.DeclarationModel = command.Variable;

                    var references = graphToolState.GraphViewState.GraphModel.FindReferencesInGraph <IVariableNodeModel>(command.Variable);
                    graphUpdater.MarkChanged(references);
                }

                graphUpdater.MarkChanged(command.Models);
            }
        }
        public void MarkChangedHasNoEffectIfModelIsNew()
        {
            var viewGuid1  = SerializableGUID.Generate();
            var state      = new GraphToolState(viewGuid1, null);
            var dummyModel = new TestNodeModel();

            using (var graphUpdater = state.GraphViewState.UpdateScope)
            {
                graphUpdater.MarkNew(dummyModel);
            }

            var changes = state.GraphViewState.GetAggregatedChangeset(0);

            Assert.IsTrue(changes.NewModels.Contains(dummyModel));

            using (var graphUpdater = state.GraphViewState.UpdateScope)
            {
                graphUpdater.MarkChanged(dummyModel);
            }

            changes = state.GraphViewState.GetAggregatedChangeset(0);
            Assert.IsFalse(changes.ChangedModels.Contains(dummyModel));
        }
        internal void MapDebuggingData(GraphToolState state)
        {
            bool needUpdate = false;

            if (m_Stopwatch == null)
            {
                m_Stopwatch = Stopwatch.StartNew();
            }
            else if (EditorApplication.isPaused || m_Stopwatch.ElapsedMilliseconds > k_UpdateIntervalMs)
            {
                needUpdate = true;
                m_Stopwatch.Restart();
            }

            var currentGraphModel = state?.GraphViewState.GraphModel;
            var debugger          = ((Stencil)currentGraphModel?.Stencil)?.Debugger;

            if (state == null || debugger == null)
            {
                return;
            }

            if (needUpdate && debugger.GetTracingSteps(currentGraphModel, state.TracingControlState.CurrentTracingFrame,
                                                       state.TracingControlState.CurrentTracingTarget,
                                                       out var stepList))
            {
                using (var updater = state.TracingDataState.UpdateScope)
                {
                    updater.MaxTracingStep = stepList?.Count ?? 0;
                    updater.DebuggingData  = stepList;
                }

                // PF FIXME HighlightTrace should be an observer on tracing states.
                ClearHighlights(state);
                HighlightTrace(state.TracingControlState.CurrentTracingStep, state.TracingDataState.DebuggingData);
            }
        }
        public void MarkDeletedRemovesModelFromTheChangedList()
        {
            var viewGuid1  = SerializableGUID.Generate();
            var state      = new GraphToolState(viewGuid1, null);
            var dummyModel = new TestNodeModel();

            using (var graphUpdater = state.GraphViewState.UpdateScope)
            {
                graphUpdater.MarkChanged(dummyModel);
            }

            var changes = state.GraphViewState.GetAggregatedChangeset(0);

            Assert.IsTrue(changes.ChangedModels.Contains(dummyModel));

            using (var graphUpdater = state.GraphViewState.UpdateScope)
            {
                graphUpdater.MarkDeleted(dummyModel);
            }

            changes = state.GraphViewState.GetAggregatedChangeset(0);
            Assert.IsFalse(changes.ChangedModels.Contains(dummyModel));
            Assert.IsTrue(changes.DeletedModels.Contains(dummyModel));
        }
        /// <summary>
        /// Default command handler.
        /// </summary>
        /// <param name="graphToolState">The state to modify.</param>
        /// <param name="command">The command to apply to the state.</param>
        public static void DefaultCommandHandler(GraphToolState graphToolState, ConvertConstantNodesAndVariableNodesCommand command)
        {
            if ((command.ConstantNodeModels?.Count ?? 0) == 0 && (command.VariableNodeModels?.Count ?? 0) == 0)
            {
                return;
            }

            graphToolState.PushUndo(command);

            using (var graphUpdater = graphToolState.GraphViewState.UpdateScope)
                using (var selectionUpdater = graphToolState.SelectionState.UpdateScope)
                {
                    var graphModel = graphToolState.GraphViewState.GraphModel;

                    foreach (var constantModel in command.ConstantNodeModels ?? Enumerable.Empty <IConstantNodeModel>())
                    {
                        var declarationModel = graphModel.CreateGraphVariableDeclaration(
                            constantModel.Type.GenerateTypeHandle(),
                            constantModel.Type.FriendlyName().CodifyStringInternal(), ModifierFlags.None, true,
                            constantModel.Value.CloneConstant());
                        graphUpdater.MarkNew(declarationModel);

                        var variableModel = graphModel.CreateVariableNode(declarationModel, constantModel.Position);
                        if (variableModel != null)
                        {
                            graphUpdater.MarkNew(variableModel);
                            selectionUpdater.SelectElement(variableModel, true);

                            variableModel.State = constantModel.State;
                            if (constantModel.HasUserColor)
                            {
                                variableModel.Color = constantModel.Color;
                            }
                            foreach (var edge in graphModel.GetEdgesConnections(constantModel.OutputPort).ToList())
                            {
                                var newEdge       = graphModel.CreateEdge(edge.ToPort, variableModel.OutputPort);
                                var deletedModels = graphModel.DeleteEdge(edge);

                                graphUpdater.MarkNew(newEdge);
                                graphUpdater.MarkDeleted(deletedModels);
                                selectionUpdater.SelectElements(deletedModels, false);
                            }
                        }

                        var deletedElements = graphModel.DeleteNode(constantModel, deleteConnections: false);
                        graphUpdater.MarkDeleted(deletedElements);
                        selectionUpdater.SelectElements(deletedElements, false);
                    }

                    foreach (var variableModel in command.VariableNodeModels ?? Enumerable.Empty <IVariableNodeModel>())
                    {
                        if (graphModel.Stencil.GetConstantNodeValueType(variableModel.GetDataType()) == null)
                        {
                            continue;
                        }
                        var constantModel = graphModel.CreateConstantNode(variableModel.GetDataType(), variableModel.Title, variableModel.Position);
                        constantModel.ObjectValue = variableModel.VariableDeclarationModel?.InitializationModel?.ObjectValue;
                        constantModel.State       = variableModel.State;
                        if (variableModel.HasUserColor)
                        {
                            constantModel.Color = variableModel.Color;
                        }
                        graphUpdater.MarkNew(constantModel);
                        selectionUpdater.SelectElement(constantModel, true);

                        var edgeModels = graphModel.GetEdgesConnections(variableModel.OutputPort).ToList();
                        foreach (var edge in edgeModels)
                        {
                            var newEdge       = graphModel.CreateEdge(edge.ToPort, constantModel.OutputPort);
                            var deletedModels = graphModel.DeleteEdge(edge);
                            graphUpdater.MarkNew(newEdge);
                            graphUpdater.MarkDeleted(deletedModels);
                            selectionUpdater.SelectElements(deletedModels, false);
                        }

                        var deletedElements = graphModel.DeleteNode(variableModel, deleteConnections: false);
                        graphUpdater.MarkDeleted(deletedElements);
                        selectionUpdater.SelectElements(deletedElements, false);
                    }
                }
        }
 public static void DefaultCommandHandler(GraphToolState graphToolState, CommandThatDoesNothing command)
 {
 }