Add a way to bind ICommands to VS commands.

And use it in the `GitHubPaneViewModel`.

Author: grokys

src/GitHub.App/GitHub.App.csproj

@@ -311,6 +311,10 @@
       <Project>{8d73575a-a89f-47cc-b153-b47dd06837f0}</Project>
       <Name>GitHub.Logging</Name>
     </ProjectReference>
+    <ProjectReference Include="..\GitHub.Services.Vssdk\GitHub.Services.Vssdk.csproj">
+      <Project>{2D3D2834-33BE-45CA-B3CC-12F853557D7B}</Project>
+      <Name>GitHub.Services.Vssdk</Name>
+    </ProjectReference>
     <ProjectReference Include="..\GitHub.UI.Reactive\GitHub.UI.Reactive.csproj">
       <Project>{158b05e8-fdbc-4d71-b871-c96e28d5adf5}</Project>
       <Name>GitHub.UI.Reactive</Name>

src/GitHub.App/ViewModels/GitHubPane/GitHubPaneViewModel.cs

@@ -1,5 +1,6 @@
 using System;
 using System.ComponentModel.Composition;
+using System.ComponentModel.Design;
 using System.Linq;
 using System.Reactive;
 using System.Reactive.Linq;
@@ -14,6 +15,7 @@
 using GitHub.Models;
 using GitHub.Primitives;
 using GitHub.Services;
+using GitHub.Services.Vssdk.Commands;
 using GitHub.VisualStudio;
 using ReactiveUI;
 using OleMenuCommand = Microsoft.VisualStudio.Shell.OleMenuCommand;
@@ -43,6 +45,8 @@ public sealed class GitHubPaneViewModel : ViewModelBase, IGitHubPaneViewModel, I
         readonly ObservableAsPropertyHelper<ContentOverride> contentOverride;
         readonly ObservableAsPropertyHelper<bool> isSearchEnabled;
         readonly ObservableAsPropertyHelper<string> title;
+        readonly ReactiveCommand<object> navigateBack;
+        readonly ReactiveCommand<object> navigateForward;
         readonly ReactiveCommand<Unit> refresh;
         readonly ReactiveCommand<Unit> showPullRequests;
         readonly ReactiveCommand<object> openInBrowser;
