Init 2

src/settings-ui/Microsoft.PowerToys.Settings.UI.WinUI3/Activation/ActivationHandler.cs

@@ -0,0 +1,44 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Diagnostics.CodeAnalysis;
+using System.Threading.Tasks;
+
+namespace Microsoft.PowerToys.Settings.UI.WinUI3.Activation
+{
+    // For more information on understanding and extending activation flow see
+    // https://github.com/Microsoft/WindowsTemplateStudio/blob/master/docs/activation.md
+    internal abstract class ActivationHandler
+    {
+        public abstract bool CanHandle(object args);
+
+        public abstract Task HandleAsync(object args);
+    }
+
+    [SuppressMessage("StyleCop.CSharp.MaintainabilityRules", "SA1402:File may only contain a single type", Justification = "abstract T and abstract")]
+    internal abstract class ActivationHandler<T> : ActivationHandler
+        where T : class
+    {
+        public override async Task HandleAsync(object args)
+        {
+            await HandleInternalAsync(args as T).ConfigureAwait(false);
+        }
+
+        public override bool CanHandle(object args)
+        {
+            // CanHandle checks the args is of type you have configured
+            return args is T && CanHandleInternal(args as T);
+        }
+
+        // Override this method to add the activation logic in your activation handler
+        protected abstract Task HandleInternalAsync(T args);
+
+        // You can override this method to add extra validation on activation args
+        // to determine if your ActivationHandler should handle this activation args
+        protected virtual bool CanHandleInternal(T args)
+        {
+            return true;
+        }
+    }
+}

src/settings-ui/Microsoft.PowerToys.Settings.UI.WinUI3/Activation/DefaultActivationHandler.cs

@@ -0,0 +1,41 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Threading.Tasks;
+using Microsoft.PowerToys.Settings.UI.WinUI3.Services;
+using Windows.ApplicationModel.Activation;
+
+namespace Microsoft.PowerToys.Settings.UI.WinUI3.Activation
+{
+    internal class DefaultActivationHandler : ActivationHandler<IActivatedEventArgs>
+    {
+        private readonly Type navElement;
+
+        public DefaultActivationHandler(Type navElement)
+        {
+            this.navElement = navElement;
+        }
+
+        protected override async Task HandleInternalAsync(IActivatedEventArgs args)
+        {
+            // When the navigation stack isn't restored, navigate to the first page and configure
+            // the new page by passing required information in the navigation parameter
+            object arguments = null;
+            if (args is LaunchActivatedEventArgs launchArgs)
+            {
+                arguments = launchArgs.Arguments;
+            }
+
+            NavigationService.Navigate(navElement, arguments);
+            await Task.CompletedTask.ConfigureAwait(false);
+        }
+
+        protected override bool CanHandleInternal(IActivatedEventArgs args)
+        {
+            // None of the ActivationHandlers has handled the app activation
+            return NavigationService.Frame.Content == null && navElement != null;
+        }
+    }
+}

src/settings-ui/Microsoft.PowerToys.Settings.UI.WinUI3/ICoreWindowInterop.cs

