public DynamoNodeButton(ModelBase model, string eventName)
     : this()
 {
     this.model = model;
     this.eventName = eventName;
     Click += OnDynamoNodeButtonClick;
 }

        internal void RecordCreatedModel(ModelBase model)
        {
            if (null == model) return;

            using (undoRecorder.BeginActionGroup())
            {
                undoRecorder.RecordCreationForUndo(model);
            }
        }

 // 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);
     }
 }

        private void UpdatePythonNodeContent(ModelBase pythonNode, string value)
        {
            var command = new DynCmd.UpdateModelValueCommand(
                System.Guid.Empty, pythonNode.GUID, "ScriptContent", value);

            ViewModel.ExecuteCommand(command);
        }

        private void UpdatePythonNodeContent(ModelBase pythonNode, string value)
        {
            var command = new DynCmd.UpdateModelValueCommand(
                pythonNode.GUID, "ScriptContent", value);

            dynSettings.Controller.DynamoViewModel.ExecuteCommand(command);
        }

 internal void RecordCreatedModel(ModelBase model)
 {
     if (null != model)
     {
         undoRecorder.BeginActionGroup();
         undoRecorder.RecordCreationForUndo(model);
         undoRecorder.EndActionGroup();
     }
 }

 public ModelEventArgs(ModelBase model)
     : this(model, false)
 {
 }

 /// <summary>
 /// This is called when a model is deleted from a group
 /// and UNDO is clicked.
 /// </summary>
 /// <param name="model">The model.</param>
 /// <param name="checkOverlap"> checkoverlap determines whether the selected model is 
 /// completely inside that group</param>
 internal void AddToSelectedModels(ModelBase model, bool checkOverlap = false)
 {           
     var list = this.SelectedModels.ToList();
     if (list.Where(x => x.GUID == model.GUID).Any()) return;
     if (!CheckModelIsInsideGroup(model, checkOverlap)) return;           
     list.Add(model);
     this.SelectedModels = list;
     this.UpdateBoundaryFromSelection();
 }

        private void RecordActionInternal(XmlElement group, ModelBase model, UserAction action)
        {
            if (IsRecordedInActionGroup(group, model))
                return;

            // Serialize the affected model into xml representation
            // and store it under the current action group.
            XmlNode childNode = model.Serialize(document, SaveContext.Undo);
            SetNodeAction(childNode, action.ToString());
            group.AppendChild(childNode);
        }

        /// <summary>
        /// The recorder calls this method to determine if a given model has 
        /// already been recorded in the active action group. For an example,
        /// if there is a connection between NodeA and NodeB, selecting both 
        /// the nodes and deleting them will cause the connection model to be 
        /// recorded twice (when a node is deleted, its connections are being 
        /// recorded for undo).
        /// </summary>
        /// <param name="group">The action group to check against.</param>
        /// <param name="model">The model to check against.</param>
        /// <returns>Returns true if the model has already been recorded in the
        /// current action group, or false otherwise.</returns>
        private bool IsRecordedInActionGroup(XmlElement group, ModelBase model)
        {
            if (null == group)
                throw new ArgumentNullException("group");
            if (null == model)
                throw new ArgumentNullException("model");

            Guid guid = model.GUID;
            foreach (XmlNode childNode in group.ChildNodes)
            {
                // See if the model supports Guid identification, in unit test cases 
                // those sample models do not support this so in such cases identity 
                // check will not be performed.
                // 
                XmlAttribute guidAttribute = childNode.Attributes["guid"];
                if (null != guidAttribute && (guid == Guid.Parse(guidAttribute.Value)))
                    return true; // This model was found to be recorded.
            }

            return false;
        }

        /// <summary>
        /// Record the given model right before it is modified. This results
        /// in a modification action to be recorded under the current action 
        /// group. Undoing this action will result in the model being reverted
        /// to the states that it was in before the modification took place.
        /// </summary>
        /// <param name="model">The model to be recorded.</param>
        public void RecordModificationForUndo(ModelBase model)
        {
            RecordActionInternal(currentActionGroup,
                model, UserAction.Modification);

            redoStack.Clear(); // Wipe out the redo-stack.
        }

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

 public void RemoveGroup(ModelBase model)
 {
     var annotation = model as AnnotationModel;
     RemoveAnnotation(annotation);
     annotation.Dispose();
 }

 public ModelModificationUndoHelper(UndoRedoRecorder recorder, ModelBase model)
     : this(recorder, new [] { model })
 {
 }

 /// <summary>
 /// Recalculate the group when a node is disposed
 /// </summary>
 /// <param name="node">The node.</param>
 private void model_Disposed(ModelBase model)
 {
     var modelList = this.SelectedModels.ToList();
     bool remove = modelList.Remove(model);
     if (remove)
     {
         DeletedModelBases.Add(model);
         SelectedModels = modelList;
         UpdateBoundaryFromSelection();
     }
 }

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

 private bool CheckModelIsInsideGroup(ModelBase model, bool checkOverlap)
 {
     if (!checkOverlap) return true;
     var modelRect = model.Rect;
     if (this.Rect.Contains(modelRect))
     {
         return true;
     }
     return false;
 }

        /// <summary>
        /// Record the given model right before it has been deleted. This 
        /// results in a deletion action to be recorded under the current action 
        /// group. Undoing this action will result in the model being created 
        /// and re-inserted into the current workspace.
        /// </summary>
        /// <param name="model">The model to be recorded.</param>
        public void RecordDeletionForUndo(ModelBase model)
        {
            RecordActionInternal(this.currentActionGroup,
                model, UserAction.Deletion);

            this.redoStack.Clear(); // Wipe out the redo-stack.
        }