public ProjectCommandWrapper(
ProjectCommandAdapter adapter,
IUndoableCommand<BlockCommandContext> command)
{
Adapter = adapter;
this.command = command;
}
public ProjectCommandWrapper(
ProjectCommandAdapter adapter,
IUndoableCommand <BlockCommandContext> command)
{
Adapter = adapter;
this.command = command;
}
public void Execute(IUndoableCommand command)
{
command.Execute();
_undoStack.Push(command);
_redoStack.Clear();
OnCommandExecuted();
}
public void Undo()
{
if (_history.Count != 0)
{
IUndoableCommand command = _history.Pop();
command.Undo();
}
}
public async Task ExecuteAsync(IUndoableCommand command)
{
await command.ExecuteAsync();
_undoStack.Push(command);
OnCommandExecuted();
}
public void InsertCommand(int index, IUndoableCommand cmd)
{
if (cmd == null)
{
return;
}
_cmdList.Insert(index, cmd);
}
public void Push(IUndoableCommand command)
{
if (_commands.Count >= _maxDepth)
{
_commands.RemoveLast();
}
_commands.AddFirst(command);
}
public void AddCommand(IUndoableCommand cmd)
{
if (cmd == null)
{
return;
}
_cmdList.Add(cmd);
}
public void Undo()
{
if ((commands.Count > 0) && (commands.Peek() is IUndoableCommand))
{
IUndoableCommand command = (IUndoableCommand)commands.Pop();
command.Undo();
}
}
public void Redo()
{
if (this.redoStack.Count > 0)
{
IUndoableCommand command = this.redoStack.Pop();
this.undoStack.Push(command);
command.Redo();
}
}
/// <summary>
/// Undo this instance.
/// </summary>
public void undo()
{
if (_iUndoableCommands.Count > 0)
{
IUndoableCommand toBeRemoved_iundoablecommand = _iUndoableCommands[_iUndoableCommands.Count - 1];
toBeRemoved_iundoablecommand.undo();
_iUndoableCommands.RemoveAt(_iUndoableCommands.Count - 1);
}
}
public IUndoableCommand Pop()
{
if (_commands.First != null)
{
IUndoableCommand first = _commands.First.Value;
_commands.RemoveFirst();
return(first);
}
return(EmptyCommand.GetEmptyCommand());
}
public void ExecuteCommand(IUndoableCommand cmd)
{
if (cmd == null)
{
return;
}
cmd.Execute();
_undoStack.Push(cmd);
}
private void InvokeLDNetworksChangedEvent(IUndoableCommand command)
{
if (command is LadderDiagramReplaceNetworksCommand ||
command is LadderDiagramRemoveNetworksCommand ||
command is LadderDiagramExchangeNetworkCommand ||
command is LadderDiagramMoveNetworkCommand)
{
ldvmodel.InvokeLDNetworksChanged();
}
}
public bool AssertEdit(IUndoableCommand command)
{
if (ldvmodel != null &&
ldvmodel.LadderMode != LadderMode.Edit &&
!(command is NetworkReplaceBreakpointCommand))
{
LocalizedMessageBox.Show(Properties.Resources.Change_Mode, LocalizedMessageIcon.Warning);
return(false);
}
return(true);
}
public void RedoLatest()
{
if (_redoStack.Count == 0)
{
return;
}
IUndoableCommand cmd = _redoStack.Pop();
cmd.Redo();
_undoStack.Push(cmd);
}
private void InitializeSlots()
{
var noCommand = NO_COMMAND;
for (int i = 0; i < _numberOfSlots; i++)
{
_onCommands.Add(noCommand);
_offCommands.Add(noCommand);
}
undoCommand = NO_COMMAND;
}
protected override void Undo(
IUndoableCommand <BlockCommandContext> command,
BlockCommandContext context)
{
// Handle the base operation.
base.Undo(command, context);
// Handle the post operation for the wrapped command.
var wrappedCommand = (IWrappedCommand)command;
wrappedCommand.PostUndo(operationContext);
}
public bool ExecuteCommand(IUndoableCommand command)
{
// Any execution removes all previous undoCommands for redo functionality.
if (undoneCommands.Any())
{
undoneCommands.Clear();
}
commands.Push(command);
return(command.Execute());
}
/// <summary>
/// Internal method for executing a command with a specific context.
/// </summary>
/// <param name="command">The command to execute.</param>
/// <param name="context">The context of the execution.</param>
protected virtual void Do(
IUndoableCommand <TContext> command,
TContext context)
{
// Establish our contracts.
if (command == null)
{
throw new ArgumentNullException("command");
}
// Execute the command and get its state.
command.Do(context);
}
public void Execute(IUndoableCommand command)
{
if (!AssertEdit(command))
{
return;
}
command.Execute();
InvokeLDNetworksChangedEvent(command);
IsModify = true;
if (command is ElementReplaceArgumentCommand &&
!((ElementReplaceArgumentCommand)command).CanUndo)
{
return;
}
UndoStack.Push(command);
RedoStack.Clear();
}
protected override void Do(
object context,
CommandFactoryManager <OperationContext> commandFactory,
object commandData,
OperationContext operationContext,
EditorViewController controller,
IDisplayContext displayContext,
TextPosition position)
{
// If we don't have a selection, this is a simple insert command.
TextPosition bufferPosition = displayContext.Caret.Position;
TextRange selection = displayContext.Caret.Selection;
if (!selection.IsEmpty)
{
// Create and execute the delete command. We do this separately
// so they show up as a different undo item.
IUndoableCommand <OperationContext> deleteCommand =
DeleteSelectionCommandFactory.CreateCommand(controller, displayContext);
controller.CommandController.Do(deleteCommand, operationContext);
// We have to reset the position so the insert happens as if
// the text doesn't exist.
bufferPosition = selection.FirstTextPosition;
operationContext = new OperationContext(
operationContext.LineBuffer, bufferPosition);
}
// Create the insert command using the (potentially) modified selection.
string text = commandData.ToString();
IInsertTextCommand <OperationContext> insertCommand =
controller.CommandController.CreateInsertTextCommand(bufferPosition, text);
insertCommand.UpdateTextPosition = DoTypes.All;
controller.CommandController.Do(insertCommand, operationContext);
// If we have a text position, we need to set it.
if (operationContext.Results.HasValue)
{
displayContext.Caret.SetAndScrollToPosition(
operationContext.Results.Value.TextPosition);
}
}
public void LaunchUndoableCommand(IUndoableCommand command)
{
if (command == null)
{
return;
}
if ((commandStack.Count - 1) > playHead)
{
commandStack.RemoveRange(playHead + 1, (commandStack.Count - 1) - playHead);
}
commandStack.Add(command);
playHead = commandStack.Count - 1;
isEmpty = false;
DoCurrentCommand();
UpdateMenus();
}
public void Undo()
{
if (!CanUndo)
{
return;
}
IUndoableCommand command = _undoStack[_undoStack.Count - 1];
_undoStack.RemoveAt(_undoStack.Count - 1);
if (command != null)
{
command.Undo();
// Add to redo stack
_redoStack.Add(command);
}
}
public void ExecuteCommand(IUndoableCommand command)
{
if (command == null)
{
return;
}
//if undo stack pointer is before the last index of the list, there have been undo actions made
if (_undoStackPointer < _undoStack.Count)
{
//overwrite remaining undo stack
_undoStack = _undoStack.GetRange(0, _undoStackPointer); //<-- undo stack becomes the first N actions, where N is the pointer value (convenient!)
}
command.Execute();
Game.Log(Logging.Category.SONG_DATA, $"Editor command executed: {command.Description}.", Logging.Level.LOG);
_undoStack.Add(command);
_undoStackPointer++;
}
public void Do(IUndoableCommand command, string commandName = "")
{
if (command != null)
{
if (RecordingSessionInProgress)
{
command.Do();
transactionRecords.Peek().CommandsGroup.Commands.Add(command);
}
else
{
command.Do();
redoCommands.Clear();
undoCommands.Push(new CommandRecord {
Command = command, CommandName = commandName
});
OnPropertyChanged(nameof(UndoableCommands));
OnPropertyChanged(nameof(RedoableCommands));
}
}
}
public void Undo(TContext context)
{
// Allow extending class to prepare for the operation.
PreUndo(context);
// To implement the command, simply iterate through the list
// of commands and execute each one. The state comes from the last
// command executed.
IList <IUndoableCommand <TContext> > commands = Commands;
for (int index = commands.Count - 1;
index >= 0;
index--)
{
IUndoableCommand <TContext> command = commands[index];
Undo(command, context);
}
// Allow extending classes to complete the operation.
PostUndo(context);
}
public void BuildCompositeCommandAndPush(IUndoableCommand command)
{
if (command == null)
{
throw new ArgumentNullException();
}
CompositeCommand commandToPush = command as CompositeCommand;
if (commandToPush == null)
{
// If the push command is not CompositeCommand, then build a CompositeCommand
// to hold it as we should change to the page in which target widgets located first when undo/redo
CompositeCommand cmds = new CompositeCommand();
cmds.AddCommand(command);
commandToPush = cmds;
}
ISelectionService selectionService = ServiceLocator.Current.GetInstance <SelectionServiceProvider>();
if (selectionService != null && null != selectionService.GetCurrentPage())
{
// Add change page command in the first item.
commandToPush.InsertCommand(0, new ChangePageCommand());
}
if (_undoStack.Count >= _undoLimit)
{
_undoStack.RemoveAt(0);
}
_undoStack.Add(commandToPush);
Debug.WriteLine("Pushed a IUndoableCommand into undo stack. Undo stack count is : {0}.", _undoStack.Count);
// New command is pushed in, clear the redo stack.
_redoStack.Clear();
}
public void LaunchUndoableCommand(IUndoableCommand command)
{
if (command != null)
{
// Dépiler ce qui est au dessus de la tête de lecture
if ((m_CommandStack.Count - 1) > m_iPlayHead)
{
m_CommandStack.RemoveRange(m_iPlayHead + 1, (m_CommandStack.Count - 1) - m_iPlayHead);
}
//Empiler la commande
m_CommandStack.Add(command);
m_iPlayHead = m_CommandStack.Count - 1;
bIsEmpty = false;
//Executer la commande
DoCurrentCommand();
// Mise à jour du menu
UpdateMenus();
}
}
public bool Execute()
{
if (!IswaitToExecute)
{
return(false);
}
if (commandIndex >= commands.Count)
{
return(false);
}
IswaitToExecute = false;
icommand = commands[commandIndex];
lastCommand = icommand;
if (icommand != null)
{
icommand.Execute();
undoFunctions.Push(icommand.UnDo);
commandIndex++;
}
return(true);
}
private void PushUndo(IUndoableCommand command)
{
UndoableCommands.Add(command);
NotifyPropertyChanged("LastUndoableCommand");
}
/// <summary>
/// Pushes a new command to the stack.
/// </summary>
/// <param name="command">The command to execute within this macro.</param>
public void Push(IUndoableCommand command)
{
_commands.AddLast(command);
}
/// <summary>
/// Adds the command to macro.
/// </summary>
/// <param name="command">The command.</param>
public void AddCommand(IUndoableCommand command)
{
Commands.Add(command);
}
public void SaveCommand(IUndoableCommand command)
{
_history.Push(command);
}
/// <summary>
/// Adds an open command to the OpenCommands list
/// </summary>
/// <param name="command">The command.</param>
public void AddOpenCommand(IUndoableCommand command)
{
OpenCommands.Add(command);
}
public void Log(IUndoableCommand command)
{
if (!replay)
{
PushUndo(command);
RedoableCommands.Clear();
HasUnsavedChanges = true;
}
}