[Settings, Common.UI, runner exe] Unify exe/dll naming (#15005)

* Unify exe/dll naming - PowerToys.Runner

Align naming with other exes - PowerToys Runner -> PowerToys.Runner

* Unify exe/dll naming - Microsoft.PowerToys.Common.UI

Project name - Microsoft.PowerToys.Common.UI -> Common.UI
dll name - Microsoft.PowerToys.Common.UI.dll -> PowerToys.Common.UI.dll

* Unify exe/dll naming - Settings

Project names - Microsoft.PowerToys.Settings* -> Settings*
Dll names - Microsoft.PowerToys.Settings*.dll -> PowerToys.Settings*.dll

* Revert file autoformat

* [Docs] Update paths to settings projects/files

* Fix tests - Update path

src/settings-ui/Settings.UI/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.Activation;
+
+using Windows.ApplicationModel.Activation;
+using Windows.UI.Xaml;
+using Windows.UI.Xaml.Controls;
+
+namespace Microsoft.PowerToys.Settings.UI.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/Settings.UI/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 Windows.UI.Xaml;
+using Windows.UI.Xaml.Controls;
+using Windows.UI.Xaml.Media.Animation;
+using Windows.UI.Xaml.Navigation;
+
+namespace Microsoft.PowerToys.Settings.UI.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);
+    }
+}