@@ -125,6 +129,14 @@ public GitHubPaneViewModel(
                 .Select(x => x is ISearchablePageViewModel)
                 .ToProperty(this, x => x.IsSearchEnabled);
 
+            navigateBack = ReactiveCommand.CreateCombined(
+                currentPage.Select(x => x != null),
+                navigator.NavigateBack);
+
+            navigateForward = ReactiveCommand.CreateCombined(
+                currentPage.Select(x => x != null),
+                navigator.NavigateForward);
+
             refresh = ReactiveCommand.CreateAsyncTask(
                 currentPage.SelectMany(x => x?.WhenAnyValue(
                         y => y.IsLoading,
@@ -213,11 +225,12 @@ public async Task InitializeAsync(IServiceProvider paneServiceProvider)
 
                 connectionManager.Connections.CollectionChanged += (_, __) => UpdateContent(LocalRepository).Forget();
 
-                BindNavigatorCommand(paneServiceProvider, PkgCmdIDList.pullRequestCommand, showPullRequests);
-                BindNavigatorCommand(paneServiceProvider, PkgCmdIDList.backCommand, navigator.NavigateBack);
-                BindNavigatorCommand(paneServiceProvider, PkgCmdIDList.forwardCommand, navigator.NavigateForward);
-                BindNavigatorCommand(paneServiceProvider, PkgCmdIDList.refreshCommand, refresh);
-                BindNavigatorCommand(paneServiceProvider, PkgCmdIDList.githubCommand, openInBrowser);
+                var menuService = (IMenuCommandService)paneServiceProvider.GetService(typeof(IMenuCommandService));
+                BindNavigatorCommand(menuService, PkgCmdIDList.pullRequestCommand, showPullRequests);
+                BindNavigatorCommand(menuService, PkgCmdIDList.backCommand, navigator.NavigateBack);
+                BindNavigatorCommand(menuService, PkgCmdIDList.forwardCommand, navigator.NavigateForward);
+                BindNavigatorCommand(menuService, PkgCmdIDList.refreshCommand, refresh);
+                BindNavigatorCommand(menuService, PkgCmdIDList.githubCommand, openInBrowser);
 
                 paneServiceProvider.AddCommandHandler(Guids.guidGitHubToolbarCmdSet, PkgCmdIDList.helpCommand,
                      (_, __) =>
@@ -304,27 +317,12 @@ public Task ShowPullRequest(string owner, string repo, int number)
                 x => x.RemoteRepositoryOwner == owner && x.LocalRepository.Name == repo && x.Number == number);
         }
 
-        OleMenuCommand BindNavigatorCommand<T>(IServiceProvider paneServiceProvider, int commandId, ReactiveCommand<T> command)
+        OleMenuCommand BindNavigatorCommand<T>(IMenuCommandService menu, int commandId, ReactiveCommand<T> command)
         {
-            Guard.ArgumentNotNull(paneServiceProvider, nameof(paneServiceProvider));
+            Guard.ArgumentNotNull(menu, nameof(menu));
             Guard.ArgumentNotNull(command, nameof(command));
 
-            Func<bool> canExecute = () => Content == navigator && command.CanExecute(null);
-
-            var result = paneServiceProvider.AddCommandHandler(
-                Guids.guidGitHubToolbarCmdSet,
-                commandId,
-                canExecute,
-                () => command.Execute(null),
-                true);
-
-            Observable.CombineLatest(
-                this.WhenAnyValue(x => x.Content),
-                command.CanExecuteObservable,
-                (c, e) => c == navigator && e)
-                .Subscribe(x => result.Enabled = x);
-
-            return result;
+            return menu.BindCommand(new CommandID(Guids.guidGitHubToolbarCmdSet, commandId), command);
         }
 
         async Task NavigateTo<TViewModel>(Func<TViewModel, Task> initialize, Func<TViewModel, bool> match = null)

src/GitHub.Services.Vssdk/Commands/MenuCommandServiceExtensions.cs

@@ -1,14 +1,95 @@
 using System;
 using System.ComponentModel.Design;
+using System.Windows.Input;
 using GitHub.Commands;
+using GitHub.Extensions;
+using Microsoft.VisualStudio.Shell;
 
 namespace GitHub.Services.Vssdk.Commands
 {
+    /// <summary>
+    /// Extension methods for <see cref="IMenuCommandService"/>.
+    /// </summary>
     public static class MenuCommandServiceExtensions
     {
+        /// <summary>
+        /// Adds an <see cref="IVsCommand"/> or <see cref="IVsCommand{TParam}"/> to a menu.
+        /// </summary>
+        /// <param name="service">The menu command service.</param>
+        /// <param name="command">The command to add.</param>
         public static void AddCommand(this IMenuCommandService service, IVsCommandBase command)
         {
+            Guard.ArgumentNotNull(service, nameof(service));
+            Guard.ArgumentNotNull(command, nameof(command));
+
             service.AddCommand((MenuCommand)command);
         }
+
+        /// <summary>
+        /// Binds an <see cref="ICommand"/> to a Visual Studio command.
+        /// </summary>
+        /// <param name="service">The menu command service.</param>
+        /// <param name="id">The ID of the visual studio command.</param>
+        /// <param name="command">The <see cref="ICommand"/> to bind</param>
+        /// <param name="hideWhenDisabled">
+        /// If true, the visual studio command will be hidden when disabled.
+        /// </param>
+        /// <remarks>
+        /// This method wires up the <paramref name="command"/> to be executed when the Visual Studio
+        /// command is invoked, and for the <paramref name="command"/>'s
+        /// <see cref="ICommand.CanExecute(object)"/> state to control the enabled/visible state of
+        /// the Visual Studio command.
+        /// </remarks>
+        /// <returns>
+        /// The created <see cref="OleMenuCommand"/>.
+        /// </returns>
+        public static OleMenuCommand BindCommand(
+            this IMenuCommandService service,
+            CommandID id,
+            ICommand command,
+            bool hideWhenDisabled = false)
+        {
+            Guard.ArgumentNotNull(service, nameof(service));
+            Guard.ArgumentNotNull(id, nameof(id));
+            Guard.ArgumentNotNull(command, nameof(command));
+
+            var bound = new BoundCommand(id, command, hideWhenDisabled);
+            service.AddCommand(bound);
+            return bound;
+        }
+
+        class BoundCommand : OleMenuCommand
+        {
+            readonly ICommand inner;
+            readonly bool hideWhenDisabled;
+
+            public BoundCommand(CommandID id, ICommand command, bool hideWhenDisabled)
+                : base(InvokeHandler, delegate { }, HandleBeforeQueryStatus, id)
+            {
+                Guard.ArgumentNotNull(id, nameof(id));
+                Guard.ArgumentNotNull(command, nameof(command));
+
+                inner = command;
+                this.hideWhenDisabled = hideWhenDisabled;
+                inner.CanExecuteChanged += (s, e) => HandleBeforeQueryStatus(this, e);
+            }
+
+            static void InvokeHandler(object sender, EventArgs e)
+            {
+                var command = sender as BoundCommand;
+                command?.inner.Execute((e as OleMenuCmdEventArgs)?.InValue);
+            }
+
+            static void HandleBeforeQueryStatus(object sender, EventArgs e)
+            {
+                var command = sender as BoundCommand;
+
+                if (command != null)
+                {
+                    command.Enabled = command.inner.CanExecute(null);
+                    command.Visible = command.hideWhenDisabled ? command.Enabled : true;
+                }
+            }
+        }
     }
 }