@@ -0,0 +1,18 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Runtime.InteropServices;
+
+namespace Microsoft.PowerToys.Settings.UI.WinUI3
+{
+    [ComImport]
+    [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+    [Guid("45D64A29-A63E-4CB6-B498-5781D298CB4F")]
+    internal interface ICoreWindowInterop
+    {
+        System.IntPtr WindowHandle { get; }
+
+        void MessageHandled(bool value);
+    }
+}

src/settings-ui/Microsoft.PowerToys.Settings.UI.WinUI3/Interop.cs

@@ -0,0 +1,31 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Runtime.InteropServices;
+
+using WinCore = Windows.UI.Core;
+
+namespace Microsoft.PowerToys.Settings.UI.WinUI3
+{
+    internal static class Interop
+    {
+        public static ICoreWindowInterop GetInterop(this WinCore.CoreWindow @this)
+        {
+            var unkIntPtr = Marshal.GetIUnknownForObject(@this);
+            try
+            {
+                var interopObj = Marshal.GetTypedObjectForIUnknown(unkIntPtr, typeof(ICoreWindowInterop)) as ICoreWindowInterop;
+                return interopObj;
+            }
+            finally
+            {
+                Marshal.Release(unkIntPtr);
+                unkIntPtr = System.IntPtr.Zero;
+            }
+        }
+
+        [System.Diagnostics.CodeAnalysis.SuppressMessage("StyleCop.CSharp.NamingRules", "SA1310:Field names should not contain underscore", Justification = "Interop naming consistency")]
+        public const int SW_HIDE = 0;
+    }
+}

src/settings-ui/Microsoft.PowerToys.Settings.UI.WinUI3/Microsoft.PowerToys.Settings.UI.WinUI3.csproj

@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <OutputType>WinExe</OutputType>
     <TargetFramework>net5.0-windows10.0.19041.0</TargetFramework>

src/settings-ui/Microsoft.PowerToys.Settings.UI.WinUI3/Services/ActivationService.cs

@@ -0,0 +1,107 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+using Microsoft.PowerToys.Settings.UI.WinUI3.Activation;
+
+using Windows.ApplicationModel.Activation;
+using Microsoft.UI.Xaml;
+using Microsoft.UI.Xaml.Controls;
+
+namespace Microsoft.PowerToys.Settings.UI.WinUI3.Services
+{
+    // For more information on understanding and extending activation flow see
+    // https://github.com/Microsoft/WindowsTemplateStudio/blob/master/docs/activation.md
+    internal class ActivationService
+    {
+        private readonly App app;
+        private readonly Type defaultNavItem;
+        private Lazy<UIElement> shell;
+
+        private object lastActivationArgs;
+
+        public ActivationService(App app, Type defaultNavItem, Lazy<UIElement> shell = null)
+        {
+            this.app = app;
+            this.shell = shell;
+            this.defaultNavItem = defaultNavItem;
+        }
+
+        public async Task ActivateAsync(object activationArgs)
+        {
+            if (IsInteractive(activationArgs))
+            {
+                // Initialize services that you need before app activation
+                // take into account that the splash screen is shown while this code runs.
+                await InitializeAsync().ConfigureAwait(false);
+
+                // Do not repeat app initialization when the Window already has content,
+                // just ensure that the window is active
+                if (Window.Current.Content == null)
+                {
+                    // Create a Shell or Frame to act as the navigation context
+                    Window.Current.Content = shell?.Value ?? new Frame();
+                }
+            }
+
+            // Depending on activationArgs one of ActivationHandlers or DefaultActivationHandler
+            // will navigate to the first page
+            await HandleActivationAsync(activationArgs).ConfigureAwait(false);
+            lastActivationArgs = activationArgs;
+
+            if (IsInteractive(activationArgs))
+            {
+                // Ensure the current window is active
+                Window.Current.Activate();
+
+                // Tasks after activation
+                await StartupAsync().ConfigureAwait(false);
+            }
+        }
+
+        private static async Task InitializeAsync()
+        {
+            await Task.CompletedTask.ConfigureAwait(false);
+        }
+
+        private async Task HandleActivationAsync(object activationArgs)
+        {
+            var activationHandler = GetActivationHandlers()
+                                                .FirstOrDefault(h => h.CanHandle(activationArgs));
+
+            if (activationHandler != null)
+            {
+                await activationHandler.HandleAsync(activationArgs).ConfigureAwait(false);
+            }
+
+            if (IsInteractive(activationArgs))
+            {
+                var defaultHandler = new DefaultActivationHandler(defaultNavItem);
+                if (defaultHandler.CanHandle(activationArgs))
+                {
+                    await defaultHandler.HandleAsync(activationArgs).ConfigureAwait(false);
+                }
+            }
+        }
+
+        private static async Task StartupAsync()
+        {
+            await Task.CompletedTask.ConfigureAwait(false);
+        }
+
+        private static IEnumerable<ActivationHandler> GetActivationHandlers()
+        {
+            yield break;
+        }
+
+        private static bool IsInteractive(object args)
+        {
+            return args is IActivatedEventArgs;
+        }
+    }
+}

src/settings-ui/Microsoft.PowerToys.Settings.UI.WinUI3/Services/NavigationService.cs

@@ -0,0 +1,105 @@
+// Copyright (c) Microsoft Corporation
+// The Microsoft Corporation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using Microsoft.UI.Xaml;
+using Microsoft.UI.Xaml.Controls;
+using Microsoft.UI.Xaml.Media.Animation;
+using Microsoft.UI.Xaml.Navigation;
+
+namespace Microsoft.PowerToys.Settings.UI.WinUI3.Services
+{
+    public static class NavigationService
+    {
+        public static event NavigatedEventHandler Navigated;
+
+        public static event NavigationFailedEventHandler NavigationFailed;
+
+        private static Frame frame;
+        private static object lastParamUsed;
+
+        public static Frame Frame
+        {
+            get
+            {
+                if (frame == null)
+                {
+                    frame = Window.Current.Content as Frame;
+                    RegisterFrameEvents();
+                }
+
+                return frame;
+            }
+
+            set
+            {
+                UnregisterFrameEvents();
+                frame = value;
+                RegisterFrameEvents();
+            }
+        }
+
+        public static bool CanGoBack => Frame.CanGoBack;
+
+        public static bool CanGoForward => Frame.CanGoForward;
+
+        public static bool GoBack()
+        {
+            if (CanGoBack)
+            {
+                Frame.GoBack();
+                return true;
+            }
+
+            return false;
+        }
+
+        public static void GoForward() => Frame.GoForward();
+
+        public static bool Navigate(Type pageType, object parameter = null, NavigationTransitionInfo infoOverride = null)
+        {
+            // Don't open the same page multiple times
+            if (Frame.Content?.GetType() != pageType || (parameter != null && !parameter.Equals(lastParamUsed)))
+            {
+                var navigationResult = Frame.Navigate(pageType, parameter, infoOverride);
+                if (navigationResult)
+                {
+                    lastParamUsed = parameter;
+                }
+
+                return navigationResult;
+            }
+            else
+            {
+                return false;
+            }
+        }
+
+        public static bool Navigate<T>(object parameter = null, NavigationTransitionInfo infoOverride = null)
+            where T : Page
+            => Navigate(typeof(T), parameter, infoOverride);
+
+        private static void RegisterFrameEvents()
+        {
+            if (frame != null)
+            {
+                frame.Navigated += Frame_Navigated;
+                frame.NavigationFailed += Frame_NavigationFailed;
+            }
+        }
+
+        private static void UnregisterFrameEvents()
+        {
+            if (frame != null)
+            {
+                frame.Navigated -= Frame_Navigated;
+                frame.NavigationFailed -= Frame_NavigationFailed;
+            }
+        }
+
+        private static void Frame_NavigationFailed(object sender, NavigationFailedEventArgs e) => NavigationFailed?.Invoke(sender, e);
+
+        private static void Frame_Navigated(object sender, NavigationEventArgs e) => Navigated?.Invoke(sender, e);
+    }
+}