Enable and disable buttons on click in ReactiveUI WPF - wpf

Question

In reactive UI, BindCommand can bind some control to view model's property or method, e.g. method in ViewModel that will be executed when some button in XAML was clicked.
https://www.reactiveui.net/docs/handbook/commands/binding-commands
How do I disable or enable a set of buttons when some of them was clicked?
According to docs, BindCommand should have 3rd argument that can accept some function, but can't find an example.
XAML
<Button Content="Start" x:Name="StartButton" />
<Button Content="Stop" x:Name="StopButton" IsEnabled="False" />
<Button Content="Pause" x:Name="PauseButton" IsEnabled="False" />
XAML.cs
// How to enable Stop and Pause when Start was clicked?
this.BindCommand(ViewModel, vm => vm.Stop, view => view.StopButton).DisposeWith(container);
this.BindCommand(ViewModel, vm => vm.Start, view => view.StartButton).DisposeWith(container);
this.BindCommand(ViewModel, vm => vm.Pause, view => view.PauseButton).DisposeWith(container);
// In plain WPF I could do modify controls inside OnClick handler
private void OnStartClick(object sender, RoutedEventArgs e)
{
// How can I do this in Reactive UI?
StopButton.IsEnabled = true;
PauseButton.IsEnabled = true;
}
View Model
public DashboardViewModel(IScreen screen)
{
HostScreen = screen;
// Or how to get access to controls in these event handlers?
Stop = ReactiveCommand.Create(() => {});
Start = ReactiveCommand.Create(() => {});
Pause = ReactiveCommand.Create(() => {});
}

Answer 1

ReactiveCommand.Create accepts an IObservable<bool> that determines whether the value of CanExecute:
Start = ReactiveCommand.Create(() => { });
Stop = ReactiveCommand.Create(() => { }, Start.Select(_ => true));
Pause = ReactiveCommand.Create(() => { }, Start.Select(_ => true));

Answer 2

Considering that 3 persons, including me, voted for creating relevant properties in View Model and binding them in XAML, I did this first.
View Model
public ReactiveCommand<Unit, Unit> StopCommand { get; protected set; }
public ReactiveCommand<Unit, Unit> StartCommand { get; protected set; }
public bool StopState { get => _stopState; set => this.RaiseAndSetIfChanged(ref _stopState, value); }
public bool StartState { get => _startState; set => this.RaiseAndSetIfChanged(ref _startState, value); }
StopCommand = ReactiveCommand.Create(() =>
{
StopState = false;
StartState = true;
});
StartCommand = ReactiveCommand.Create(() =>
{
StopState = true;
StartState = false;
});
XAML
<Button Content="Start" IsEnabled="{Binding Path=StartState}" x:Name="StartButton" />
<Button Content="Stop" IsEnabled="{Binding Path=StopState}" x:Name="StopButton" />
That seemed like the most MVVM approach, even though not exactly a Reactive UI approach. Then, I found this answer that seems to be way more elegant and doesn't require hardcoded bindings between XAML and View Model.
What are the distinctions between the various WhenAny methods in Reactive UI
Using WhenAnyObservable I can subscribe to selected command and modify XAML from the code-behind, without creating a bunch of unnecessary properties in the View Model
this
.BindCommand(ViewModel, vm => vm.StartCommand, view => view.StartButton)
.WhenAnyObservable(o => o.ViewModel.StartCommand)
.Subscribe(o =>
{
StartButton.IsEnabled = false;
StopButton.IsEnabled = true;
})
.DisposeWith(container);
Done.