Esempio n. 1
0
        private void addCommandViewModel(IProgramCommand command)
        {
            var item = new ProgramCommandListItemViewModel(command);

            item.CommandRemove += onCommandRemoval;

            CommandsCollection.Add(item);
        }
        public void Apply(IProgramCommand action)
        {
            action.Execute(_canvasNode);
            _canvasNode.UpdateLayout();
            _canvasNode.InvalidateVisual();

            _changeStack.Push(action);
        }
Esempio n. 3
0
        public void AddCommand_ShouldBeInvoked_IfCreatedViewModelWillRequestThat()
        {
            IProgramCommand receivedCommand  = null;
            IProgramCommand commandToReceive = new Mock <IProgramCommand>().Object;

            viewModel.AddCommand += (_, e) => receivedCommand = e.Command;

            commandListTestVM.AddCommandInvoke(commandToReceive);

            Assert.Equal(commandToReceive, receivedCommand);
        }
Esempio n. 4
0
        public void AddMoveCommand_Execute_CreatesCommandAndChangesState()
        {
            IProgramCommand  receivedCommand = null;
            CommandListState?receivedState   = null;

            ViewModel.Distance = 123;

            ViewModel.AddProgram += (_, e) => receivedCommand = e.Command;
            ViewModel.Transition += (_, e) => receivedState = e.State;

            CommandMoveViewModel.AddMoveCommand.Execute(ViewModel);

            Assert.Equal(CommandListState.Buttons, receivedState);

            Assert.True(receivedCommand is MoveCommand);
            Assert.Equal(123d, (receivedCommand as MoveCommand).Distance);
        }
Esempio n. 5
0
        public void RemoveCommand_ShouldNotChangeOrder()
        {
            Program program     = new Program();
            var     commandMock = new Mock <IProgramCommand>();

            IProgramCommand[] commands = new IProgramCommand[]
            {
                new Mock <IProgramCommand>().Object,
                new Mock <IProgramCommand>().Object,
                new Mock <IProgramCommand>().Object
            };

            foreach (var c in commands)
            {
                program.AddCommand(c);
            }

            program.RemoveCommand(commands[1]);

            Assert.Equal(commands[0], program.Commands.ElementAt(0));
            Assert.Equal(commands[2], program.Commands.ElementAt(1));
        }
Esempio n. 6
0
 public void AddCommand(IProgramCommand action)
 {
     _commands.Add(action);
 }
Esempio n. 7
0
 public static Change CreateChange(int id, IProgramCommand action)
 {
     return new Change(id, action);
 }
Esempio n. 8
0
 private Change(int id, IProgramCommand action)
 {
     _commands = new List<IProgramCommand>();
     _commands.Add(action);
     _changeId = id;
 }
Esempio n. 9
0
 public ProgramExecutorCommandEventArgs(IProgramCommand command, IProgram program, IRobot robot)
 {
     this.Command = command;
     this.Program = program;
     this.Robot   = robot;
 }
Esempio n. 10
0
 public void AddCommand(IProgramCommand command)
 {
     addCommandViewModel(command);
     Program.AddCommand(command);
 }
 public ProgramCommandListItemViewModel(IProgramCommand command)
 {
     this.command = command;
     this.CommandRemoveCommand = new ActionCommand <ProgramCommandListItemViewModel>(onCommandRemove);
 }
Esempio n. 12
0
 public AddCommandEventArgs(IProgramCommand command)
 {
     this.Command = command;
 }
Esempio n. 13
0
 public ProgramCommandItemEventArgs(IProgramCommand command)
 {
     this.Command = command;
 }
Esempio n. 14
0
 public virtual new void AddCommandInvoke(IProgramCommand c) => base.AddCommandInvoke(c);