/// <summary>
/// Adds a command to the history without executing it. This is usefull if
/// the command was executed somewhere else but still needs undo/redo.
/// </summary>
/// <param name="currentMover"></param>
public void AddCommand(IUndoable command)
{
_undoStack.AddLast(command);
// Clear the redo stack (it might be empty already) because we just editted.
_redoStack.Clear();
}
void IPropertyValueAggregate.SetValue(object value)
{
// Snag the Undo/Redo system off of the first associated property, so we can put all of these Set values into a macro.
WUndoStack undoStack = null;
if (m_associatedProperties.Count > 0)
{
IUndoable undoableValue = m_associatedProperties[0] as IUndoable;
undoStack = undoableValue.GetUndoStack();
}
if (undoStack != null)
{
undoStack.BeginMacro(string.Format("Set {0}", Name));
}
foreach (var property in m_associatedProperties)
{
property.SetValue(value);
}
if (undoStack != null)
{
undoStack.EndMacro();
}
}
public NodeEditorPanel(IGUI _gui,
EditorWindow _editorWindow,
ConstellationScript _script,
IUndoable _undoable,
ClipBoard _editorClipBoard,
float positionX,
float positionY,
LinkAdded linkAdded,
NodeAdded nodeAdded,
NodeRemoved nodeRemoved)
{
nodesFactory = new NodesFactory();
constellationScript = _script;
undoable = _undoable;
Nodes = new List <NodeView> ();
GUI = _gui;
EditorWindow = _editorWindow;
editorScrollSize = new Vector2(500, 500);
Background = AssetDatabase.LoadAssetAtPath(editorPath + "background.png", typeof(Texture2D)) as Texture2D;
var allNodes = NodesFactory.GetAllNodes();
nodes = new string[allNodes.Length];
editorScrollPos = new Vector2(positionX, positionY);
for (var i = 0; i < allNodes.Length; i++)
{
nodes[i] = allNodes[i];
}
OnLinkAdded += linkAdded;
OnNodeAdded += nodeAdded;
OnNodeRemoved += nodeRemoved;
nodeEditorSelection = new NodeEditorSelection(GUI, _editorClipBoard);
}
/// <summary>
/// Add an action to the top of the undo stack.
/// This operation clears the redo stack.
/// </summary>
/// <param name="action"></param>
public void Add(IUndoable action)
{
undos.Push(action);
redos.Clear();
if (savepoint.HasValue)
{
if (savepoint <= 0)
{
// when adding an undo item, the save point moves away
// further back into the undo stack
// negatives redos means undos are required
savepoint--;
}
else
{
// savepoint is on the redo stack
// redo stack just got cleared
savepoint = null;
}
}
NotifyAllProps();
}
public NodeEditorNodes(EditorWindow _editorWindow,
NodeConfig _nodeConfig,
ConstellationScript _constellationScript,
IUndoable _undoable,
NodeEditorSelection _nodeEditorSelection,
ILinkEditor _linkEditor,
IGUI _gui,
IVisibleObject _visibleObject,
NodeAdded _nodeAdded,
NodeRemoved _nodeRemoved,
HelpClicked _helpClicked)
{
linkEditor = _linkEditor;
editorWindow = _editorWindow;
Nodes = new List <NodeView> ();
nodeConfig = _nodeConfig;
constellationScript = _constellationScript;
isInstance = constellationScript.IsInstance;
nodesFactory = new NodesFactory();
undoable = _undoable;
nodeEditorSelection = _nodeEditorSelection;
GUI = _gui;
visibleObject = _visibleObject;
OnNodeAdded += _nodeAdded;
OnNodeRemoved += _nodeRemoved;
OnHelpClicked += _helpClicked;
SetNodes();
}
public void Redo()
{
if (redoStack.Count == 0)
{
return;
}
IUndoable <T> action = redoStack.Pop();
T obj = action.Redo();
if (ReferenceEquals(action, redoCleanAction))
{
fileIsClean.OnNext(Unit.Default);
}
affectedObject.OnNext(obj);
AddUndoInternal(action);
if (redoStack.Count == 0)
{
NotifyRedoUnavailable();
}
else
{
redoDescription.OnNext(redoStack.Peek().Description);
}
}
/// <summary>
/// Constructor for associating an <see cref="UndoManager"/>
/// with a <see cref="IUndoable"/>. The generalized interface
/// makes it possible to unit test this class separate from
/// <see cref="SrmDocument"/>, though in the running application,
/// it is always managing references to document instances.
/// </summary>
/// <param name="client">Undo state provider</param>
public UndoManager(IUndoable client)
{
_client = client;
_undoStack = new Stack <UndoRecord>();
_redoStack = new Stack <UndoRecord>();
}
public static bool Draw(ILoadable loadable, IUndoable undoable, ICopyable copyable)
{
EditorGUILayout.BeginHorizontal();
if (GUILayout.Button("File", EditorStyles.toolbarButton, GUILayout.Width(35)))
{
GenericMenu menu = new GenericMenu();
menu.AddItem(new GUIContent("New: Ctrl+Atl+N "), false, OnNew, loadable);
menu.AddItem(new GUIContent("Load: Ctrl+Atl+L"), false, OnLoad, loadable);
menu.AddItem(new GUIContent("Save: Ctrl+Atl+S"), false, OnSave, loadable);
menu.ShowAsContext();
return(true);
}
if (GUILayout.Button("Edit", EditorStyles.toolbarButton, GUILayout.Width(35)))
{
GenericMenu menu = new GenericMenu();
menu.AddItem(new GUIContent("Undo: Ctrl+Atl+Z"), false, OnUndo, undoable);
menu.AddItem(new GUIContent("Redo: Ctrl+Atl+Y"), false, OnRedo, undoable);
menu.AddItem(new GUIContent("Copy: Ctrl+Atl+C"), false, Copy, copyable);
menu.AddItem(new GUIContent("Past: Ctrl+Atl+V"), false, Paste, copyable);
menu.ShowAsContext();
return(true);
}
if (GUILayout.Button("View", EditorStyles.toolbarButton, GUILayout.Width(35)))
{
GenericMenu menu = new GenericMenu();
menu.ShowAsContext();
return(true);
}
GUILayout.Label("", EditorStyles.toolbarButton);
EditorGUILayout.EndHorizontal();
return(false);
}
public void Clear()
{
undoCleanAction = null;
redoCleanAction = null;
ClearRedo();
ClearUndo();
}
public void AddInsert(int collectionOwnerId, IUndoable insertedObjectState, int indexAt, string description, int clientId)
{
var insertChange = new Change(ChangeReason.InsertAt, collectionOwnerId, insertedObjectState.Id,
insertedObjectState, indexAt);
_transactionService.Add(insertChange, clientId, description);
}
/// <summary>
/// Adds the specified IUndoable to this UndoableGroup.
/// </summary>
/// <param name="undoable">The IUndoable to add to this UndoableGroup.</param>
protected override void AddUndoable(IUndoable undoable)
{
UndoablePropertyChange currentUndoablePropertyChange = (UndoablePropertyChange)undoable;
int hashCode = this.GetHashCode(currentUndoablePropertyChange);
this.Reset();
UndoablePropertyChange rootUndoablePropertyChange;
if (!this.rootUndoablePropertyChanges.TryGetValue(hashCode, out rootUndoablePropertyChange))
{
rootUndoablePropertyChange = currentUndoablePropertyChange;
this.rootUndoablePropertyChanges.Add(hashCode, currentUndoablePropertyChange);
}
this.rootUndoablePropertyChanges[hashCode] = new UndoablePropertyChange(
rootUndoablePropertyChange.ModelObject,
rootUndoablePropertyChange.PropertyDescriptor.Name,
rootUndoablePropertyChange.OldValue,
currentUndoablePropertyChange.NewValue);
foreach (UndoablePropertyChange undoablePropertyChange in this.rootUndoablePropertyChanges.Values)
{
base.AddUndoable(undoablePropertyChange);
}
}
public void AddRemove(int collectionOwnerId, IUndoable removedObjectState, int indexAt, string description, int clientId)
{
var removeChange = new Change(ChangeReason.RemoveAt, collectionOwnerId, removedObjectState.Id,
removedObjectState, indexAt);
_transactionService.Add(removeChange, clientId, description);
}
/// <summary>
/// Adds a command to the history without executing it. This is usefull if
/// the command was executed somewhere else but still needs undo/redo.
/// </summary>
/// <param name="currentMover"></param>
public void AddCommand(IUndoable command)
{
_undoStack.AddLast(command);
// Clear the redo stack (it might be empty already) because we just editted.
_redoStack.Clear();
}
public DoAction(
ObservableStack <IUndoable> undoableActions, ObservableStack <IUndoable> redoableActions, IUndoable action)
{
_undoableActions = undoableActions;
_redoableActions = redoableActions;
_action = action;
}
/// <summary>
/// Determines whether this UndoableGroup or the CurrentUndoable can contain the specified IUndoable.
/// </summary>
/// <param name="undoable">The IUndoable to check for containability.</param>
/// <returns><c>true</c> if the specified IUndoable can be contained by this UndoableGroup, <c>false</c> otherwise.</returns>
public bool CanContain(IUndoable undoable)
{
if (this.CurrentUndoable != null && this.CurrentUndoable.CanContain(undoable))
{
return(true);
}
return(this.CanContainUndoable(undoable));
}
/// <summary>
/// Determines whether this UndoableGroup can contain the specified IUndoable directly.
/// </summary>
/// <param name="undoable">The IUndoable to check for containability.</param>
/// <returns>
/// <c>true</c> if the specified IUndoable can be contained by this UndoableGroup, <c>false</c> otherwise.
/// </returns>
protected override bool CanContainUndoable(IUndoable undoable)
{
if (DateTime.Now.Subtract(this.lastAddTime) <= groupingTimeout)
{
return(true);
}
return(false);
}
/// <summary>
/// Ctor for update.
/// </summary>
/// <param name="changeReason"></param>
/// <param name="ownerId"></param>
/// <param name="undoObjectState"></param>
/// <param name="redoObjectState"></param>
public Change(int ownerId, IUndoable undoObjectState, IUndoable redoObjectState)
{
UndoObjectState = undoObjectState;
RedoObjectState = redoObjectState;
ChangeReason = ChangeReason.Update;
OwnerId = ownerId;
ItemId = ownerId;
}
/// <summary>
/// Undo the last action.
/// </summary>
public void Undo()
{
if (UndoableActions.Count > 0)
{
IUndoable action = UndoableActions.Pop();
action.Undo();
RedoableActions.Push(action);
}
}
/// <summary>
/// Adds the specified IUndoable to this UndoableGroup if it can be contained.
/// </summary>
/// <param name="undoable">The IUndoable to add to this UndoableGroup.</param>
/// <returns><c>true</c> if the specified IUndoable was added to this UndoableGroup, <c>false</c> otherwise.</returns>
public virtual bool Add(IUndoable undoable)
{
if (this.CanContain(undoable))
{
this.AddUndoable(undoable);
return(true);
}
return(false);
}
/// <summary>
/// Determines whether this UndoableExplicitGroup can contain the specified IUndoable directly.
/// </summary>
/// <param name="undoable">The IUndoable to check for containability.</param>
/// <returns>
/// <c>true</c> if the specified IUndoable can be contained by this UndoableGroup, <c>false</c> otherwise.
/// </returns>
protected override bool CanContainUndoable(IUndoable undoable)
{
if (!base.CanContainUndoable(undoable) || !(undoable is UndoablePropertyChange))
{
return(false);
}
return(true);
}
/// <summary>
/// Redo the last undone action.
/// </summary>
public void Redo()
{
if (RedoableActions.Count > 0)
{
IUndoable action = RedoableActions.Pop();
action.Execute();
UndoableActions.Push(action);
}
}
public DesignerCanvas()
{
string initialStore = this.StoreDiagram().ToString();
this.diagramState = new Undoable <string>(initialStore);
designerItems = new List <DesignerItem>();
//this.CommandBindings.Add(new CommandBinding(ApplicationCommands.New, New_Executed));
//this.CommandBindings.Add(new CommandBinding(ApplicationCommands.Open, Open_Executed));
//this.CommandBindings.Add(new CommandBinding(ApplicationCommands.Save, Save_Executed));
//this.CommandBindings.Add(new CommandBinding(ApplicationCommands.Print, Print_Executed));
this.CommandBindings.Add(new CommandBinding(ApplicationCommands.Cut, Cut_Executed, Cut_Enabled));
this.CommandBindings.Add(new CommandBinding(ApplicationCommands.Copy, Copy_Executed, Copy_Enabled));
this.CommandBindings.Add(new CommandBinding(ApplicationCommands.Paste, Paste_Executed, Paste_Enabled));
this.CommandBindings.Add(new CommandBinding(ApplicationCommands.Delete, Delete_Executed, Delete_Enabled));
this.CommandBindings.Add(new CommandBinding(ApplicationCommands.Undo, Undo_Executed, Undo_Enabled));
this.CommandBindings.Add(new CommandBinding(ApplicationCommands.Redo, Redo_Executed, Redo_Enabled));
this.CommandBindings.Add(new CommandBinding(DesignerCanvas.Group, Group_Executed, Group_Enabled));
this.CommandBindings.Add(new CommandBinding(DesignerCanvas.Ungroup, Ungroup_Executed, Ungroup_Enabled));
this.CommandBindings.Add(new CommandBinding(DesignerCanvas.BringForward, BringForward_Executed, Order_Enabled));
this.CommandBindings.Add(new CommandBinding(DesignerCanvas.BringToFront, BringToFront_Executed, Order_Enabled));
this.CommandBindings.Add(new CommandBinding(DesignerCanvas.SendBackward, SendBackward_Executed, Order_Enabled));
this.CommandBindings.Add(new CommandBinding(DesignerCanvas.SendToBack, SendToBack_Executed, Order_Enabled));
this.CommandBindings.Add(new CommandBinding(DesignerCanvas.AlignTop, AlignTop_Executed, Align_Enabled));
this.CommandBindings.Add(new CommandBinding(DesignerCanvas.AlignVerticalCenters, AlignVerticalCenters_Executed, Align_Enabled));
this.CommandBindings.Add(new CommandBinding(DesignerCanvas.AlignBottom, AlignBottom_Executed, Align_Enabled));
this.CommandBindings.Add(new CommandBinding(DesignerCanvas.AlignLeft, AlignLeft_Executed, Align_Enabled));
this.CommandBindings.Add(new CommandBinding(DesignerCanvas.AlignHorizontalCenters, AlignHorizontalCenters_Executed, Align_Enabled));
this.CommandBindings.Add(new CommandBinding(DesignerCanvas.AlignRight, AlignRight_Executed, Align_Enabled));
this.CommandBindings.Add(new CommandBinding(DesignerCanvas.DistributeHorizontal, DistributeHorizontal_Executed, Distribute_Enabled));
this.CommandBindings.Add(new CommandBinding(DesignerCanvas.DistributeVertical, DistributeVertical_Executed, Distribute_Enabled));
this.CommandBindings.Add(new CommandBinding(DesignerCanvas.SelectAll, SelectAll_Executed));
//this.InputBindings.Add(new KeyBinding(ApplicationCommands.Delete,Key.))
ApplicationCommands.Delete.InputGestures.Add(new KeyGesture(Key.Delete));
SelectAll.InputGestures.Add(new KeyGesture(Key.A, ModifierKeys.Control));
this.AllowDrop = true;
SelectionService.SelectionChanged += () =>
{
if (SelectionChanged != null)
{
SelectionChanged(this, null);
}
OnPropertyChanged("SelectedItems");
OnPropertyChanged("SelectionLayer");
};
this.ConnectionGenerator = (source, sink, pathFinder) => new Connection(source, sink, pathFinder);
this.RequestBringIntoView += DesignerCanvas_RequestBringIntoView;
this.PreviewMouseWheel += DesignerCanvas_PreviewMouseWheel;
}
public void AddUndo(IUndoable <T> action, bool fileDirty)
{
if (!fileDirty)
{
undoCleanAction = action;
}
AddUndoInternal(action);
ClearRedo();
}
/// <summary>
/// 执行撤销操作
/// </summary>
public virtual void Undo(XUndoEventArgs args)
{
for (int iCount = myItems.Count - 1; iCount >= 0; iCount--)
{
IUndoable undo = ( IUndoable )myItems[iCount];
undo.InGroup = true;
undo.Undo(args);
//( ( IUndoable )myItems[ iCount ]).Undo();
}
}
/// <summary>
/// Adds the specified IUndoable to this UndoManager.
/// </summary>
/// <param name="undoable">The IUndoable to add to this UndoManager.</param>
protected override void AddUndoable(IUndoable undoable)
{
// If there is no current undoable or the timeout on the current undoable temporal group has expired,
// create a new undoable temporal group before adding the specified IUndoable
if (this.CurrentUndoable == null || !(this.CurrentUndoable is UndoableTemporalGroup) || !((UndoableTemporalGroup)this.CurrentUndoable).CanContain(undoable))
{
base.AddUndoable(new UndoableTemporalGroup(this.GroupingTimeout));
}
base.AddUndoable(undoable);
}
/// <summary>
/// 添加一个撤销动作对象到列表中
/// </summary>
/// <param name="undo">要添加的撤销动作对象</param>
public void Add(IUndoable undo)
{
if (undo == null || myLogItems == null || myLogItems.Contains(undo))
{
return;
}
if (myLogItems != null)
{
myLogItems.Add(undo);
}
}
private void AddRedo(IUndoable <T> action)
{
redoStack.Push(action);
if (redoStack.Count == 1)
{
redoAvailable.OnNext(true);
}
redoDescription.OnNext(action.Description);
}
private void AddUndoInternal(IUndoable <T> action)
{
undoStack.Push(action);
if (undoStack.Count == 1)
{
undoAvailable.OnNext(true);
}
undoDescription.OnNext(action.Description);
}
/// <summary>
/// Save the current state of the object so that you can revert to it if necessary.
/// </summary>
public void CreateSnapshot()
{
Type currentType;
Hashtable state = new Hashtable();
FieldInfo[] fields;
string fieldName;
_bindingEdit = true;
currentType = this.GetType();
do
{
// Get the member-fields of this type
fields = currentType.GetFields(BindingFlags.Public |
BindingFlags.NonPublic |
BindingFlags.Instance);
foreach (FieldInfo field in fields)
{
// If this field is declared in the current-type, and, it is
// a field that is undoable, then keep track of its state.
if (field.DeclaringType == currentType &&
this.IsUndoableField(field))
{
object fieldValue = field.GetValue(this);
// If the field is an IUndoable type, cascade the call.
IUndoable uf = fieldValue as IUndoable;
if (uf != null)
{
uf.CreateSnapshot();
}
else
{
fieldName = currentType.Name + "." + field.Name;
state.Add(fieldName, fieldValue);
}
}
}
currentType = currentType.BaseType;
} while(currentType != typeof(BusinessObject));
// Now we have saved the complete state of the object in the
// hashtable. We need to stack it into the state-stack.
MemoryStream buffer = new MemoryStream();
BinaryFormatter fmt = new BinaryFormatter();
fmt.Serialize(buffer, state);
_stateStack.Push(buffer.ToArray()); // Stack it as a byte-array
}
// HOW-TO: Request a COM interface
public static void How_to_request_a_COM_interface(IEngine engine)
{
// If a COM object supports multiple interfaces, you can query
// the required interface by casting the object to this interface.
// For example, FlexiCapture documents support undo/redo operations.
// This feature is available through an auxiliary interface IUndoable:
trace("Cast the object to the required interface.");
IDocument document = PrepareNewRecognizedDocument(engine);
IUndoable undoable = document as IUndoable;
}
public void OnRedo(IUndoable data)
{
if (data.Name == "Position")
{
OnPropertyChanged("X");
OnPropertyChanged("Y");
}
else
{
OnPropertyChanged(data.Name);
}
}
public bool Redo()
{
bool result = redoStack.Count > 0;
if (result)
{
IUndoable c = redoStack.Pop();
undoStack.Push(c);
c.Redo();
}
return(result);
}
public void makelike(IUndoable other)
{
/*Layer l2 = (Layer)other;
Items = l2.Items;
treenode.Nodes.Clear();
foreach (Item i in Items)
{
Editor.Instance.addItem(i);
}*/
Level l2 = (Level)other;
Layers = l2.Layers;
treenode.Nodes.Clear();
foreach (Layer l in Layers)
{
Editor.Instance.addLayer(l);
//TODO add all items
}
}
public void AddBuffer(IUndoable undoable)
{
if (CurrentIndex == Undos.Count)
Undos.Add(undoable);
else
{
Undos.RemoveRange(CurrentIndex, Undos.Count - CurrentIndex);
Undos.Add(undoable);
CurrentIndex = Undos.Count;
}
}
/// <summary>
/// Constructor for associating an <see cref="UndoManager"/>
/// with a <see cref="IUndoable"/>. The generalized interface
/// makes it possible to unit test this class separate from
/// <see cref="SrmDocument"/>, though in the running application,
/// it is always managing references to document instances.
/// </summary>
/// <param name="client">Undo state provider</param>
public UndoManager(IUndoable client)
{
_client = client;
_undoStack = new Stack<UndoRecord>();
_redoStack = new Stack<UndoRecord>();
}
public Reverse(IUndoable iud, string name)
{
this.iud = iud;
this.name = name;
}
/// <summary>
/// Executes a command and adds it to the command history so it can
/// be undone/redone.
/// </summary>
/// <param name="command">The command to execute and keep history of.</param>
public void Execute(IUndoable command)
{
command.Do();
AddCommand(command);
}
public Reverse(IUndoable iud)
{
this.iud = iud;
this.name = iud.Name;
}
