Exemple #1
0
        private void InitaliseCommands()
        {
            StartGameCommand = ReactiveCommand.Create();
            StartGameCommand.Subscribe(arg => StartGameCommandHandler());

            ResetCommand = ReactiveCommand.Create();
            ResetCommand.Subscribe(arg => ResetCommandHandler());

            StopGameCommand = ReactiveCommand.Create();
            StopGameCommand.Subscribe(arg => StopGameWindowHandler());

            OpenNewGameWindow = ReactiveCommand.Create();
            OpenNewGameWindow.Subscribe(arg => OpenNewGameWindowHandler());

            FlipCommand = ReactiveCommand.Create();
            FlipCommand.Subscribe(arg => FlipCommandHandler());

            UndoCommand = ReactiveCommand.Create();
            UndoCommand.Subscribe(arg => UndoCommandHandler());

            AcceptScoreCommand = ReactiveCommand.Create();
            AcceptScoreCommand.Subscribe(arg => AcceptScoreCommandHandler());

            RejectScoreCommand = ReactiveCommand.Create();
            RejectScoreCommand.Subscribe(arg => RejectScoreCommandHandler());
        }
        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);
        }