C# Core.UndoRedoRecorder类代码示例

        protected WorkspaceModel(
            String name, IEnumerable<NodeModel> e, IEnumerable<ConnectorModel> c, double x, double y)
        {
            Name = name;

            Nodes = new TrulyObservableCollection<NodeModel>(e);
            Connectors = new TrulyObservableCollection<ConnectorModel>(c);
            Notes = new ObservableCollection<NoteModel>();
            X = x;
            Y = y;

            HasUnsavedChanges = false;
            LastSaved = DateTime.Now;

            WorkspaceSaved += OnWorkspaceSaved;
            WorkspaceVersion = AssemblyHelper.GetDynamoVersion();
            undoRecorder = new UndoRedoRecorder(this);
        }

        private void CommitChanges(UndoRedoRecorder recorder)
        {
            // Code block editor can lose focus in many scenarios (e.g. switching 
            // of tabs or application), if there has not been any changes, do not
            // commit the change.
            // 
            if (!codeBlockNode.Code.Equals(InnerTextEditor.Text))
            {
                UpdateNodeValue("Code");
            }

            if (createdForNewCodeBlock)
            {
                // If this editing was started due to a new code block node, 
                // then by this point there would have been two action groups 
                // recorded on the undo-stack: one for node creation, and 
                // another for node editing (as part of ExecuteCommand above).
                // Pop off the two action groups...
                // 
                recorder.PopFromUndoGroup(); // Pop off modification action.

                // Note that due to various external factors a code block node 
                // loaded from file may be created empty. In such cases, the 
                // creation step would not have been recorded (there was no 
                // explicit creation of the node, it was created from loading 
                // of a file), and nothing should be popped off of the undo stack.
                if (recorder.CanUndo)
                    recorder.PopFromUndoGroup(); // Pop off creation action.

                // ... and record this new node as new creation.
                using (recorder.BeginActionGroup())
                {
                    recorder.RecordCreationForUndo(codeBlockNode);
                }
            }
        }

 internal override bool HandleModelEventCore(string eventName, int value, UndoRedoRecorder recorder)
 {
     return VariableInputController.HandleModelEventCore(eventName, value, recorder)
         || base.HandleModelEventCore(eventName, value, recorder);
 }

 internal DummyWorkspace()
 {
     undoRecorder = new UndoRedoRecorder(this);
 }

 public void TestConstructor()
 {
     Assert.Throws<ArgumentNullException>(() =>
     {
         UndoRedoRecorder temp = new UndoRedoRecorder(null);
     });
 }

        private void DiscardChangesAndOptionallyRemoveNode(UndoRedoRecorder recorder)
        {
            if (!string.IsNullOrEmpty(InnerTextEditor.Text))
            {
                throw new InvalidOperationException(
                    "This method is meant only for empty text box");
            }

            if (createdForNewCodeBlock)
            {
                // If this editing was started due to a new code block node, 
                // then by this point the creation of the node would have been 
                // recorded, we need to pop that off the undo stack. Note that 
                // due to various external factors a code block node loaded 
                // from file may be created empty. In such cases, the creation 
                // step would not have been recorded (there was no explicit 
                // creation of the node, it was created from loading of a file),
                // and nothing should be popped off of the undo stack.
                // 
                if (recorder.CanUndo)
                    recorder.PopFromUndoGroup(); // Pop off creation action.               
            }
            else
            {
                // If the editing was started for an existing code block node,
                // and user deletes the text contents, it should be restored to 
                // the original codes.
                InnerTextEditor.Text = nodeModel.Code;               
            }
        }

        internal static void RecordModelsForUndo(Dictionary<ModelBase, UndoRedoRecorder.UserAction> models, UndoRedoRecorder recorder)
        {
            if (null == recorder)
                return;
            if (!ShouldProceedWithRecording(models))
                return;

            using (recorder.BeginActionGroup())
            {
                foreach (var modelPair in models)
                {
                    switch (modelPair.Value)
                    {
                        case UndoRedoRecorder.UserAction.Creation:
                            recorder.RecordCreationForUndo(modelPair.Key);
                            break;
                        case UndoRedoRecorder.UserAction.Deletion:
                            recorder.RecordDeletionForUndo(modelPair.Key);
                            break;
                        case UndoRedoRecorder.UserAction.Modification:
                            recorder.RecordModificationForUndo(modelPair.Key);
                            break;
                    }
                }
            }
        }

 // See RecordModelsForModification below for more details.
 internal static void RecordModelForModification(ModelBase model, UndoRedoRecorder recorder)
 {
     if (null != model)
     {
         var models = new List<ModelBase> { model };
         RecordModelsForModification(models, recorder);
     }
 }

        internal bool HandleModelEventCore(string eventName, UndoRedoRecorder recorder)
        {
            if (eventName == "AddInPort")
            {
                AddInputToModel();
                model.RegisterAllPorts();
                return true; // Handled here.
            }

            if (eventName == "RemoveInPort")
            {
                RemoveInputFromModel();
                model.RegisterAllPorts();
                return true; // Handled here.
            }

            return false; // base.HandleModelEventCore(eventName);
        }

            public ModelModificationUndoHelper(UndoRedoRecorder recorder, IEnumerable<ModelBase> models)
            {
                this.recorder = recorder;

                this.models = new List<ModelBase>(models);
                existingConnectors = new Dictionary<Guid, XmlElement>();
                remainingConnectors = new Dictionary<Guid, ConnectorModel>();

                var allConnectors = new List<ConnectorModel>();
                using (this.recorder.BeginActionGroup())
                {
                    // Assuming no connectors will be modified as part of this, we 
                    // record the node prior to it being modified. If for some 
                    // reason connectors are dropped/created along the way, then 
                    // this particular action group will be pop off the undo stack.
                    // 
                    foreach (var model in this.models)
                    {
                        var nodeModel = model as NodeModel;
                        if (nodeModel != null)
                            allConnectors.AddRange(nodeModel.AllConnectors);

                        this.recorder.RecordModificationForUndo(model);
                    }
                }

                // Record the existing connectors...
                foreach (var connectorModel in allConnectors)
                {
                    var element = connectorModel.Serialize(
                        recorder.document, SaveContext.Undo);

                    existingConnectors[connectorModel.GUID] = element;
                }
            }

 public ActionGroupDisposable(UndoRedoRecorder recorder)
 {
     this.recorder = recorder;
 }

 /// <summary>
 /// This method is currently used as a way to send an event to ModelBase
 /// derived objects. Its primary use is in DynamoNodeButton class, which
 /// sends this event when clicked, to change the number of ports in a
 /// VariableInputNode.
 /// </summary>
 /// <param name="eventName">The name of the event.</param>
 /// <param name="value">For the SetInPortCount event, the number of
 /// ports desired.  Ignored for other events.</param>
 /// <param name="recorder"></param>
 /// <returns>Returns true if the call has been handled, or false otherwise.
 /// </returns>
 internal bool HandleModelEvent(string eventName, int value, UndoRedoRecorder recorder)
 {
     return HandleModelEventCore(eventName, value, recorder);
 }

        private void RecordModels(UndoRedoRecorder recorder)
        {
            if (model.InPorts.Count == 0)
                return;

            var connectors = model.InPorts.Last().Connectors;
            if (connectors.Count != 0)
            {
                if (connectors.Count != 1)
                {
                    throw new InvalidOperationException(
                        "There should be only one connection to an input port");
                }
                var models = new Dictionary<ModelBase, UndoRedoRecorder.UserAction>
                {
                    { connectors[0], UndoRedoRecorder.UserAction.Deletion },
                    { model, UndoRedoRecorder.UserAction.Modification }
                };
                WorkspaceModel.RecordModelsForUndo(models, recorder);
            }
            else
                WorkspaceModel.RecordModelForModification(model, recorder);
        }

 /// <summary>
 /// This method is currently used as a way to send an event to ModelBase 
 /// derived objects. Its primary use is in DynamoNodeButton class, which 
 /// sends this event when clicked.
 /// </summary>
 /// <param name="eventName">The name of the event.</param>
 /// <param name="recorder"></param>
 /// <returns>Returns true if the call has been handled, or false otherwise.
 /// </returns>
 public bool HandleModelEvent(string eventName, UndoRedoRecorder recorder)
 {
     return HandleModelEventCore(eventName, recorder);
 }

        /// <summary>
        /// TODO(Ben): This method is exposed this way for external codes (e.g. 
        /// the DragCanvas) to record models before they are modified. This is 
        /// by no means ideal. The ideal case of course is for ALL codes that 
        /// end up modifying models to be folded back into WorkspaceViewModel in 
        /// the form of commands. These commands then internally record those
        /// affected models before updating them. We need this method to be gone
        /// sooner than later.
        /// </summary>
        /// <param name="models">The models to be recorded for undo.</param>
        /// <param name="recorder"></param>
        internal static void RecordModelsForModification(List<ModelBase> models, UndoRedoRecorder recorder)
        {
            if (null == recorder)
                return;
            if (!ShouldProceedWithRecording(models))
                return;

            using (recorder.BeginActionGroup())
            {
                foreach (var model in models)
                    recorder.RecordModificationForUndo(model);
            }
        }