/// <summary> /// Sets the value of the component to a different value. /// </summary> /// <param name="component"> /// The component with the property value that is to be set. /// </param> /// <param name="value">The new value.</param> public override void SetValue(object component, object value) { UndoRedoWrapper owner = component as UndoRedoWrapper; if (owner == null) { parent.SetValue(component, value); } else if (!owner.CanRun) { throw new InvalidOperationException(); } else { MethodInfo undoRedoSetter = UndoRedoMethodInfo; if (undoRedoSetter != null) { owner.UndoRedoManager.Run(new MethodAction(owner, this, value)); } else { IAction action = owner.CreateAction(this, value); if (action != null) { owner.UndoRedoManager.Run(action); } } } }
/// <summary> /// Creates new instance of the T object. /// </summary> /// <returns>New T instance.</returns> protected virtual T OnCreateNew() { AddingNewEventHandler eventHandler = AddingNew; if (eventHandler == null) { if (default(T) == null) { return(Activator.CreateInstance <T>()); } else { return(default(T)); } } AddingNewEventArgs eventArgs = new AddingNewEventArgs(); eventHandler(this, eventArgs); if (eventArgs.NewObject == null) { return(Activator.CreateInstance <T>()); } UndoRedoWrapper wrapper = eventArgs.NewObject as UndoRedoWrapper; if (wrapper != null) { return((T)wrapper.Instance); } return((T)eventArgs.NewObject); }
object IBindingList.AddNew() { UndoRedoWrapper item = CreateItem(); this.Add(item); return(item); }
/// <summary> /// Converts instance of UndoRedoWrapper into instance of T. /// </summary> /// <param name="t">Instance of UndoRedoWrapper type.</param> /// <returns>Instance of T type.</returns> protected override T Convert(UndoRedoWrapper t) { if (t == null) { return(default(T)); } return(((UndoRedoItem)t).Instance); }
/// <summary> /// Creates an instance of the ActionEventArgs. /// </summary> /// <param name="undoRedoManager"> /// An instance of undo and redo manager that runs an action. /// </param> /// <param name="type">Action type.</param> /// <param name="instance">Instance, which is a subject of the action.</param> /// <param name="value">Optional action value.</param> public ActionEventArgs( UndoRedoManager undoRedoManager, ActionType type, UndoRedoWrapper instance, object value) { this.undoRedoManager = undoRedoManager; this.type = type; this.instance = instance; this.value = value; this.result = true; }
/// <summary> /// Tests if two instances are equal. /// </summary> /// <param name="obj">Instance to compare with.</param> /// <returns>true if instances are equal, and false otherwise.</returns> public override bool Equals(object obj) { if (this == obj) { return(true); } UndoRedoWrapper that = obj as UndoRedoWrapper; if (that == null) { return(false); } return(Instance.Equals(that.Instance)); }
/// <summary> /// Creates an instance of the Action. /// </summary> /// <param name="owner">Owner type.</param> /// <param name="property">Property to change.</param> /// <param name="value">Value of the property.</param> public Action( UndoRedoWrapper owner, UndoRedoProperty property, object value) { if (owner == null) { throw new ArgumentNullException("owner"); } if (property == null) { throw new ArgumentNullException("property"); } this.owner = owner; this.property = property; this.value = value; }
public MethodAction(UndoRedoWrapper owner, UndoRedoProperty property, object value) { this.owner = owner; this.property = property; this.value = value; }
/// <summary> /// Enables other objects to be notified when this property changes. /// </summary> /// <param name="component">The component to remove the handler for.</param> /// <param name="handler">The delegate to remove as a listener.</param> public override void RemoveValueChanged(object component, EventHandler handler) { UndoRedoWrapper owner = component as UndoRedoWrapper; parent.RemoveValueChanged(owner != null ? owner.Instance : component, handler); }
/// <summary> /// Determines a value indicating whether the value of this property needs /// to be persisted. /// </summary> /// <param name="component"> /// The component with the property to be examined for persistence. /// </param> /// <returns>true if the property should be persisted and false otherwise.</returns> public override bool ShouldSerializeValue(object component) { UndoRedoWrapper owner = component as UndoRedoWrapper; return(parent.ShouldSerializeValue(owner != null ? owner.Instance : component)); }
/// <summary> /// Gets the current value of the property on a component. /// </summary> /// <param name="component"> /// The component with the property for which to retrieve the value. /// </param> /// <returns>The value of a property for a given component.</returns> public override object GetValue(object component) { UndoRedoWrapper owner = component as UndoRedoWrapper; return(parent.GetValue(owner != null ? owner.Instance : component)); }