public void CanRedoWithHistoryWithoutRollForward()
{
var history = new Mock<ITimeline>();
{
history.Setup(h => h.CanRollForward)
.Returns(false);
}
var project = new Mock<IProject>();
{
project.Setup(p => p.History)
.Returns(history.Object);
}
var projectFacade = new ProjectFacade(project.Object);
var projectLink = new Mock<ILinkToProjects>();
{
projectLink.Setup(p => p.ActiveProject())
.Returns(projectFacade);
}
Func<string, IDisposable> timerFunc = s => new MockDisposable();
var command = new RedoCommand(projectLink.Object, timerFunc);
Assert.IsFalse(command.CanExecute(null));
}
private void ExecuteUndoCommand(object parameter)
{
txt.Text = "Undo Command executed";
_canExecuteUndo = false;
_canExecuteRedo = true;
UndoCommand.RaiseCanExecuteChanged();
RedoCommand.RaiseCanExecuteChanged();
}
/// <summary>
/// Updates UI bound to the view model properties.
/// </summary>
private void UpdateView()
{
SyncModelProperties();
UpdateBoard();
UndoCommand.RaiseCanExecuteChanged();
RedoCommand.RaiseCanExecuteChanged();
MoveCommand.RaiseCanExecuteChanged();
}
/// <summary>
/// Creates controller for a model
/// </summary>
/// <param name="model">associated model</param>
/// <param name="project">associated project</param>
public ModelController(Model.Model model, Project project)
{
Model = model;
Project = project;
UndoCommand = new UndoCommand(getUndoStack(), this);
RedoCommand = new RedoCommand(getRedoStack(), this);
}
private void UpdateModelValueImpl(UpdateModelValueCommand command)
{
CurrentSpace.UpdateModelValue(command.ModelGuid,
command.Name, command.Value);
UndoCommand.RaiseCanExecuteChanged();
RedoCommand.RaiseCanExecuteChanged();
}
private void ConvertNodesToCodeImpl(ConvertNodesToCodeCommand command)
{
CurrentSpace.ConvertNodesToCodeInternal(command.NodeId);
UndoCommand.RaiseCanExecuteChanged();
RedoCommand.RaiseCanExecuteChanged();
CurrentSpace.HasUnsavedChanges = true;
}
public CommandManager()
{
commandQueue = new LinkedList <Command>();
undoStack = new LinkedList <Command>();
redoStack = new LinkedList <Command>();
undoCommand = new UndoCommand(this);
redoCommand = new RedoCommand(this);
}
public void SetComposition(Composition composition)
{
var lilypondText = LilypondFactory.GetLilypond(composition);
LilypondTextLoaded(lilypondText);
UndoCommand.RaiseCanExecuteChanged();
RedoCommand.RaiseCanExecuteChanged();
}
private void CreateNoteImpl(CreateNoteCommand command)
{
NoteModel noteModel = Model.AddNoteInternal(command, null);
CurrentSpace.RecordCreatedModel(noteModel);
UndoCommand.RaiseCanExecuteChanged();
RedoCommand.RaiseCanExecuteChanged();
}
public CommandManager()
{
commandQueue = new LinkedList<Command>();
undoStack = new LinkedList<Command>();
redoStack = new LinkedList<Command>();
undoCommand = new UndoCommand(this);
redoCommand = new RedoCommand(this);
}
private void UpdateCommands()
{
RemoveImageCommand.RaiseCanExecuteChanged();
SaveCommand.RaiseCanExecuteChanged();
RedoCommand.RaiseCanExecuteChanged();
UndoCommand.RaiseCanExecuteChanged();
RemoveBackgroundCommand.RaiseCanExecuteChanged();
RemoveOverlayCommand.RaiseCanExecuteChanged();
}
public void LilypondTextLoaded(string text)
{
_textChangedByLoad = true;
_caretaker.reset();
LilypondText = text;
_caretaker.change();
UndoCommand.RaiseCanExecuteChanged();
RedoCommand.RaiseCanExecuteChanged();
_textChangedByLoad = false;
}
private void OnLevelPropertyChanged(Object sender, PropertyChangedEventArgs e)
{
if ("CanUndo".Equals(e.PropertyName))
{
UndoCommand.RaiseCanExecuteChanged();
}
else if ("CanRedo".Equals(e.PropertyName))
{
RedoCommand.RaiseCanExecuteChanged();
}
}
private void UndoRedoManagerOnPropertyChanged(object sender, PropertyChangedEventArgs args)
{
if (args.IsProperty<UndoRedoManager>(i => i.CanUndo))
{
UndoCommand.RaiseCanExecuteChanged();
SaveDocumentCommand.RaiseCanExecuteChanged();
SaveDocumentAsCommand.RaiseCanExecuteChanged();
}
if (args.IsProperty<UndoRedoManager>(i => i.CanRedo))
RedoCommand.RaiseCanExecuteChanged();
}
private void CreateNoteImpl(CreateNoteCommand command)
{
NoteModel noteModel = Model.CurrentWorkspace.AddNote(
command.DefaultPosition,
command.X,
command.Y,
command.NoteText,
command.NodeId);
CurrentSpace.RecordCreatedModel(noteModel);
UndoCommand.RaiseCanExecuteChanged();
RedoCommand.RaiseCanExecuteChanged();
}
private void UndoRedoImpl(UndoRedoCommand command)
{
if (command.CmdOperation == UndoRedoCommand.Operation.Undo)
{
CurrentSpace.Undo();
}
else if (command.CmdOperation == UndoRedoCommand.Operation.Redo)
{
CurrentSpace.Redo();
}
UndoCommand.RaiseCanExecuteChanged();
RedoCommand.RaiseCanExecuteChanged();
}
//Summary
// Commit changes to data source, after commit, clear undo/redo list
public void Commit()
{
_selectedVertices.Clear();
_operations.Clear();
_operationsRedo.Clear();
UndoCommand.RaiseCanExecuteChanged();
RedoCommand.RaiseCanExecuteChanged();
HasChange = false;
IsInEditing = false;
PostStatusMessage("Ready");
}
private void OnIsActiveChanged()
{
SaveCommand.RaiseCanExecuteChanged();
CompileCommand.IsActive = IsActive;
CompileCommand.RaiseCanExecuteChanged();
RedoCommand.IsActive = IsActive;
RedoCommand.RaiseCanExecuteChanged();
UndoCommand.IsActive = IsActive;
UndoCommand.RaiseCanExecuteChanged();
IsActiveChanged?.Invoke(this, new EventArgs());
}
private void CreateNodeImpl(CreateNodeCommand command)
{
NodeModel nodeModel = CurrentSpace.AddNode(
command.NodeId,
command.NodeName,
command.X,
command.Y,
command.DefaultPosition,
command.TransformCoordinates);
CurrentSpace.RecordCreatedModel(nodeModel);
UndoCommand.RaiseCanExecuteChanged();
RedoCommand.RaiseCanExecuteChanged();
}
public MainWindowVm()
{
NetworkVm = new NetworkViewModel(OperationController);
// Undo Command
UndoCommand =
OperationController
.StackChangedAsObservable()
.Select(x => OperationController.CanUndo)
.ToReactiveCommand();
UndoCommand.Subscribe(OperationController.Undo);
//! Redo Command
RedoCommand =
OperationController
.StackChangedAsObservable()
.Select(x => OperationController.CanRedo)
.ToReactiveCommand();
RedoCommand.Subscribe(OperationController.Redo);
//! Undo / Redoが行われたときに Undo / Redo ViewModelを生成する
OperationController.StackChangedAsObservable().Subscribe(_ =>
{
Operations = OperationController
.Operations.Concat(OperationController.RollForwardTargets)
.Select(x => new OperationVm(x, OperationController))
.ToObservableCollection();
RaisePropertyChanged(nameof(Operations));
}).AddTo(CompositeDisposable);
SelectedOperation = new ReactiveProperty <OperationVm>().AddTo(CompositeDisposable);
SelectedOperation
.Where(x => x != null)
.Subscribe(x => x.GotoCommand?.Execute(null))
.AddTo(CompositeDisposable);
RefreshViewModelCommand = new ReactiveCommand().AddTo(CompositeDisposable);
RefreshViewModelCommand.Subscribe(
() =>
{
OperationController.Flush();
NetworkVm = new NetworkViewModel(OperationController);
RaisePropertyChanged(nameof(NetworkVm));
}).AddTo(CompositeDisposable);
}
private void RedoUndoModel_PropertyChanged(object sender, PropertyChangedEventArgs e)
{
switch (e.PropertyName)
{
case "CanRedoOneStep":
RedoCommand.RaiseCanExecuteChanged();
break;
case "CanUndoOneStep":
UndoCommand.RaiseCanExecuteChanged();
break;
default:
break;
}
}
public void DisplayTest()
{
Document doc = new Document();
DocumentCommand discmd = new DisplayCommand(doc);
DocumentCommand undcmd = new UndoCommand(doc);
DocumentCommand redcmd = new RedoCommand(doc);
DocumentInvoker invoker = new DocumentInvoker(discmd, undcmd, redcmd);
invoker.Display();
}
public HomeVM(User loggedInUser, Window view)
{
//System.Diagnostics.PresentationTraceSources.SetTraceLevel(this.View.dataGrid.ItemContainerGenerator, System.Diagnostics.PresentationTraceLevel.High);
CurrentUser = loggedInUser;
this.View = view;
//InMemoryAppender.LogData
selectedSubstationChangedCmd = new SubstationSelectionChanged(this);
selectedDeviceChangedCmd = new DeviceSelectionChanged(this);
openAddSubstationDialogCmd = new OpenAddSubstation(this);
deleteSubstationCmd = new DeleteSubstation(this);
redoCmd = new RedoCommand(this);
undoCmd = new UndoCommand(this);
openEditSubstationCmd = new OpenEditSubstation(this);
refreshCommand = new RefreshCommand(this);
signOutCmd = new SignOutCommand(this);
openAddUserCmd = new OpenAddUser(this);
openEditUserDataCmd = new OpenEditUserData(this);
cloneSubstationCmd = new CloneSubstationCmd(this);
filterSubstationCmd = new FilterSubstationsCmd(this);
openAddDeviceCmd = new OpenAddDevice(this);
deleteDeviceCmd = new DeleteDeviceCmd(this);
openAddMeasurementCmd = new OpenAddMeasurement(this);
deleteMeasurementCmd = new DeleteMeasurement(this);
#region initialize Undo/Redo data holders
RedoHistory = new List <BaseCommand>();
UndoHistory = new List <BaseCommand>();
SubstationsUndo = new List <Substation>();
DevicesUndo = new List <Device>();
MeasurementsUndo = new List <Measurement>();
SubstationsRedo = new List <Substation>();
DevicesRedo = new List <Device>();
MeasurementsRedo = new List <Measurement>();
#endregion
FilterName = "";
FilterLocation = "";
//CurrentUser = UserProxy.Instance.Proxy.Login("admin", "admin");
visibleIfAdmin = CurrentUser.isAdmin ? "Visible" : "Hidden"; // show/hide GUI elements based on priviledge
RefreshData();
}
/// <summary>
/// Handles UI buttons and activates the command pattern
/// </summary>
private async void UserActionClick(object sender, RoutedEventArgs e)
{
if (sender is AppBarButton button)
{
IUserActionCommand cmd = null;
switch (button.Name)
{
case "OpenButton":
cmd = new OpenFileCommand(this);
break;
case "SaveButton":
cmd = new SaveFileCommand();
break;
case "RedoButton":
cmd = new RedoCommand(this);
break;
case "UndoButton":
cmd = new UndoCommand(this);
break;
case "GroupButton":
cmd = new GroupCommand(this);
break;
case "UnGroupButton":
cmd = new UnGroupCommand(this);
break;
case "DeleteButton":
cmd = new DeleteItemCommand(this);
break;
}
if (cmd != null)
{
cmd.RedoStack = _redoStack;
cmd.UndoStack = _undoStack;
cmd.ShapeList = _shapeList;
await _userInvoker.InvokeUserActionAsync(cmd);
}
}
}
public LilypondViewModel(MainViewModel mainViewModel, MusicLoader musicLoader)
{
// TODO: Can we use some sort of eventing system so the managers layer doesn't have to know the viewmodel layer and viewmodels don't know each other?
// And viewmodels don't
_mainViewModel = mainViewModel;
_musicLoader = musicLoader;
_musicLoader.LilypondViewModel = this;
_text = new LilypondText();
_caretaker = new LilypondTextCaretaker(_text);
_movedInHistory = false;
LilypondText = "Your lilypond text will appear here.";
_caretaker.change();
UndoCommand.RaiseCanExecuteChanged();
RedoCommand.RaiseCanExecuteChanged();
}
static void Main(string[] args)
{
Document doc = new Document();
DocumentCommand discmd = new DisplayCommand(doc);
DocumentCommand undcmd = new UndoCommand(doc);
DocumentCommand redcmd = new RedoCommand(doc);
DocumentInvoker invoker = new DocumentInvoker(discmd, undcmd, redcmd);
invoker.Display();
invoker.Undo();
invoker.Redo();
}
public EditCommand(UndoCommand undoCommand, RedoCommand redoCommand, CutCommand cutCommand,
CopyCommand copyCommand, PasteCommand pasteCommand, SelectAllCommand selectAllCommand,
ExponentCommand exponentCommand)
: base(MenuStrings.editToolStripMenuItem1_Text)
{
ChildrenCommands = new List <IToolbarCommand>
{
undoCommand,
redoCommand,
null,
cutCommand,
copyCommand,
pasteCommand,
null,
selectAllCommand,
null,
exponentCommand
};
}
public void Execute(RedoCommand command)
{
IsUndoRedo = true;
Repository = Container.Resolve <IRepository>();
var redoGroup = Repository.All <RedoItem>().GroupBy(p => p.Group).LastOrDefault();
if (redoGroup == null)
{
return;
}
foreach (var redoItem in redoGroup)
{
// Create redo item
var undoItem = InvertJsonExtensions.DeserializeObject(typeof(UndoItem), JSON.Parse(redoItem.UndoData)) as UndoItem;
if (redoItem.Type == UndoType.Inserted)
{
var record = Repository.GetById <IDataRecord>(redoItem.DataRecordId);
Repository.Remove(record);
}
else if (redoItem.Type == UndoType.Removed)
{
var obj = InvertJsonExtensions.DeserializeObject(Type.GetType(redoItem.RecordType), JSON.Parse(redoItem.Data).AsObject) as IDataRecord;
Repository.Add(obj);
}
else
{
var record = Repository.GetById <IDataRecord>(redoItem.DataRecordId);
// We don't want to signal any events on deserialization
record.Repository = null;
InvertJsonExtensions.DeserializeExistingObject(record, JSON.Parse(redoItem.Data).AsObject);
record.Changed = true;
record.Repository = Repository;
}
Repository.Remove(redoItem);
Repository.Add(undoItem);
}
IsUndoRedo = false;
Repository.Commit();
}
private void Window_PreviewKeyDown(object sender, KeyEventArgs e)
{
if (e.Key == Key.Z && e.KeyboardDevice.Modifiers.HasFlag(ModifierKeys.Control))
{
UndoCommand.Execute(null);
}
else if (e.Key == Key.Y && e.KeyboardDevice.Modifiers.HasFlag(ModifierKeys.Control))
{
RedoCommand.Execute(null);
}
else if (e.Key == Key.N && e.KeyboardDevice.Modifiers.HasFlag(ModifierKeys.Control))
{
NewFlowCommand.Execute(null);
}
else if (e.Key == Key.O && e.KeyboardDevice.Modifiers.HasFlag(ModifierKeys.Control))
{
OpenFlowCommand.Execute(null);
}
else if (e.Key == Key.S && e.KeyboardDevice.Modifiers.HasFlag(ModifierKeys.Control | ModifierKeys.Shift))
{
SaveAllFlowsCommand.Execute(null);
}
else if (e.Key == Key.S && e.KeyboardDevice.Modifiers.HasFlag(ModifierKeys.Control))
{
SaveFlowCommand.Execute(null);
}
else if (e.Key == Key.F5 && e.KeyboardDevice.Modifiers.HasFlag(ModifierKeys.Shift))
{
StopFlowCommand.Execute(null);
}
else if (e.Key == Key.F5)
{
RunFlowCommand.Execute(null);
}
else if (e.Key == Key.F10)
{
StepFlowCommand.Execute(null);
}
}
//Summary
// Execute new operaton and put the operation in to undoable list
public void Do(IOperation operation)
{
operation.Do();
HasChange = true;
_operations.Insert(0, operation);
foreach (var v in _operationsRedo)
{
v.Dispose();
}
_operationsRedo.Clear();
UndoCommand.RaiseCanExecuteChanged();
RedoCommand.RaiseCanExecuteChanged();
if (!string.IsNullOrEmpty(operation.Sammary))
{
PostStatusMessage(operation.Sammary);
}
}
/// <summary>
/// Handle redo event in menu.
/// </summary>
/// <param name="sender">sender.</param>
/// <param name="e">event args.</param>
private void HandleRedo(object sender, EventArgs e)
{
if (this.newSheet.CountRedoStack() > 0)
{
// if the redo stack is not empty.
RedoCommand newCommand = (RedoCommand)this.newSheet.RedoStackPeek();
this.newSheet.SpreadSheetRedo();
if (newCommand.CommandType == CommandType.Color)
{
// color redo command.
this.dataGridView1.Rows[newCommand.Cell.RowIndex].Cells[newCommand.Cell.ColumnIndex].Style.BackColor = System.Drawing.Color.FromArgb(this.newSheet.Get_Cell(newCommand.Cell.RowIndex, newCommand.Cell.ColumnIndex).Color);
}
else if (newCommand.CommandType == CommandType.Text)
{
// text redo command.
this.dataGridView1.Rows[newCommand.Cell.RowIndex].Cells[newCommand.Cell.ColumnIndex].Value = this.newSheet.Get_Cell(newCommand.Cell.RowIndex, newCommand.Cell.ColumnIndex).Value;
}
// pop the extra command.
this.newSheet.UndostackPop();
}
}
void ExecuteUndo()
{
var op = Operations.FirstOrDefault();
if (op == null || !op.IsUnDoable)
{
return;
}
op.UnDo();
Operations.Remove(op);
OperationsRedo.Insert(0, op);
UndoCommand.RaiseCanExecuteChanged();
RedoCommand.RaiseCanExecuteChanged();
if (!string.IsNullOrEmpty(op.Sammary))
{
PostStatusMessage("Undo " + op.Sammary);
}
}
public BaseDataModel()
{
// setup
ContentScale = 1;
SelectedEntities = new ObservableCollection <IVisualElement>();
SelectedEntities.CollectionChanged += SelectedEntities_CollectionChanged;
CornerManipulators = new ObservableCollection <VisualCornerManipulator>();
MapEntities = new ObservableCollection <IVisualElement>();
// commands
UndoCommand = new UndoCommand(this);
RedoCommand = new RedoCommand(this);
CopyCommand = new CopyCommand(this);
PasteCommand = new PasteCommand(this);
DeleteCommand = new DeleteCommand(this);
DeselectAllCommand = new DeselectAllCommand(this);
EditEntityCommand = new EditEntityCommand(this);
CreateMarkerCommand = new CreateMarkerCommand(this);
ShowManipulationPoints = new ShowManipulationPoints(this);
CreateWallCommand = new CreateWallCommand(this);
CreateDoorCommand = new CreateDoorCommand(this);
}
public void CanRedoWithoutActiveProject()
{
var projectLink = new Mock<ILinkToProjects>();
{
projectLink.Setup(p => p.HasActiveProject())
.Returns(false);
}
Func<string, IDisposable> timerFunc = s => new MockDisposable();
var command = new RedoCommand(projectLink.Object, timerFunc);
Assert.IsFalse(command.CanExecute(null));
}
public void Redo()
{
var currentMark = new TimeMarker(10);
var markers = new List<TimeMarker>
{
new TimeMarker(1),
};
var history = new Mock<ITimeline>();
{
history.Setup(h => h.CanRollForward)
.Returns(true);
history.Setup(h => h.MarkersInTheFuture())
.Returns(markers);
history.Setup(h => h.Current)
.Returns(currentMark);
history.Setup(h => h.RollForwardTo(It.IsAny<TimeMarker>(), It.IsAny<TimelineTraveller>()))
.Verifiable();
}
var project = new Mock<IProject>();
{
project.Setup(p => p.History)
.Returns(history.Object);
}
var projectFacade = new ProjectFacade(project.Object);
var projectLink = new Mock<ILinkToProjects>();
{
projectLink.Setup(p => p.ActiveProject())
.Returns(projectFacade);
projectLink.Setup(p => p.HasActiveProject())
.Returns(true);
}
Func<string, IDisposable> timerFunc = s => new MockDisposable();
var command = new RedoCommand(projectLink.Object, timerFunc);
command.Execute(null);
history.Verify(h => h.RollForwardTo(It.IsAny<TimeMarker>(), It.IsAny<TimelineTraveller>()), Times.Once());
}
public void CanRedoWithMarkers()
{
var currentMark = new TimeMarker(10);
var markers = new List<TimeMarker>
{
new TimeMarker(1),
};
var history = new Mock<ITimeline>();
{
history.Setup(h => h.CanRollForward)
.Returns(true);
history.Setup(h => h.MarkersInTheFuture())
.Returns(markers);
history.Setup(h => h.Current)
.Returns(currentMark);
}
var project = new Mock<IProject>();
{
project.Setup(p => p.History)
.Returns(history.Object);
}
var projectFacade = new ProjectFacade(project.Object);
var projectLink = new Mock<ILinkToProjects>();
{
projectLink.Setup(p => p.ActiveProject())
.Returns(projectFacade);
projectLink.Setup(p => p.HasActiveProject())
.Returns(true);
}
Func<string, IDisposable> timerFunc = s => new MockDisposable();
var command = new RedoCommand(projectLink.Object, timerFunc);
Assert.IsTrue(command.CanExecute(null));
}
public void CanRedoWithNullFacade()
{
Func<string, IDisposable> timerFunc = s => new MockDisposable();
var command = new RedoCommand(null, timerFunc);
Assert.IsFalse(command.CanExecute(null));
}
