Migrate spelling-0.0.21 changes from main

NuGet.Config

@@ -1,14 +1,24 @@
 <?xml version="1.0" encoding="utf-8"?>
 <configuration>
     <packageSources>
-        <clear />
-        <!-- Dependencies that we can turn on to force override for testing purposes before uploading. -->
+        <add key="NuGet.org" value="https://api.nuget.org/v3/index.json" />
+        <!-- Add repositories here to the list of available repositories -->
+        
+        <!-- Dependencies that we must carry because they're not on public nuget feeds right now. -->
         <!--<add key="Static Package Dependencies" value="dep\packages" />-->
+        
+        <!-- Use our own NuGet Feed -->
         <add key="TerminalDependencies" value="https://pkgs.dev.azure.com/ms/terminal/_packaging/TerminalDependencies/nuget/v3/index.json" />
+		
+		<!-- Temporarily? use the feeds from our friends in MUX for Helix test stuff -->
+		<add key="dotnetfeed" value="https://dotnetfeed.blob.core.windows.net/dotnet-core/index.json" />
+        <add key="dnceng" value="https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-eng/nuget/v3/index.json" />
+        <add key="MUX-Dependencies" value="https://pkgs.dev.azure.com/ms/microsoft-ui-xaml/_packaging/MUX-Dependencies/nuget/v3/index.json" />
+        
+        <!-- Internal NuGet feeds that may not be accessible outside Microsoft corporate network -->
+        <!--<add key="TAEF - internal" value="https://microsoft.pkgs.visualstudio.com/DefaultCollection/_packaging/Taef/nuget/v3/index.json" />
+        <add key="OpenConsole - Internal" value="https://microsoft.pkgs.visualstudio.com/_packaging/OpenConsole/nuget/v3/index.json" />-->
     </packageSources>
-    <disabledPackageSources>
-        <clear />
-    </disabledPackageSources>
     <config>
         <add key="repositorypath" value=".\packages" />
     </config>

build/Helix/runtests.cmd

@@ -18,7 +18,7 @@ FOR %%A IN (TestHostApp.exe,te.exe,te.processhost.exe,conhost.exe,OpenConsole.ex
 
 echo %TIME%
 
-:: kill dhandler, which is a tool designed to handle unexpected windows appearing. But since our tests are
+:: kill dhandler, which is a tool designed to handle unexpected windows appearing. But since our tests are 
 :: expected to show UI we don't want it running.
 taskkill -f -im dhandler.exe
 
@@ -28,7 +28,7 @@ echo %TIME%
 powershell -ExecutionPolicy Bypass .\InstallTestAppDependencies.ps1
 echo %TIME%
 
-set testBinaryCandidates=TerminalApp.LocalTests.dll SettingsModel.LocalTests.dll Conhost.UIA.Tests.dll
+set testBinaryCandidates=TerminalApp.LocalTests.dll Conhost.UIA.Tests.dll
 set testBinaries=
 for %%B in (%testBinaryCandidates%) do (
     if exist %%B (
@@ -103,4 +103,4 @@ copy /y *_subresults.json %HELIX_WORKITEM_UPLOAD_ROOT%
 
 type testResults.xml
 
-echo %TIME%
+echo %TIME%

build/pipelines/templates/helix-runtests-job.yml

@@ -5,14 +5,14 @@ parameters:
   testSuite: ''
   # If a Pipeline runs this template more than once, this parameter should be unique per build flavor to differentiate the
   # the different test runs:
-  helixType: 'test/devtest'
+  helixType: 'test/devtest' 
   artifactName: 'drop'
   maxParallel: 4
   rerunPassesRequiredToAvoidFailure: 5
   taefQuery: ''
   # if 'useBuildOutputFromBuildId' is set, we will default to using a build from this pipeline:
   useBuildOutputFromPipeline: $(System.DefinitionId)
-  matrix:
+  matrix: 
     # Release_x86:
     #   buildPlatform: 'x86'
     #   buildConfiguration: 'release'
@@ -39,13 +39,13 @@ jobs:
     taefPath: $(Build.SourcesDirectory)\build\Helix\packages\taef.redist.wlk.10.57.200731005-develop\build\Binaries\$(buildPlatform)
     helixCommonArgs: '/binaryLogger:$(Build.SourcesDirectory)/${{parameters.name}}.$(buildPlatform).$(buildConfiguration).binlog /p:HelixBuild=$(Build.BuildId).$(buildPlatform).$(buildConfiguration) /p:Platform=$(buildPlatform) /p:Configuration=$(buildConfiguration) /p:HelixType=${{parameters.helixType}} /p:TestSuite=${{parameters.testSuite}} /p:ProjFilesPath=$(Build.ArtifactStagingDirectory) /p:rerunPassesRequiredToAvoidFailure=${{parameters.rerunPassesRequiredToAvoidFailure}}'
 
-
+      
   steps:
   - task: CmdLine@1
     displayName: 'Display build machine environment variables'
     inputs:
       filename: 'set'
-
+      
   - task: NuGetToolInstaller@0
     displayName: 'Use NuGet 5.2.0'
     inputs:
@@ -59,23 +59,23 @@ jobs:
       nugetConfigPath: nuget.config
       restoreDirectory: packages
 
-  - task: DownloadBuildArtifacts@0
+  - task: DownloadBuildArtifacts@0 
     condition:
       and(succeeded(),eq(variables['useBuildOutputFromBuildId'],''))
-    inputs:
-      artifactName: ${{ parameters.artifactName }}
+    inputs: 
+      artifactName: ${{ parameters.artifactName }} 
       downloadPath: '$(artifactsDir)'
 
-  - task: DownloadBuildArtifacts@0
+  - task: DownloadBuildArtifacts@0 
     condition:
       and(succeeded(),ne(variables['useBuildOutputFromBuildId'],''))
-    inputs:
+    inputs: 
       buildType: specific
       buildVersionToDownload: specific
       project: $(System.TeamProjectId)
       pipeline: ${{ parameters.useBuildOutputFromPipeline }}
       buildId: $(useBuildOutputFromBuildId)
-      artifactName: ${{ parameters.artifactName }}
+      artifactName: ${{ parameters.artifactName }} 
       downloadPath: '$(artifactsDir)'
 
   - task: CmdLine@1
@@ -90,7 +90,7 @@ jobs:
       targetType: filePath
       filePath: build\Helix\PrepareHelixPayload.ps1
       arguments: -Platform '$(buildPlatform)' -Configuration '$(buildConfiguration)' -ArtifactName '${{ parameters.artifactName }}'
-
+      
   - task: CmdLine@1
     displayName: 'Display Helix payload contents'
     inputs:
@@ -104,16 +104,7 @@ jobs:
       outputProjFileName: 'RunTestsInHelix-TerminalAppLocalTests.proj'
       testSuite: '${{ parameters.testSuite }}'
       taefQuery: ${{ parameters.taefQuery }}
-
-  - template: helix-createprojfile-steps.yml
-    parameters:
-      condition: and(succeeded(),ne('${{ parameters.testSuite }}','NugetTestSuite'))
-      testFilePath: '$(artifactsDir)\${{ parameters.artifactName }}\$(buildConfiguration)\$(buildPlatform)\Test\SettingsModel.LocalTests.dll'
-      outputProjFileName: 'RunTestsInHelix-SettingsModelLocalTests.proj'
-      testSuite: '${{ parameters.testSuite }}'
-      taefQuery: ${{ parameters.taefQuery }}
-
-
+      
   - template: helix-createprojfile-steps.yml
     parameters:
       condition: and(succeeded(),ne('${{ parameters.testSuite }}','NugetTestSuite'))
@@ -127,7 +118,7 @@ jobs:
     inputs:
       PathtoPublish: $(Build.ArtifactStagingDirectory)
       artifactName: ${{ parameters.artifactName }}
-
+      
   - task: DotNetCoreCLI@2
     displayName: 'Run tests in Helix (open queues)'
     env:

consolegit2gitfilters.json

@@ -21,8 +21,7 @@
     "/res/terminal/",
     "/doc/specs/",
     "/doc/cascadia/",
-    "/doc/user-docs/",
-    "/src/tools/MonarchPeasantSample/",
+    "/doc/user-docs/"
   ],
   "SuffixFilters": [
     ".dbb",
@@ -39,5 +38,5 @@
     ".rec",
     ".err",
     ".xlsx"
-  ]
+  ]    
 }

doc/cascadia/AddASetting.md

@@ -1,395 +0,0 @@
-# Adding Settings to Windows Terminal
-
-Adding a setting to Windows Terminal is fairly straightforward. This guide serves as a reference on how to add a setting.
-
-## 1. Terminal Settings Model
-
-The Terminal Settings Model (`Microsoft.Terminal.Settings.Model`) is responsible for (de)serializing and exposing settings.
-
-### `GETSET_SETTING` macro
-
-The `GETSET_SETTING` macro can be used to implement inheritance for your new setting and store the setting in the settings model. It takes three parameters:
-- `type`: the type that the setting will be stored as
-- `name`: the name of the variable for storage
-- `defaultValue`: the value to use if the user does not define the setting anywhere
-
-### Adding a Profile setting
-
-This tutorial will add `CloseOnExitMode CloseOnExit` as a profile setting.
-
-1. In `Profile.h`, declare/define the setting:
-
-```c++
-GETSET_SETTING(CloseOnExitMode, CloseOnExit, CloseOnExitMode::Graceful)
-```
-
-2. In `Profile.idl`, expose the setting via WinRT:
-
-```c++
-Boolean HasCloseOnExit();
-void ClearCloseOnExit();
-CloseOnExitMode CloseOnExit;
-```
-
-3. In `Profile.cpp`, add (de)serialization and copy logic:
-
-```c++
-// Top of file:
-// - Add the serialization key
-static constexpr std::string_view CloseOnExitKey{ "closeOnExit" };
-
-// CopySettings() or Copy():
-// - The setting is exposed in the Settings UI
-profile->_CloseOnExit = source->_CloseOnExit;
-
-// LayerJson():
-// - get the value from the JSON
-JsonUtils::GetValueForKey(json, CloseOnExitKey, _CloseOnExit);
-
-// ToJson():
-// - write the value to the JSON
-JsonUtils::SetValueForKey(json, CloseOnExitKey, _CloseOnExit);
-```
-
-  - If the setting is not a primitive type, in `TerminalSettingsSerializationHelpers.h` add (de)serialization logic for the accepted values:
-
-```c++
-// For enum values...
-JSON_ENUM_MAPPER(::winrt::Microsoft::Terminal::Settings::Model::CloseOnExitMode)
-{
-    JSON_MAPPINGS(3) = {
-        pair_type{ "always", ValueType::Always },
-        pair_type{ "graceful", ValueType::Graceful },
-        pair_type{ "never", ValueType::Never },
-    };
-};
-
-// For enum flag values...
-JSON_FLAG_MAPPER(::winrt::Microsoft::Terminal::TerminalControl::CopyFormat)
-{
-    JSON_MAPPINGS(5) = {
-        pair_type{ "none", AllClear },
-        pair_type{ "html", ValueType::HTML },
-        pair_type{ "rtf", ValueType::RTF },
-        pair_type{ "all", AllSet },
-    };
-};
-
-// NOTE: This is also where you can add functionality for...
-// - overloaded type support (i.e. accept a bool and an enum)
-// - custom (de)serialization logic (i.e. coordinates)
-```
-
-### Adding a Global setting
-
-Follow the "adding a Profile setting" instructions above, but do it on the `GlobalAppSettings` files.
-
-### Adding an Action
-
-This tutorial will add the `openSettings` action.
-
-1. In `KeyMapping.idl`, declare the action:
-
-```c++
-// Add the action to ShortcutAction
-enum ShortcutAction
-{
-    OpenSettings
-}
-```
-
-2. In `ActionAndArgs.cpp`, add serialization logic:
-
-```c++
-// Top of file:
-// - Add the serialization key
-static constexpr std::string_view OpenSettingsKey{ "openSettings" };
-
-// ActionKeyNamesMap:
-// - map the new enum to the json key
-{ OpenSettingsKey, ShortcutAction::OpenSettings },
-```
-
-3. If the action should automatically generate a name when it appears in the Command Palette...
-```c++
-// In ActionAndArgs.cpp GenerateName() --> GeneratedActionNames
-{ ShortcutAction::OpenSettings, RS_(L"OpenSettingsCommandKey") },
-
-// In Resources.resw for Microsoft.Terminal.Settings.Model.Lib,
-// add the generated name
-// NOTE: Visual Studio presents the resw file as a table.
-//       If you choose to edit the file with a text editor,
-//       the code should look something like this...
-<data name="OpenSettingsCommandKey" xml:space="preserve">
-    <value>Open settings file</value>
-</data>
-```
-
-4. If the action supports arguments...
-  - In `ActionArgs.idl`, declare the arguments
-```c++
-[default_interface] runtimeclass OpenSettingsArgs : IActionArgs
-{
-    // this declares the "target" arg
-    SettingsTarget Target { get; };
-};
-```
-  - In `ActionArgs.h`, define the new runtime class
-```c++
-struct OpenSettingsArgs : public OpenSettingsArgsT<OpenSettingsArgs>
-{
-    OpenSettingsArgs() = default;
-
-    // adds a getter/setter for your argument, and defines the json key
-    GETSET_PROPERTY(SettingsTarget, Target, SettingsTarget::SettingsFile);
-    static constexpr std::string_view TargetKey{ "target" };
-
-    public:
-        hstring GenerateName() const;
-
-        bool Equals(const IActionArgs& other)
-        {
-            auto otherAsUs = other.try_as<OpenSettingsArgs>();
-            if (otherAsUs)
-            {
-                return otherAsUs->_Target == _Target;
-            }
-            return false;
-        };
-
-        static FromJsonResult FromJson(const Json::Value& json)
-        {
-            // LOAD BEARING: Not using make_self here _will_ break you in the future!
-            auto args = winrt::make_self<OpenSettingsArgs>();
-            JsonUtils::GetValueForKey(json, TargetKey, args->_Target);
-            return { *args, {} };
-        }
-
-        IActionArgs Copy() const
-        {
-            auto copy{ winrt::make_self<OpenSettingsArgs>() };
-            copy->_Target = _Target;
-            return *copy;
-        }
-};
-```
-  - In `ActionArgs.cpp`, define `GenerateName()`. This is used to automatically generate a name when it appears in the Command Palette.
-  - In `ActionAndArgs.cpp`, add serialization logic:
-
-```c++
-// ActionKeyNamesMap --> argParsers
-{ ShortcutAction::OpenSettings, OpenSettingsArgs::FromJson },
-```
-
-### Adding an Action Argument
-
-Follow step 3 from the "adding an Action" instructions above, but modify the relevant `ActionArgs` files.
-
-## 2. Setting Functionality
-
-Now that the Terminal Settings Model is updated, Windows Terminal can read and write to the settings file. This section covers how to add functionality to your newly created setting.
-
-### App-level settings
-
-App-level settings are settings that affect the frame of Windows Terminal. Generally, these tend to be global settings. The `TerminalApp` project is responsible for presenting the frame of Windows Terminal. A few files of interest include:
-- `TerminalPage`: XAML control responsible for the look and feel of Windows Terminal
-- `AppLogic`: WinRT class responsible for window-related issues (i.e. the titlebar, focus mode, etc...)
-
-Both have access to a `CascadiaSettings` object, for you to read the loaded setting and update Windows Terminal appropriately.
-
-### Terminal-level settings
-
-Terminal-level settings are settings that affect a shell session. Generally, these tend to be profile settings. The `TerminalApp` project is responsible for packaging this settings from the Terminal Settings Model to the terminal instance. There are two kinds of settings here:
-- `IControlSettings`:
-  - These are settings that affect the `TerminalControl` (a XAML control that hosts a shell session).
-  - Examples include background image customization, interactivity behavior (i.e. selection), acrylic and font customization.
-  - The `TerminalControl` project has access to these settings via a saved `IControlSettings` member.
-- `ICoreSettings`:
-  - These are settings that affect the `TerminalCore` (a lower level object that interacts with the text buffer).
-  - Examples include initial size, history size, and cursor customization.
-  - The `TerminalCore` project has access to these settings via a saved `ICoreSettings` member.
-
-`TerminalApp` packages these settings into a `TerminalSettings : IControlSettings, ICoreSettings` object upon creating a new terminal instance. To do so, you must submit the following changes:
-- Declare the setting in `IControlSettings.idl` or `ICoreSettings.idl` (whichever is relevant to your setting). If your setting is an enum setting, declare the enum here instead of in the `TerminalSettingsModel` project.
-- In `TerminalSettings.h`, declare/define the setting...
-```c++
-// The GETSET_PROPERTY macro declares/defines a getter setter for the setting.
-// Like GETSET_SETTING, it takes in a type, name, and defaultValue.
-GETSET_PROPERTY(bool, UseAcrylic, false);
-```
-- In `TerminalSettings.cpp`...
-  - update `_ApplyProfileSettings` for profile settings
-  - update `_ApplyGlobalSettings` for global settings
-  - If additional processing is necessary, that would happen here. For example, `backgroundImageAlignment` is stored as a `ConvergedAlignment` in the Terminal Settings Model, but converted into XAML's separate horizontal and vertical alignment enums for packaging.
-
-### Actions
-
-Actions are packaged as an `ActionAndArgs` object, then handled in `TerminalApp`. To add functionality for actions...
-- In the `ShortcutActionDispatch` files, dispatch an event when the action occurs...
-```c++
-// ShortcutActionDispatch.idl
-event Windows.Foundation.TypedEventHandler<ShortcutActionDispatch, Microsoft.Terminal.Settings.Model.ActionEventArgs> OpenSettings;
-
-// ShortcutActionDispatch.h
-TYPED_EVENT(OpenSettings, TerminalApp::ShortcutActionDispatch, Microsoft::Terminal::Settings::Model::ActionEventArgs);
-
-// ShortcutActionDispatch.cpp --> DoAction()
-// - dispatch the appropriate event
-case ShortcutAction::OpenSettings:
-{
-    _OpenSettingsHandlers(*this, eventArgs);
-    break;
-}
-```
-- In `TerminalPage` files, handle the event...
-```c++
-// TerminalPage.h
-// - declare the handler
-void _HandleOpenSettings(const IInspectable& sender, const Microsoft::Terminal::Settings::Model::ActionEventArgs& args);
-
-// TerminalPage.cpp --> _RegisterActionCallbacks()
-// - register the handler
-_actionDispatch->OpenSettings({ this, &TerminalPage::_HandleOpenSettings });
-
-// AppActionHandlers.cpp
-// - direct the function to the right place and call a helper function
-void TerminalPage::_HandleOpenSettings(const IInspectable& /*sender*/,
-                                       const ActionEventArgs& args)
-{
-    // NOTE: this if-statement can be omitted if the action does not support arguments
-    if (const auto& realArgs = args.ActionArgs().try_as<OpenSettingsArgs>())
-    {
-        _LaunchSettings(realArgs.Target());
-        args.Handled(true);
-    }
-}
-```
-
-`AppActionHandlers` vary based on the action you want to perform. A few useful helper functions include:
-- `_GetFocusedTab()`: retrieves the focused tab
-- `_GetActiveControl()`: retrieves the active terminal control
-- `_GetTerminalTabImpl()`: tries to cast the given tab as a `TerminalTab` (a tab that hosts a terminal instance)
-
-
-## 3. Settings UI
-
-### Exposing Enum Settings
-If the new setting supports enums, you need to expose a map of the enum and the respective value in the Terminal Settings Model's `EnumMappings`:
-
-```c++
-// EnumMappings.idl
-static Windows.Foundation.Collections.IMap<String, Microsoft.Terminal.Settings.Model.CloseOnExitMode> CloseOnExitMode { get; };
-
-// EnumMappings.h
-static winrt::Windows::Foundation::Collections::IMap<winrt::hstring, CloseOnExitMode> CloseOnExitMode();
-
-// EnumMappings.cpp
-// - this macro leverages the json enum mapper in TerminalSettingsSerializationHelper to expose
-//   the mapped values across project boundaries
-DEFINE_ENUM_MAP(Model::CloseOnExitMode, CloseOnExitMode);
-```
-
-### Binding and Localizing the Enum Setting
-
-Find the page in the Settings UI that the new setting fits best in. In this example, we are adding `LaunchMode`.
-1. In `Launch.idl`, expose the bindable setting...
-```c++
-// Expose the current value for the setting
-IInspectable CurrentLaunchMode;
-
-// Expose the list of possible values
-Windows.Foundation.Collections.IObservableVector<Microsoft.Terminal.Settings.Editor.EnumEntry> LaunchModeList { get; };
-```
-
-2. In `Launch.h`, declare the bindable enum setting...
-```c++
-// the GETSET_BINDABLE_ENUM_SETTING macro accepts...
-// - name: the name of the setting
-// - enumType: the type of the setting
-// - settingsModelName: how to retrieve the setting (use State() to get access to the settings model)
-// - settingNameInModel: the name of the setting in the terminal settings model
-GETSET_BINDABLE_ENUM_SETTING(LaunchMode, Model::LaunchMode, State().Settings().GlobalSettings, LaunchMode);
-```
-
-3. In `Launch.cpp`, populate these functions...
-```c++
-// Constructor (after InitializeComponent())
-// the INITIALIZE_BINDABLE_ENUM_SETTING macro accepts...
-// - name: the name of the setting
-// - enumMappingsName: the name from the TerminalSettingsModel's EnumMappings
-// - enumType: the type for the enum
-// - resourceSectionAndType: prefix for the localization
-// - resourceProperty: postfix for the localization
-INITIALIZE_BINDABLE_ENUM_SETTING(LaunchMode, LaunchMode, LaunchMode, L"Globals_LaunchMode", L"Content");
-```
-
-4. In `Resources.resw` for Microsoft.Terminal.Settings.Editor, add the localized text to expose each enum value. Use the following format: `<SettingGroup>_<SettingName><EnumValue>.Content`
-  - `SettingGroup`:
-    - `Globals` for global settings
-    - `Profile` for profile settings
-  - `SettingName`:
-    - the Pascal-case format for the setting type (i.e. `LaunchMode` for `"launchMode"`)
-  - `EnumValue`:
-    - the json key for the setting value, but with the first letter capitalized (i.e. `Focus` for `"focus"`)
-  - The resulting resw key should look something like this `Globals_LaunchModeFocus.Content`
-  - This is the text that will be used in your control
-
-### Updating the UI
-
-#### Enum Settings
-
-Now, create a XAML control in the relevant XAML file. Use the following tips and tricks to style everything appropriately:
-- Wrap the control in a `ContentPresenter` adhering to the `SettingContainerStyle` style
-- Bind `SelectedItem` to the relevant `Current<Setting>` (i.e. `CurrentLaunchMode`). Ensure it's a TwoWay binding
-- Bind `ItemsSource` to `<Setting>List` (i.e. `LaunchModeList`)
-- Set the ItemTemplate to the `Enum<ControlType>Template` (i.e. `EnumRadioButtonTemplate` for radio buttons)
-- Set the style to the appropriate one in `CommonResources.xaml`
-
-```xml
-<!--Launch Mode-->
-<ContentPresenter Style="{StaticResource SettingContainerStyle}">
-    <muxc:RadioButtons x:Uid="Globals_LaunchMode"
-                       SelectedItem="{x:Bind CurrentLaunchMode, Mode="TwoWay"}"
-                       ItemsSource="{x:Bind LaunchModeList}"
-                       ItemTemplate="{StaticResource EnumRadioButtonTemplate}"
-                       Style="{StaticResource RadioButtonsSettingStyle}"/>
-</ContentPresenter>
-```
-
-To add any localized text, add a `x:Uid`, and access the relevant property via the Resources.resw file. For example, `Globals_LaunchMode.Header` sets the header for this control. You can also set the tooltip text like this:
-`Globals_DefaultProfile.[using:Windows.UI.Xaml.Controls]ToolTipService.ToolTip`.
-
-#### Non-Enum Settings
-
-Continue to reference `CommonResources.xaml` for appropriate styling and wrap the control with a similar `ContentPresenter`. However, instead of binding to the `Current<Setting>` and `<Setting>List`, bind directly to the setting via the state. Binding a setting like `altGrAliasing` should look something like this:
-```xml
-<!--AltGr Aliasing-->
-<ContentPresenter Style="{StaticResource SettingContainerStyle}">
-    <CheckBox x:Uid="Profile_AltGrAliasing"
-              IsChecked="{x:Bind State.Profile.AltGrAliasing, Mode=TwoWay}"
-              Style="{StaticResource CheckBoxSettingStyle}"/>
-</ContentPresenter>
-```
-
-#### Profile Settings
-
-If you are specifically adding a Profile setting, in addition to the steps above, you need to make the setting observable by modifying the `Profiles` files...
-```c++
-// Profiles.idl --> ProfileViewModel
-// - this declares the setting as observable using the type and the name of the setting
-OBSERVABLE_PROJECTED_SETTING(Microsoft.Terminal.Settings.Model.CloseOnExitMode, CloseOnExit);
-
-// Profiles.h --> ProfileViewModel
-// - this defines the setting as observable off of the _profile object
-OBSERVABLE_PROJECTED_SETTING(_profile, CloseOnExit);
-
-// Profiles.h --> ProfileViewModel
-// - if the setting cannot be inherited by another profile (aka missing the Clear() function), use the following macro instead:
-PERMANENT_OBSERVABLE_PROJECTED_SETTING(_profile, Guid);
-```
-
-The `ProfilePageNavigationState` holds a `ProfileViewModel`, which wraps the `Profile` object from the Terminal Settings Model. The `ProfileViewModel` makes all of the profile settings observable.
-
-### Actions
-
-Actions are not yet supported in the Settings UI.

doc/cascadia/profiles.schema.json

@@ -93,8 +93,6 @@
         "scrollDownPage",
         "scrollUp",
         "scrollUpPage",
-        "scrollToBottom",
-        "scrollToTop",
         "sendInput",
         "setColorScheme",
         "setTabColor",
@@ -371,13 +369,6 @@
             "splitMode": {
               "default": "duplicate",
               "description": "Control how the pane splits. Only accepts \"duplicate\" which will duplicate the focused pane's profile into a new pane."
-            },
-            "size": {
-              "default": 0.5,
-              "description": "Specify how large the new pane should be, as a fraction of the current pane's size. 1.0 would be 'all of the current pane', and 0.0 is 'None of the parent'. Accepts floating point values from 0-1 (default 0.5).",
-              "maximum": 1,
-              "minimum": 0,
-              "type": "number"
             }
           }
         }
@@ -658,10 +649,6 @@
           "description": "Sets the default profile. Opens by clicking the \"+\" icon or typing the key binding assigned to \"newTab\".",
           "type": "string"
         },
-        "startupActions": {
-          "description": "Sets the list of actions to apply if no command line is provided. Uses the same format as command line arguments",
-          "type": "string"
-        },
         "disabledProfileSources": {
           "description": "Disables all the dynamic profile generators in this list, preventing them from adding their profiles to the list of profiles on startup.",
           "items": {
@@ -935,10 +922,9 @@
         },
         "cursorShape": {
           "default": "bar",
-          "description": "Sets the shape of the cursor. Possible values:\n -\"bar\" ( ┃, default )\n -\"doubleUnderscore\" ( ‗ )\n -\"emptyBox\" ( ▯ )\n -\"filledBox\" ( █ )\n -\"underscore\" ( ▁ )\n -\"vintage\" ( ▃ )",
+          "description": "Sets the shape of the cursor. Possible values:\n -\"bar\" ( ┃, default )\n -\"emptyBox\" ( ▯ )\n -\"filledBox\" ( █ )\n -\"underscore\" ( ▁ )\n -\"vintage\" ( ▃ )",
           "enum": [
             "bar",
-            "doubleUnderscore",
             "emptyBox",
             "filledBox",
             "underscore",

doc/specs/#2871 - Pane Navigation/#2871 - Pane Navigation.md

@@ -1,302 +0,0 @@
----
-author: Mike Griese @zadjii-msft
-created on: 2020-11-23
-last updated: 2020-12-15
-issue id: #2871
----
-
-# Focus Pane Actions
-
-## Abstract
-
-Currently, the Terminal only allows users to navigate through panes
-_directionally_. However, we might also want to allow a user to navigate through
-panes in most recently used order ("MRU" order), or to navigate directly to a
-specific pane. This spec proposes some additional actions in order to enable
-these sorts of scenarios.
-
-## Background
-
-### Inspiration
-
-`tmux` allows the user to navigate through panes using its `select-pane`
-command. The `select-pane` command works in the following way:
-
-```
-select-pane [-DLlMmRU] [-T title] [-t target-pane]
-
-     Make pane target-pane the active pane in window target-window, or set its
-     style (with -P).  If one of -D, -L, -R, or -U is used, respectively the
-     pane below, to the left, to the right, or above the target pane is used.
-     -l is the same as using the last-pane command.
-
-     -m and -M are used to set and clear the marked pane.  There is one marked
-     pane at a time, setting a new marked pane clears the last.  The marked pane
-     is the default target for -s to join-pane, swap-pane and swap-window.
-```
-_from `man tmux`_.
-
-The Terminal currently allows the user to navigate through panes with the
-`moveFocus` action, which only accepts a `direction` to move in.
-
-Additionally, the Terminal allows movement between tabs with the `nextTab` and
-`prevTab` actions, who move between tabs either in-order or in MRU order.
-Furthermore, these actions may or may not display the "tab switcher" user
-interface, based on the value of `tabSwitcherMode`.
-
-### User Stories
-
-* **Scenario 1**: A user who wants to be able to split the window into 4 equal
-  corners from the commandline. Currently this isn't possible, because the user
-  cannot move focus during the startup actions - `split-pane` actions always end
-  up splitting the current leaf in the tree of panes. (see [#5464])
-* **Scenario 2**: A user who wants to quickly navigate to the previous pane they
-  had opened. (see [#2871])
-* **Scenario 3**: A user who wants to bind a keybinding like <kbd>alt+1</kbd>,
-  <kbd>alt+2</kbd>, etc to immediately focus the first, second, etc. pane in a
-  tab. (see [#5803])
-
-### Future Considerations
-
-There's been talk of updating the advanced tab switcher to also display panes,
-in addition to just tabs. This would allow users to navigate through the ATS
-directly to a pane, and see all the panes in a tab. Currently, `tabSwitcherMode`
-changes the behavior of `nextTab`, `prevTab` - should we just build the
-`paneSwitcherMode` directly into the action we end up designing?
-
-## Solution Design
-
-Does using the pane switcher with a theoretical `focusPane(target=id)` action
-even make sense? Certainly not! That's like `switchToTab(index=id)`, the user
-already knows which tab they want to go to, there's no reason to pop an
-ephemeral UI in front of them.
-
-Similarly, it almost certainly doesn't make sense to display the pane switcher
-while moving focus directionally. Consider moving focus with a key bound to the
-arrow keys. Displaying another UI in front of them while moving focus with the
-arrow keys would be confusing.
-
-Addressing Scenario 1 is relatively easy. So long as we add any of the proposed
-actions, including the existing `moveFocus` action as a subcommand that can be
-passed to `wt.exe`, then the user should be able to navigate through the panes
-they've created with the startup commandline, and build the tree of panes
-however they see fit.
-
-Scenario 2 is more complicated, because MRU switching is always more
-complicated. Without a UI of some sort, there's no way to switch to another pane
-in the MRU order without also updating the MRU order as you go. So this would
-almost certainly necessitate a "pane switcher", like the tab switcher.
-
-
-### Proposal A: Add next, prev to moveFocus
-
-* `moveFocus(direction="up|down|left|right|next|prev")`
-
-* **Pros**:
-  - Definitely gets the "MRU Pane Switching" scenario working
-* **Cons**:
-  - Doesn't really address any of the other scenarios
-  - How will it play with pane switching in the UI?
-  - MRU switching without a dialog to track & display the MRU stack doesn't
-    really work - this only allows to the user to navigate to the most recently
-    used pane, or through all the panes in least-recently-used order. This is
-    because switching to the MRU pane _will update the MRU pane_.
-
-❌ This proposal is no longer being considered.
-
-### Proposal B: focusNextPane, focusPrevPane with order, useSwitcher args
-
-```json
-// Focus pane 1
-// - This is sensible, no arguments here
-{ "command": { "action": "focusPane", "id": 1 } },
-
-// Focus the next MRU pane
-// - Without the switcher, this can only go one pane deep in the MRU stack
-// - presumably once there's a pane switcher, it would default to enabled?
-{ "command": { "action": "focusNextPane", "order": "mru" } },
-
-// Focus the prev inOrder pane
-// - this seems straightforward
-{ "command": { "action": "focusPrevPane", "order": "inOrder" } },
-
-// Focus the next pane, in mru order, explicitly disable the switcher
-// - The user opted in to only being able to MRU switch one deep. That's fine, that's what they want.
-{ "command": { "action": "focusNextPane", "order": "mru", "useSwitcher": false} },
-
-// Focus the prev inOrder pane, explicitly with the switcher
-// - Maybe they disabled the switcher globally, but what it on for this action?
-{ "command": { "action": "focusPrevPane", "order": "inOrder", "useSwitcher": true } },
-```
-_From [discussion in the implementation
-PR](https://github.com/microsoft/terminal/pull/8183#issuecomment-729672645)_
-
-Boiled down, that's three actions:
-* `focusPane(target=id)`
-* `focusNextPane(order="inOrder|mru", useSwitcher=true|false)`
-* `focusPrevPane(order="inOrder|mru", useSwitcher=true|false)`
-
-* **Pros**:
-  - Everything is explicit, including the option to use the pane switcher (when
-    available)
-  - Adds support for in-order pane switching
-  - No "conditional parameters" - where providing one argument makes other
-    arguments invalid or ambiguous.
-* **Cons**:
-  - Doesn't really address any of the other scenarios
-  - What does the "next most-recently-used tab" even mean? How is it different
-    than "previous most-recently-used tab"? Semantically, these are the same
-    thing!
-  - No one's even asked for in-order pane switching. Is that a UX that even
-    really makes sense?
-
-❌ This proposal is no longer being considered.
-
-> 👉 **NOTE**: At this point, we stopped considering navigating in both MRU
-> "directions", since both the next and prev MRU pane are the same thing. We're
-> now using "last" to mean "the previous MRU pane".
-
-### Proposal C: One actions, combine the args
-
-* `moveFocus(target=id|"up|down|left|right|last")`
-
-* **Pros**:
-  - Absolutely the least complicated action to author. There's only one
-    parameter, `target`.
-  - No "conditional parameters".
-* **Cons**:
-  - How do we express this in the Settings UI? Mixed-type enums work fine for
-    the font weight, where each enum value has a distinct integer value it maps
-    to, but in this case, using `id` is entirely different from the other
-    directional values
-
-❌ This proposal is no longer being considered.
-
-### Proposal D: Two actions
-
-* `focusPane(target=id)`
-* `moveFocus(direction="up|down|left|right|last")`
-
-* **Pros**:
-  - Each action does explicitly one thing.
-* **Cons**:
-  - two actions for _similar_ behavior
-  - This now forks the "Direction" enum into "MoveFocusDirection" and
-    "ResizeDirection" (because `resizePane(last)` doesn't make any sense).
-
-This proposal doesn't really have any special consideration for the pane
-switcher UX. Neither of these actions would summon the pane switcher UX.
-
-### Proposal E: Three actions
-
-* `focusPane(target=id)`
-* `moveFocus(direction="up|down|left|right")`
-* `focusLastPane(usePaneSwitcher=false|true)`
-
-In this design, neither `focusPane` nor `moveFocus` will summon the pane
-switcher UI (even once it's added). However, the `focusLastPane` one _could_,
-and subsequent keypresses could pop you through the MRU stack, while it's
-visible? The pane switcher could then display the panes for the tab in MRU
-order, and the user could just use the arrow keys to navigate the list if they
-so choose.
-
-* **Pros**:
-  - Each action does explicitly one thing.
-  - Design accounts for future pane switcher UX
-* **Cons**:
-  - Three separate actions for similar behavior
-
-❌ This proposal is no longer being considered.
-
-### Proposal F: It's literally just tmux
-
-_Also known as the "one action to rule them all" proposal_
-
-`focusPane(target=id, direction="up|down|left|right|last")`
-
-Previously, this design was avoided, because what does `focusPane(target=4,
-direction=down)` do? Does it focus pane 4, or does it move focus down?
-
-`tmux` solves this in one action by just doing both!
-
-```
-Make pane target-pane the active pane ...  If one of -D, -L, -R, or -U is used,
-respectively the pane below, to the left, to the right, or above the target pane
-is used.
-```
-_from `man tmux`_.
-
-So `focusPane(target=1, direction=up)` will attempt to focus the pane above pane
-1. This action would not summon the pane switcher UX, even for
-`focusPane(direction=last)`
-
-* **Pros**:
-  - Fewest redundant actions
-* **Cons**:
-  - Is this intuitive? That combining the params would do both, with `target`
-    happening "first"?
-  - Assumes that there will be a separate action added in the future for "Open
-    the pane switcher (with some given ordering)"
-
-
-> 👉 **NOTE**: At this point, the author considered "Do we even want a separate
-> action to engage the tab switcher with panes expanded?" Perhaps panes being
-> visible in the tab switcher is just part fo the tab switcher's behavior. Maybe
-> there shouldn't be a separate "open the tab switcher with the panes expanded
-> to the pane I'm currently on, and the panes listed in MRU order" action.
-
-❌ This proposal is no longer being considered.
-
-## Conclusion
-
-After much discussion as a team, we decided that **Proposal D** would be the
-best option. We felt that there wasn't a need to add any extra configuration to
-invoke the "pane switcher" as anything different than the "tab switcher". The
-"pane switcher" should really just exist as a part of the functionality of the
-advanced tab switcher, not as it's own thing.
-
-Additionally, we concurred that the new "direction" value should be `prev`, not
-`last`, for consistency's sake.
-
-## UI/UX Design
-
-The only real UX being added with the agreed upon design is allowing the user to
-execute an action to move to the previously active pane within a single tab. No
-additional UX (including the pane switcher) is being prescribed in this spec at
-this time.
-
-## Potential Issues
-
-<table>
-<tr>
-<td><strong>Compatibility</strong></td>
-<td>
-
-We've only adding a single enum value to an existing enum. Since we're not
-changing the meaning of any of the existing values, we do not expect any
-compatibility issues there. Additionally, we're not changing the default value
-of the `direction` param of the `moveFocus` action, so there are no further
-compatibility concerns there. Furthermore, no additional parameters are being
-added to the `moveFocus` action that would potentially give it a different
-meaning.
-
-</td>
-</tr>
-</table>
-
-In the current design, there's no way to move through all the panes with a
-single keybinding. For example, if a user wanted to bind <kbd>Alt+]</kbd> to
-move to the "next" pane, and <kbd>Alt+[</kbd> to move to the "previous" one.
-These movements would necessarily need to be in-order traversals, since there's
-no way of doing multiple MRU steps.
-
-Fortunately, no one's really asked for traversing the panes in-order, so we're
-not really worried about this. Otherwise, it would maybe make sense for `last`
-to be the "previous MRU pane", and reserve `next`/`prev` for in-order traversal.
-
-
-[#2871]: https://github.com/microsoft/terminal/issues/2871
-[#5464]: https://github.com/microsoft/terminal/issues/5464
-[#5803]: https://github.com/microsoft/terminal/issues/5803
-
-

res/README.md

@@ -17,5 +17,5 @@ Please consult the [license](https://raw.githubusercontent.com/microsoft/cascadi
 
 ### Fonts Included
 
-* Cascadia Code, Cascadia Mono (2102.25)
-   * from microsoft/cascadia-code@911dc421f333e3b72b97381d16fee5b71eb48f04
+* Cascadia Code, Cascadia Mono (2009.21)
+   * from microsoft/cascadia-code@32f84124db1970fa5d032f0fe9019e6922961beb

src/buffer/out/AttrRow.cpp

@@ -184,7 +184,7 @@ size_t ATTR_ROW::FindAttrIndex(const size_t index, size_t* const pApplies) const
 // Routine Description:
 // - Finds the hyperlink IDs present in this row and returns them
 // Return value:
-// - The hyperlink IDs present in this row
+// - An unordered set containing the hyperlink IDs present in this row
 std::vector<uint16_t> ATTR_ROW::GetHyperlinks()
 {
     std::vector<uint16_t> ids;

src/buffer/out/AttrRow.hpp

@@ -39,6 +39,8 @@ public:
     noexcept = default;
     ATTR_ROW& operator=(ATTR_ROW&&) noexcept = default;
 
+    void Reset(const TextAttribute attr);
+
     TextAttribute GetAttrByColumn(const size_t column) const;
     TextAttribute GetAttrByColumn(const size_t column,
                                   size_t* const pApplies) const;
@@ -70,16 +72,12 @@ public:
 
     friend bool operator==(const ATTR_ROW& a, const ATTR_ROW& b) noexcept;
     friend class AttrRowIterator;
-    friend class ROW;
 
 private:
-    void Reset(const TextAttribute attr);
-
     boost::container::small_vector<TextAttributeRun, 1> _list;
     size_t _cchRowWidth;
 
 #ifdef UNIT_TESTING
     friend class AttrRowTests;
-    friend class CommonState;
 #endif
 };

src/buffer/out/CharRow.cpp

@@ -18,12 +18,58 @@
 #pragma warning(push)
 #pragma warning(disable : 26447) // small_vector's constructor says it can throw but it should not given how we use it.  This suppresses this error for the AuditMode build.
 CharRow::CharRow(size_t rowWidth, ROW* const pParent) noexcept :
+    _wrapForced{ false },
+    _doubleBytePadded{ false },
     _data(rowWidth, value_type()),
     _pParent{ FAIL_FAST_IF_NULL(pParent) }
 {
 }
 #pragma warning(pop)
 
+// Routine Description:
+// - Sets the wrap status for the current row
+// Arguments:
+// - wrapForced - True if the row ran out of space and we forced to wrap to the next row. False otherwise.
+// Return Value:
+// - <none>
+void CharRow::SetWrapForced(const bool wrapForced) noexcept
+{
+    _wrapForced = wrapForced;
+}
+
+// Routine Description:
+// - Gets the wrap status for the current row
+// Arguments:
+// - <none>
+// Return Value:
+// - True if the row ran out of space and we were forced to wrap to the next row. False otherwise.
+bool CharRow::WasWrapForced() const noexcept
+{
+    return _wrapForced;
+}
+
+// Routine Description:
+// - Sets the double byte padding for the current row
+// Arguments:
+// - fWrapWasForced - True if the row ran out of space for a double byte character and we padded out the row. False otherwise.
+// Return Value:
+// - <none>
+void CharRow::SetDoubleBytePadded(const bool doubleBytePadded) noexcept
+{
+    _doubleBytePadded = doubleBytePadded;
+}
+
+// Routine Description:
+// - Gets the double byte padding status for the current row.
+// Arguments:
+// - <none>
+// Return Value:
+// - True if the row didn't have space for a double byte character and we were padded out the row. False otherwise.
+bool CharRow::WasDoubleBytePadded() const noexcept
+{
+    return _doubleBytePadded;
+}
+
 // Routine Description:
 // - gets the size of the row, in glyph cells
 // Arguments:
@@ -47,6 +93,9 @@ void CharRow::Reset() noexcept
     {
         cell.Reset();
     }
+
+    _wrapForced = false;
+    _doubleBytePadded = false;
 }
 
 // Routine Description:

src/buffer/out/CharRow.hpp

@@ -56,14 +56,21 @@ public:
 
     CharRow(size_t rowWidth, ROW* const pParent) noexcept;
 
+    void SetWrapForced(const bool wrap) noexcept;
+    bool WasWrapForced() const noexcept;
+    void SetDoubleBytePadded(const bool doubleBytePadded) noexcept;
+    bool WasDoubleBytePadded() const noexcept;
     size_t size() const noexcept;
+    void Reset() noexcept;
     [[nodiscard]] HRESULT Resize(const size_t newSize) noexcept;
     size_t MeasureLeft() const noexcept;
     size_t MeasureRight() const;
+    void ClearCell(const size_t column);
     bool ContainsText() const noexcept;
     const DbcsAttribute& DbcsAttrAt(const size_t column) const;
     DbcsAttribute& DbcsAttrAt(const size_t column);
     void ClearGlyph(const size_t column);
+    std::wstring GetText() const;
 
     const DelimiterClass DelimiterClassAt(const size_t column, const std::wstring_view wordDelimiters) const;
 
@@ -74,11 +81,9 @@ public:
     // iterators
     iterator begin() noexcept;
     const_iterator cbegin() const noexcept;
-    const_iterator begin() const noexcept { return cbegin(); }
 
     iterator end() noexcept;
     const_iterator cend() const noexcept;
-    const_iterator end() const noexcept { return cend(); }
 
     UnicodeStorage& GetUnicodeStorage() noexcept;
     const UnicodeStorage& GetUnicodeStorage() const noexcept;
@@ -87,14 +92,15 @@ public:
     void UpdateParent(ROW* const pParent);
 
     friend CharRowCellReference;
-    friend class ROW;
-
-private:
-    void Reset() noexcept;
-    void ClearCell(const size_t column);
-    std::wstring GetText() const;
+    friend constexpr bool operator==(const CharRow& a, const CharRow& b) noexcept;
 
 protected:
+    // Occurs when the user runs out of text in a given row and we're forced to wrap the cursor to the next line
+    bool _wrapForced;
+
+    // Occurs when the user runs out of text to support a double byte character and we're forced to the next line
+    bool _doubleBytePadded;
+
     // storage for glyph data and dbcs attributes
     boost::container::small_vector<value_type, 120> _data;
 
@@ -102,6 +108,13 @@ protected:
     ROW* _pParent;
 };
 
+constexpr bool operator==(const CharRow& a, const CharRow& b) noexcept
+{
+    return (a._wrapForced == b._wrapForced &&
+            a._doubleBytePadded == b._doubleBytePadded &&
+            a._data == b._data);
+}
+
 template<typename InputIt1, typename InputIt2>
 void OverwriteColumns(InputIt1 startChars, InputIt1 endChars, InputIt2 startAttrs, CharRow::iterator outIt)
 {

src/buffer/out/Row.cpp

@@ -21,8 +21,6 @@ ROW::ROW(const SHORT rowId, const unsigned short rowWidth, const TextAttribute f
     _rowWidth{ rowWidth },
     _charRow{ rowWidth, this },
     _attrRow{ rowWidth, fillAttribute },
-    _wrapForced{ false },
-    _doubleBytePadded{ false },
     _pParent{ pParent }
 {
 }
@@ -35,8 +33,6 @@ ROW::ROW(const SHORT rowId, const unsigned short rowWidth, const TextAttribute f
 // - <none>
 bool ROW::Reset(const TextAttribute Attr)
 {
-    _wrapForced = false;
-    _doubleBytePadded = false;
     _charRow.Reset();
     try
     {
@@ -163,7 +159,7 @@ OutputCellIterator ROW::WriteCells(OutputCellIterator it, const size_t index, co
                 else if (fillingLastColumn && it->DbcsAttr().IsLeading())
                 {
                     _charRow.ClearCell(currentIndex);
-                    SetDoubleBytePadded(true);
+                    _charRow.SetDoubleBytePadded(true);
                 }
                 // Otherwise, copy the data given and increment the iterator.
                 else
@@ -181,7 +177,7 @@ OutputCellIterator ROW::WriteCells(OutputCellIterator it, const size_t index, co
                 if (wrap.has_value() && fillingLastColumn)
                 {
                     // set wrap status on the row to parameter's value.
-                    SetWrapForced(*wrap);
+                    _charRow.SetWrapForced(wrap.value());
                 }
             }
             else

src/buffer/out/Row.hpp

@@ -24,6 +24,7 @@ Revision History:
 #include "OutputCell.hpp"
 #include "OutputCellIterator.hpp"
 #include "CharRow.hpp"
+#include "RowCellIterator.hpp"
 #include "UnicodeStorage.hpp"
 
 class TextBuffer;
@@ -36,12 +37,6 @@ public:
 
     size_t size() const noexcept { return _rowWidth; }
 
-    void SetWrapForced(const bool wrap) noexcept { _wrapForced = wrap; }
-    bool WasWrapForced() const noexcept { return _wrapForced; }
-
-    void SetDoubleBytePadded(const bool doubleBytePadded) noexcept { _doubleBytePadded = doubleBytePadded; }
-    bool WasDoubleBytePadded() const noexcept { return _doubleBytePadded; }
-
     const CharRow& GetCharRow() const noexcept { return _charRow; }
     CharRow& GetCharRow() noexcept { return _charRow; }
 
@@ -57,13 +52,17 @@ public:
     void ClearColumn(const size_t column);
     std::wstring GetText() const { return _charRow.GetText(); }
 
+    RowCellIterator AsCellIter(const size_t startIndex) const { return AsCellIter(startIndex, size() - startIndex); }
+    RowCellIterator AsCellIter(const size_t startIndex, const size_t count) const { return RowCellIterator(*this, startIndex, count); }
+
     UnicodeStorage& GetUnicodeStorage() noexcept;
     const UnicodeStorage& GetUnicodeStorage() const noexcept;
 
     OutputCellIterator WriteCells(OutputCellIterator it, const size_t index, const std::optional<bool> wrap = std::nullopt, std::optional<size_t> limitRight = std::nullopt);
 
+    friend bool operator==(const ROW& a, const ROW& b) noexcept;
+
 #ifdef UNIT_TESTING
-    friend constexpr bool operator==(const ROW& a, const ROW& b) noexcept;
     friend class RowTests;
 #endif
 
@@ -72,18 +71,14 @@ private:
     ATTR_ROW _attrRow;
     SHORT _id;
     unsigned short _rowWidth;
-    // Occurs when the user runs out of text in a given row and we're forced to wrap the cursor to the next line
-    bool _wrapForced;
-    // Occurs when the user runs out of text to support a double byte character and we're forced to the next line
-    bool _doubleBytePadded;
     TextBuffer* _pParent; // non ownership pointer
 };
 
-#ifdef UNIT_TESTING
-constexpr bool operator==(const ROW& a, const ROW& b) noexcept
+inline bool operator==(const ROW& a, const ROW& b) noexcept
 {
-    // comparison is only used in the tests; this should suffice.
-    return (a._pParent == b._pParent &&
+    return (a._charRow == b._charRow &&
+            a._attrRow == b._attrRow &&
+            a._rowWidth == b._rowWidth &&
+            a._pParent == b._pParent &&
             a._id == b._id);
 }
-#endif

src/buffer/out/RowCellIterator.cpp

@@ -0,0 +1,110 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+
+#include "precomp.h"
+
+#include "RowCellIterator.hpp"
+#include "Row.hpp"
+
+#include "../../types/inc/convert.hpp"
+#include "../../types/inc/Utf16Parser.hpp"
+
+RowCellIterator::RowCellIterator(const ROW& row, const size_t start, const size_t length) :
+    _row(row),
+    _start(start),
+    _length(length),
+    _pos(start),
+    _view(s_GenerateView(row, start))
+{
+}
+
+RowCellIterator::operator bool() const noexcept
+{
+    // In lieu of using start and end, this custom iterator type simply becomes bool false
+    // when we run out of items to iterate over.
+    return _pos < (_start + _length);
+}
+
+bool RowCellIterator::operator==(const RowCellIterator& it) const noexcept
+{
+    return _row == it._row &&
+           _start == it._start &&
+           _length == it._length &&
+           _pos == it._pos;
+}
+bool RowCellIterator::operator!=(const RowCellIterator& it) const noexcept
+{
+    return !(*this == it);
+}
+
+RowCellIterator& RowCellIterator::operator+=(const ptrdiff_t& movement) noexcept
+{
+    _pos += movement;
+
+    return (*this);
+}
+
+RowCellIterator& RowCellIterator::operator++() noexcept
+{
+    return this->operator+=(1);
+}
+
+RowCellIterator RowCellIterator::operator++(int) noexcept
+{
+    auto temp(*this);
+    operator++();
+    return temp;
+}
+
+RowCellIterator RowCellIterator::operator+(const ptrdiff_t& movement) noexcept
+{
+    auto temp(*this);
+    temp += movement;
+    return temp;
+}
+
+const OutputCellView& RowCellIterator::operator*() const noexcept
+{
+    return _view;
+}
+
+const OutputCellView* RowCellIterator::operator->() const noexcept
+{
+    return &_view;
+}
+
+// Routine Description:
+// - Member function to update the view to the current position in the buffer with
+//   the data held on this object.
+// Arguments:
+// - <none>
+// Return Value:
+// - <none>
+void RowCellIterator::_RefreshView()
+{
+    _view = s_GenerateView(_row, _pos);
+}
+
+// Routine Description:
+// - Static function to create a view.
+// - It's pulled out statically so it can be used during construction with just the given
+//   variables (so OutputCellView doesn't need an empty default constructor)
+// - This will infer the width of the glyph and apply the appropriate attributes to the view.
+// Arguments:
+// - view - View representing characters corresponding to a single glyph
+// - attr - Color attributes to apply to the text
+// Return Value:
+// - Object representing the view into this cell
+OutputCellView RowCellIterator::s_GenerateView(const ROW& row,
+                                               const size_t pos)
+{
+    const auto& charRow = row.GetCharRow();
+
+    const auto glyph = charRow.GlyphAt(pos);
+    const auto dbcsAttr = charRow.DbcsAttrAt(pos);
+
+    const auto textAttr = row.GetAttrRow().GetAttrByColumn(pos);
+    const auto behavior = TextAttributeBehavior::Stored;
+
+    return OutputCellView(glyph, dbcsAttr, textAttr, behavior);
+}

src/buffer/out/RowCellIterator.hpp

@@ -0,0 +1,59 @@
+/*++
+Copyright (c) Microsoft Corporation
+Licensed under the MIT license.
+
+Module Name:
+- RowCellIterator.hpp
+
+Abstract:
+- Read-only view into cells already in the input buffer.
+- This is done for performance reasons (avoid heap allocs and copies).
+
+Author:
+- Michael Niksa (MiNiksa) 12-Oct-2018
+
+--*/
+
+#pragma once
+
+#include "OutputCellView.hpp"
+class ROW;
+
+class RowCellIterator final
+{
+public:
+    using iterator_category = std::forward_iterator_tag;
+    using value_type = OutputCellView;
+    using difference_type = ptrdiff_t;
+    using pointer = OutputCellView*;
+    using reference = OutputCellView&;
+
+    RowCellIterator(const ROW& row, const size_t start, const size_t length);
+    ~RowCellIterator() = default;
+
+    RowCellIterator& operator=(const RowCellIterator& it) = delete;
+
+    operator bool() const noexcept;
+
+    bool operator==(const RowCellIterator& it) const noexcept;
+    bool operator!=(const RowCellIterator& it) const noexcept;
+
+    RowCellIterator& operator+=(const ptrdiff_t& movement) noexcept;
+    RowCellIterator& operator++() noexcept;
+    RowCellIterator operator++(int) noexcept;
+    RowCellIterator operator+(const ptrdiff_t& movement) noexcept;
+
+    const OutputCellView& operator*() const noexcept;
+    const OutputCellView* operator->() const noexcept;
+
+private:
+    const ROW& _row;
+    const size_t _start;
+    const size_t _length;
+
+    size_t _pos;
+    OutputCellView _view;
+
+    void _RefreshView();
+    static OutputCellView s_GenerateView(const ROW& row, const size_t pos);
+};

src/buffer/out/lib/bufferout.vcxproj

@@ -18,6 +18,7 @@
     <ClCompile Include="..\OutputCellRect.cpp" />
     <ClCompile Include="..\OutputCellView.cpp" />
     <ClCompile Include="..\Row.cpp" />
+    <ClCompile Include="..\RowCellIterator.cpp" />
     <ClCompile Include="..\search.cpp" />
     <ClCompile Include="..\TextColor.cpp" />
     <ClCompile Include="..\TextAttribute.cpp" />
@@ -43,6 +44,7 @@
     <ClInclude Include="..\OutputCellRect.hpp" />
     <ClInclude Include="..\OutputCellView.hpp" />
     <ClInclude Include="..\Row.hpp" />
+    <ClInclude Include="..\RowCellIterator.hpp" />
     <ClInclude Include="..\search.h" />
     <ClInclude Include="..\TextColor.h" />
     <ClInclude Include="..\TextAttribute.h" />
@@ -58,4 +60,4 @@
   </ItemGroup>
   <!-- Careful reordering these. Some default props (contained in these files) are order sensitive. -->
   <Import Project="$(SolutionDir)src\common.build.post.props" />
-</Project>
+</Project>

src/buffer/out/sources.inc

@@ -37,6 +37,7 @@ SOURCES= \
     ..\OutputCellRect.cpp \
     ..\OutputCellView.cpp \
     ..\Row.cpp \
+    ..\RowCellIterator.cpp \
     ..\TextColor.cpp \
     ..\TextAttribute.cpp \
     ..\textBuffer.cpp \

src/buffer/out/textBuffer.cpp

@@ -254,7 +254,7 @@ bool TextBuffer::_AssertValidDoubleByteSequence(const DbcsAttribute dbcsAttribut
         // Erase previous character into an N type.
         try
         {
-            prevRow.ClearColumn(coordPrevPosition.X);
+            prevRow.GetCharRow().ClearCell(coordPrevPosition.X);
         }
         catch (...)
         {
@@ -296,8 +296,8 @@ bool TextBuffer::_PrepareForDoubleByteSequence(const DbcsAttribute dbcsAttribute
         if (GetCursor().GetPosition().X == sBufferWidth - 1)
         {
             // set that we're wrapping for double byte reasons
-            auto& row = GetRowByOffset(GetCursor().GetPosition().Y);
-            row.SetDoubleBytePadded(true);
+            CharRow& charRow = GetRowByOffset(GetCursor().GetPosition().Y).GetCharRow();
+            charRow.SetDoubleBytePadded(true);
 
             // then move the cursor forward and onto the next row
             fSuccess = IncrementCursor();
@@ -480,7 +480,7 @@ void TextBuffer::_AdjustWrapOnCurrentRow(const bool fSet)
     const UINT uiCurrentRowOffset = GetCursor().GetPosition().Y;
 
     // Set the wrap status as appropriate
-    GetRowByOffset(uiCurrentRowOffset).SetWrapForced(fSet);
+    GetRowByOffset(uiCurrentRowOffset).GetCharRow().SetWrapForced(fSet);
 }
 
 //Routine Description:
@@ -810,7 +810,8 @@ void TextBuffer::Reset()
 
     for (auto& row : _storage)
     {
-        row.Reset(attr);
+        row.GetCharRow().Reset();
+        row.GetAttrRow().Reset(attr);
     }
 }
 
@@ -1587,7 +1588,7 @@ const TextBuffer::TextAndColor TextBuffer::GetText(const bool includeCRLF,
         }
 
         // We apply formatting to rows if the row was NOT wrapped or formatting of wrapped rows is allowed
-        const bool shouldFormatRow = formatWrappedRows || !GetRowByOffset(iRow).WasWrapForced();
+        const bool shouldFormatRow = formatWrappedRows || !GetRowByOffset(iRow).GetCharRow().WasWrapForced();
 
         if (trimTrailingWhitespace)
         {
@@ -2068,7 +2069,7 @@ HRESULT TextBuffer::Reflow(TextBuffer& oldBuffer,
         // included.)
         // As such, adjust the "right" to be the width of the row
         // to capture all these spaces
-        if (row.WasWrapForced())
+        if (charRow.WasWrapForced())
         {
             iRight = cOldColsTotal;
 
@@ -2077,7 +2078,7 @@ HRESULT TextBuffer::Reflow(TextBuffer& oldBuffer,
             // piece of padding because of a double byte LEADING
             // character, then remove one from the "right" to
             // leave this padding out of the copy process.
-            if (row.WasDoubleBytePadded())
+            if (charRow.WasDoubleBytePadded())
             {
                 iRight--;
             }
@@ -2141,7 +2142,7 @@ HRESULT TextBuffer::Reflow(TextBuffer& oldBuffer,
             // Only do so if we were not forced to wrap. If we did
             // force a word wrap, then the existing line break was
             // only because we ran out of space.
-            if (iRight < cOldColsTotal && !row.WasWrapForced())
+            if (iRight < cOldColsTotal && !charRow.WasWrapForced())
             {
                 if (iRight == cOldCursorPos.X && iOldRow == cOldCursorPos.Y)
                 {
@@ -2185,7 +2186,7 @@ HRESULT TextBuffer::Reflow(TextBuffer& oldBuffer,
                     const COORD coordNewCursor = newCursor.GetPosition();
                     if (coordNewCursor.X == 0 && coordNewCursor.Y > 0)
                     {
-                        if (newBuffer.GetRowByOffset(gsl::narrow_cast<size_t>(coordNewCursor.Y) - 1).WasWrapForced())
+                        if (newBuffer.GetRowByOffset(gsl::narrow_cast<size_t>(coordNewCursor.Y) - 1).GetCharRow().WasWrapForced())
                         {
                             hr = newBuffer.NewlineCursor() ? hr : E_OUTOFMEMORY;
                         }
@@ -2218,7 +2219,7 @@ HRESULT TextBuffer::Reflow(TextBuffer& oldBuffer,
 
             // If the last row of the new buffer wrapped, there's going to be one less newline needed,
             //   because the cursor is already on the next line
-            if (newBuffer.GetRowByOffset(cNewLastChar.Y).WasWrapForced())
+            if (newBuffer.GetRowByOffset(cNewLastChar.Y).GetCharRow().WasWrapForced())
             {
                 iNewlines = std::max(iNewlines - 1, 0);
             }
@@ -2226,7 +2227,7 @@ HRESULT TextBuffer::Reflow(TextBuffer& oldBuffer,
             {
                 // if this buffer didn't wrap, but the old one DID, then the d(columns) of the
                 //   old buffer will be one more than in this buffer, so new need one LESS.
-                if (oldBuffer.GetRowByOffset(cOldLastChar.Y).WasWrapForced())
+                if (oldBuffer.GetRowByOffset(cOldLastChar.Y).GetCharRow().WasWrapForced())
                 {
                     iNewlines = std::max(iNewlines - 1, 0);
                 }
@@ -2416,7 +2417,7 @@ PointTree TextBuffer::GetPatterns(const size_t firstRow, const size_t lastRow) c
     for (auto i = firstRow; i <= lastRow; ++i)
     {
         auto& row = GetRowByOffset(i);
-        concatAll += row.GetText();
+        concatAll += row.GetCharRow().GetText();
     }
 
     // for each pattern we know of, iterate through the string

src/buffer/out/ut_textbuffer/ReflowTests.cpp

@@ -1,856 +0,0 @@
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT license.
-
-#include "precomp.h"
-#include "WexTestClass.h"
-#include "../../inc/consoletaeftemplates.hpp"
-
-#include "../textBuffer.hpp"
-#include "../../renderer/inc/DummyRenderTarget.hpp"
-#include "../../types/inc/Utf16Parser.hpp"
-#include "../../types/inc/GlyphWidth.hpp"
-
-#include <IDataSource.h>
-
-template<>
-class WEX::TestExecution::VerifyOutputTraits<wchar_t>
-{
-public:
-    static WEX::Common::NoThrowString ToString(const wchar_t& wch)
-    {
-        return WEX::Common::NoThrowString().Format(L"'%c'", wch);
-    }
-};
-
-using namespace WEX::Common;
-using namespace WEX::Logging;
-using namespace WEX::TestExecution;
-
-namespace
-{
-    struct TestRow
-    {
-        std::wstring_view text;
-        bool wrap;
-    };
-
-    struct TestBuffer
-    {
-        COORD size;
-        std::vector<TestRow> rows;
-        COORD cursor;
-    };
-
-    struct TestCase
-    {
-        std::wstring_view name;
-        std::vector<TestBuffer> buffers;
-    };
-
-    static constexpr auto true_due_to_exact_wrap_bug{ true };
-
-    static const TestCase testCases[] = {
-        TestCase{
-            L"No reflow required",
-            {
-                TestBuffer{
-                    { 6, 5 },
-                    {
-                        { L"AB    ", false },
-                        { L"$     ", false },
-                        { L"CD    ", false },
-                        { L"EFG   ", false },
-                        { L"      ", false },
-                    },
-                    { 0, 1 } // cursor on $
-                },
-                TestBuffer{
-                    { 5, 5 }, // reduce width by 1
-                    {
-                        { L"AB   ", false },
-                        { L"$    ", false },
-                        { L"CD   ", false },
-                        { L"EFG  ", false },
-                        { L"     ", false },
-                    },
-                    { 0, 1 } // cursor on $
-                },
-                TestBuffer{
-                    { 4, 5 },
-                    {
-                        { L"AB  ", false },
-                        { L"$   ", false },
-                        { L"CD  ", false },
-                        { L"EFG ", false },
-                        { L"    ", false },
-                    },
-                    { 0, 1 } // cursor on $
-                },
-            },
-        },
-        TestCase{
-            L"SBCS, cursor remains in buffer, no circling, no original wrap",
-            {
-                TestBuffer{
-                    { 6, 5 },
-                    {
-                        { L"ABCDEF", false },
-                        { L"$     ", false },
-                        { L"      ", false },
-                        { L"      ", false },
-                        { L"      ", false },
-                    },
-                    { 0, 1 } // cursor on $
-                },
-                TestBuffer{
-                    { 5, 5 }, // reduce width by 1
-                    {
-                        { L"ABCDE", true },
-                        { L"F$   ", false }, // [BUG] EXACT WRAP. $ should be alone on next line.
-                        { L"     ", false },
-                        { L"     ", false },
-                        { L"     ", false },
-                    },
-                    { 1, 1 } // cursor on $
-                },
-                TestBuffer{
-                    { 6, 5 }, // grow width back to original
-                    {
-                        { L"ABCDEF", true_due_to_exact_wrap_bug },
-                        { L"$     ", false },
-                        { L"      ", false },
-                        { L"      ", false },
-                        { L"      ", false },
-                    },
-                    { 0, 1 } // cursor on $
-                },
-                TestBuffer{
-                    { 7, 5 }, // grow width wider than original
-                    {
-                        { L"ABCDEF$", true_due_to_exact_wrap_bug }, // EXACT WRAP BUG: $ should be alone on next line
-                        { L"       ", false },
-                        { L"       ", false },
-                        { L"       ", false },
-                        { L"       ", false },
-                    },
-                    { 6, 0 } // cursor on $
-                },
-            },
-        },
-        TestCase{
-            L"SBCS, cursor remains in buffer, no circling, with original wrap",
-            {
-                TestBuffer{
-                    { 6, 5 },
-                    {
-                        { L"ABCDEF", true },
-                        { L"G$    ", false },
-                        { L"      ", false },
-                        { L"      ", false },
-                        { L"      ", false },
-                    },
-                    { 1, 1 } // cursor on $
-                },
-                TestBuffer{
-                    { 5, 5 }, // reduce width by 1
-                    {
-                        { L"ABCDE", true },
-                        { L"FG$  ", false },
-                        { L"     ", false },
-                        { L"     ", false },
-                        { L"     ", false },
-                    },
-                    { 2, 1 } // cursor on $
-                },
-                TestBuffer{
-                    { 6, 5 }, // grow width back to original
-                    {
-                        { L"ABCDEF", true },
-                        { L"G$    ", false },
-                        { L"      ", false },
-                        { L"      ", false },
-                        { L"      ", false },
-                    },
-                    { 1, 1 } // cursor on $
-                },
-                TestBuffer{
-                    { 7, 5 }, // grow width wider than original
-                    {
-                        { L"ABCDEFG", true },
-                        { L"$      ", false },
-                        { L"       ", false },
-                        { L"       ", false },
-                        { L"       ", false },
-                    },
-                    { 0, 1 } // cursor on $
-                },
-            },
-        },
-        TestCase{
-            L"SBCS line padded with spaces (to wrap)",
-            {
-                TestBuffer{
-                    { 6, 5 },
-                    {
-                        { L"AB    ", true }, // AB    $     CD is one long wrapped line
-                        { L"$     ", true },
-                        { L"CD    ", false },
-                        { L"EFG   ", false },
-                        { L"      ", false },
-                    },
-                    { 0, 1 } // cursor on $
-                },
-                TestBuffer{
-                    { 7, 5 }, // reduce width by 1
-                    {
-                        { L"AB    $", true },
-                        { L"     CD", true_due_to_exact_wrap_bug },
-                        { L"       ", false },
-                        { L"EFG    ", false },
-                        { L"       ", false },
-                    },
-                    { 6, 0 } // cursor on $
-                },
-                TestBuffer{
-                    { 8, 5 },
-                    {
-                        { L"AB    $ ", true },
-                        { L"    CD  ", false }, // Goes to false because we hit the end of ..CD
-                        { L"EFG     ", false }, // [BUG] EFG moves up due to exact wrap bug above
-                        { L"        ", false },
-                        { L"        ", false },
-                    },
-                    { 6, 0 } // cursor on $
-                },
-            },
-        },
-        TestCase{
-            L"DBCS, cursor remains in buffer, no circling, with original wrap",
-            {
-                TestBuffer{
-                    { 6, 5 },
-                    {
-                        //--0123456--
-                        { L"カタカ", true }, // KA TA KA
-                        { L"ナ$   ", false }, // NA
-                        { L"      ", false },
-                        { L"      ", false },
-                        { L"      ", false },
-                    },
-                    { 2, 1 } // cursor on $
-                },
-                TestBuffer{
-                    { 5, 5 }, // reduce width by 1
-                    {
-                        //--012345--
-                        { L"カタ ", true }, // KA TA [FORCED SPACER]
-                        { L"カナ$", true_due_to_exact_wrap_bug }, // KA NA
-                        { L"     ", false },
-                        { L"     ", false },
-                        { L"     ", false },
-                    },
-                    { 4, 1 } // cursor on $
-                },
-                TestBuffer{
-                    { 6, 5 }, // grow width back to original
-                    {
-                        //--0123456--
-                        { L"カタカ", true }, // KA TA KA
-                        { L"ナ$   ", false }, // NA
-                        { L"      ", false },
-                        { L"      ", false },
-                        { L"      ", false },
-                    },
-                    { 2, 1 } // cursor on $
-                },
-                TestBuffer{
-                    { 7, 5 }, // grow width wider than original (by one; no visible change!)
-                    {
-                        //--0123456--
-                        { L"カタカ ", true }, // KA TA KA [FORCED SPACER]
-                        { L"ナ$    ", false }, // NA
-                        { L"       ", false },
-                        { L"       ", false },
-                        { L"       ", false },
-                    },
-                    { 2, 1 } // cursor on $
-                },
-                TestBuffer{
-                    { 8, 5 }, // grow width enough to fit second DBCS
-                    {
-                        //--01234567--
-                        { L"カタカナ", true }, // KA TA KA NA
-                        { L"$       ", false },
-                        { L"        ", false },
-                        { L"        ", false },
-                        { L"        ", false },
-                    },
-                    { 0, 1 } // cursor on $
-                },
-            },
-        },
-        TestCase{
-            L"SBCS, cursor remains in buffer, with circling, no original wrap",
-            {
-                TestBuffer{
-                    { 6, 5 },
-                    {
-                        { L"ABCDEF", false },
-                        { L"$     ", false },
-                        { L"GHIJKL", false },
-                        { L"MNOPQR", false },
-                        { L"STUVWX", false },
-                    },
-                    { 0, 1 } // cursor on $
-                },
-                TestBuffer{
-                    { 5, 5 }, // reduce width by 1
-                    {
-                        { L"F$   ", false },
-                        { L"GHIJK", true }, // [BUG] We should see GHIJK\n L\n MNOPQ\n R\n
-                        { L"LMNOP", true }, // The wrapping here is irregular
-                        { L"QRSTU", true },
-                        { L"VWX  ", false },
-                    },
-                    { 1, 1 } // [BUG] cursor moves to 1,1 instead of sticking with the $
-                },
-                TestBuffer{
-                    { 6, 5 }, // going back to 6,5, the data lost has been destroyed
-                    {
-                        //{ L"F$    ", false }, // [BUG] this line is erroneously destroyed too!
-                        { L"GHIJKL", true },
-                        { L"MNOPQR", true },
-                        { L"STUVWX", true },
-                        { L"      ", false },
-                        { L"      ", false }, // [BUG] this line is added
-                    },
-                    { 1, 1 }, // [BUG] cursor does not follow [H], it sticks at 1,1
-                },
-                TestBuffer{
-                    { 7, 5 }, // a number of errors are carried forward from the previous buffer
-                    {
-                        { L"GHIJKLM", true },
-                        { L"NOPQRST", true },
-                        { L"UVWX   ", false }, // [BUG] This line loses wrap for some reason
-                        { L"       ", false },
-                        { L"       ", false },
-                    },
-                    { 0, 1 }, // [BUG] The cursor moves to 0, 1 now, sticking with the [N] from before
-                },
-            },
-        },
-        TestCase{
-            // The cursor is not found during character insertion.
-            // Instead, it is found off the right edge of the text. This triggers
-            // a separate cursor found codepath in the original algorithm.
-            L"SBCS, cursor off rightmost char in non-wrapped line",
-            {
-                TestBuffer{
-                    { 6, 5 },
-                    {
-                        { L"ABCDEF", false },
-                        { L"$     ", false },
-                        { L"      ", false },
-                        { L"      ", false },
-                        { L"      ", false },
-                    },
-                    { 1, 1 } // cursor *after* $
-                },
-                TestBuffer{
-                    { 5, 5 }, // reduce width by 1
-                    {
-                        { L"ABCDE", true },
-                        { L"F$   ", false }, // [BUG] EXACT WRAP. $ should be alone on next line.
-                        { L"     ", false },
-                        { L"     ", false },
-                        { L"     ", false },
-                    },
-                    { 2, 1 } // cursor follows space after $ to next line
-                },
-            },
-        },
-        TestCase{
-            L"SBCS, cursor off rightmost char in wrapped line, which is then pushed off bottom",
-            {
-                TestBuffer{
-                    { 6, 5 },
-                    {
-                        { L"ABCDEF", true },
-                        { L"GHIJKL", true },
-                        { L"MNOPQR", true },
-                        { L"STUVWX", true },
-                        { L"YZ0 $ ", false },
-                    },
-                    { 5, 4 } // cursor *after* $
-                },
-                TestBuffer{
-                    { 5, 5 }, // reduce width by 1
-                    {
-                        { L"FGHIJ", true },
-                        { L"KLMNO", true },
-                        { L"PQRST", true },
-                        { L"UVWXY", true },
-                        { L"Z0 $ ", false },
-                    },
-                    { 4, 4 } // cursor follows space after $ to newly introduced bottom line
-                },
-            },
-        },
-        TestCase{
-            L"SBCS, cursor off in space to far right of text (end of buffer content)",
-            {
-                TestBuffer{
-                    { 6, 5 },
-                    {
-                        { L"ABCDEF", false },
-                        //       v cursor
-                        { L"$     ", false },
-                        //       ^ cursor
-                        { L"      ", false },
-                        { L"      ", false },
-                        { L"      ", false },
-                    },
-                    { 5, 1 } // cursor in space far after $
-                },
-                TestBuffer{
-                    { 5, 5 }, // reduce width by 1
-                    {
-                        { L"ABCDE", true },
-                        { L"F$   ", true }, // [BUG] This line is marked wrapped, and I do not know why
-                        //   v cursor
-                        { L"     ", false },
-                        //   ^ cursor
-                        { L"     ", false },
-                        { L"     ", false },
-                    },
-                    { 1, 2 } // cursor stays same linear distance from $
-                },
-                TestBuffer{
-                    { 6, 5 }, // grow back to original size
-                    {
-                        { L"ABCDEF", true_due_to_exact_wrap_bug },
-                        //      v cursor [BUG] cursor does not retain linear distance from $
-                        { L"$     ", false },
-                        //      ^ cursor
-                        { L"      ", false },
-                        { L"      ", false },
-                        { L"      ", false },
-                    },
-                    { 4, 1 } // cursor stays same linear distance from $
-                },
-            },
-        },
-        TestCase{
-            L"SBCS, cursor off in space to far right of text (middle of buffer content)",
-            {
-                TestBuffer{
-                    { 6, 5 },
-                    {
-                        { L"ABCDEF", false },
-                        //       v cursor
-                        { L"$     ", false },
-                        //       ^ cursor
-                        { L"BLAH  ", false },
-                        { L"BLAH  ", false },
-                        { L"      ", false },
-                    },
-                    { 5, 1 } // cursor in space far after $
-                },
-                TestBuffer{
-                    { 5, 5 }, // reduce width by 1
-                    {
-                        { L"ABCDE", true },
-                        { L"F$   ", false },
-                        { L"BLAH ", false },
-                        { L"BLAH ", true }, // [BUG] this line wraps, no idea why
-                        //  v cursor [BUG] cursor erroneously moved to end of all content
-                        { L"     ", false },
-                        //  ^ cursor
-                    },
-                    { 0, 4 } },
-                TestBuffer{
-                    { 6, 5 }, // grow back to original size
-                    {
-                        { L"ABCDEF", true },
-                        { L"$     ", false },
-                        { L"BLAH  ", false },
-                        //       v cursor [BUG] cursor is pulled up to previous line because it was marked wrapped
-                        { L"BLAH  ", false },
-                        //       ^ cursor
-                        { L"      ", false },
-                    },
-                    { 5, 3 } },
-            },
-        },
-        TestCase{
-            // Shrinking the buffer this much forces a multi-line wrap before the cursor
-            L"SBCS, cursor off in space to far right of text (end of buffer content), aggressive shrink",
-            {
-                TestBuffer{
-                    { 6, 5 },
-                    {
-                        { L"ABCDEF", false },
-                        //       v cursor
-                        { L"$     ", false },
-                        //       ^ cursor
-                        { L"      ", false },
-                        { L"      ", false },
-                        { L"      ", false },
-                    },
-                    { 5, 1 } // cursor in space far after $
-                },
-                TestBuffer{
-                    { 2, 5 }, // reduce width aggressively
-                    {
-                        { L"CD", true },
-                        { L"EF", true },
-                        { L"$ ", true },
-                        { L"  ", true },
-                        //   v cursor
-                        { L"  ", false },
-                        //   ^ cursor
-                    },
-                    { 1, 4 } },
-            },
-        },
-        TestCase{
-            L"SBCS, cursor off in space to far right of text (end of buffer content), fully wrapped, aggressive shrink",
-            {
-                TestBuffer{
-                    { 6, 5 },
-                    {
-                        { L"ABCDEF", true },
-                        //       v cursor
-                        { L"$     ", true },
-                        //       ^ cursor
-                        { L"      ", true },
-                        { L"      ", true },
-                        { L"      ", true },
-                    },
-                    { 5, 1 } // cursor in space far after $
-                },
-                TestBuffer{
-                    { 2, 5 }, // reduce width aggressively
-                    {
-                        { L"EF", true },
-                        { L"$ ", true },
-                        { L"  ", true },
-                        { L"  ", true },
-                        //   v cursor [BUG] cursor does not maintain linear distance from $
-                        { L"  ", false },
-                        //   ^ cursor
-                    },
-                    { 1, 4 } },
-            },
-        },
-        TestCase{
-            L"SBCS, cursor off in space to far right of text (middle of buffer content), fully wrapped, aggressive shrink",
-            {
-                TestBuffer{
-                    { 6, 5 },
-                    {
-                        { L"ABCDEF", true },
-                        //       v cursor
-                        { L"$     ", true },
-                        //       ^ cursor
-                        { L"      ", true },
-                        { L"      ", true },
-                        { L"     Q", true },
-                    },
-                    { 5, 1 } // cursor in space far after $
-                },
-                TestBuffer{
-                    { 2, 5 }, // reduce width aggressively
-                    {
-                        { L"  ", true },
-                        { L"  ", true },
-                        { L"  ", true },
-                        { L" Q", true },
-                        //   v cursor [BUG] cursor jumps to end of world
-                        { L"  ", false }, // POTENTIAL [BUG] a whole new blank line is added for the cursor
-                        //   ^ cursor
-                    },
-                    { 1, 4 } },
-            },
-        },
-        TestCase{
-            L"SBCS, cursor off in space to far right of text (middle of buffer content), partially wrapped, aggressive shrink",
-            {
-                TestBuffer{
-                    { 6, 5 },
-                    {
-                        { L"ABCDEF", false },
-                        //       v cursor
-                        { L"$     ", false },
-                        //       ^ cursor
-                        { L"      ", false },
-                        { L"      ", true },
-                        { L"     Q", true },
-                    },
-                    { 5, 1 } // cursor in space far after $
-                },
-                TestBuffer{
-                    { 2, 5 }, // reduce width aggressively
-                    {
-                        { L"  ", true },
-                        { L"  ", true },
-                        { L"  ", true },
-                        { L" Q", true },
-                        //  v  cursor [BUG] cursor jumps to different place than fully wrapped case
-                        { L"  ", false },
-                        //  ^  cursor
-                    },
-                    { 0, 4 } },
-            },
-        },
-        TestCase{
-            // This triggers the cursor being walked forward w/ newlines to maintain
-            // distance from the last char in the buffer
-            L"SBCS, cursor at end of buffer, otherwise same as previous test",
-            {
-                TestBuffer{
-                    { 6, 5 },
-                    {
-                        { L"ABCDEF", false },
-                        { L"$     ", false },
-                        { L"     Q", true },
-                        { L"      ", true },
-                        //       v cursor
-                        { L"      ", true },
-                        //       ^ cursor
-                    },
-                    { 5, 4 } // cursor at end of buffer
-                },
-                TestBuffer{
-                    { 2, 5 }, // reduce width aggressively
-                    {
-                        { L"  ", true },
-                        { L"  ", true },
-                        { L" Q", true },
-                        { L"  ", false },
-                        //  v  cursor [BUG] cursor loses linear distance from Q; is this important?
-                        { L"  ", false },
-                        //  ^  cursor
-                    },
-                    { 0, 4 } },
-            },
-        },
-    };
-
-#pragma region TAEF hookup for the test case array above
-    struct ArrayIndexTaefAdapterRow : public Microsoft::WRL::RuntimeClass<Microsoft::WRL::RuntimeClassFlags<Microsoft::WRL::ClassicCom | Microsoft::WRL::InhibitFtmBase>, IDataRow>
-    {
-        HRESULT RuntimeClassInitialize(const size_t index)
-        {
-            _index = index;
-            return S_OK;
-        }
-
-        STDMETHODIMP GetTestData(BSTR /*pszName*/, SAFEARRAY** ppData) override
-        {
-            const auto indexString{ wil::str_printf<std::wstring>(L"%zu", _index) };
-            auto safeArray{ SafeArrayCreateVector(VT_BSTR, 0, 1) };
-            LONG index{ 0 };
-            auto indexBstr{ wil::make_bstr(indexString.c_str()) };
-            (void)SafeArrayPutElement(safeArray, &index, indexBstr.release());
-            *ppData = safeArray;
-            return S_OK;
-        }
-
-        STDMETHODIMP GetMetadataNames(SAFEARRAY** ppMetadataNames) override
-        {
-            *ppMetadataNames = nullptr;
-            return S_FALSE;
-        }
-
-        STDMETHODIMP GetMetadata(BSTR /*pszName*/, SAFEARRAY** ppData) override
-        {
-            *ppData = nullptr;
-            return S_FALSE;
-        }
-
-        STDMETHODIMP GetName(BSTR* ppszRowName) override
-        {
-            *ppszRowName = nullptr;
-            return S_FALSE;
-        }
-
-    private:
-        size_t _index;
-    };
-
-    struct ArrayIndexTaefAdapterSource : public Microsoft::WRL::RuntimeClass<Microsoft::WRL::RuntimeClassFlags<Microsoft::WRL::ClassicCom | Microsoft::WRL::InhibitFtmBase>, IDataSource>
-    {
-        STDMETHODIMP Advance(IDataRow** ppDataRow) override
-        {
-            if (_index < std::extent<decltype(testCases)>::value)
-            {
-                Microsoft::WRL::MakeAndInitialize<ArrayIndexTaefAdapterRow>(ppDataRow, _index++);
-            }
-            else
-            {
-                *ppDataRow = nullptr;
-            }
-            return S_OK;
-        }
-
-        STDMETHODIMP Reset() override
-        {
-            _index = 0;
-            return S_OK;
-        }
-
-        STDMETHODIMP GetTestDataNames(SAFEARRAY** names) override
-        {
-            auto safeArray{ SafeArrayCreateVector(VT_BSTR, 0, 1) };
-            LONG index{ 0 };
-            auto dataNameBstr{ wil::make_bstr(L"index") };
-            (void)SafeArrayPutElement(safeArray, &index, dataNameBstr.release());
-            *names = safeArray;
-            return S_OK;
-        }
-
-        STDMETHODIMP GetTestDataType(BSTR /*name*/, BSTR* type) override
-        {
-            *type = nullptr;
-            return S_OK;
-        }
-
-    private:
-        size_t _index{ 0 };
-    };
-#pragma endregion
-}
-
-extern "C" HRESULT __declspec(dllexport) __cdecl ReflowTestDataSource(IDataSource** ppDataSource, void*)
-{
-    auto source{ Microsoft::WRL::Make<ArrayIndexTaefAdapterSource>() };
-    return source.CopyTo(ppDataSource);
-}
-
-class ReflowTests
-{
-    TEST_CLASS(ReflowTests);
-
-    static DummyRenderTarget target;
-    static std::unique_ptr<TextBuffer> _textBufferFromTestBuffer(const TestBuffer& testBuffer)
-    {
-        auto buffer = std::make_unique<TextBuffer>(testBuffer.size, TextAttribute{ 0x7 }, 0, target);
-
-        size_t i{};
-        for (const auto& testRow : testBuffer.rows)
-        {
-            auto& row{ buffer->GetRowByOffset(i) };
-
-            auto& charRow{ row.GetCharRow() };
-            row.SetWrapForced(testRow.wrap);
-
-            size_t j{};
-            for (auto it{ charRow.begin() }; it != charRow.end(); ++it)
-            {
-                // Yes, we're about to manually create a buffer. It is unpleasant.
-                const auto ch{ til::at(testRow.text, j) };
-                it->Char() = ch;
-                if (IsGlyphFullWidth(ch))
-                {
-                    it->DbcsAttr().SetLeading();
-                    it++;
-                    it->Char() = ch;
-                    it->DbcsAttr().SetTrailing();
-                }
-                else
-                {
-                    it->DbcsAttr().SetSingle();
-                }
-                j++;
-            }
-            i++;
-        }
-
-        buffer->GetCursor().SetPosition(testBuffer.cursor);
-        return buffer;
-    }
-
-    static std::unique_ptr<TextBuffer> _textBufferByReflowingTextBuffer(TextBuffer& originalBuffer, const COORD newSize)
-    {
-        auto buffer = std::make_unique<TextBuffer>(newSize, TextAttribute{ 0x7 }, 0, target);
-        TextBuffer::Reflow(originalBuffer, *buffer, std::nullopt, std::nullopt);
-        return buffer;
-    }
-
-    static void _compareTextBufferAgainstTestBuffer(const TextBuffer& buffer, const TestBuffer& testBuffer)
-    {
-        VERIFY_ARE_EQUAL(testBuffer.cursor, buffer.GetCursor().GetPosition());
-        VERIFY_ARE_EQUAL(testBuffer.size, buffer.GetSize().Dimensions());
-
-        size_t i{};
-        for (const auto& testRow : testBuffer.rows)
-        {
-            NoThrowString indexString;
-            const auto& row{ buffer.GetRowByOffset(i) };
-
-            const auto& charRow{ row.GetCharRow() };
-
-            indexString.Format(L"[Row %d]", i);
-            VERIFY_ARE_EQUAL(testRow.wrap, row.WasWrapForced(), indexString);
-
-            size_t j{};
-            for (auto it{ charRow.begin() }; it != charRow.end(); ++it)
-            {
-                indexString.Format(L"[Cell %d, %d; Text line index %d]", it - charRow.begin(), i, j);
-                // Yes, we're about to manually create a buffer. It is unpleasant.
-                const auto ch{ til::at(testRow.text, j) };
-                if (IsGlyphFullWidth(ch))
-                {
-                    // Char is full width in test buffer, so
-                    // ensure that real buffer is LEAD, TRAIL (ch)
-                    VERIFY_IS_TRUE(it->DbcsAttr().IsLeading(), indexString);
-                    VERIFY_ARE_EQUAL(ch, it->Char(), indexString);
-
-                    it++;
-                    VERIFY_IS_TRUE(it->DbcsAttr().IsTrailing(), indexString);
-                }
-                else
-                {
-                    VERIFY_IS_TRUE(it->DbcsAttr().IsSingle(), indexString);
-                }
-
-                VERIFY_ARE_EQUAL(ch, it->Char(), indexString);
-                j++;
-            }
-            i++;
-        }
-    }
-
-    TEST_METHOD(TestReflowCases)
-    {
-        BEGIN_TEST_METHOD_PROPERTIES()
-            TEST_METHOD_PROPERTY(L"DataSource", L"Export:ReflowTestDataSource")
-        END_TEST_METHOD_PROPERTIES()
-
-        WEX::TestExecution::DisableVerifyExceptions disableVerifyExceptions{};
-        WEX::TestExecution::SetVerifyOutput verifyOutputScope{ WEX::TestExecution::VerifyOutputSettings::LogOnlyFailures };
-
-        unsigned int i{};
-        TestData::TryGetValue(L"index", i); // index is produced by the ArrayIndexTaefAdapterSource above
-        const auto& testCase{ testCases[i] };
-        Log::Comment(NoThrowString().Format(L"[%zu.0] Test case \"%.*s\"", i, testCase.name.size(), testCase.name.data()));
-
-        // Create initial text buffer from Buffer 0
-        auto textBuffer{ _textBufferFromTestBuffer(testCase.buffers.front()) };
-        for (size_t bufferIndex{ 1 }; bufferIndex < testCase.buffers.size(); ++bufferIndex)
-        {
-            const auto& testBuffer{ til::at(testCase.buffers, bufferIndex) };
-            Log::Comment(NoThrowString().Format(L"[%zu.%zu] Resizing to %dx%d", i, bufferIndex, testBuffer.size.X, testBuffer.size.Y));
-
-            auto newBuffer{ _textBufferByReflowingTextBuffer(*textBuffer, testBuffer.size) };
-
-            // All future operations are based on the new buffer
-            std::swap(textBuffer, newBuffer);
-
-            _compareTextBufferAgainstTestBuffer(*textBuffer, testBuffer);
-        }
-    }
-};
-
-DummyRenderTarget ReflowTests::target{};

src/buffer/out/ut_textbuffer/TextBuffer.Unit.Tests.vcxproj

@@ -10,8 +10,6 @@
   </PropertyGroup>
   <Import Project="$(SolutionDir)src\common.build.pre.props" />
   <ItemGroup>
-    <ClCompile Include="AttrRowTests.cpp" />
-    <ClCompile Include="ReflowTests.cpp" />
     <ClCompile Include="TextColorTests.cpp" />
     <ClCompile Include="TextAttributeTests.cpp" />
     <ClCompile Include="UnicodeStorageTests.cpp" />
@@ -20,9 +18,6 @@
     </ClCompile>
   </ItemGroup>
   <ItemGroup>
-    <ProjectReference Include="..\..\..\types\lib\types.vcxproj">
-      <Project>{18d09a24-8240-42d6-8cb6-236eee820263}</Project>
-    </ProjectReference>
     <ProjectReference Include="..\lib\bufferout.vcxproj">
       <Project>{0cf235bd-2da0-407e-90ee-c467e8bbc714}</Project>
     </ProjectReference>

src/buffer/out/ut_textbuffer/sources

@@ -14,15 +14,12 @@ DLLDEF                  =
 
 SOURCES = \
     $(SOURCES) \
-    AttrRowTests.cpp \
-    ReflowTests.cpp \
     TextColorTests.cpp \
     TextAttributeTests.cpp \
     DefaultResource.rc \
 
 TARGETLIBS = \
     $(CONSOLE_OBJ_PATH)\buffer\out\lib\$(O)\ConBufferOut.lib \
-    $(CONSOLE_OBJ_PATH)\types\lib\$(O)\ConTypes.lib \
     $(TARGETLIBS) \
 
 # -------------------------------------

src/cascadia/CascadiaPackage/CascadiaPackage.wapproj

@@ -3,7 +3,8 @@
   <Import Project="..\..\..\common.openconsole.props" Condition="'$(OpenConsoleDir)'==''" />
   <Import Project="$(OpenConsoleDir)src\wap-common.build.pre.props" />
   <PropertyGroup Label="Configuration">
-
+    <!-- This is necessary so the build system doesn't think we're a .NET project... -->
+    <TargetRuntime>Native</TargetRuntime>
     <TargetPlatformVersion>10.0.18362.0</TargetPlatformVersion>
     <TargetPlatformMinVersion>10.0.18362.0</TargetPlatformMinVersion>
     <!--
@@ -16,10 +17,6 @@
     <AppxOSMaxVersionTestedReplaceManifestVersion>false</AppxOSMaxVersionTestedReplaceManifestVersion>
     <OCExecutionAliasName Condition="'$(WindowsTerminalBranding)'==''">wtd</OCExecutionAliasName>
     <OCExecutionAliasName Condition="'$(OCExecutionAliasName)'==''">wt</OCExecutionAliasName>
-    <!-- VS 16.8 causes WAP projects to accidentally package System.Core.dll (from the CLR).
-         This has been fixed in VS 16.9 using the property below. It's safe for us to include
-         it here, even after 16.9 comes out. -->
-    <AddAdditionalExplicitAssemblyReferences>false</AddAdditionalExplicitAssemblyReferences>
   </PropertyGroup>
   <PropertyGroup>
     <ProjectGuid>CA5CAD1A-224A-4171-B13A-F16E576FDD12</ProjectGuid>

src/cascadia/CascadiaPackage/Package-Dev.appxmanifest

@@ -82,9 +82,14 @@
                 <desktop5:ItemType Type="Directory">
                     <desktop5:Verb Id="Command1" Clsid="9f156763-7844-4dc4-b2b1-901f640f5155" />
                 </desktop5:ItemType>
+                <!-- Due to a bug in the OS, this doesn't actually work right -
+                we'll get a nullptr in our implementation. So this is disabled
+                temporarily. See MSFT:24623699 for more details.
+
                 <desktop5:ItemType Type="Directory\Background">
-                  <desktop5:Verb Id="Command2" Clsid="9f156763-7844-4dc4-b2b1-901f640f5155" />
-                </desktop5:ItemType>                
+                    <desktop5:Verb Id="Command2" Clsid="9f156763-7844-4dc4-b2b1-901f640f5155" />
+                </desktop5:ItemType>
+                -->
             </desktop4:FileExplorerContextMenus>
         </desktop4:Extension>
 

src/cascadia/CascadiaPackage/Package-Pre.appxmanifest

@@ -82,9 +82,15 @@
                 <desktop5:ItemType Type="Directory">
                     <desktop5:Verb Id="Command1" Clsid="9f156763-7844-4dc4-b2b1-901f640f5155" />
                 </desktop5:ItemType>
+                <!-- Due to a bug in the OS, this doesn't actually work right -
+                we'll get a nullptr in our implementation. So this is disabled
+                temporarily. See MSFT:24623699 for more details.
+
                 <desktop5:ItemType Type="Directory\Background">
-                  <desktop5:Verb Id="Command2" Clsid="9f156763-7844-4dc4-b2b1-901f640f5155" />
+                    <desktop5:Verb Id="Command2" Clsid="9f156763-7844-4dc4-b2b1-901f640f5155" />
                 </desktop5:ItemType>
+                -->
+
             </desktop4:FileExplorerContextMenus>
         </desktop4:Extension>
 

src/cascadia/CascadiaPackage/Package.appxmanifest

@@ -83,9 +83,14 @@
                 <desktop5:ItemType Type="Directory">
                     <desktop5:Verb Id="Command1" Clsid="9f156763-7844-4dc4-b2b1-901f640f5155" />
                 </desktop5:ItemType>
+                <!-- Due to a bug in the OS, this doesn't actually work right -
+                we'll get a nullptr in our implementation. So this is disabled
+                temporarily. See MSFT:24623699 for more details.
+
                 <desktop5:ItemType Type="Directory\Background">
-                  <desktop5:Verb Id="Command2" Clsid="9f156763-7844-4dc4-b2b1-901f640f5155" />
+                    <desktop5:Verb Id="Command2" Clsid="9f156763-7844-4dc4-b2b1-901f640f5155" />
                 </desktop5:ItemType>
+                -->
             </desktop4:FileExplorerContextMenus>
         </desktop4:Extension>
 

src/cascadia/LocalTests_SettingsModel/ColorSchemeTests.cpp

@@ -35,7 +35,6 @@ namespace SettingsModelLocalTests
         TEST_METHOD(CanLayerColorScheme);
         TEST_METHOD(LayerColorSchemeProperties);
         TEST_METHOD(LayerColorSchemesOnArray);
-        TEST_METHOD(UpdateSchemeReferences);
 
         TEST_CLASS_SETUP(ClassSetup)
         {
@@ -291,81 +290,4 @@ namespace SettingsModelLocalTests
             VERIFY_ARE_EQUAL(ARGB(0, 7, 7, 7), scheme2->_Background);
         }
     }
-
-    void ColorSchemeTests::UpdateSchemeReferences()
-    {
-        const std::string settingsString{ R"json({
-                                                "defaultProfile": "Inherited reference",
-                                                "profiles": {
-                                                    "defaults": {
-                                                        "colorScheme": "Scheme 1"
-                                                    },
-                                                    "list": [
-                                                        {
-                                                            "name": "Explicit scheme reference",
-                                                            "colorScheme": "Scheme 1"
-                                                        },
-                                                        {
-                                                            "name": "Explicit reference; hidden",
-                                                            "colorScheme": "Scheme 1",
-                                                            "hidden": true
-                                                        },
-                                                        {
-                                                            "name": "Inherited reference"
-                                                        },
-                                                        {
-                                                            "name": "Different reference",
-                                                            "colorScheme": "Scheme 2"
-                                                        }
-                                                    ]
-                                                },
-                                                "schemes": [
-                                                    { "name": "Scheme 1" },
-                                                    { "name": "Scheme 2" },
-                                                    { "name": "Scheme 1 (renamed)" }
-                                                ]
-                                            })json" };
-
-        auto settings{ winrt::make_self<CascadiaSettings>(false) };
-        settings->_ParseJsonString(settingsString, false);
-        settings->_ApplyDefaultsFromUserSettings();
-        settings->LayerJson(settings->_userSettings);
-        settings->_ValidateSettings();
-
-        // update all references to "Scheme 1"
-        const auto newName{ L"Scheme 1 (renamed)" };
-        settings->UpdateColorSchemeReferences(L"Scheme 1", newName);
-
-        // verify profile defaults
-        Log::Comment(L"Profile Defaults");
-        VERIFY_ARE_EQUAL(newName, settings->ProfileDefaults().ColorSchemeName());
-        VERIFY_IS_TRUE(settings->ProfileDefaults().HasColorSchemeName());
-
-        // verify all other profiles
-        const auto& profiles{ settings->AllProfiles() };
-        {
-            const auto& prof{ profiles.GetAt(0) };
-            Log::Comment(prof.Name().c_str());
-            VERIFY_ARE_EQUAL(newName, prof.ColorSchemeName());
-            VERIFY_IS_TRUE(prof.HasColorSchemeName());
-        }
-        {
-            const auto& prof{ profiles.GetAt(1) };
-            Log::Comment(prof.Name().c_str());
-            VERIFY_ARE_EQUAL(newName, prof.ColorSchemeName());
-            VERIFY_IS_TRUE(prof.HasColorSchemeName());
-        }
-        {
-            const auto& prof{ profiles.GetAt(2) };
-            Log::Comment(prof.Name().c_str());
-            VERIFY_ARE_EQUAL(newName, prof.ColorSchemeName());
-            VERIFY_IS_FALSE(prof.HasColorSchemeName());
-        }
-        {
-            const auto& prof{ profiles.GetAt(3) };
-            Log::Comment(prof.Name().c_str());
-            VERIFY_ARE_EQUAL(L"Scheme 2", prof.ColorSchemeName());
-            VERIFY_IS_TRUE(prof.HasColorSchemeName());
-        }
-    }
 }

src/cascadia/LocalTests_SettingsModel/CommandTests.cpp

@@ -37,7 +37,6 @@ namespace SettingsModelLocalTests
         TEST_METHOD(ManyCommandsSameAction);
         TEST_METHOD(LayerCommand);
         TEST_METHOD(TestSplitPaneArgs);
-        TEST_METHOD(TestSplitPaneBadSize);
         TEST_METHOD(TestResourceKeyName);
         TEST_METHOD(TestAutogeneratedName);
         TEST_METHOD(TestLayerOnAutogeneratedName);
@@ -148,8 +147,7 @@ namespace SettingsModelLocalTests
             { "name": "command1", "command": { "action": "splitPane", "split": "vertical" } },
             { "name": "command2", "command": { "action": "splitPane", "split": "horizontal" } },
             { "name": "command4", "command": { "action": "splitPane" } },
-            { "name": "command5", "command": { "action": "splitPane", "split": "auto" } },
-            { "name": "command6", "command": { "action": "splitPane", "size": 0.25 } },
+            { "name": "command5", "command": { "action": "splitPane", "split": "auto" } }
         ])" };
 
         const auto commands0Json = VerifyParseSucceeded(commands0String);
@@ -158,7 +156,7 @@ namespace SettingsModelLocalTests
         VERIFY_ARE_EQUAL(0u, commands.Size());
         auto warnings = implementation::Command::LayerJson(commands, commands0Json);
         VERIFY_ARE_EQUAL(0u, warnings.size());
-        VERIFY_ARE_EQUAL(5u, commands.Size());
+        VERIFY_ARE_EQUAL(4u, commands.Size());
 
         {
             auto command = commands.Lookup(L"command1");
@@ -169,7 +167,6 @@ namespace SettingsModelLocalTests
             VERIFY_IS_NOT_NULL(realArgs);
             // Verify the args have the expected value
             VERIFY_ARE_EQUAL(SplitState::Vertical, realArgs.SplitStyle());
-            VERIFY_ARE_EQUAL(0.5, realArgs.SplitSize());
         }
         {
             auto command = commands.Lookup(L"command2");
@@ -180,7 +177,6 @@ namespace SettingsModelLocalTests
             VERIFY_IS_NOT_NULL(realArgs);
             // Verify the args have the expected value
             VERIFY_ARE_EQUAL(SplitState::Horizontal, realArgs.SplitStyle());
-            VERIFY_ARE_EQUAL(0.5, realArgs.SplitSize());
         }
         {
             auto command = commands.Lookup(L"command4");
@@ -191,7 +187,6 @@ namespace SettingsModelLocalTests
             VERIFY_IS_NOT_NULL(realArgs);
             // Verify the args have the expected value
             VERIFY_ARE_EQUAL(SplitState::Automatic, realArgs.SplitStyle());
-            VERIFY_ARE_EQUAL(0.5, realArgs.SplitSize());
         }
         {
             auto command = commands.Lookup(L"command5");
@@ -202,51 +197,8 @@ namespace SettingsModelLocalTests
             VERIFY_IS_NOT_NULL(realArgs);
             // Verify the args have the expected value
             VERIFY_ARE_EQUAL(SplitState::Automatic, realArgs.SplitStyle());
-            VERIFY_ARE_EQUAL(0.5, realArgs.SplitSize());
-        }
-        {
-            auto command = commands.Lookup(L"command6");
-            VERIFY_IS_NOT_NULL(command);
-            VERIFY_IS_NOT_NULL(command.Action());
-            VERIFY_ARE_EQUAL(ShortcutAction::SplitPane, command.Action().Action());
-            const auto& realArgs = command.Action().Args().try_as<SplitPaneArgs>();
-            VERIFY_IS_NOT_NULL(realArgs);
-            // Verify the args have the expected value
-            VERIFY_ARE_EQUAL(SplitState::Automatic, realArgs.SplitStyle());
-            VERIFY_ARE_EQUAL(0.25, realArgs.SplitSize());
         }
     }
-
-    void CommandTests::TestSplitPaneBadSize()
-    {
-        const std::string commands0String{ R"([
-            { "name": "command1", "command": { "action": "splitPane", "size": 0.25 } },
-            { "name": "command2", "command": { "action": "splitPane", "size": 1.0 } },
-            { "name": "command3", "command": { "action": "splitPane", "size": 0 } },
-            { "name": "command4", "command": { "action": "splitPane", "size": 50 } },
-        ])" };
-
-        const auto commands0Json = VerifyParseSucceeded(commands0String);
-
-        IMap<winrt::hstring, Command> commands = winrt::single_threaded_map<winrt::hstring, Command>();
-        VERIFY_ARE_EQUAL(0u, commands.Size());
-        auto warnings = implementation::Command::LayerJson(commands, commands0Json);
-        VERIFY_ARE_EQUAL(3u, warnings.size());
-        VERIFY_ARE_EQUAL(1u, commands.Size());
-
-        {
-            auto command = commands.Lookup(L"command1");
-            VERIFY_IS_NOT_NULL(command);
-            VERIFY_IS_NOT_NULL(command.Action());
-            VERIFY_ARE_EQUAL(ShortcutAction::SplitPane, command.Action().Action());
-            const auto& realArgs = command.Action().Args().try_as<SplitPaneArgs>();
-            VERIFY_IS_NOT_NULL(realArgs);
-            // Verify the args have the expected value
-            VERIFY_ARE_EQUAL(SplitState::Automatic, realArgs.SplitStyle());
-            VERIFY_ARE_EQUAL(0.25, realArgs.SplitSize());
-        }
-    }
-
     void CommandTests::TestResourceKeyName()
     {
         // This test checks looking up a name from a resource key.

src/cascadia/LocalTests_SettingsModel/DeserializationTests.cpp

@@ -79,7 +79,6 @@ namespace SettingsModelLocalTests
         TEST_METHOD(TestCommandsAndKeybindings);
 
         TEST_METHOD(TestNestedCommandWithoutName);
-        TEST_METHOD(TestNestedCommandWithBadSubCommands);
         TEST_METHOD(TestUnbindNestedCommand);
         TEST_METHOD(TestRebindNestedCommand);
 
@@ -1377,7 +1376,7 @@ namespace SettingsModelLocalTests
                 },
                 {
                     "name": "parent",
-                    "commands": [
+                    "commands": [                        
                         { "command": { "action": "setColorScheme", "colorScheme": "invalidScheme" } }
                     ]
                 }
@@ -1404,11 +1403,11 @@ namespace SettingsModelLocalTests
                 },
                 {
                     "name": "grandparent",
-                    "commands": [
+                    "commands": [                        
                         {
                             "name": "parent",
                             "commands": [
-                                {
+                                { 
                                     "command": { "action": "setColorScheme", "colorScheme": "invalidScheme" }
                                 }
                             ]
@@ -1910,8 +1909,7 @@ namespace SettingsModelLocalTests
             "keybindings": [
                 { "command": { "action": "splitPane", "split":"auto" }, "keys": [ "ctrl+alt+t", "ctrl+a" ] },
                 { "command": { "action": "moveFocus" }, "keys": [ "ctrl+a" ] },
-                { "command": { "action": "resizePane" }, "keys": [ "ctrl+b" ] },
-                { "name": "invalid nested", "commands":[ { "name" : "hello" }, { "name" : "world" } ] }
+                { "command": { "action": "resizePane" }, "keys": [ "ctrl+b" ] }
             ]
         })" };
 
@@ -1920,20 +1918,18 @@ namespace SettingsModelLocalTests
 
         VERIFY_ARE_EQUAL(0u, settings->_globals->_keymap->_keyShortcuts.size());
 
-        VERIFY_ARE_EQUAL(4u, settings->_globals->_keybindingsWarnings.size());
+        VERIFY_ARE_EQUAL(3u, settings->_globals->_keybindingsWarnings.size());
         VERIFY_ARE_EQUAL(SettingsLoadWarnings::TooManyKeysForChord, settings->_globals->_keybindingsWarnings.at(0));
         VERIFY_ARE_EQUAL(SettingsLoadWarnings::MissingRequiredParameter, settings->_globals->_keybindingsWarnings.at(1));
         VERIFY_ARE_EQUAL(SettingsLoadWarnings::MissingRequiredParameter, settings->_globals->_keybindingsWarnings.at(2));
-        VERIFY_ARE_EQUAL(SettingsLoadWarnings::FailedToParseSubCommands, settings->_globals->_keybindingsWarnings.at(3));
 
         settings->_ValidateKeybindings();
 
-        VERIFY_ARE_EQUAL(5u, settings->_warnings.Size());
+        VERIFY_ARE_EQUAL(4u, settings->_warnings.Size());
         VERIFY_ARE_EQUAL(SettingsLoadWarnings::AtLeastOneKeybindingWarning, settings->_warnings.GetAt(0));
         VERIFY_ARE_EQUAL(SettingsLoadWarnings::TooManyKeysForChord, settings->_warnings.GetAt(1));
         VERIFY_ARE_EQUAL(SettingsLoadWarnings::MissingRequiredParameter, settings->_warnings.GetAt(2));
         VERIFY_ARE_EQUAL(SettingsLoadWarnings::MissingRequiredParameter, settings->_warnings.GetAt(3));
-        VERIFY_ARE_EQUAL(SettingsLoadWarnings::FailedToParseSubCommands, settings->_warnings.GetAt(4));
     }
 
     void DeserializationTests::ValidateExecuteCommandlineWarning()
@@ -2320,53 +2316,6 @@ namespace SettingsModelLocalTests
         VERIFY_ARE_EQUAL(0u, commands.Size());
     }
 
-    void DeserializationTests::TestNestedCommandWithBadSubCommands()
-    {
-        // This test tests a nested command without a name specified. This type
-        // of command should just be ignored, since we can't auto-generate names
-        // for nested commands, they _must_ have names specified.
-
-        const std::string settingsJson{ R"(
-        {
-            "defaultProfile": "{6239a42c-0000-49a3-80bd-e8fdd045185c}",
-            "profiles": [
-                {
-                    "name": "profile0",
-                    "guid": "{6239a42c-0000-49a3-80bd-e8fdd045185c}",
-                    "historySize": 1,
-                    "commandline": "cmd.exe"
-                }
-            ],
-            "actions": [
-                {
-                    "name": "nested command",
-                    "commands": [
-                        {
-                            "name": "child1"
-                        },
-                        {
-                            "name": "child2"
-                        }
-                    ]
-                },
-            ],
-            "schemes": [ { "name": "Campbell" } ] // This is included here to prevent settings validation errors.
-        })" };
-
-        VerifyParseSucceeded(settingsJson);
-
-        auto settings = winrt::make_self<implementation::CascadiaSettings>();
-        settings->_ParseJsonString(settingsJson, false);
-        settings->LayerJson(settings->_userSettings);
-        auto commands = settings->_globals->Commands();
-        settings->_ValidateSettings();
-
-        VERIFY_ARE_EQUAL(2u, settings->_warnings.Size());
-        VERIFY_ARE_EQUAL(SettingsLoadWarnings::AtLeastOneKeybindingWarning, settings->_warnings.GetAt(0));
-        VERIFY_ARE_EQUAL(SettingsLoadWarnings::FailedToParseSubCommands, settings->_warnings.GetAt(1));
-        VERIFY_ARE_EQUAL(0u, commands.Size());
-    }
-
     void DeserializationTests::TestUnbindNestedCommand()
     {
         // Test that layering a command with `"commands": null` set will unbind a command that already exists.

src/cascadia/LocalTests_SettingsModel/SerializationTests.cpp

@@ -226,7 +226,6 @@ namespace SettingsModelLocalTests
         const std::string settingsString{ R"({
                                                 "$schema": "https://aka.ms/terminal-profiles-schema",
                                                 "defaultProfile": "{61c54bbd-1111-5271-96e7-009a87ff44bf}",
-                                                "disabledProfileSources": [ "Windows.Terminal.Wsl" ],
 
                                                 "profiles": {
                                                     "defaults": {

src/cascadia/LocalTests_TerminalApp/CommandlineTest.cpp

@@ -47,7 +47,6 @@ namespace TerminalAppLocalTests
         TEST_METHOD(ParseSplitPaneIntoArgs);
         TEST_METHOD(ParseComboCommandlineIntoArgs);
         TEST_METHOD(ParseFocusTabArgs);
-        TEST_METHOD(ParseMoveFocusArgs);
         TEST_METHOD(ParseArgumentsWithParsingTerminators);
 
         TEST_METHOD(ParseNoCommandIsNewTab);
@@ -62,8 +61,6 @@ namespace TerminalAppLocalTests
         TEST_METHOD(TestLaunchMode);
         TEST_METHOD(TestLaunchModeWithNoCommand);
 
-        TEST_METHOD(TestMultipleSplitPaneSizes);
-
     private:
         void _buildCommandlinesHelper(AppCommandlineArgs& appArgs,
                                       const size_t expectedSubcommands,
@@ -79,23 +76,6 @@ namespace TerminalAppLocalTests
             appArgs.ValidateStartupCommands();
         }
 
-        void _buildCommandlinesExpectFailureHelper(AppCommandlineArgs& appArgs,
-                                                   const size_t expectedSubcommands,
-                                                   std::vector<const wchar_t*>& rawCommands)
-        {
-            auto commandlines = AppCommandlineArgs::BuildCommands(rawCommands);
-            VERIFY_ARE_EQUAL(expectedSubcommands, commandlines.size());
-            for (auto& cmdBlob : commandlines)
-            {
-                const auto result = appArgs.ParseCommand(cmdBlob);
-                VERIFY_ARE_NOT_EQUAL(0, result);
-                VERIFY_ARE_NOT_EQUAL("", appArgs._exitMessage);
-                Log::Comment(NoThrowString().Format(
-                    L"Exit Message:\n%hs",
-                    appArgs._exitMessage.c_str()));
-            }
-        }
-
         void _logCommandline(std::vector<const wchar_t*>& rawCommands)
         {
             std::wstring buffer;
@@ -1015,124 +995,6 @@ namespace TerminalAppLocalTests
         }
     }
 
-    void CommandlineTest::ParseMoveFocusArgs()
-    {
-        BEGIN_TEST_METHOD_PROPERTIES()
-            TEST_METHOD_PROPERTY(L"Data:useShortForm", L"{false, true}")
-        END_TEST_METHOD_PROPERTIES()
-
-        INIT_TEST_PROPERTY(bool, useShortForm, L"If true, use `mf` instead of `move-focus`");
-        const wchar_t* subcommand = useShortForm ? L"mf" : L"move-focus";
-
-        {
-            AppCommandlineArgs appArgs{};
-            std::vector<const wchar_t*> rawCommands{ L"wt.exe", subcommand };
-            Log::Comment(NoThrowString().Format(
-                L"Just the subcommand, without a direction, should fail."));
-
-            _buildCommandlinesExpectFailureHelper(appArgs, 1u, rawCommands);
-        }
-        {
-            AppCommandlineArgs appArgs{};
-            std::vector<const wchar_t*> rawCommands{ L"wt.exe", subcommand, L"left" };
-            _buildCommandlinesHelper(appArgs, 1u, rawCommands);
-
-            VERIFY_ARE_EQUAL(2u, appArgs._startupActions.size());
-
-            // The first action is going to always be a new-tab action
-            VERIFY_ARE_EQUAL(ShortcutAction::NewTab, appArgs._startupActions.at(0).Action());
-
-            auto actionAndArgs = appArgs._startupActions.at(1);
-            VERIFY_ARE_EQUAL(ShortcutAction::MoveFocus, actionAndArgs.Action());
-            VERIFY_IS_NOT_NULL(actionAndArgs.Args());
-            auto myArgs = actionAndArgs.Args().try_as<MoveFocusArgs>();
-            VERIFY_IS_NOT_NULL(myArgs);
-            VERIFY_ARE_EQUAL(FocusDirection::Left, myArgs.FocusDirection());
-        }
-        {
-            AppCommandlineArgs appArgs{};
-            std::vector<const wchar_t*> rawCommands{ L"wt.exe", subcommand, L"right" };
-            _buildCommandlinesHelper(appArgs, 1u, rawCommands);
-
-            VERIFY_ARE_EQUAL(2u, appArgs._startupActions.size());
-
-            // The first action is going to always be a new-tab action
-            VERIFY_ARE_EQUAL(ShortcutAction::NewTab, appArgs._startupActions.at(0).Action());
-
-            auto actionAndArgs = appArgs._startupActions.at(1);
-            VERIFY_ARE_EQUAL(ShortcutAction::MoveFocus, actionAndArgs.Action());
-            VERIFY_IS_NOT_NULL(actionAndArgs.Args());
-            auto myArgs = actionAndArgs.Args().try_as<MoveFocusArgs>();
-            VERIFY_IS_NOT_NULL(myArgs);
-            VERIFY_ARE_EQUAL(FocusDirection::Right, myArgs.FocusDirection());
-        }
-        {
-            AppCommandlineArgs appArgs{};
-            std::vector<const wchar_t*> rawCommands{ L"wt.exe", subcommand, L"up" };
-            _buildCommandlinesHelper(appArgs, 1u, rawCommands);
-
-            VERIFY_ARE_EQUAL(2u, appArgs._startupActions.size());
-
-            // The first action is going to always be a new-tab action
-            VERIFY_ARE_EQUAL(ShortcutAction::NewTab, appArgs._startupActions.at(0).Action());
-
-            auto actionAndArgs = appArgs._startupActions.at(1);
-            VERIFY_ARE_EQUAL(ShortcutAction::MoveFocus, actionAndArgs.Action());
-            VERIFY_IS_NOT_NULL(actionAndArgs.Args());
-            auto myArgs = actionAndArgs.Args().try_as<MoveFocusArgs>();
-            VERIFY_IS_NOT_NULL(myArgs);
-            VERIFY_ARE_EQUAL(FocusDirection::Up, myArgs.FocusDirection());
-        }
-        {
-            AppCommandlineArgs appArgs{};
-            std::vector<const wchar_t*> rawCommands{ L"wt.exe", subcommand, L"down" };
-            _buildCommandlinesHelper(appArgs, 1u, rawCommands);
-
-            VERIFY_ARE_EQUAL(2u, appArgs._startupActions.size());
-
-            // The first action is going to always be a new-tab action
-            VERIFY_ARE_EQUAL(ShortcutAction::NewTab, appArgs._startupActions.at(0).Action());
-
-            auto actionAndArgs = appArgs._startupActions.at(1);
-            VERIFY_ARE_EQUAL(ShortcutAction::MoveFocus, actionAndArgs.Action());
-            VERIFY_IS_NOT_NULL(actionAndArgs.Args());
-            auto myArgs = actionAndArgs.Args().try_as<MoveFocusArgs>();
-            VERIFY_IS_NOT_NULL(myArgs);
-            VERIFY_ARE_EQUAL(FocusDirection::Down, myArgs.FocusDirection());
-        }
-        {
-            AppCommandlineArgs appArgs{};
-            std::vector<const wchar_t*> rawCommands{ L"wt.exe", subcommand, L"badDirection" };
-            Log::Comment(NoThrowString().Format(
-                L"move-focus with an invalid direction should fail."));
-            _buildCommandlinesExpectFailureHelper(appArgs, 1u, rawCommands);
-        }
-        {
-            AppCommandlineArgs appArgs{};
-            std::vector<const wchar_t*> rawCommands{ L"wt.exe", subcommand, L"left", L";", subcommand, L"right" };
-            _buildCommandlinesHelper(appArgs, 2u, rawCommands);
-
-            VERIFY_ARE_EQUAL(3u, appArgs._startupActions.size());
-
-            // The first action is going to always be a new-tab action
-            VERIFY_ARE_EQUAL(ShortcutAction::NewTab, appArgs._startupActions.at(0).Action());
-
-            auto actionAndArgs = appArgs._startupActions.at(1);
-            VERIFY_ARE_EQUAL(ShortcutAction::MoveFocus, actionAndArgs.Action());
-            VERIFY_IS_NOT_NULL(actionAndArgs.Args());
-            auto myArgs = actionAndArgs.Args().try_as<MoveFocusArgs>();
-            VERIFY_IS_NOT_NULL(myArgs);
-            VERIFY_ARE_EQUAL(FocusDirection::Left, myArgs.FocusDirection());
-
-            actionAndArgs = appArgs._startupActions.at(2);
-            VERIFY_ARE_EQUAL(ShortcutAction::MoveFocus, actionAndArgs.Action());
-            VERIFY_IS_NOT_NULL(actionAndArgs.Args());
-            myArgs = actionAndArgs.Args().try_as<MoveFocusArgs>();
-            VERIFY_IS_NOT_NULL(myArgs);
-            VERIFY_ARE_EQUAL(FocusDirection::Right, myArgs.FocusDirection());
-        }
-    }
-
     void CommandlineTest::ValidateFirstCommandIsNewTab()
     {
         AppCommandlineArgs appArgs{};
@@ -1463,119 +1325,4 @@ namespace TerminalAppLocalTests
             VERIFY_ARE_EQUAL(L"powershell.exe", myArgs.TerminalArgs().Commandline());
         }
     }
-
-    void CommandlineTest::TestMultipleSplitPaneSizes()
-    {
-        BEGIN_TEST_METHOD_PROPERTIES()
-            TEST_METHOD_PROPERTY(L"Data:useShortForm", L"{false, true}")
-        END_TEST_METHOD_PROPERTIES()
-
-        INIT_TEST_PROPERTY(bool, useShortForm, L"If true, use `sp` instead of `split-pane`");
-        const wchar_t* subcommand = useShortForm ? L"sp" : L"split-pane";
-
-        {
-            AppCommandlineArgs appArgs{};
-            std::vector<const wchar_t*> rawCommands{ L"wt.exe", subcommand };
-            _buildCommandlinesHelper(appArgs, 1u, rawCommands);
-
-            VERIFY_ARE_EQUAL(2u, appArgs._startupActions.size());
-
-            // The first action is going to always be a new-tab action
-            VERIFY_ARE_EQUAL(ShortcutAction::NewTab, appArgs._startupActions.at(0).Action());
-
-            // The one we actually want to test here is the SplitPane action we created
-            auto actionAndArgs = appArgs._startupActions.at(1);
-            VERIFY_ARE_EQUAL(ShortcutAction::SplitPane, actionAndArgs.Action());
-            VERIFY_IS_NOT_NULL(actionAndArgs.Args());
-            auto myArgs = actionAndArgs.Args().try_as<SplitPaneArgs>();
-            VERIFY_IS_NOT_NULL(myArgs);
-            VERIFY_ARE_EQUAL(SplitState::Automatic, myArgs.SplitStyle());
-            VERIFY_ARE_EQUAL(0.5f, myArgs.SplitSize());
-            VERIFY_IS_NOT_NULL(myArgs.TerminalArgs());
-        }
-        {
-            AppCommandlineArgs appArgs{};
-            std::vector<const wchar_t*> rawCommands{ L"wt.exe", subcommand, L"-s", L".3" };
-            _buildCommandlinesHelper(appArgs, 1u, rawCommands);
-
-            VERIFY_ARE_EQUAL(2u, appArgs._startupActions.size());
-
-            // The first action is going to always be a new-tab action
-            VERIFY_ARE_EQUAL(ShortcutAction::NewTab, appArgs._startupActions.at(0).Action());
-
-            // The one we actually want to test here is the SplitPane action we created
-            auto actionAndArgs = appArgs._startupActions.at(1);
-            VERIFY_ARE_EQUAL(ShortcutAction::SplitPane, actionAndArgs.Action());
-            VERIFY_IS_NOT_NULL(actionAndArgs.Args());
-            auto myArgs = actionAndArgs.Args().try_as<SplitPaneArgs>();
-            VERIFY_IS_NOT_NULL(myArgs);
-            VERIFY_ARE_EQUAL(SplitState::Automatic, myArgs.SplitStyle());
-            VERIFY_ARE_EQUAL(0.3f, myArgs.SplitSize());
-            VERIFY_IS_NOT_NULL(myArgs.TerminalArgs());
-        }
-        {
-            AppCommandlineArgs appArgs{};
-            std::vector<const wchar_t*> rawCommands{ L"wt.exe", subcommand, L"-s", L".3", L";", subcommand };
-            _buildCommandlinesHelper(appArgs, 2u, rawCommands);
-
-            VERIFY_ARE_EQUAL(3u, appArgs._startupActions.size());
-
-            // The first action is going to always be a new-tab action
-            VERIFY_ARE_EQUAL(ShortcutAction::NewTab, appArgs._startupActions.at(0).Action());
-
-            {
-                // The one we actually want to test here is the SplitPane action we created
-                auto actionAndArgs = appArgs._startupActions.at(1);
-                VERIFY_ARE_EQUAL(ShortcutAction::SplitPane, actionAndArgs.Action());
-                VERIFY_IS_NOT_NULL(actionAndArgs.Args());
-                auto myArgs = actionAndArgs.Args().try_as<SplitPaneArgs>();
-                VERIFY_IS_NOT_NULL(myArgs);
-                VERIFY_ARE_EQUAL(SplitState::Automatic, myArgs.SplitStyle());
-                VERIFY_ARE_EQUAL(0.3f, myArgs.SplitSize());
-                VERIFY_IS_NOT_NULL(myArgs.TerminalArgs());
-            }
-            {
-                auto actionAndArgs = appArgs._startupActions.at(2);
-                VERIFY_ARE_EQUAL(ShortcutAction::SplitPane, actionAndArgs.Action());
-                VERIFY_IS_NOT_NULL(actionAndArgs.Args());
-                auto myArgs = actionAndArgs.Args().try_as<SplitPaneArgs>();
-                VERIFY_IS_NOT_NULL(myArgs);
-                VERIFY_ARE_EQUAL(SplitState::Automatic, myArgs.SplitStyle());
-                VERIFY_ARE_EQUAL(0.5f, myArgs.SplitSize());
-                VERIFY_IS_NOT_NULL(myArgs.TerminalArgs());
-            }
-        }
-        {
-            AppCommandlineArgs appArgs{};
-            std::vector<const wchar_t*> rawCommands{ L"wt.exe", subcommand, L"-s", L".3", L";", subcommand, L"-s", L".7" };
-            _buildCommandlinesHelper(appArgs, 2u, rawCommands);
-
-            VERIFY_ARE_EQUAL(3u, appArgs._startupActions.size());
-
-            // The first action is going to always be a new-tab action
-            VERIFY_ARE_EQUAL(ShortcutAction::NewTab, appArgs._startupActions.at(0).Action());
-
-            {
-                // The one we actually want to test here is the SplitPane action we created
-                auto actionAndArgs = appArgs._startupActions.at(1);
-                VERIFY_ARE_EQUAL(ShortcutAction::SplitPane, actionAndArgs.Action());
-                VERIFY_IS_NOT_NULL(actionAndArgs.Args());
-                auto myArgs = actionAndArgs.Args().try_as<SplitPaneArgs>();
-                VERIFY_IS_NOT_NULL(myArgs);
-                VERIFY_ARE_EQUAL(SplitState::Automatic, myArgs.SplitStyle());
-                VERIFY_ARE_EQUAL(0.3f, myArgs.SplitSize());
-                VERIFY_IS_NOT_NULL(myArgs.TerminalArgs());
-            }
-            {
-                auto actionAndArgs = appArgs._startupActions.at(2);
-                VERIFY_ARE_EQUAL(ShortcutAction::SplitPane, actionAndArgs.Action());
-                VERIFY_IS_NOT_NULL(actionAndArgs.Args());
-                auto myArgs = actionAndArgs.Args().try_as<SplitPaneArgs>();
-                VERIFY_IS_NOT_NULL(myArgs);
-                VERIFY_ARE_EQUAL(SplitState::Automatic, myArgs.SplitStyle());
-                VERIFY_ARE_EQUAL(0.7f, myArgs.SplitSize());
-                VERIFY_IS_NOT_NULL(myArgs.TerminalArgs());
-            }
-        }
-    }
 }

src/cascadia/LocalTests_TerminalApp/TabTests.cpp

@@ -486,7 +486,7 @@ namespace TerminalAppLocalTests
 
         Log::Comment(NoThrowString().Format(L"Duplicate the first pane"));
         result = RunOnUIThread([&page]() {
-            page->_SplitPane(SplitState::Automatic, SplitType::Duplicate, 0.5f, nullptr);
+            page->_SplitPane(SplitState::Automatic, SplitType::Duplicate, nullptr);
 
             VERIFY_ARE_EQUAL(1u, page->_tabs.Size());
             auto tab = page->_GetTerminalTabImpl(page->_tabs.GetAt(0));
@@ -504,7 +504,7 @@ namespace TerminalAppLocalTests
 
         Log::Comment(NoThrowString().Format(L"Duplicate the pane, and don't crash"));
         result = RunOnUIThread([&page]() {
-            page->_SplitPane(SplitState::Automatic, SplitType::Duplicate, 0.5f, nullptr);
+            page->_SplitPane(SplitState::Automatic, SplitType::Duplicate, nullptr);
 
             VERIFY_ARE_EQUAL(1u, page->_tabs.Size());
             auto tab = page->_GetTerminalTabImpl(page->_tabs.GetAt(0));

src/cascadia/Remoting/CommandlineArgs.cpp

@@ -1,25 +0,0 @@
-#include "pch.h"
-
-#include "CommandlineArgs.h"
-#include "CommandlineArgs.g.cpp"
-using namespace winrt;
-using namespace winrt::Microsoft::Terminal;
-using namespace winrt::Windows::Foundation;
-
-namespace winrt::Microsoft::Terminal::Remoting::implementation
-{
-    // LOAD BEARING CODE
-    // If you try to move this into the header, you will experience P A I N
-    // It must be defined after CommandlineArgs.g.cpp, otherwise the compiler
-    // will give you just the most impossible template errors to try and
-    // decipher.
-    void CommandlineArgs::Args(winrt::array_view<const winrt::hstring> const& value)
-    {
-        _args = { value.begin(), value.end() };
-    }
-
-    winrt::com_array<winrt::hstring> CommandlineArgs::Args()
-    {
-        return winrt::com_array<winrt::hstring>{ _args.begin(), _args.end() };
-    }
-}

src/cascadia/Remoting/CommandlineArgs.h

@@ -1,39 +0,0 @@
-#pragma once
-
-#include "CommandlineArgs.g.h"
-#include "../cascadia/inc/cppwinrt_utils.h"
-
-namespace winrt::Microsoft::Terminal::Remoting::implementation
-{
-    struct CommandlineArgs : public CommandlineArgsT<CommandlineArgs>
-    {
-    public:
-        CommandlineArgs() :
-            _args{},
-            _cwd{ L"" }
-        {
-        }
-
-        CommandlineArgs(const winrt::array_view<const winrt::hstring>& args,
-                        winrt::hstring currentDirectory) :
-            _args{ args.begin(), args.end() },
-            _cwd{ currentDirectory }
-        {
-        }
-
-        winrt::hstring CurrentDirectory() { return _cwd; };
-
-        void Args(winrt::array_view<const winrt::hstring> const& value);
-        winrt::com_array<winrt::hstring> Args();
-
-    private:
-        winrt::com_array<winrt::hstring> _args;
-        winrt::hstring _cwd;
-    };
-
-}
-
-namespace winrt::Microsoft::Terminal::Remoting::factory_implementation
-{
-    BASIC_FACTORY(CommandlineArgs);
-}

src/cascadia/Remoting/Microsoft.Terminal.RemotingLib.vcxproj

@@ -1,97 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <ProjectGuid>{43ce4ce5-0010-4b99-9569-672670d26e26}</ProjectGuid>
-    <Keyword>Win32Proj</Keyword>
-    <ProjectName>Microsoft.Terminal.Remoting.Lib</ProjectName>
-    <RootNamespace>Microsoft.Terminal.Remoting</RootNamespace>
-    <TargetName>Microsoft.Terminal.Remoting.Lib</TargetName>
-    <WindowsTargetPlatformMinVersion>10.0.17763.0</WindowsTargetPlatformMinVersion>
-    <ConfigurationType>StaticLibrary</ConfigurationType>
-    <SubSystem>Console</SubSystem>
-    <OpenConsoleUniversalApp>true</OpenConsoleUniversalApp>
-  </PropertyGroup>
-  <Import Project="..\..\..\common.openconsole.props" Condition="'$(OpenConsoleDir)'==''" />
-  <Import Project="$(OpenConsoleDir)src\cppwinrt.build.pre.props" />
-
-  <!-- ========================= Headers ======================== -->
-  <ItemGroup>
-    <ClInclude Include="Monarch.h">
-      <DependentUpon>Monarch.idl</DependentUpon>
-    </ClInclude>
-    <ClInclude Include="pch.h" />
-    <ClInclude Include="MonarchFactory.h" />
-    <ClInclude Include="Peasant.h">
-      <DependentUpon>Peasant.idl</DependentUpon>
-    </ClInclude>
-    <ClInclude Include="WindowManager.h">
-      <DependentUpon>WindowManager.idl</DependentUpon>
-    </ClInclude>
-    <ClInclude Include="CommandlineArgs.h">
-      <DependentUpon>Peasant.idl</DependentUpon>
-    </ClInclude>
-  </ItemGroup>
-  <!-- ========================= Cpp Files ======================== -->
-  <ItemGroup>
-    <ClCompile Include="Monarch.cpp">
-      <DependentUpon>Monarch.idl</DependentUpon>
-    </ClCompile>
-    <ClCompile Include="pch.cpp">
-      <PrecompiledHeader>Create</PrecompiledHeader>
-    </ClCompile>
-    <ClCompile Include="Peasant.cpp">
-      <DependentUpon>Peasant.idl</DependentUpon>
-    </ClCompile>
-    <ClCompile Include="WindowManager.cpp">
-      <DependentUpon>WindowManager.idl</DependentUpon>
-    </ClCompile>
-    <ClCompile Include="CommandlineArgs.cpp">
-      <DependentUpon>Peasant.idl</DependentUpon>
-    </ClCompile>
-    <ClCompile Include="$(GeneratedFilesDir)module.g.cpp" />
-  </ItemGroup>
-  <!-- ========================= idl Files ======================== -->
-  <ItemGroup>
-    <Midl Include="Monarch.idl" />
-    <Midl Include="Peasant.idl" />
-    <Midl Include="WindowManager.idl" />
-  </ItemGroup>
-  <!-- ========================= Misc Files ======================== -->
-  <ItemGroup>
-    <PRIResource Include="Resources\en-US\Resources.resw" />
-    <OCResourceDirectory Include="Resources" />
-    <None Include="packages.config" />
-  </ItemGroup>
-  <!-- ========================= Project References ======================== -->
-  <ItemGroup>
-    <!--
-      the packaging project won't recurse through our dependencies, you have to
-      make sure that if you add a cppwinrt dependency to any of these projects,
-      you also update all the consumers
-    -->
-    <ProjectReference Include="$(OpenConsoleDir)src\types\lib\types.vcxproj" />
-    <ProjectReference Include="$(OpenConsoleDir)src\cascadia\WinRTUtils\WinRTUtils.vcxproj">
-      <Project>{CA5CAD1A-039A-4929-BA2A-8BEB2E4106FE}</Project>
-      <ReferenceOutputAssembly>false</ReferenceOutputAssembly>
-    </ProjectReference>
-    <!-- For whatever reason, we can't include the TerminalControl and
-    TerminalSettings projects' winmds via project references. So we'll have to
-    manually include the winmds as References below -->
-  </ItemGroup>
-  <!-- ====================== Compiler & Linker Flags ===================== -->
-  <ItemDefinitionGroup>
-    <ClCompile>
-      <PrecompiledHeaderFile>pch.h</PrecompiledHeaderFile>
-    </ClCompile>
-    <Link>
-      <AdditionalDependencies>WindowsApp.lib;user32.lib;shell32.lib;%(AdditionalDependencies)</AdditionalDependencies>
-    </Link>
-    <Reference>
-      <Private>false</Private>
-    </Reference>
-  </ItemDefinitionGroup>
-  <!-- ========================= Globals ======================== -->
-  <Import Project="$(OpenConsoleDir)src\cppwinrt.build.post.props" />
-
-  <Import Project="$(SolutionDir)build\rules\CollectWildcardResources.targets" />
-</Project>

src/cascadia/Remoting/Monarch.cpp

@@ -1,137 +0,0 @@
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT license.
-
-#include "pch.h"
-#include "Monarch.h"
-#include "CommandlineArgs.h"
-
-#include "Monarch.g.cpp"
-#include "../../types/inc/utils.hpp"
-
-using namespace winrt;
-using namespace winrt::Microsoft::Terminal;
-using namespace winrt::Windows::Foundation;
-using namespace ::Microsoft::Console;
-
-namespace winrt::Microsoft::Terminal::Remoting::implementation
-{
-    Monarch::Monarch() :
-        _ourPID{ GetCurrentProcessId() }
-    {
-    }
-
-    // This is a private constructor to be used in unit tests, where we don't
-    // want each Monarch to necessarily use the current PID.
-    Monarch::Monarch(const uint64_t testPID) :
-        _ourPID{ testPID }
-    {
-    }
-
-    Monarch::~Monarch()
-    {
-    }
-
-    uint64_t Monarch::GetPID()
-    {
-        return _ourPID;
-    }
-
-    // Method Description:
-    // - Add the given peasant to the list of peasants we're tracking. This Peasant may have already been assigned an ID. If it hasn't, then give it an ID.
-    // Arguments:
-    // - peasant: the new Peasant to track.
-    // Return Value:
-    // - the ID assigned to the peasant.
-    uint64_t Monarch::AddPeasant(Remoting::IPeasant peasant)
-    {
-        // TODO:projects/5 This is terrible. There's gotta be a better way
-        // of finding the first opening in a non-consecutive map of int->object
-        const auto providedID = peasant.GetID();
-
-        if (providedID == 0)
-        {
-            // Peasant doesn't currently have an ID. Assign it a new one.
-            peasant.AssignID(_nextPeasantID++);
-        }
-        else
-        {
-            // Peasant already had an ID (from an older monarch). Leave that one
-            // be. Make sure that the next peasant's ID is higher than it.
-            _nextPeasantID = providedID >= _nextPeasantID ? providedID + 1 : _nextPeasantID;
-        }
-
-        auto newPeasantsId = peasant.GetID();
-        _peasants[newPeasantsId] = peasant;
-
-        // Add an event listener to the peasant's WindowActivated event.
-        peasant.WindowActivated({ this, &Monarch::_peasantWindowActivated });
-
-        // TODO:projects/5 Wait on the peasant's PID, and remove them from the
-        // map if they die. This won't work great in tests though, with fake
-        // PIDs.
-
-        return newPeasantsId;
-    }
-
-    // Method Description:
-    // - Event handler for the Peasant::WindowActivated event. Used as an
-    //   opportunity for us to update our internal stack of the "most recent
-    //   window".
-    // Arguments:
-    // - sender: the Peasant that raised this event. This might be out-of-proc!
-    // Return Value:
-    // - <none>
-    void Monarch::_peasantWindowActivated(const winrt::Windows::Foundation::IInspectable& sender,
-                                          const winrt::Windows::Foundation::IInspectable& /*args*/)
-    {
-        // TODO:projects/5 Pass the desktop and timestamp of when the window was
-        // activated in `args`.
-
-        if (auto peasant{ sender.try_as<Remoting::Peasant>() })
-        {
-            auto theirID = peasant.GetID();
-            _setMostRecentPeasant(theirID);
-        }
-    }
-
-    // Method Description:
-    // - Lookup a peasant by its ID.
-    // Arguments:
-    // - peasantID: The ID Of the peasant to find
-    // Return Value:
-    // - the peasant if it exists in our map, otherwise null
-    Remoting::IPeasant Monarch::_getPeasant(uint64_t peasantID)
-    {
-        auto peasantSearch = _peasants.find(peasantID);
-        return peasantSearch == _peasants.end() ? nullptr : peasantSearch->second;
-    }
-
-    void Monarch::_setMostRecentPeasant(const uint64_t peasantID)
-    {
-        // TODO:projects/5 Use a heap/priority queue per-desktop to track which
-        // peasant was the most recent per-desktop. When we want to get the most
-        // recent of all desktops (WindowingBehavior::UseExisting), then use the
-        // most recent of all desktops.
-        _mostRecentPeasant = peasantID;
-    }
-
-    // Method Description:
-    // - Try to handle a commandline from a new WT invocation. We might need to
-    //   hand the commandline to an existing window, or we might need to tell
-    //   the caller that they need to become a new window to handle it themselves.
-    // Arguments:
-    // - <none>
-    // Return Value:
-    // - <none>
-    bool Monarch::ProposeCommandline(const Remoting::CommandlineArgs& /*args*/)
-    {
-        // TODO:projects/5
-        // The branch dev/migrie/f/remote-commandlines has a more complete
-        // version of this function, with a naive implementation. For now, we
-        // always want to create a new window, so we'll just return true. This
-        // will tell the caller that we didn't handle the commandline, and they
-        // should open a new window to deal with it themselves.
-        return true;
-    }
-
-}

src/cascadia/Remoting/Monarch.h

@@ -1,80 +0,0 @@
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT license.
-
-#pragma once
-
-#include "Monarch.g.h"
-#include "Peasant.h"
-#include "../cascadia/inc/cppwinrt_utils.h"
-
-// We sure different GUIDs here depending on whether we're running a Release,
-// Preview, or Dev build. This ensures that different installs don't
-// accidentally talk to one another.
-//
-// * Release: {06171993-7eb1-4f3e-85f5-8bdd7386cce3}
-// * Preview: {04221993-7eb1-4f3e-85f5-8bdd7386cce3}
-// * Dev:     {08302020-7eb1-4f3e-85f5-8bdd7386cce3}
-constexpr GUID Monarch_clsid
-{
-#if defined(WT_BRANDING_RELEASE)
-    0x06171993,
-#elif defined(WT_BRANDING_PREVIEW)
-    0x04221993,
-#else
-    0x08302020,
-#endif
-        0x7eb1,
-        0x4f3e,
-    {
-        0x85, 0xf5, 0x8b, 0xdd, 0x73, 0x86, 0xcc, 0xe3
-    }
-};
-
-enum class WindowingBehavior : uint64_t
-{
-    UseNew = 0,
-    UseExisting = 1,
-};
-
-namespace RemotingUnitTests
-{
-    class RemotingTests;
-};
-
-namespace winrt::Microsoft::Terminal::Remoting::implementation
-{
-    struct Monarch : public MonarchT<Monarch>
-    {
-        Monarch();
-        ~Monarch();
-
-        uint64_t GetPID();
-
-        uint64_t AddPeasant(winrt::Microsoft::Terminal::Remoting::IPeasant peasant);
-
-        bool ProposeCommandline(const winrt::Microsoft::Terminal::Remoting::CommandlineArgs& args);
-
-    private:
-        Monarch(const uint64_t testPID);
-        uint64_t _ourPID;
-
-        uint64_t _nextPeasantID{ 1 };
-        uint64_t _thisPeasantID{ 0 };
-        uint64_t _mostRecentPeasant{ 0 };
-        WindowingBehavior _windowingBehavior{ WindowingBehavior::UseNew };
-        std::unordered_map<uint64_t, winrt::Microsoft::Terminal::Remoting::IPeasant> _peasants;
-
-        winrt::Microsoft::Terminal::Remoting::IPeasant _getPeasant(uint64_t peasantID);
-        void _setMostRecentPeasant(const uint64_t peasantID);
-
-        void _peasantWindowActivated(const winrt::Windows::Foundation::IInspectable& sender,
-                                     const winrt::Windows::Foundation::IInspectable& args);
-
-        friend class RemotingUnitTests::RemotingTests;
-    };
-}
-
-namespace winrt::Microsoft::Terminal::Remoting::factory_implementation
-{
-    BASIC_FACTORY(Monarch);
-}

src/cascadia/Remoting/Monarch.idl

@@ -1,15 +0,0 @@
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT license.
-
-import "Peasant.idl";
-
-namespace Microsoft.Terminal.Remoting
-{
-    [default_interface] runtimeclass Monarch {
-        Monarch();
-
-        UInt64 GetPID();
-        UInt64 AddPeasant(IPeasant peasant);
-        Boolean ProposeCommandline(CommandlineArgs args);
-    };
-}

src/cascadia/Remoting/MonarchFactory.h

@@ -1,49 +0,0 @@
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT license.
-
-#include "pch.h"
-
-#include "Monarch.h"
-
-// This seems like a hack, but it works.
-//
-// This class factory works so that there's only ever one instance of a Monarch
-// per-process. Once the first monarch is created, we'll stash it in g_weak.
-// Future callers who try to instantiate a Monarch will get the one that's
-// already been made.
-
-struct MonarchFactory : winrt::implements<MonarchFactory, ::IClassFactory>
-{
-    MonarchFactory() = default;
-
-    HRESULT __stdcall CreateInstance(IUnknown* outer, GUID const& iid, void** result) noexcept
-    {
-        static winrt::weak_ref<winrt::Microsoft::Terminal::Remoting::implementation::Monarch> g_weak{ nullptr };
-
-        *result = nullptr;
-        if (outer)
-        {
-            return CLASS_E_NOAGGREGATION;
-        }
-
-        // Lock the ref immediately. We don't want it freed from out beneath us
-        auto strong = g_weak.get();
-        if (!strong)
-        {
-            // Create a new Monarch instance
-            strong = winrt::make_self<winrt::Microsoft::Terminal::Remoting::implementation::Monarch>();
-            g_weak = (*strong).get_weak();
-            return strong.as(iid, result);
-        }
-        else
-        {
-            // We already instantiated one Monarch, let's just return that one!
-            return strong.as(iid, result);
-        }
-    }
-
-    HRESULT __stdcall LockServer(BOOL) noexcept
-    {
-        return S_OK;
-    }
-};

src/cascadia/Remoting/Peasant.cpp

@@ -1,66 +0,0 @@
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT license.
-
-#include "pch.h"
-#include "Peasant.h"
-#include "CommandlineArgs.h"
-#include "Peasant.g.cpp"
-#include "../../types/inc/utils.hpp"
-
-using namespace winrt;
-using namespace winrt::Microsoft::Terminal;
-using namespace winrt::Windows::Foundation;
-using namespace ::Microsoft::Console;
-
-namespace winrt::Microsoft::Terminal::Remoting::implementation
-{
-    Peasant::Peasant() :
-        _ourPID{ GetCurrentProcessId() }
-    {
-    }
-
-    // This is a private constructor to be used in unit tests, where we don't
-    // want each Peasant to necessarily use the current PID.
-    Peasant::Peasant(const uint64_t testPID) :
-        _ourPID{ testPID }
-    {
-    }
-
-    void Peasant::AssignID(uint64_t id)
-    {
-        _id = id;
-    }
-    uint64_t Peasant::GetID()
-    {
-        return _id;
-    }
-
-    uint64_t Peasant::GetPID()
-    {
-        return _ourPID;
-    }
-
-    bool Peasant::ExecuteCommandline(const Remoting::CommandlineArgs& args)
-    {
-        // If this is the first set of args we were ever told about, stash them
-        // away. We'll need to get at them later, when we setup the startup
-        // actions for the window.
-        if (_initialArgs == nullptr)
-        {
-            _initialArgs = args;
-        }
-
-        // Raise an event with these args. The AppHost will listen for this
-        // event to know when to take these args and dispatch them to a
-        // currently-running window.
-        _ExecuteCommandlineRequestedHandlers(*this, args);
-
-        return true;
-    }
-
-    Remoting::CommandlineArgs Peasant::InitialArgs()
-    {
-        return _initialArgs;
-    }
-
-}

src/cascadia/Remoting/Peasant.h

@@ -1,44 +0,0 @@
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT license.
-
-#pragma once
-
-#include "Peasant.g.h"
-#include "../cascadia/inc/cppwinrt_utils.h"
-
-namespace RemotingUnitTests
-{
-    class RemotingTests;
-};
-namespace winrt::Microsoft::Terminal::Remoting::implementation
-{
-    struct Peasant : public PeasantT<Peasant>
-    {
-        Peasant();
-
-        void AssignID(uint64_t id);
-        uint64_t GetID();
-        uint64_t GetPID();
-
-        bool ExecuteCommandline(const winrt::Microsoft::Terminal::Remoting::CommandlineArgs& args);
-
-        winrt::Microsoft::Terminal::Remoting::CommandlineArgs InitialArgs();
-        TYPED_EVENT(WindowActivated, winrt::Windows::Foundation::IInspectable, winrt::Windows::Foundation::IInspectable);
-        TYPED_EVENT(ExecuteCommandlineRequested, winrt::Windows::Foundation::IInspectable, winrt::Microsoft::Terminal::Remoting::CommandlineArgs);
-
-    private:
-        Peasant(const uint64_t testPID);
-        uint64_t _ourPID;
-
-        uint64_t _id{ 0 };
-
-        winrt::Microsoft::Terminal::Remoting::CommandlineArgs _initialArgs{ nullptr };
-
-        friend class RemotingUnitTests::RemotingTests;
-    };
-}
-
-namespace winrt::Microsoft::Terminal::Remoting::factory_implementation
-{
-    BASIC_FACTORY(Peasant);
-}

src/cascadia/Remoting/Peasant.idl

@@ -1,32 +0,0 @@
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT license.
-
-namespace Microsoft.Terminal.Remoting
-{
-
-    runtimeclass CommandlineArgs
-    {
-        CommandlineArgs();
-        CommandlineArgs(String[] args, String cwd);
-
-        String[] Args { get; set; };
-        String CurrentDirectory();
-    };
-
-    interface IPeasant
-    {
-        CommandlineArgs InitialArgs { get; };
-
-        void AssignID(UInt64 id);
-        UInt64 GetID();
-        UInt64 GetPID();
-        Boolean ExecuteCommandline(CommandlineArgs args);
-        event Windows.Foundation.TypedEventHandler<Object, Object> WindowActivated;
-        event Windows.Foundation.TypedEventHandler<Object, CommandlineArgs> ExecuteCommandlineRequested;
-    };
-
-    [default_interface] runtimeclass Peasant : IPeasant
-    {
-        Peasant();
-    };
-}

src/cascadia/Remoting/Resources/en-US/Resources.resw

@@ -1,120 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<root>
-  <!--
-    Microsoft ResX Schema
-
-    Version 2.0
-
-    The primary goals of this format is to allow a simple XML format
-    that is mostly human readable. The generation and parsing of the
-    various data types are done through the TypeConverter classes
-    associated with the data types.
-
-    Example:
-
-    ... ado.net/XML headers & schema ...
-    <resheader name="resmimetype">text/microsoft-resx</resheader>
-    <resheader name="version">2.0</resheader>
-    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
-    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
-    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
-    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
-    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
-        <value>[base64 mime encoded serialized .NET Framework object]</value>
-    </data>
-    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
-        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
-        <comment>This is a comment</comment>
-    </data>
-
-    There are any number of "resheader" rows that contain simple
-    name/value pairs.
-
-    Each data row contains a name, and value. The row also contains a
-    type or mimetype. Type corresponds to a .NET class that support
-    text/value conversion through the TypeConverter architecture.
-    Classes that don't support this are serialized and stored with the
-    mimetype set.
-
-    The mimetype is used for serialized objects, and tells the
-    ResXResourceReader how to depersist the object. This is currently not
-    extensible. For a given mimetype the value must be set accordingly:
-
-    Note - application/x-microsoft.net.object.binary.base64 is the format
-    that the ResXResourceWriter will generate, however the reader can
-    read any of the formats listed below.
-
-    mimetype: application/x-microsoft.net.object.binary.base64
-    value   : The object must be serialized with
-            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
-            : and then encoded with base64 encoding.
-
-    mimetype: application/x-microsoft.net.object.soap.base64
-    value   : The object must be serialized with
-            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
-            : and then encoded with base64 encoding.
-
-    mimetype: application/x-microsoft.net.object.bytearray.base64
-    value   : The object must be serialized into a byte array
-            : using a System.ComponentModel.TypeConverter
-            : and then encoded with base64 encoding.
-    -->
-  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
-    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
-    <xsd:element name="root" msdata:IsDataSet="true">
-      <xsd:complexType>
-        <xsd:choice maxOccurs="unbounded">
-          <xsd:element name="metadata">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" />
-              </xsd:sequence>
-              <xsd:attribute name="name" use="required" type="xsd:string" />
-              <xsd:attribute name="type" type="xsd:string" />
-              <xsd:attribute name="mimetype" type="xsd:string" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="assembly">
-            <xsd:complexType>
-              <xsd:attribute name="alias" type="xsd:string" />
-              <xsd:attribute name="name" type="xsd:string" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="data">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
-              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
-              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
-              <xsd:attribute ref="xml:space" />
-            </xsd:complexType>
-          </xsd:element>
-          <xsd:element name="resheader">
-            <xsd:complexType>
-              <xsd:sequence>
-                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
-              </xsd:sequence>
-              <xsd:attribute name="name" type="xsd:string" use="required" />
-            </xsd:complexType>
-          </xsd:element>
-        </xsd:choice>
-      </xsd:complexType>
-    </xsd:element>
-  </xsd:schema>
-  <resheader name="resmimetype">
-    <value>text/microsoft-resx</value>
-  </resheader>
-  <resheader name="version">
-    <value>2.0</value>
-  </resheader>
-  <resheader name="reader">
-    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-  <resheader name="writer">
-    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
-  </resheader>
-</root>

src/cascadia/Remoting/WindowManager.cpp

@@ -1,109 +0,0 @@
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT license.
-
-#include "pch.h"
-#include "WindowManager.h"
-#include "MonarchFactory.h"
-#include "CommandlineArgs.h"
-
-#include "WindowManager.g.cpp"
-#include "../../types/inc/utils.hpp"
-
-using namespace winrt;
-using namespace winrt::Microsoft::Terminal;
-using namespace winrt::Windows::Foundation;
-using namespace ::Microsoft::Console;
-
-namespace winrt::Microsoft::Terminal::Remoting::implementation
-{
-    WindowManager::WindowManager()
-    {
-        // Register with COM as a server for the Monarch class
-        _registerAsMonarch();
-        // Instantiate an instance of the Monarch. This may or may not be in-proc!
-        _createMonarch();
-    }
-
-    WindowManager::~WindowManager()
-    {
-        // IMPORTANT! Tear down the registration as soon as we exit. If we're not a
-        // real peasant window (the monarch passed our commandline to someone else),
-        // then the monarch dies, we don't want our registration becoming the active
-        // monarch!
-        CoRevokeClassObject(_registrationHostClass);
-        _registrationHostClass = 0;
-    }
-
-    void WindowManager::ProposeCommandline(const Remoting::CommandlineArgs& args)
-    {
-        const bool isKing = _areWeTheKing();
-        // If we're the king, we _definitely_ want to process the arguments, we were
-        // launched with them!
-        //
-        // Otherwise, the King will tell us if we should make a new window
-        _shouldCreateWindow = isKing ||
-                              _monarch.ProposeCommandline(args);
-
-        if (_shouldCreateWindow)
-        {
-            // If we should create a new window, then instantiate our Peasant
-            // instance, and tell that peasant to handle that commandline.
-            _createOurPeasant();
-
-            _peasant.ExecuteCommandline(args);
-        }
-        // Otherwise, we'll do _nothing_.
-    }
-
-    bool WindowManager::ShouldCreateWindow()
-    {
-        return _shouldCreateWindow;
-    }
-
-    void WindowManager::_registerAsMonarch()
-    {
-        winrt::check_hresult(CoRegisterClassObject(Monarch_clsid,
-                                                   winrt::make<::MonarchFactory>().get(),
-                                                   CLSCTX_LOCAL_SERVER,
-                                                   REGCLS_MULTIPLEUSE,
-                                                   &_registrationHostClass));
-    }
-
-    void WindowManager::_createMonarch()
-    {
-        // Heads up! This only works because we're using
-        // "metadata-based-marshalling" for our WinRT types. That means the OS is
-        // using the .winmd file we generate to figure out the proxy/stub
-        // definitions for our types automatically. This only works in the following
-        // cases:
-        //
-        // * If we're running unpackaged: the .winmd must be a sibling of the .exe
-        // * If we're running packaged: the .winmd must be in the package root
-        _monarch = create_instance<Remoting::Monarch>(Monarch_clsid,
-                                                      CLSCTX_LOCAL_SERVER);
-    }
-
-    bool WindowManager::_areWeTheKing()
-    {
-        const auto kingPID{ _monarch.GetPID() };
-        const auto ourPID{ GetCurrentProcessId() };
-        return (ourPID == kingPID);
-    }
-
-    Remoting::IPeasant WindowManager::_createOurPeasant()
-    {
-        auto p = winrt::make_self<Remoting::implementation::Peasant>();
-        _peasant = *p;
-        _monarch.AddPeasant(_peasant);
-
-        // TODO:projects/5 Spawn a thread to wait on the monarch, and handle the election
-
-        return _peasant;
-    }
-
-    Remoting::Peasant WindowManager::CurrentWindow()
-    {
-        return _peasant;
-    }
-
-}

src/cascadia/Remoting/WindowManager.h

@@ -1,39 +0,0 @@
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT license.
-
-#pragma once
-
-#include "WindowManager.g.h"
-#include "Peasant.h"
-#include "Monarch.h"
-#include "../cascadia/inc/cppwinrt_utils.h"
-
-namespace winrt::Microsoft::Terminal::Remoting::implementation
-{
-    struct WindowManager final : public WindowManagerT<WindowManager>
-    {
-        WindowManager();
-        ~WindowManager();
-
-        void ProposeCommandline(const winrt::Microsoft::Terminal::Remoting::CommandlineArgs& args);
-        bool ShouldCreateWindow();
-
-        winrt::Microsoft::Terminal::Remoting::Peasant CurrentWindow();
-
-    private:
-        bool _shouldCreateWindow{ false };
-        DWORD _registrationHostClass{ 0 };
-        winrt::Microsoft::Terminal::Remoting::Monarch _monarch{ nullptr };
-        winrt::Microsoft::Terminal::Remoting::Peasant _peasant{ nullptr };
-
-        void _registerAsMonarch();
-        void _createMonarch();
-        bool _areWeTheKing();
-        winrt::Microsoft::Terminal::Remoting::IPeasant _createOurPeasant();
-    };
-}
-
-namespace winrt::Microsoft::Terminal::Remoting::factory_implementation
-{
-    BASIC_FACTORY(WindowManager);
-}

src/cascadia/Remoting/WindowManager.idl

@@ -1,13 +0,0 @@
-import "Peasant.idl";
-
-
-namespace Microsoft.Terminal.Remoting
-{
-    [default_interface] runtimeclass WindowManager
-    {
-        WindowManager();
-        void ProposeCommandline(CommandlineArgs args);
-        Boolean ShouldCreateWindow { get; };
-        IPeasant CurrentWindow();
-    };
-}

src/cascadia/Remoting/dll/Microsoft.Terminal.Remoting.def

@@ -1,3 +0,0 @@
-EXPORTS
-DllCanUnloadNow = WINRT_CanUnloadNow                    PRIVATE
-DllGetActivationFactory = WINRT_GetActivationFactory    PRIVATE

src/cascadia/Remoting/dll/Microsoft.Terminal.Remoting.vcxproj

@@ -1,74 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup Label="Globals">
-    <ProjectGuid>{27b5aaeb-a548-44cf-9777-f8baa32af7ae}</ProjectGuid>
-    <ProjectName>Microsoft.Terminal.Remoting</ProjectName>
-    <RootNamespace>Microsoft.Terminal.Remoting</RootNamespace>
-    <!-- cppwinrt.build.pre.props depends on these settings: -->
-    <!-- build a dll, not exe (Application) -->
-    <ConfigurationType>DynamicLibrary</ConfigurationType>
-    <SubSystem>Console</SubSystem>
-    <!-- sets a bunch of Windows Universal properties -->
-    <OpenConsoleUniversalApp>true</OpenConsoleUniversalApp>
-  </PropertyGroup>
-  <Import Project="..\..\..\..\common.openconsole.props" Condition="'$(OpenConsoleDir)'==''" />
-  <Import Project="$(OpenConsoleDir)src\cppwinrt.build.pre.props" />
-  <!-- ========================= XAML files ======================== -->
-  <ItemGroup>
-    <!-- DON'T PUT XAML FILES HERE! Put them in TerminalAppLib.vcxproj -->
-  </ItemGroup>
-  <!-- ========================= Headers ======================== -->
-  <ItemGroup>
-    <!-- Only put headers for winrt types in here. Don't put other header files
-    in here - put them in the lib's vcxproj instead! -->
-    <ClInclude Include="../Monarch.h" />
-    <ClInclude Include="../Peasant.h" />
-  </ItemGroup>
-  <!-- ========================= Cpp Files ======================== -->
-  <!-- Don't put source files in here - put them in the lib's vcxproj instead! -->
-  <!-- ========================= idl Files ======================== -->
-  <ItemGroup>
-    <!-- DON'T PUT IDL FILES HERE! Put them in the lib's vcxproj -->
-  </ItemGroup>
-  <!-- ========================= Misc Files ======================== -->
-  <ItemGroup>
-    <None Include="packages.config" />
-    <None Include="Microsoft.Terminal.Remoting.def" />
-  </ItemGroup>
-  <!-- ========================= Project References ======================== -->
-  <ItemGroup>
-    <!--
-      the packaging project won't recurse through our dependencies, you have to
-      make sure that if you add a cppwinrt dependency to any of these projects,
-      you also update all the consumers
-    -->
-    <ProjectReference Include="$(OpenConsoleDir)src\types\lib\types.vcxproj">
-      <Project>{18D09A24-8240-42D6-8CB6-236EEE820263}</Project>
-    </ProjectReference>
-    <!-- Reference Microsoft.Terminal.RemotingLib here, so we can use it's winmd as
-    our winmd. This didn't work correctly in VS2017, you'd need to
-    manually reference the lib -->
-    <ProjectReference Include="$(OpenConsoleDir)src\cascadia\Remoting\Microsoft.Terminal.RemotingLib.vcxproj">
-      <Private>true</Private>
-      <CopyLocalSatelliteAssemblies>true</CopyLocalSatelliteAssemblies>
-    </ProjectReference>
-  </ItemGroup>
-
-
-  <ItemDefinitionGroup>
-    <ClCompile>
-      <AdditionalIncludeDirectories>$(OpenConsoleDir)\dep\jsoncpp\json;%(AdditionalIncludeDirectories);</AdditionalIncludeDirectories>
-    </ClCompile>
-    <Link>
-      <AdditionalDependencies>User32.lib;WindowsApp.lib;shell32.lib;%(AdditionalDependencies)</AdditionalDependencies>
-      <!-- Our lib contains a DllMain that we need to force the use of. -->
-      <AdditionalOptions Condition="'$(Platform)'=='Win32'">/INCLUDE:_DllMain@12</AdditionalOptions>
-      <AdditionalOptions Condition="'$(Platform)'!='Win32'">/INCLUDE:DllMain</AdditionalOptions>
-    </Link>
-    <Reference>
-      <!-- Do not propagate microsoft.ui.xaml upwards as a private dependency. -->
-      <Private>false</Private>
-    </Reference>
-  </ItemDefinitionGroup>
-  <Import Project="$(OpenConsoleDir)src\cppwinrt.build.post.props" />
-</Project>

src/cascadia/Remoting/packages.config

@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="Microsoft.Windows.CppWinRT" version="2.0.210309.3" targetFramework="native" />
-</packages>

src/cascadia/Remoting/pch.cpp

@@ -1,4 +0,0 @@
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT license.
-
-#include "pch.h"

src/cascadia/Remoting/pch.h

@@ -1,48 +0,0 @@
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT license.
-//
-// pch.h
-// Header for platform projection include files
-//
-
-#pragma once
-
-#define WIN32_LEAN_AND_MEAN
-#define NOMCX
-#define NOHELP
-#define NOCOMM
-
-// Manually include til after we include Windows.Foundation to give it winrt superpowers
-#define BLOCK_TIL
-#include <LibraryIncludes.h>
-// This is inexplicable, but for whatever reason, cppwinrt conflicts with the
-//      SDK definition of this function, so the only fix is to undef it.
-// from WinBase.h
-// Windows::UI::Xaml::Media::Animation::IStoryboard::GetCurrentTime
-#ifdef GetCurrentTime
-#undef GetCurrentTime
-#endif
-
-#include <wil/cppwinrt.h>
-
-#include <unknwn.h>
-
-#include <hstring.h>
-
-#include <winrt/Windows.ApplicationModel.h>
-#include <winrt/Windows.Foundation.h>
-#include <winrt/Windows.Foundation.Collections.h>
-
-#include <winrt/Windows.System.h>
-
-// Including TraceLogging essentials for the binary
-#include <TraceLoggingProvider.h>
-#include <winmeta.h>
-TRACELOGGING_DECLARE_PROVIDER(g_hSettingsModelProvider);
-#include <telemetry/ProjectTelemetry.h>
-#include <TraceLoggingActivity.h>
-
-#include <shellapi.h>
-
-// Manually include til after we include Windows.Foundation to give it winrt superpowers
-#include "til.h"

src/cascadia/ShellExtension/OpenTerminalHere.cpp

@@ -3,7 +3,6 @@
 
 #include "pch.h"
 #include "OpenTerminalHere.h"
-#include <ShlObj.h>
 
 // TODO GH#6112: Localize these strings
 static constexpr std::wstring_view VerbDisplayName{ L"Open in Windows Terminal" };
@@ -118,29 +117,14 @@ static std::wstring _getExePath()
 HRESULT OpenTerminalHere::Invoke(IShellItemArray* psiItemArray,
                                  IBindCtx* /*pBindContext*/)
 {
+    DWORD count;
+    psiItemArray->GetCount(&count);
+
+    winrt::com_ptr<IShellItem> psi;
+    RETURN_IF_FAILED(psiItemArray->GetItemAt(0, psi.put()));
+
     wil::unique_cotaskmem_string pszName;
-
-    if (psiItemArray == nullptr)
-    {
-        // get the current path from explorer.exe
-        const auto path = this->_GetPathFromExplorer();
-
-        // no go, unable to get a reasonable path
-        if (path.empty())
-        {
-            return S_FALSE;
-        }
-        pszName = wil::make_cotaskmem_string(path.c_str(), path.length());
-    }
-    else
-    {
-        DWORD count;
-        psiItemArray->GetCount(&count);
-
-        winrt::com_ptr<IShellItem> psi;
-        RETURN_IF_FAILED(psiItemArray->GetItemAt(0, psi.put()));
-        RETURN_IF_FAILED(psi->GetDisplayName(SIGDN_FILESYSPATH, &pszName));
-    }
+    RETURN_IF_FAILED(psi->GetDisplayName(SIGDN_FILESYSPATH, &pszName));
 
     {
         wil::unique_process_information _piClient;
@@ -230,103 +214,3 @@ HRESULT OpenTerminalHere::EnumSubCommands(IEnumExplorerCommand** ppEnum)
     *ppEnum = nullptr;
     return E_NOTIMPL;
 }
-
-std::wstring OpenTerminalHere::_GetPathFromExplorer() const
-{
-    using namespace std;
-    using namespace winrt;
-
-    wstring path;
-    HRESULT hr = NOERROR;
-
-    auto hwnd = ::GetForegroundWindow();
-    if (hwnd == nullptr)
-    {
-        return path;
-    }
-
-    TCHAR szName[MAX_PATH] = { 0 };
-    ::GetClassName(hwnd, szName, MAX_PATH);
-    if (0 == StrCmp(szName, L"WorkerW") ||
-        0 == StrCmp(szName, L"Progman"))
-    {
-        //special folder: desktop
-        hr = ::SHGetFolderPath(NULL, CSIDL_DESKTOP, NULL, SHGFP_TYPE_CURRENT, szName);
-        if (FAILED(hr))
-        {
-            return path;
-        }
-
-        path = szName;
-        return path;
-    }
-
-    if (0 != StrCmp(szName, L"CabinetWClass"))
-    {
-        return path;
-    }
-
-    com_ptr<IShellWindows> shell;
-    try
-    {
-        shell = create_instance<IShellWindows>(CLSID_ShellWindows, CLSCTX_ALL);
-    }
-    catch (...)
-    {
-        //look like try_create_instance is not available no more
-    }
-
-    if (shell == nullptr)
-    {
-        return path;
-    }
-
-    com_ptr<IDispatch> disp;
-    wil::unique_variant variant;
-    variant.vt = VT_I4;
-
-    com_ptr<IWebBrowserApp> browser;
-    // look for correct explorer window
-    for (variant.intVal = 0;
-         shell->Item(variant, disp.put()) == S_OK;
-         variant.intVal++)
-    {
-        com_ptr<IWebBrowserApp> tmp;
-        if (FAILED(disp->QueryInterface(tmp.put())))
-        {
-            disp = nullptr; // get rid of DEBUG non-nullptr warning
-            continue;
-        }
-
-        HWND tmpHWND = NULL;
-        hr = tmp->get_HWND(reinterpret_cast<SHANDLE_PTR*>(&tmpHWND));
-        if (hwnd == tmpHWND)
-        {
-            browser = tmp;
-            disp = nullptr; // get rid of DEBUG non-nullptr warning
-            break; //found
-        }
-
-        disp = nullptr; // get rid of DEBUG non-nullptr warning
-    }
-
-    if (browser != nullptr)
-    {
-        wil::unique_bstr url;
-        hr = browser->get_LocationURL(&url);
-        if (FAILED(hr))
-        {
-            return path;
-        }
-
-        wstring sUrl(url.get(), SysStringLen(url.get()));
-        DWORD size = MAX_PATH;
-        hr = ::PathCreateFromUrl(sUrl.c_str(), szName, &size, NULL);
-        if (SUCCEEDED(hr))
-        {
-            path = szName;
-        }
-    }
-
-    return path;
-}

src/cascadia/ShellExtension/OpenTerminalHere.h

@@ -46,9 +46,6 @@ struct __declspec(uuid("9f156763-7844-4dc4-b2b1-901f640f5155"))
     STDMETHODIMP GetCanonicalName(GUID* pguidCommandName);
     STDMETHODIMP EnumSubCommands(IEnumExplorerCommand** ppEnum);
 #pragma endregion
-
-private:
-    std::wstring _GetPathFromExplorer() const;
 };
 
 CoCreatableClass(OpenTerminalHere);

src/cascadia/ShellExtension/WindowsTerminalShellExt.vcxproj

@@ -11,13 +11,10 @@
     <!-- sets a bunch of Windows Universal properties -->
     <OpenConsoleUniversalApp>true</OpenConsoleUniversalApp>
   </PropertyGroup>
+
   <Import Project="..\..\..\common.openconsole.props" Condition="'$(OpenConsoleDir)'==''" />
   <Import Project="$(OpenConsoleDir)src\cppwinrt.build.pre.props" />
-  <ItemDefinitionGroup>
-    <Link>
-      <AdditionalDependencies>User32.lib;%(AdditionalDependencies)</AdditionalDependencies>
-    </Link>
-  </ItemDefinitionGroup>
+
   <ItemGroup>
     <ClInclude Include="pch.h" />
     <ClInclude Include="OpenTerminalHere.h" />
@@ -43,6 +40,7 @@
     <None Include="packages.config" />
     <None Include="WindowsTerminalShellExt.def" />
   </ItemGroup>
+
   <!-- ========================= Project References ======================== -->
   <ItemGroup>
     <!--
@@ -58,5 +56,7 @@
       <ReferenceOutputAssembly>false</ReferenceOutputAssembly>
     </ProjectReference>
   </ItemGroup>
+
+
   <Import Project="$(OpenConsoleDir)src\cppwinrt.build.post.props" />
 </Project>

src/cascadia/ShellExtension/packages.config

@@ -1,4 +1,4 @@
 <?xml version="1.0" encoding="utf-8"?>
 <packages>
-  <package id="Microsoft.Windows.CppWinRT" version="2.0.210309.3" targetFramework="native" />
+  <package id="Microsoft.Windows.CppWinRT" version="2.0.201017.1" targetFramework="native" />
 </packages>

src/cascadia/TerminalApp/AppActionHandlers.cpp

@@ -122,11 +122,7 @@ namespace winrt::TerminalApp::implementation
         }
         else if (const auto& realArgs = args.ActionArgs().try_as<SplitPaneArgs>())
         {
-            _SplitPane(realArgs.SplitStyle(),
-                       realArgs.SplitMode(),
-                       // This is safe, we're already filtering so the value is (0, 1)
-                       ::base::saturated_cast<float>(realArgs.SplitSize()),
-                       realArgs.TerminalArgs());
+            _SplitPane(realArgs.SplitStyle(), realArgs.SplitMode(), realArgs.TerminalArgs());
             args.Handled(true);
         }
     }
@@ -134,20 +130,23 @@ namespace winrt::TerminalApp::implementation
     void TerminalPage::_HandleTogglePaneZoom(const IInspectable& /*sender*/,
                                              const ActionEventArgs& args)
     {
-        if (const auto activeTab{ _GetFocusedTabImpl() })
+        if (auto focusedTab = _GetFocusedTab())
         {
-            // Don't do anything if there's only one pane. It's already zoomed.
-            if (activeTab->GetLeafPaneCount() > 1)
+            if (auto activeTab = _GetTerminalTabImpl(focusedTab))
             {
-                // First thing's first, remove the current content from the UI
-                // tree. This is important, because we might be leaving zoom, and if
-                // a pane is zoomed, then it's currently in the UI tree, and should
-                // be removed before it's re-added in Pane::Restore
-                _tabContent.Children().Clear();
+                // Don't do anything if there's only one pane. It's already zoomed.
+                if (activeTab && activeTab->GetLeafPaneCount() > 1)
+                {
+                    // First thing's first, remove the current content from the UI
+                    // tree. This is important, because we might be leaving zoom, and if
+                    // a pane is zoomed, then it's currently in the UI tree, and should
+                    // be removed before it's re-added in Pane::Restore
+                    _tabContent.Children().Clear();
 
-                // Togging the zoom on the tab will cause the tab to inform us of
-                // the new root Content for this tab.
-                activeTab->ToggleZoom();
+                    // Togging the zoom on the tab will cause the tab to inform us of
+                    // the new root Content for this tab.
+                    activeTab->ToggleZoom();
+                }
             }
         }
 
@@ -344,16 +343,19 @@ namespace winrt::TerminalApp::implementation
         args.Handled(false);
         if (const auto& realArgs = args.ActionArgs().try_as<SetColorSchemeArgs>())
         {
-            if (const auto activeTab{ _GetFocusedTabImpl() })
+            if (auto focusedTab = _GetFocusedTab())
             {
-                if (auto activeControl = activeTab->GetActiveTerminalControl())
+                if (auto activeTab = _GetTerminalTabImpl(focusedTab))
                 {
-                    if (const auto scheme = _settings.GlobalSettings().ColorSchemes().TryLookup(realArgs.SchemeName()))
+                    if (auto activeControl = activeTab->GetActiveTerminalControl())
                     {
-                        auto controlSettings = activeControl.Settings().as<TerminalSettings>();
-                        controlSettings->ApplyColorScheme(scheme);
-                        activeControl.UpdateSettings(*controlSettings);
-                        args.Handled(true);
+                        if (const auto scheme = _settings.GlobalSettings().ColorSchemes().TryLookup(realArgs.SchemeName()))
+                        {
+                            auto controlSettings = activeControl.Settings().as<TerminalSettings>();
+                            controlSettings->ApplyColorScheme(scheme);
+                            activeControl.UpdateSettings(*controlSettings);
+                            args.Handled(true);
+                        }
                     }
                 }
             }
@@ -370,15 +372,18 @@ namespace winrt::TerminalApp::implementation
             tabColor = realArgs.TabColor();
         }
 
-        if (const auto activeTab{ _GetFocusedTabImpl() })
+        if (auto focusedTab = _GetFocusedTab())
         {
-            if (tabColor)
+            if (auto activeTab = _GetTerminalTabImpl(focusedTab))
             {
-                activeTab->SetRuntimeTabColor(tabColor.Value());
-            }
-            else
-            {
-                activeTab->ResetRuntimeTabColor();
+                if (tabColor)
+                {
+                    activeTab->SetRuntimeTabColor(tabColor.Value());
+                }
+                else
+                {
+                    activeTab->ResetRuntimeTabColor();
+                }
             }
         }
         args.Handled(true);
@@ -387,9 +392,12 @@ namespace winrt::TerminalApp::implementation
     void TerminalPage::_HandleOpenTabColorPicker(const IInspectable& /*sender*/,
                                                  const ActionEventArgs& args)
     {
-        if (const auto activeTab{ _GetFocusedTabImpl() })
+        if (auto focusedTab = _GetFocusedTab())
         {
-            activeTab->ActivateColorPicker();
+            if (auto activeTab = _GetTerminalTabImpl(focusedTab))
+            {
+                activeTab->ActivateColorPicker();
+            }
         }
         args.Handled(true);
     }
@@ -404,15 +412,18 @@ namespace winrt::TerminalApp::implementation
             title = realArgs.Title();
         }
 
-        if (const auto activeTab{ _GetFocusedTabImpl() })
+        if (auto focusedTab = _GetFocusedTab())
         {
-            if (title.has_value())
+            if (auto activeTab = _GetTerminalTabImpl(focusedTab))
             {
-                activeTab->SetTabText(title.value());
-            }
-            else
-            {
-                activeTab->ResetTabText();
+                if (title.has_value())
+                {
+                    activeTab->SetTabText(title.value());
+                }
+                else
+                {
+                    activeTab->ResetTabText();
+                }
             }
         }
         args.Handled(true);
@@ -421,9 +432,12 @@ namespace winrt::TerminalApp::implementation
     void TerminalPage::_HandleOpenTabRenamer(const IInspectable& /*sender*/,
                                              const ActionEventArgs& args)
     {
-        if (const auto activeTab{ _GetFocusedTabImpl() })
+        if (auto focusedTab = _GetFocusedTab())
         {
-            activeTab->ActivateTabRenamer();
+            if (auto activeTab = _GetTerminalTabImpl(focusedTab))
+            {
+                activeTab->ActivateTabRenamer();
+            }
         }
         args.Handled(true);
     }
@@ -439,7 +453,7 @@ namespace winrt::TerminalApp::implementation
             if (_startupActions.Size() != 0)
             {
                 actionArgs.Handled(true);
-                ProcessStartupActions(actions, false);
+                _ProcessStartupActions(actions, false);
             }
         }
     }
@@ -521,8 +535,13 @@ namespace winrt::TerminalApp::implementation
     void TerminalPage::_HandleOpenTabSearch(const IInspectable& /*sender*/,
                                             const ActionEventArgs& args)
     {
-        CommandPalette().SetTabs(_tabs, _mruTabs);
-        CommandPalette().EnableTabSearchMode();
+        // Tab search is always in-order.
+        CommandPalette().SetTabs(_tabs, true);
+
+        auto opt = _GetFocusedTabIndex();
+        uint32_t startIdx = opt.value_or(0);
+
+        CommandPalette().EnableTabSwitcherMode(true, startIdx);
         CommandPalette().Visibility(Visibility::Visible);
 
         args.Handled(true);

src/cascadia/TerminalApp/AppCommandlineArgs.cpp

@@ -189,7 +189,6 @@ void AppCommandlineArgs::_buildParser()
     _buildNewTabParser();
     _buildSplitPaneParser();
     _buildFocusTabParser();
-    _buildMoveFocusParser();
 }
 
 // Method Description:
@@ -248,10 +247,6 @@ void AppCommandlineArgs::_buildSplitPaneParser()
                                                                      _splitVertical,
                                                                      RS_A(L"CmdSplitPaneVerticalArgDesc"));
         subcommand._verticalOption->excludes(subcommand._horizontalOption);
-        auto* sizeOpt = subcommand.subcommand->add_option("-s,--size",
-                                                          _splitPaneSize,
-                                                          RS_A(L"CmdSplitPaneSizeArgDesc"));
-        sizeOpt->check(CLI::Range(0.01f, 0.99f));
 
         // When ParseCommand is called, if this subcommand was provided, this
         // callback function will be triggered on the same thread. We can be sure
@@ -279,7 +274,7 @@ void AppCommandlineArgs::_buildSplitPaneParser()
                     style = SplitState::Vertical;
                 }
             }
-            SplitPaneArgs args{ style, _splitPaneSize, terminalArgs };
+            SplitPaneArgs args{ style, terminalArgs };
             splitPaneActionAndArgs.Args(args);
             _startupActions.push_back(splitPaneActionAndArgs);
         });
@@ -342,54 +337,6 @@ void AppCommandlineArgs::_buildFocusTabParser()
     setupSubcommand(_focusTabShort);
 }
 
-// Method Description:
-// - Adds the `move-focus` subcommand and related options to the commandline parser.
-// - Additionally adds the `mf` subcommand, which is just a shortened version of `move-focus`
-// Arguments:
-// - <none>
-// Return Value:
-// - <none>
-void AppCommandlineArgs::_buildMoveFocusParser()
-{
-    _moveFocusCommand = _app.add_subcommand("move-focus", RS_A(L"CmdMoveFocusDesc"));
-    _moveFocusShort = _app.add_subcommand("mf", RS_A(L"CmdMFDesc"));
-
-    auto setupSubcommand = [this](auto* subcommand) {
-        std::map<std::string, FocusDirection> map = {
-            { "left", FocusDirection::Left },
-            { "right", FocusDirection::Right },
-            { "up", FocusDirection::Up },
-            { "down", FocusDirection::Down }
-        };
-
-        auto* directionOpt = subcommand->add_option("direction",
-                                                    _moveFocusDirection,
-                                                    RS_A(L"CmdMoveFocusDirectionArgDesc"));
-
-        directionOpt->transform(CLI::CheckedTransformer(map, CLI::ignore_case));
-        directionOpt->required();
-        // When ParseCommand is called, if this subcommand was provided, this
-        // callback function will be triggered on the same thread. We can be sure
-        // that `this` will still be safe - this function just lets us know this
-        // command was parsed.
-        subcommand->callback([&, this]() {
-            if (_moveFocusDirection != FocusDirection::None)
-            {
-                MoveFocusArgs args{ _moveFocusDirection };
-
-                ActionAndArgs actionAndArgs{};
-                actionAndArgs.Action(ShortcutAction::MoveFocus);
-                actionAndArgs.Args(args);
-
-                _startupActions.push_back(std::move(actionAndArgs));
-            }
-        });
-    };
-
-    setupSubcommand(_moveFocusCommand);
-    setupSubcommand(_moveFocusShort);
-}
-
 // Method Description:
 // - Add the `NewTerminalArgs` parameters to the given subcommand. This enables
 //   that subcommand to support all the properties in a NewTerminalArgs.
@@ -497,8 +444,6 @@ bool AppCommandlineArgs::_noCommandsProvided()
              *_newTabShort.subcommand ||
              *_focusTabCommand ||
              *_focusTabShort ||
-             *_moveFocusCommand ||
-             *_moveFocusShort ||
              *_newPaneShort.subcommand ||
              *_newPaneCommand.subcommand);
 }
@@ -521,13 +466,11 @@ void AppCommandlineArgs::_resetStateToDefault()
 
     _splitVertical = false;
     _splitHorizontal = false;
-    _splitPaneSize = 0.5f;
 
     _focusTabIndex = -1;
     _focusNextTab = false;
     _focusPrevTab = false;
 
-    _moveFocusDirection = FocusDirection::None;
     // DON'T clear _launchMode here! This will get called once for every
     // subcommand, so we don't want `wt -F new-tab ; split-pane` clearing out
     // the "global" fullscreen flag (-F).

src/cascadia/TerminalApp/AppCommandlineArgs.h

@@ -74,9 +74,6 @@ private:
     NewPaneSubcommand _newPaneShort;
     CLI::App* _focusTabCommand;
     CLI::App* _focusTabShort;
-    CLI::App* _moveFocusCommand;
-    CLI::App* _moveFocusShort;
-
     // Are you adding a new sub-command? Make sure to update _noCommandsProvided!
 
     std::string _profileName;
@@ -84,14 +81,11 @@ private:
     std::string _startingTitle;
     std::string _startingTabColor;
 
-    winrt::Microsoft::Terminal::Settings::Model::FocusDirection _moveFocusDirection{ winrt::Microsoft::Terminal::Settings::Model::FocusDirection::None };
-
     // _commandline will contain the command line with which we'll be spawning a new terminal
     std::vector<std::string> _commandline;
 
     bool _splitVertical{ false };
     bool _splitHorizontal{ false };
-    float _splitPaneSize{ 0.5f };
 
     int _focusTabIndex{ -1 };
     bool _focusNextTab{ false };
@@ -111,7 +105,6 @@ private:
     void _buildNewTabParser();
     void _buildSplitPaneParser();
     void _buildFocusTabParser();
-    void _buildMoveFocusParser();
     bool _noCommandsProvided();
     void _resetStateToDefault();
     int _handleExit(const CLI::App& command, const CLI::Error& e);

src/cascadia/TerminalApp/AppLogic.cpp

@@ -42,10 +42,7 @@ static const std::array<std::wstring_view, static_cast<uint32_t>(SettingsLoadWar
     USES_RESOURCE(L"LegacyGlobalsProperty"),
     USES_RESOURCE(L"FailedToParseCommandJson"),
     USES_RESOURCE(L"FailedToWriteToSettings"),
-    USES_RESOURCE(L"InvalidColorSchemeInCmd"),
-    USES_RESOURCE(L"InvalidSplitSize"),
-    USES_RESOURCE(L"FailedToParseStartupActions"),
-    USES_RESOURCE(L"FailedToParseSubCommands"),
+    USES_RESOURCE(L"InvalidColorSchemeInCmd")
 };
 static const std::array<std::wstring_view, static_cast<uint32_t>(SettingsLoadErrors::ERRORS_SIZE)> settingsLoadErrorsLabels {
     USES_RESOURCE(L"NoProfilesText"),
@@ -265,14 +262,6 @@ namespace winrt::TerminalApp::implementation
             _settings.GlobalSettings().ShowTabsInTitlebar(false);
         }
 
-        // Pay attention, that even if some command line arguments were parsed (like launch mode),
-        // we will not use the startup actions from settings.
-        // While this simplifies the logic, we might want to reconsider this behavior in the future.
-        if (!_hasCommandLineArguments && _hasSettingsStartupActions)
-        {
-            _root->SetStartupActions(_settingsAppArgs.GetStartupActions());
-        }
-
         _root->SetSettings(_settings, false);
         _root->Loaded({ this, &AppLogic::_OnLoaded });
         _root->Initialized([this](auto&&, auto&&) {
@@ -436,7 +425,8 @@ namespace winrt::TerminalApp::implementation
         // Make sure the lines of text wrap
         warningsTextBlock.TextWrapping(TextWrapping::Wrap);
 
-        for (const auto& warning : _warnings)
+        const auto warnings = _settings.Warnings();
+        for (const auto& warning : warnings)
         {
             // Try looking up the warning message key for each warning.
             const auto warningText = _GetWarningText(warning);
@@ -725,34 +715,7 @@ namespace winrt::TerminalApp::implementation
                 return E_INVALIDARG;
             }
 
-            _warnings.clear();
-            for (uint32_t i = 0; i < _settings.Warnings().Size(); i++)
-            {
-                _warnings.push_back(_settings.Warnings().GetAt(i));
-            }
-
-            _hasSettingsStartupActions = false;
-            const auto startupActions = _settings.GlobalSettings().StartupActions();
-            if (!startupActions.empty())
-            {
-                _settingsAppArgs.FullResetState();
-
-                ExecuteCommandlineArgs args{ _settings.GlobalSettings().StartupActions() };
-                auto result = _settingsAppArgs.ParseArgs(args);
-                if (result == 0)
-                {
-                    _hasSettingsStartupActions = true;
-
-                    // Validation also injects new-tab command if implicit new-tab was provided.
-                    _settingsAppArgs.ValidateStartupCommands();
-                }
-                else
-                {
-                    _warnings.push_back(SettingsLoadWarnings::FailedToParseStartupActions);
-                }
-            }
-
-            hr = _warnings.empty() ? S_OK : S_FALSE;
+            hr = _settings.Warnings().Size() == 0 ? S_OK : S_FALSE;
         }
         catch (const winrt::hresult_error& e)
         {
@@ -842,8 +805,7 @@ namespace winrt::TerminalApp::implementation
                            // editors, who will write a temp file, then rename it to be the
                            // actual file you wrote. So listen for that too.
                            if (!(event == wil::FolderChangeEvent::Modified ||
-                                 event == wil::FolderChangeEvent::RenameNewName ||
-                                 event == wil::FolderChangeEvent::Removed))
+                                 event == wil::FolderChangeEvent::RenameNewName))
                            {
                                return;
                            }
@@ -1142,9 +1104,6 @@ namespace winrt::TerminalApp::implementation
         const auto result = _appArgs.ParseArgs(args);
         if (result == 0)
         {
-            // If the size of the arguments list is 1,
-            // then it contains only the executable name and no other arguments.
-            _hasCommandLineArguments = args.size() > 1;
             _appArgs.ValidateStartupCommands();
             _root->SetStartupActions(_appArgs.GetStartupActions());
         }
@@ -1152,19 +1111,6 @@ namespace winrt::TerminalApp::implementation
         return result;
     }
 
-    int32_t AppLogic::ExecuteCommandline(array_view<const winrt::hstring> args)
-    {
-        ::TerminalApp::AppCommandlineArgs appArgs;
-        auto result = appArgs.ParseArgs(args);
-        if (result == 0)
-        {
-            auto actions = winrt::single_threaded_vector<ActionAndArgs>(std::move(appArgs.GetStartupActions()));
-            _root->ProcessStartupActions(actions, false);
-        }
-
-        return result; // TODO:MG does a return value make sense
-    }
-
     // Method Description:
     // - If there were any errors parsing the commandline that was used to
     //   initialize the terminal, this will return a string containing that

src/cascadia/TerminalApp/AppLogic.h

@@ -29,7 +29,6 @@ namespace winrt::TerminalApp::implementation
         [[nodiscard]] Microsoft::Terminal::Settings::Model::CascadiaSettings GetSettings() const noexcept;
 
         int32_t SetStartupCommandline(array_view<const winrt::hstring> actions);
-        int32_t ExecuteCommandline(array_view<const winrt::hstring> actions);
         winrt::hstring ParseCommandlineMessage();
         bool ShouldExitEarly();
 
@@ -86,7 +85,6 @@ namespace winrt::TerminalApp::implementation
         std::atomic<bool> _settingsReloadQueued{ false };
 
         ::TerminalApp::AppCommandlineArgs _appArgs;
-        ::TerminalApp::AppCommandlineArgs _settingsAppArgs;
         int _ParseArgs(winrt::array_view<const hstring>& args);
 
         void _ShowLoadErrorsDialog(const winrt::hstring& titleKey, const winrt::hstring& contentKey, HRESULT settingsLoadedResult);
@@ -108,10 +106,6 @@ namespace winrt::TerminalApp::implementation
 
         void _ApplyTheme(const Windows::UI::Xaml::ElementTheme& newTheme);
 
-        bool _hasCommandLineArguments{ false };
-        bool _hasSettingsStartupActions{ false };
-        std::vector<Microsoft::Terminal::Settings::Model::SettingsLoadWarnings> _warnings;
-
         // These are events that are handled by the TerminalPage, but are
         // exposed through the AppLogic. This macro is used to forward the event
         // directly to them.

src/cascadia/TerminalApp/AppLogic.idl

@@ -29,7 +29,6 @@ namespace TerminalApp
         Boolean IsElevated();
 
         Int32 SetStartupCommandline(String[] commands);
-        Int32 ExecuteCommandline(String[] commands);
         String ParseCommandlineMessage { get; };
         Boolean ShouldExitEarly { get; };
 

src/cascadia/TerminalApp/ColorPickupFlyout.xaml

@@ -12,7 +12,7 @@
         </Style>
     </Flyout.FlyoutPresenterStyle>
     <StackPanel Orientation="Horizontal">
-        <StackPanel XYFocusKeyboardNavigation="Enabled">
+        <StackPanel>
             <VariableSizedWrapGrid Orientation="Horizontal" MaximumRowsOrColumns="4" HorizontalAlignment="Center" Margin="0, 3, 0, 0">
                 <VariableSizedWrapGrid.Resources>
                     <Style TargetType="Rectangle">

src/cascadia/TerminalApp/CommandPalette.cpp

@@ -31,7 +31,6 @@ namespace winrt::TerminalApp::implementation
         _currentNestedCommands = winrt::single_threaded_vector<winrt::TerminalApp::FilteredCommand>();
         _allCommands = winrt::single_threaded_vector<winrt::TerminalApp::FilteredCommand>();
         _tabActions = winrt::single_threaded_vector<winrt::TerminalApp::FilteredCommand>();
-        _mruTabActions = winrt::single_threaded_vector<winrt::TerminalApp::FilteredCommand>();
         _commandLineHistory = winrt::single_threaded_vector<winrt::TerminalApp::FilteredCommand>();
 
         _switchToMode(CommandPaletteMode::ActionMode);
@@ -52,12 +51,6 @@ namespace winrt::TerminalApp::implementation
         RegisterPropertyChangedCallback(UIElement::VisibilityProperty(), [this](auto&&, auto&&) {
             if (Visibility() == Visibility::Visible)
             {
-                if (_filteredActionsView().Items().Size() == 0 && _filteredActions.Size() > 0)
-                {
-                    // Force immediate binding update so we can select an item
-                    Bindings->Update();
-                }
-
                 if (_currentMode == CommandPaletteMode::TabSwitchMode)
                 {
                     _searchBox().Visibility(Visibility::Collapsed);
@@ -73,6 +66,7 @@ namespace winrt::TerminalApp::implementation
                 {
                     _filteredActionsView().SelectedIndex(0);
                     _searchBox().Focus(FocusState::Programmatic);
+                    _updateFilteredActions();
                 }
 
                 TraceLoggingWrite(
@@ -118,7 +112,7 @@ namespace winrt::TerminalApp::implementation
     // - <none>
     void CommandPalette::SelectNextItem(const bool moveDown)
     {
-        auto selected = _filteredActionsView().SelectedIndex();
+        const auto selected = _filteredActionsView().SelectedIndex();
         const int numItems = ::base::saturated_cast<int>(_filteredActionsView().Items().Size());
 
         // Do not try to select an item if
@@ -243,9 +237,6 @@ namespace winrt::TerminalApp::implementation
                                                 Windows::UI::Xaml::Input::KeyRoutedEventArgs const& e)
     {
         auto key = e.OriginalKey();
-        auto const ctrlDown = WI_IsFlagSet(CoreWindow::GetForCurrentThread().GetKeyState(winrt::Windows::System::VirtualKey::Control), CoreVirtualKeyStates::Down);
-        auto const altDown = WI_IsFlagSet(CoreWindow::GetForCurrentThread().GetKeyState(winrt::Windows::System::VirtualKey::Menu), CoreVirtualKeyStates::Down);
-        auto const shiftDown = WI_IsFlagSet(CoreWindow::GetForCurrentThread().GetKeyState(winrt::Windows::System::VirtualKey::Shift), CoreVirtualKeyStates::Down);
 
         // Some keypresses such as Tab, Return, Esc, and Arrow Keys are ignored by controls because
         // they're not considered input key presses. While they don't raise KeyDown events,
@@ -254,38 +245,54 @@ namespace winrt::TerminalApp::implementation
         // Only give anchored tab switcher the ability to cycle through tabs with the tab button.
         // For unanchored mode, accessibility becomes an issue when we try to hijack tab since it's
         // a really widely used keyboard navigation key.
-        if (_currentMode == CommandPaletteMode::TabSwitchMode && _keymap)
+        if (_currentMode == CommandPaletteMode::TabSwitchMode && key == VirtualKey::Tab)
         {
-            winrt::Microsoft::Terminal::TerminalControl::KeyChord kc{ ctrlDown, altDown, shiftDown, static_cast<int32_t>(key) };
-            const auto action = _keymap.TryLookup(kc);
-            if (action)
+            auto const state = CoreWindow::GetForCurrentThread().GetKeyState(winrt::Windows::System::VirtualKey::Shift);
+            if (WI_IsFlagSet(state, CoreVirtualKeyStates::Down))
             {
-                if (action.Action() == ShortcutAction::PrevTab)
-                {
-                    SelectNextItem(false);
-                    e.Handled(true);
-                    return;
-                }
-                else if (action.Action() == ShortcutAction::NextTab)
-                {
-                    SelectNextItem(true);
-                    e.Handled(true);
-                    return;
-                }
+                SelectNextItem(false);
+                e.Handled(true);
+            }
+            else
+            {
+                SelectNextItem(true);
+                e.Handled(true);
             }
         }
+        else if (key == VirtualKey::Home)
+        {
+            auto const state = CoreWindow::GetForCurrentThread().GetKeyState(winrt::Windows::System::VirtualKey::Control);
+            if (WI_IsFlagSet(state, CoreVirtualKeyStates::Down))
+            {
+                ScrollToTop();
+                e.Handled(true);
+            }
+        }
+        else if (key == VirtualKey::End)
+        {
+            auto const state = CoreWindow::GetForCurrentThread().GetKeyState(winrt::Windows::System::VirtualKey::Control);
+            if (WI_IsFlagSet(state, CoreVirtualKeyStates::Down))
+            {
+                ScrollToBottom();
+                e.Handled(true);
+            }
+        }
+    }
 
-        if (key == VirtualKey::Home && ctrlDown)
-        {
-            ScrollToTop();
-            e.Handled(true);
-        }
-        else if (key == VirtualKey::End && ctrlDown)
-        {
-            ScrollToBottom();
-            e.Handled(true);
-        }
-        else if (key == VirtualKey::Up)
+    // Method Description:
+    // - Process keystrokes in the input box. This is used for moving focus up
+    //   and down the list of commands in Action mode, and for executing
+    //   commands in both Action mode and Commandline mode.
+    // Arguments:
+    // - e: the KeyRoutedEventArgs containing info about the keystroke.
+    // Return Value:
+    // - <none>
+    void CommandPalette::_keyDownHandler(IInspectable const& /*sender*/,
+                                         Windows::UI::Xaml::Input::KeyRoutedEventArgs const& e)
+    {
+        auto key = e.OriginalKey();
+
+        if (key == VirtualKey::Up)
         {
             // Action Mode: Move focus to the next item in the list.
             SelectNextItem(false);
@@ -331,23 +338,41 @@ namespace winrt::TerminalApp::implementation
 
             e.Handled(true);
         }
-        else if (key == VirtualKey::Back && _searchBox().Text().empty() && _lastFilterTextWasEmpty && _currentMode == CommandPaletteMode::ActionMode)
+        else if (key == VirtualKey::Back)
         {
             // If the last filter text was empty, and we're backspacing from
             // that state, then the user "backspaced" the virtual '>' we're
             // using as the action mode indicator. Switch into commandline mode.
-            _switchToMode(CommandPaletteMode::CommandlineMode);
+            if (_searchBox().Text().empty() && _lastFilterTextWasEmpty && _currentMode == CommandPaletteMode::ActionMode)
+            {
+                _switchToMode(CommandPaletteMode::CommandlineMode);
+            }
+
             e.Handled(true);
         }
-        else if (key == VirtualKey::C && ctrlDown)
+        else
         {
-            _searchBox().CopySelectionToClipboard();
-            e.Handled(true);
-        }
-        else if (key == VirtualKey::V && ctrlDown)
-        {
-            _searchBox().PasteFromClipboard();
-            e.Handled(true);
+            const auto vkey = ::gsl::narrow_cast<WORD>(e.OriginalKey());
+
+            // In the interest of not telling all modes to check for keybindings, limit to TabSwitch mode for now.
+            if (_currentMode == CommandPaletteMode::TabSwitchMode)
+            {
+                auto const ctrlDown = WI_IsFlagSet(CoreWindow::GetForCurrentThread().GetKeyState(winrt::Windows::System::VirtualKey::Control), CoreVirtualKeyStates::Down);
+                auto const altDown = WI_IsFlagSet(CoreWindow::GetForCurrentThread().GetKeyState(winrt::Windows::System::VirtualKey::Menu), CoreVirtualKeyStates::Down);
+                auto const shiftDown = WI_IsFlagSet(CoreWindow::GetForCurrentThread().GetKeyState(winrt::Windows::System::VirtualKey::Shift), CoreVirtualKeyStates::Down);
+
+                auto success = _bindings.TryKeyChord({
+                    ctrlDown,
+                    altDown,
+                    shiftDown,
+                    vkey,
+                });
+
+                if (success)
+                {
+                    e.Handled(true);
+                }
+            }
         }
     }
 
@@ -436,12 +461,6 @@ namespace winrt::TerminalApp::implementation
     void CommandPalette::_lostFocusHandler(Windows::Foundation::IInspectable const& /*sender*/,
                                            Windows::UI::Xaml::RoutedEventArgs const& /*args*/)
     {
-        const auto flyout = _searchBox().ContextFlyout();
-        if (flyout && flyout.IsOpen())
-        {
-            return;
-        }
-
         auto focusedElementOrAncestor = Input::FocusManager::GetFocusedElement(this->XamlRoot()).try_as<DependencyObject>();
         while (focusedElementOrAncestor)
         {
@@ -558,7 +577,7 @@ namespace winrt::TerminalApp::implementation
         case CommandPaletteMode::TabSearchMode:
             return _tabActions;
         case CommandPaletteMode::TabSwitchMode:
-            return _tabSwitcherMode == TabSwitcherMode::MostRecentlyUsed ? _mruTabActions : _tabActions;
+            return _tabActions;
         case CommandPaletteMode::CommandlineMode:
             return _commandLineHistory;
         default:
@@ -671,10 +690,7 @@ namespace winrt::TerminalApp::implementation
         {
             if (const auto tabPaletteItem{ filteredCommand.Item().try_as<winrt::TerminalApp::TabPaletteItem>() })
             {
-                if (const auto tab{ tabPaletteItem.Tab() })
-                {
-                    _SwitchToTabRequestedHandlers(*this, tab);
-                }
+                _SwitchToTabRequestedHandlers(*this, tabPaletteItem.Tab());
             }
         }
     }
@@ -836,9 +852,9 @@ namespace winrt::TerminalApp::implementation
         return _filteredActions;
     }
 
-    void CommandPalette::SetKeyMap(const Microsoft::Terminal::Settings::Model::KeyMapping& keymap)
+    void CommandPalette::SetKeyBindings(Microsoft::Terminal::TerminalControl::IKeyBindings bindings)
     {
-        _keymap = keymap;
+        _bindings = bindings;
     }
 
     void CommandPalette::SetCommands(Collections::IVector<Command> const& actions)
@@ -851,40 +867,31 @@ namespace winrt::TerminalApp::implementation
             _allCommands.Append(filteredCommand);
         }
 
-        if (Visibility() == Visibility::Visible && _currentMode == CommandPaletteMode::ActionMode)
-        {
-            _updateFilteredActions();
-        }
+        _updateFilteredActions();
     }
 
-    // Method Description:
-    // - Replaces a list of filtered commands in the target collection with new
-    //   commands based on the tabs in the source collection.
-    // Although the source observable we still don't register on it,
-    // so the palette user will need to reset the binding manually every time
-    // the source collection changes
-    // Arguments:
-    // - source: the tabs to use for creation filtered commands
-    // - target: the collection to store newly created filtered commands
-    // Return Value:
-    // - <none>
-    void CommandPalette::_bindTabs(
-        Windows::Foundation::Collections::IObservableVector<winrt::TerminalApp::TabBase> const& source,
-        Windows::Foundation::Collections::IVector<winrt::TerminalApp::FilteredCommand> const& target)
+    void CommandPalette::SetTabs(Collections::IVector<TabBase> const& tabs, const bool clearList)
     {
-        target.Clear();
-        for (const auto& tab : source)
+        _tabActions.Clear();
+        for (const auto& tab : tabs)
         {
             auto tabPaletteItem{ winrt::make<winrt::TerminalApp::implementation::TabPaletteItem>(tab) };
             auto filteredCommand{ winrt::make<FilteredCommand>(tabPaletteItem) };
-            target.Append(filteredCommand);
+            _tabActions.Append(filteredCommand);
         }
-    }
 
-    void CommandPalette::SetTabs(Collections::IObservableVector<TabBase> const& tabs, Collections::IObservableVector<TabBase> const& mruTabs)
-    {
-        _bindTabs(tabs, _tabActions);
-        _bindTabs(mruTabs, _mruTabActions);
+        // The smooth remove/add animations that happen during
+        // UpdateFilteredActions don't work very well with changing the tab
+        // order, because of the sheer amount of remove/adds. So, let's just
+        // clear & rebuild the list when we change the set of tabs.
+        //
+        // Some callers might actually want smooth updating, like when the list
+        // of tabs changes.
+        if (clearList && _currentMode == CommandPaletteMode::TabSwitchMode)
+        {
+            _filteredActions.Clear();
+        }
+        _updateFilteredActions();
     }
 
     void CommandPalette::EnableCommandPaletteMode(CommandPaletteLaunchMode const launchMode)
@@ -894,11 +901,26 @@ namespace winrt::TerminalApp::implementation
                               CommandPaletteMode::ActionMode;
 
         _switchToMode(mode);
+        _updateFilteredActions();
     }
 
     void CommandPalette::_switchToMode(CommandPaletteMode mode)
     {
-        _currentMode = mode;
+        // The smooth remove/add animations that happen during
+        // UpdateFilteredActions don't work very well when switching between
+        // modes because of the sheer amount of remove/adds. So, let's just
+        // clear + append when switching between modes.
+        if (mode != _currentMode)
+        {
+            _currentMode = mode;
+            _filteredActions.Clear();
+            auto commandsToFilter = _commandsToFilter();
+
+            for (auto action : commandsToFilter)
+            {
+                _filteredActions.Append(action);
+            }
+        }
 
         ParsedCommandLineText(L"");
         _searchBox().Text(L"");
@@ -931,13 +953,6 @@ namespace winrt::TerminalApp::implementation
             PrefixCharacter(L">");
             break;
         }
-
-        // The smooth remove/add animations that happen during
-        // UpdateFilteredActions don't work very well when switching between
-        // modes because of the sheer amount of remove/adds. So, let's just
-        // clear + append when switching between modes.
-        _filteredActions.Clear();
-        _updateFilteredActions();
     }
 
     // Method Description:
@@ -954,34 +969,27 @@ namespace winrt::TerminalApp::implementation
         winrt::hstring searchText{ _getTrimmedInput() };
 
         auto commandsToFilter = _commandsToFilter();
+        for (const auto& action : commandsToFilter)
+        {
+            // Update filter for all commands
+            // This will modify the highlighting but will also lead to re-computation of weight (and consequently sorting).
+            // Pay attention that it already updates the highlighting in the UI
+            action.UpdateFilter(searchText);
 
-        if (_currentMode == CommandPaletteMode::TabSwitchMode)
-        {
-            std::copy(begin(commandsToFilter), end(commandsToFilter), std::back_inserter(actions));
-        }
-        else if (_currentMode == CommandPaletteMode::TabSearchMode || _currentMode == CommandPaletteMode::ActionMode || _currentMode == CommandPaletteMode::CommandlineMode)
-        {
-            for (const auto& action : commandsToFilter)
+            // if there is active search we skip commands with 0 weight
+            if (searchText.empty() || action.Weight() > 0)
             {
-                // Update filter for all commands
-                // This will modify the highlighting but will also lead to re-computation of weight (and consequently sorting).
-                // Pay attention that it already updates the highlighting in the UI
-                action.UpdateFilter(searchText);
-
-                // if there is active search we skip commands with 0 weight
-                if (searchText.empty() || action.Weight() > 0)
-                {
-                    actions.push_back(action);
-                }
+                actions.push_back(action);
             }
         }
 
-        // We want to present the commands sorted
-        if (_currentMode == CommandPaletteMode::ActionMode)
+        // We want to present the commands sorted,
+        // unless we are in the TabSwitcherMode and TabSearchMode,
+        // in which we want to preserve the original order (to be aligned with the tab view)
+        if (_currentMode != CommandPaletteMode::TabSearchMode && _currentMode != CommandPaletteMode::TabSwitchMode && _currentMode != CommandPaletteMode::CommandlineMode)
         {
             std::sort(actions.begin(), actions.end(), FilteredCommand::Compare);
         }
-
         return actions;
     }
 
@@ -1056,18 +1064,20 @@ namespace winrt::TerminalApp::implementation
         _currentNestedCommands.Clear();
     }
 
-    void CommandPalette::EnableTabSwitcherMode(const uint32_t startIdx, TabSwitcherMode tabSwitcherMode)
+    void CommandPalette::EnableTabSwitcherMode(const bool searchMode, const uint32_t startIdx)
     {
-        // The _switcherStartIdx field allows us to select the current tab
-        // We need to take it into account only in the in-order mode,
-        // as an MRU mode the current tab is on top by definition.
-        _switcherStartIdx = tabSwitcherMode == TabSwitcherMode::InOrder ? startIdx : 0;
-        _tabSwitcherMode = tabSwitcherMode;
-        _switchToMode(CommandPaletteMode::TabSwitchMode);
+        _switcherStartIdx = startIdx;
+
+        if (searchMode)
+        {
+            _switchToMode(CommandPaletteMode::TabSearchMode);
+        }
+        else
+        {
+            _switchToMode(CommandPaletteMode::TabSwitchMode);
+        }
+
+        _updateFilteredActions();
     }
 
-    void CommandPalette::EnableTabSearchMode()
-    {
-        _switchToMode(CommandPaletteMode::TabSearchMode);
-    }
 }

src/cascadia/TerminalApp/CommandPalette.h

@@ -31,8 +31,10 @@ namespace winrt::TerminalApp::implementation
         Windows::Foundation::Collections::IObservableVector<winrt::TerminalApp::FilteredCommand> FilteredActions();
 
         void SetCommands(Windows::Foundation::Collections::IVector<Microsoft::Terminal::Settings::Model::Command> const& actions);
-        void SetTabs(Windows::Foundation::Collections::IObservableVector<winrt::TerminalApp::TabBase> const& tabs, Windows::Foundation::Collections::IObservableVector<winrt::TerminalApp::TabBase> const& mruTabs);
-        void SetKeyMap(const Microsoft::Terminal::Settings::Model::KeyMapping& keymap);
+        void SetTabs(Windows::Foundation::Collections::IVector<winrt::TerminalApp::TabBase> const& tabs, const bool clearList);
+        void SetKeyBindings(Microsoft::Terminal::TerminalControl::IKeyBindings bindings);
+
+        void EnableCommandPaletteMode(Microsoft::Terminal::Settings::Model::CommandPaletteLaunchMode const launchMode);
 
         bool OnDirectKeyEvent(const uint32_t vkey, const uint8_t scanCode, const bool down);
 
@@ -43,9 +45,9 @@ namespace winrt::TerminalApp::implementation
         void ScrollToTop();
         void ScrollToBottom();
 
-        void EnableCommandPaletteMode(Microsoft::Terminal::Settings::Model::CommandPaletteLaunchMode const launchMode);
-        void EnableTabSwitcherMode(const uint32_t startIdx, Microsoft::Terminal::Settings::Model::TabSwitcherMode tabSwitcherMode);
-        void EnableTabSearchMode();
+        // Tab Switcher
+        void EnableTabSwitcherMode(const bool searchMode, const uint32_t startIdx);
+        void SetTabSwitchOrder(const Microsoft::Terminal::Settings::Model::TabSwitcherMode order);
 
         WINRT_CALLBACK(PropertyChanged, Windows::UI::Xaml::Data::PropertyChangedEventHandler);
         OBSERVABLE_GETSET_PROPERTY(winrt::hstring, NoMatchesText, _PropertyChangedHandlers);
@@ -75,7 +77,8 @@ namespace winrt::TerminalApp::implementation
                                 Windows::UI::Xaml::RoutedEventArgs const& args);
         void _previewKeyDownHandler(Windows::Foundation::IInspectable const& sender,
                                     Windows::UI::Xaml::Input::KeyRoutedEventArgs const& e);
-
+        void _keyDownHandler(Windows::Foundation::IInspectable const& sender,
+                             Windows::UI::Xaml::Input::KeyRoutedEventArgs const& e);
         void _keyUpHandler(Windows::Foundation::IInspectable const& sender,
                            Windows::UI::Xaml::Input::KeyRoutedEventArgs const& e);
 
@@ -106,15 +109,11 @@ namespace winrt::TerminalApp::implementation
         std::wstring _getTrimmedInput();
         void _evaluatePrefix();
 
-        Microsoft::Terminal::Settings::Model::KeyMapping _keymap{ nullptr };
+        Microsoft::Terminal::TerminalControl::IKeyBindings _bindings;
 
         // Tab Switcher
         Windows::Foundation::Collections::IVector<winrt::TerminalApp::FilteredCommand> _tabActions{ nullptr };
-        Windows::Foundation::Collections::IVector<winrt::TerminalApp::FilteredCommand> _mruTabActions{ nullptr };
-        Microsoft::Terminal::Settings::Model::TabSwitcherMode _tabSwitcherMode;
         uint32_t _switcherStartIdx;
-
-        void _bindTabs(Windows::Foundation::Collections::IObservableVector<winrt::TerminalApp::TabBase> const& source, Windows::Foundation::Collections::IVector<winrt::TerminalApp::FilteredCommand> const& target);
         void _anchorKeyUpHandler();
 
         winrt::Windows::UI::Xaml::Controls::ListView::SizeChanged_revoker _sizeChangedRevoker;

src/cascadia/TerminalApp/CommandPalette.idl

@@ -22,16 +22,13 @@ namespace TerminalApp
         Windows.Foundation.Collections.IObservableVector<FilteredCommand> FilteredActions { get; };
 
         void SetCommands(Windows.Foundation.Collections.IVector<Microsoft.Terminal.Settings.Model.Command> actions);
-
-        void SetTabs(Windows.Foundation.Collections.IObservableVector<TabBase> tabs, Windows.Foundation.Collections.IObservableVector<TabBase> mruTabs);
-
-        void SetKeyMap(Microsoft.Terminal.Settings.Model.KeyMapping keymap);
+        void SetTabs(Windows.Foundation.Collections.IVector<TabBase> tabs, Boolean clearList);
+        void SetKeyBindings(Microsoft.Terminal.TerminalControl.IKeyBindings bindings);
+        void EnableCommandPaletteMode(Microsoft.Terminal.Settings.Model.CommandPaletteLaunchMode launchMode);
 
         void SelectNextItem(Boolean moveDown);
 
-        void EnableCommandPaletteMode(Microsoft.Terminal.Settings.Model.CommandPaletteLaunchMode launchMode);
-        void EnableTabSwitcherMode(UInt32 startIdx, Microsoft.Terminal.Settings.Model.TabSwitcherMode tabSwitcherMode);
-        void EnableTabSearchMode();
+        void EnableTabSwitcherMode(Boolean searchMode, UInt32 startIdx);
 
         event Windows.Foundation.TypedEventHandler<CommandPalette, TabBase> SwitchToTabRequested;
         event Windows.Foundation.TypedEventHandler<CommandPalette, Microsoft.Terminal.Settings.Model.Command> DispatchCommandRequested;

src/cascadia/TerminalApp/CommandPalette.xaml

@@ -16,6 +16,7 @@ the MIT License. See LICENSE in the project root for license information. -->
     AllowFocusOnInteraction="True"
     PointerPressed="_rootPointerPressed"
     PreviewKeyDown="_previewKeyDownHandler"
+    KeyDown="_keyDownHandler"
     PreviewKeyUp="_keyUpHandler"
     LostFocus="_lostFocusHandler"
     mc:Ignorable="d"
@@ -33,7 +34,6 @@ the MIT License. See LICENSE in the project root for license information. -->
             <local:EmptyStringVisibilityConverter x:Key="ParsedCommandLineTextVisibilityConverter"/>
             <local:EmptyStringVisibilityConverter x:Key="ParentCommandVisibilityConverter"/>
             <local:HasNestedCommandsVisibilityConverter x:Key="HasNestedCommandsVisibilityConverter"/>
-            <local:HasNestedCommandsHelpTextConverter x:Key="HasNestedCommandsHelpTextConverter"/>
             <model:IconPathConverter x:Key="IconSourceConverter"/>
 
             <ResourceDictionary.ThemeDictionaries>
@@ -132,7 +132,7 @@ the MIT License. See LICENSE in the project root for license information. -->
                     <Style x:Key="KeyChordTextBlockStyle" TargetType="TextBlock"/>
 
                     <!--  ParsedCommandLineText styles (use XAML defaults for High Contrast theme) -->
-                    <Style x:Key="ParsedCommandLineBorderStyle" TargetType="Border"/>
+                    <Style x:Key="ParsedCommandLineBoderStyle" TargetType="Border"/>
                     <Style x:Key="ParsedCommandLineTextBlockStyle" TargetType="TextBlock"/>
                 </ResourceDictionary>
             </ResourceDictionary.ThemeDictionaries>
@@ -278,6 +278,7 @@ the MIT License. See LICENSE in the project root for license information. -->
                 AllowDrop="False"
                 IsItemClickEnabled="True"
                 ItemClick="_listItemClicked"
+                PreviewKeyDown="_keyDownHandler"
                 ItemsSource="{x:Bind FilteredActions}">
 
                 <ItemsControl.ItemTemplate >
@@ -286,9 +287,9 @@ the MIT License. See LICENSE in the project root for license information. -->
                         <!-- This HorizontalContentAlignment="Stretch" is important
                         to make sure it takes the entire width of the line -->
                         <ListViewItem HorizontalContentAlignment="Stretch"
+                                  IsTabStop="False"
                                   AutomationProperties.Name="{x:Bind Item.Name, Mode=OneWay}"
-                                  AutomationProperties.AcceleratorKey="{x:Bind Item.KeyChordText, Mode=OneWay}"
-                                  AutomationProperties.HelpText="{x:Bind Item, Mode=OneWay, Converter={StaticResource HasNestedCommandsHelpTextConverter}}">
+                                  AutomationProperties.AcceleratorKey="{x:Bind Item.KeyChordText, Mode=OneWay}">
 
                             <Grid HorizontalAlignment="Stretch" ColumnSpacing="8" >
                                 <Grid.ColumnDefinitions>
@@ -313,13 +314,7 @@ the MIT License. See LICENSE in the project root for license information. -->
 
                                 <!-- The block for the key chord is only visible
                                 when there's actual text set as the label. See
-                                CommandKeyChordVisibilityConverter for details.
-
-                                We're setting the accessibility view on the
-                                border and text block to Raw because otherwise,
-                                Narrator will read out the key chord. Problem is,
-                                it already did that because it was the list item's
-                                "AcceleratorKey". It's redundant. -->
+                                CommandKeyChordVisibilityConverter for details. -->
                                 <Border
                                     Grid.Column="2"
                                     Visibility="{x:Bind Item.KeyChordText,
@@ -328,14 +323,12 @@ the MIT License. See LICENSE in the project root for license information. -->
                                     Style="{ThemeResource KeyChordBorderStyle}"
                                     Padding="2,0,2,0"
                                     HorizontalAlignment="Right"
-                                    VerticalAlignment="Center"
-                                    AutomationProperties.AccessibilityView="Raw">
+                                    VerticalAlignment="Center">
 
                                     <TextBlock
                                         Style="{ThemeResource KeyChordTextBlockStyle}"
                                         FontSize="12"
-                                        Text="{x:Bind Item.KeyChordText, Mode=OneWay}"
-                                        AutomationProperties.AccessibilityView="Raw" />
+                                        Text="{x:Bind Item.KeyChordText, Mode=OneWay}" />
                                 </Border>
 
                                 <!-- xE70E is ChevronUp. Rotated 90 degrees, it's _ChevronRight_ -->

src/cascadia/TerminalApp/HasNestedCommandsVisibilityConverter.cpp

@@ -1,9 +1,6 @@
 #include "pch.h"
 #include "HasNestedCommandsVisibilityConverter.h"
 #include "HasNestedCommandsVisibilityConverter.g.cpp"
-#include "HasNestedCommandsHelpTextConverter.g.cpp"
-
-#include "LibraryResources.h"
 
 using namespace winrt::Windows;
 using namespace winrt::Windows::UI::Xaml;
@@ -39,23 +36,4 @@ namespace winrt::TerminalApp::implementation
     {
         throw hresult_not_implemented();
     }
-
-    Foundation::IInspectable HasNestedCommandsHelpTextConverter::Convert(Foundation::IInspectable const& value,
-                                                                         Windows::UI::Xaml::Interop::TypeName const& /* targetType */,
-                                                                         Foundation::IInspectable const& /* parameter */,
-                                                                         hstring const& /* language */)
-    {
-        const auto paletteItem{ value.try_as<winrt::TerminalApp::ActionPaletteItem>() };
-        const auto hasNestedCommands = paletteItem && paletteItem.Command().HasNestedCommands();
-        return winrt::box_value(hasNestedCommands ? RS_(L"CommandPalette_MoreOptions/[using:Windows.UI.Xaml.Automation]AutomationProperties/HelpText") : L"");
-    }
-
-    // unused for one-way bindings
-    Foundation::IInspectable HasNestedCommandsHelpTextConverter::ConvertBack(Foundation::IInspectable const& /* value */,
-                                                                             Windows::UI::Xaml::Interop::TypeName const& /* targetType */,
-                                                                             Foundation::IInspectable const& /* parameter */,
-                                                                             hstring const& /* language */)
-    {
-        throw hresult_not_implemented();
-    }
 }

src/cascadia/TerminalApp/HasNestedCommandsVisibilityConverter.h

@@ -1,7 +1,6 @@
 #pragma once
 
 #include "HasNestedCommandsVisibilityConverter.g.h"
-#include "HasNestedCommandsHelpTextConverter.g.h"
 #include "../inc/cppwinrt_utils.h"
 
 namespace winrt::TerminalApp::implementation
@@ -20,25 +19,9 @@ namespace winrt::TerminalApp::implementation
                                                       Windows::Foundation::IInspectable const& parameter,
                                                       hstring const& language);
     };
-
-    struct HasNestedCommandsHelpTextConverter : HasNestedCommandsHelpTextConverterT<HasNestedCommandsHelpTextConverter>
-    {
-        HasNestedCommandsHelpTextConverter() = default;
-
-        Windows::Foundation::IInspectable Convert(Windows::Foundation::IInspectable const& value,
-                                                  Windows::UI::Xaml::Interop::TypeName const& targetType,
-                                                  Windows::Foundation::IInspectable const& parameter,
-                                                  hstring const& language);
-
-        Windows::Foundation::IInspectable ConvertBack(Windows::Foundation::IInspectable const& value,
-                                                      Windows::UI::Xaml::Interop::TypeName const& targetType,
-                                                      Windows::Foundation::IInspectable const& parameter,
-                                                      hstring const& language);
-    };
 }
 
 namespace winrt::TerminalApp::factory_implementation
 {
     BASIC_FACTORY(HasNestedCommandsVisibilityConverter);
-    BASIC_FACTORY(HasNestedCommandsHelpTextConverter);
 }

src/cascadia/TerminalApp/HasNestedCommandsVisibilityConverter.idl

@@ -16,9 +16,4 @@ namespace TerminalApp
         HasNestedCommandsVisibilityConverter();
     };
 
-    runtimeclass HasNestedCommandsHelpTextConverter : [default] Windows.UI.Xaml.Data.IValueConverter
-    {
-        HasNestedCommandsHelpTextConverter();
-    };
-
 }

src/cascadia/TerminalApp/MinMaxCloseControl.cpp

@@ -10,9 +10,6 @@
 #include "MinMaxCloseControl.h"
 
 #include "MinMaxCloseControl.g.cpp"
-
-#include <LibraryResources.h>
-
 using namespace winrt::Windows::UI::Xaml;
 
 namespace winrt::TerminalApp::implementation
@@ -80,7 +77,6 @@ namespace winrt::TerminalApp::implementation
             MinimizeButton().Height(maximizedHeight);
             MaximizeButton().Height(maximizedHeight);
             CloseButton().Height(maximizedHeight);
-            MaximizeToolTip().Text(RS_(L"WindowRestoreDownButtonToolTip"));
             break;
 
         case WindowVisualState::WindowVisualStateNormal:
@@ -91,7 +87,6 @@ namespace winrt::TerminalApp::implementation
             MinimizeButton().Height(windowedHeight);
             MaximizeButton().Height(windowedHeight);
             CloseButton().Height(windowedHeight);
-            MaximizeToolTip().Text(RS_(L"WindowMaximizeButtonToolTip"));
             break;
         }
     }

src/cascadia/TerminalApp/MinMaxCloseControl.xaml

@@ -22,11 +22,9 @@ the MIT License. See LICENSE in the project root for license information. -->
                     <StaticResource x:Key="CaptionButtonBackgroundPointerOver" ResourceKey="SystemControlBackgroundBaseLowBrush"/>
                     <StaticResource x:Key="CaptionButtonBackgroundPressed" ResourceKey="SystemControlBackgroundBaseMediumLowBrush"/>
                     <StaticResource x:Key="CaptionButtonStroke" ResourceKey="SystemControlForegroundBaseHighBrush"/>
-                    <StaticResource x:Key="CaptionButtonStrokeColor" ResourceKey="SystemBaseHighColor"/>
                     <StaticResource x:Key="CaptionButtonStrokePointerOver" ResourceKey="SystemControlForegroundBaseHighBrush"/>
                     <StaticResource x:Key="CaptionButtonStrokePressed" ResourceKey="SystemControlForegroundBaseHighBrush"/>
                     <SolidColorBrush x:Key="CaptionButtonBackground" Color="Transparent" />
-                    <Color x:Key="CaptionButtonBackgroundColor">Transparent</Color>
                     <SolidColorBrush x:Key="CloseButtonBackgroundPointerOver" Color="#e81123"/>
                     <SolidColorBrush x:Key="CloseButtonStrokePointerOver" Color="White"/>
                     <SolidColorBrush x:Key="CloseButtonBackgroundPressed" Color="#f1707a"/>
@@ -37,11 +35,9 @@ the MIT License. See LICENSE in the project root for license information. -->
                     <StaticResource x:Key="CaptionButtonBackgroundPointerOver" ResourceKey="SystemControlBackgroundBaseLowBrush"/>
                     <StaticResource x:Key="CaptionButtonBackgroundPressed" ResourceKey="SystemControlBackgroundBaseMediumLowBrush"/>
                     <StaticResource x:Key="CaptionButtonStroke" ResourceKey="SystemControlForegroundBaseHighBrush"/>
-                    <StaticResource x:Key="CaptionButtonStrokeColor" ResourceKey="SystemBaseHighColor"/>
                     <StaticResource x:Key="CaptionButtonStrokePointerOver" ResourceKey="SystemControlForegroundBaseHighBrush"/>
                     <StaticResource x:Key="CaptionButtonStrokePressed" ResourceKey="SystemControlForegroundBaseHighBrush"/>
                     <SolidColorBrush x:Key="CaptionButtonBackground" Color="Transparent" />
-                    <Color x:Key="CaptionButtonBackgroundColor">Transparent</Color>
                     <SolidColorBrush x:Key="CloseButtonBackgroundPointerOver" Color="#e81123"/>
                     <SolidColorBrush x:Key="CloseButtonStrokePointerOver" Color="White"/>
                     <SolidColorBrush x:Key="CloseButtonBackgroundPressed" Color="#f1707a"/>
@@ -50,11 +46,9 @@ the MIT License. See LICENSE in the project root for license information. -->
                 <ResourceDictionary x:Key="HighContrast">
                     <x:Double x:Key="CaptionButtonStrokeWidth">3.0</x:Double>
                     <SolidColorBrush x:Key="CaptionButtonBackground" Color="{ThemeResource SystemColorButtonFaceColor}"/>
-                    <StaticResource x:Key="CaptionButtonBackgroundColor" ResourceKey="SystemColorButtonFaceColor"/>
                     <SolidColorBrush x:Key="CaptionButtonBackgroundPointerOver" Color="{ThemeResource SystemColorHighlightColor}"/>
                     <SolidColorBrush x:Key="CaptionButtonBackgroundPressed" Color="{ThemeResource SystemColorHighlightColor}"/>
                     <SolidColorBrush x:Key="CaptionButtonStroke" Color="{ThemeResource SystemColorButtonTextColor}"/>
-                    <StaticResource x:Key="CaptionButtonStrokeColor" ResourceKey="SystemColorButtonTextColor"/>
                     <SolidColorBrush x:Key="CaptionButtonStrokePointerOver" Color="{ThemeResource SystemColorHighlightTextColor}"/>
                     <SolidColorBrush x:Key="CaptionButtonStrokePressed" Color="{ThemeResource SystemColorHighlightTextColor}"/>
                     <SolidColorBrush x:Key="CloseButtonBackgroundPointerOver" Color="{ThemeResource SystemColorHighlightColor}"/>
@@ -101,8 +95,8 @@ the MIT License. See LICENSE in the project root for license information. -->
                                         <VisualStateGroup.Transitions>
                                             <VisualTransition From="PointerOver" To="Normal">
                                                 <Storyboard>
-                                                    <ColorAnimation Storyboard.TargetName="ButtonBaseElement" Storyboard.TargetProperty="(UIElement.Background).(SolidColorBrush.Color)" To="{ThemeResource CaptionButtonBackgroundColor}" Duration="0:0:0.2"/>
-                                                    <ColorAnimation Storyboard.TargetName="Path" Storyboard.TargetProperty="(UIElement.Stroke).(SolidColorBrush.Color)" To="{ThemeResource CaptionButtonStrokeColor}" Duration="0:0:0.1"/>
+                                                    <ColorAnimation Storyboard.TargetName="ButtonBaseElement" Storyboard.TargetProperty="(UIElement.Background).(SolidColorBrush.Color)" To="{Binding Color, Source={ThemeResource CaptionButtonBackground}}" Duration="0:0:0.2"/>
+                                                    <ColorAnimation Storyboard.TargetName="Path" Storyboard.TargetProperty="(UIElement.Stroke).(SolidColorBrush.Color)" To="{Binding Color, Source={ThemeResource CaptionButtonStroke}}" Duration="0:0:0.1"/>
                                                 </Storyboard>
                                             </VisualTransition>
                                         </VisualStateGroup.Transitions>
@@ -188,13 +182,6 @@ the MIT License. See LICENSE in the project root for license information. -->
                 <x:String x:Key="CaptionButtonPathWindowMaximized">M 0 2 h 8 v 8 h -8 v -8 M 2 2 v -2 h 8 v 8 h -2</x:String>
             </ResourceDictionary>
         </Button.Resources>
-        <ToolTipService.ToolTip>
-            <ToolTip>
-                <TextBlock>
-                <Run x:Name="MaximizeToolTip"/>
-                </TextBlock>
-            </ToolTip>
-        </ToolTipService.ToolTip>
     </Button>
     <Button Height="{StaticResource CaptionButtonHeightWindowed}" MinWidth="46.0" Width="46.0"
             x:Name="CloseButton"

src/cascadia/TerminalApp/Pane.cpp

@@ -21,6 +21,7 @@ using namespace TerminalApp;
 
 static const int PaneBorderSize = 2;
 static const int CombinedPaneBorderSize = 2 * PaneBorderSize;
+static const float Half = 0.50f;
 
 // WARNING: Don't do this! This won't work
 //   Duration duration{ std::chrono::milliseconds{ 200 } };
@@ -59,7 +60,6 @@ Pane::Pane(const GUID& profile, const TermControl& control, const bool lastFocus
 
     // Register an event with the control to have it inform us when it gains focus.
     _gotFocusRevoker = control.GotFocus(winrt::auto_revoke, { this, &Pane::_ControlGotFocusHandler });
-    _lostFocusRevoker = control.LostFocus(winrt::auto_revoke, { this, &Pane::_ControlLostFocusHandler });
 
     // When our border is tapped, make sure to transfer focus to our control.
     // LOAD-BEARING: This will NOT work if the border's BorderBrush is set to
@@ -368,18 +368,15 @@ void Pane::_ControlWarningBellHandler(const winrt::Windows::Foundation::IInspect
     auto paneProfile = settings.FindProfile(_profile.value());
     if (paneProfile)
     {
-        // We don't want to do anything if nothing is set, so check for that first
-        if (static_cast<int>(paneProfile.BellStyle()) != 0)
+        if (WI_IsFlagSet(paneProfile.BellStyle(), winrt::Microsoft::Terminal::Settings::Model::BellStyle::Audible))
         {
-            if (WI_IsFlagSet(paneProfile.BellStyle(), winrt::Microsoft::Terminal::Settings::Model::BellStyle::Audible))
-            {
-                // Audible is set, play the sound
-                const auto soundAlias = reinterpret_cast<LPCTSTR>(SND_ALIAS_SYSTEMHAND);
-                PlaySound(soundAlias, NULL, SND_ALIAS_ID | SND_ASYNC | SND_SENTRY);
-            }
-
-            // raise the event with the bool value corresponding to the visual flag
-            _PaneRaiseBellHandlers(nullptr, WI_IsFlagSet(paneProfile.BellStyle(), winrt::Microsoft::Terminal::Settings::Model::BellStyle::Visual));
+            const auto soundAlias = reinterpret_cast<LPCTSTR>(SND_ALIAS_SYSTEMHAND);
+            PlaySound(soundAlias, NULL, SND_ALIAS_ID | SND_ASYNC | SND_SENTRY);
+        }
+        if (WI_IsFlagSet(paneProfile.BellStyle(), winrt::Microsoft::Terminal::Settings::Model::BellStyle::Visual))
+        {
+            // Bubble this event up to app host, starting with bubbling to the hosting tab
+            _PaneRaiseVisualBellHandlers(nullptr);
         }
     }
 }
@@ -398,16 +395,6 @@ void Pane::_ControlGotFocusHandler(winrt::Windows::Foundation::IInspectable cons
     _GotFocusHandlers(shared_from_this());
 }
 
-// Event Description:
-// - Called when our control loses focus. We'll use this to trigger our LostFocus
-//   callback. The tab that's hosting us should have registered a callback which
-//   can be used to update its own internal focus state
-void Pane::_ControlLostFocusHandler(winrt::Windows::Foundation::IInspectable const& /* sender */,
-                                    RoutedEventArgs const& /* args */)
-{
-    _LostFocusHandlers(shared_from_this());
-}
-
 // Method Description:
 // - Fire our Closed event to tell our parent that we should be removed.
 // Arguments:
@@ -597,19 +584,6 @@ void Pane::_FocusFirstChild()
 {
     if (_IsLeaf())
     {
-        if (_root.ActualWidth() == 0 && _root.ActualHeight() == 0)
-        {
-            // When these sizes are 0, then the pane might still be in startup,
-            // and doesn't yet have a real size. In that case, the control.Focus
-            // event won't be handled until _after_ the startup events are all
-            // processed. This will lead to the Tab not being notified that the
-            // focus moved to a different Pane.
-            //
-            // In that scenario, trigger the event manually here, to correctly
-            // inform the Tab that we're now focused.
-            _GotFocusHandlers(shared_from_this());
-        }
-
         _control.Focus(FocusState::Programmatic);
     }
     else
@@ -730,7 +704,6 @@ void Pane::_CloseChild(const bool closeFirst)
 
         // re-attach our handler for the control's GotFocus event.
         _gotFocusRevoker = _control.GotFocus(winrt::auto_revoke, { this, &Pane::_ControlGotFocusHandler });
-        _lostFocusRevoker = _control.LostFocus(winrt::auto_revoke, { this, &Pane::_ControlLostFocusHandler });
 
         // If we're inheriting the "last active" state from one of our children,
         // focus our control now. This should trigger our own GotFocus event.
@@ -1243,6 +1216,32 @@ void Pane::_SetupEntranceAnimation()
     setupAnimation(secondSize, false);
 }
 
+// Method Description:
+// - Determines whether the pane can be split
+// Arguments:
+// - splitType: what type of split we want to create.
+// Return Value:
+// - True if the pane can be split. False otherwise.
+bool Pane::CanSplit(SplitState splitType)
+{
+    if (_IsLeaf())
+    {
+        return _CanSplit(splitType);
+    }
+
+    if (_firstChild->_HasFocusedChild())
+    {
+        return _firstChild->CanSplit(splitType);
+    }
+
+    if (_secondChild->_HasFocusedChild())
+    {
+        return _secondChild->CanSplit(splitType);
+    }
+
+    return false;
+}
+
 // Method Description:
 // - This is a helper to determine if a given Pane can be split, but without
 //   using the ActualWidth() and ActualHeight() methods. This is used during
@@ -1273,15 +1272,12 @@ void Pane::_SetupEntranceAnimation()
 // - This method is highly similar to Pane::PreCalculateAutoSplit
 std::optional<bool> Pane::PreCalculateCanSplit(const std::shared_ptr<Pane> target,
                                                SplitState splitType,
-                                               const float splitSize,
                                                const winrt::Windows::Foundation::Size availableSpace) const
 {
     if (_IsLeaf())
     {
         if (target.get() == this)
         {
-            const auto firstPrecent = 1.0f - splitSize;
-            const auto secondPercent = splitSize;
             // If this pane is a leaf, and it's the pane we're looking for, use
             // the available space to calculate which direction to split in.
             const Size minSize = _GetMinSize();
@@ -1294,19 +1290,17 @@ std::optional<bool> Pane::PreCalculateCanSplit(const std::shared_ptr<Pane> targe
             else if (splitType == SplitState::Vertical)
             {
                 const auto widthMinusSeparator = availableSpace.Width - CombinedPaneBorderSize;
-                const auto newFirstWidth = widthMinusSeparator * firstPrecent;
-                const auto newSecondWidth = widthMinusSeparator * secondPercent;
+                const auto newWidth = widthMinusSeparator * Half;
 
-                return { newFirstWidth > minSize.Width && newSecondWidth > minSize.Width };
+                return { newWidth > minSize.Width };
             }
 
             else if (splitType == SplitState::Horizontal)
             {
                 const auto heightMinusSeparator = availableSpace.Height - CombinedPaneBorderSize;
-                const auto newFirstHeight = heightMinusSeparator * firstPrecent;
-                const auto newSecondHeight = heightMinusSeparator * secondPercent;
+                const auto newHeight = heightMinusSeparator * Half;
 
-                return { newFirstHeight > minSize.Height && newSecondHeight > minSize.Height };
+                return { newHeight > minSize.Height };
             }
         }
         else
@@ -1335,8 +1329,8 @@ std::optional<bool> Pane::PreCalculateCanSplit(const std::shared_ptr<Pane> targe
                                        (availableSpace.Height - firstHeight) - PaneBorderSize :
                                        availableSpace.Height;
 
-        const auto firstResult = _firstChild->PreCalculateCanSplit(target, splitType, splitSize, { firstWidth, firstHeight });
-        return firstResult.has_value() ? firstResult : _secondChild->PreCalculateCanSplit(target, splitType, splitSize, { secondWidth, secondHeight });
+        const auto firstResult = _firstChild->PreCalculateCanSplit(target, splitType, { firstWidth, firstHeight });
+        return firstResult.has_value() ? firstResult : _secondChild->PreCalculateCanSplit(target, splitType, { secondWidth, secondHeight });
     }
 
     // We should not possibly be getting here - both the above branches should
@@ -1354,26 +1348,23 @@ std::optional<bool> Pane::PreCalculateCanSplit(const std::shared_ptr<Pane> targe
 // - control: A TermControl to use in the new pane.
 // Return Value:
 // - The two newly created Panes
-std::pair<std::shared_ptr<Pane>, std::shared_ptr<Pane>> Pane::Split(SplitState splitType,
-                                                                    const float splitSize,
-                                                                    const GUID& profile,
-                                                                    const TermControl& control)
+std::pair<std::shared_ptr<Pane>, std::shared_ptr<Pane>> Pane::Split(SplitState splitType, const GUID& profile, const TermControl& control)
 {
     if (!_IsLeaf())
     {
         if (_firstChild->_HasFocusedChild())
         {
-            return _firstChild->Split(splitType, splitSize, profile, control);
+            return _firstChild->Split(splitType, profile, control);
         }
         else if (_secondChild->_HasFocusedChild())
         {
-            return _secondChild->Split(splitType, splitSize, profile, control);
+            return _secondChild->Split(splitType, profile, control);
         }
 
         return { nullptr, nullptr };
     }
 
-    return _Split(splitType, splitSize, profile, control);
+    return _Split(splitType, profile, control);
 }
 
 // Method Description:
@@ -1401,6 +1392,45 @@ SplitState Pane::_convertAutomaticSplitState(const SplitState& splitType) const
     return splitType;
 }
 
+// Method Description:
+// - Determines whether the pane can be split.
+// Arguments:
+// - splitType: what type of split we want to create.
+// Return Value:
+// - True if the pane can be split. False otherwise.
+bool Pane::_CanSplit(SplitState splitType)
+{
+    const Size actualSize{ gsl::narrow_cast<float>(_root.ActualWidth()),
+                           gsl::narrow_cast<float>(_root.ActualHeight()) };
+
+    const Size minSize = _GetMinSize();
+
+    auto actualSplitType = _convertAutomaticSplitState(splitType);
+
+    if (actualSplitType == SplitState::None)
+    {
+        return false;
+    }
+
+    if (actualSplitType == SplitState::Vertical)
+    {
+        const auto widthMinusSeparator = actualSize.Width - CombinedPaneBorderSize;
+        const auto newWidth = widthMinusSeparator * Half;
+
+        return newWidth > minSize.Width;
+    }
+
+    if (actualSplitType == SplitState::Horizontal)
+    {
+        const auto heightMinusSeparator = actualSize.Height - CombinedPaneBorderSize;
+        const auto newHeight = heightMinusSeparator * Half;
+
+        return newHeight > minSize.Height;
+    }
+
+    return false;
+}
+
 // Method Description:
 // - Does the bulk of the work of creating a new split. Initializes our UI,
 //   creates a new Pane to host the control, registers event handlers.
@@ -1410,10 +1440,7 @@ SplitState Pane::_convertAutomaticSplitState(const SplitState& splitType) const
 // - control: A TermControl to use in the new pane.
 // Return Value:
 // - The two newly created Panes
-std::pair<std::shared_ptr<Pane>, std::shared_ptr<Pane>> Pane::_Split(SplitState splitType,
-                                                                     const float splitSize,
-                                                                     const GUID& profile,
-                                                                     const TermControl& control)
+std::pair<std::shared_ptr<Pane>, std::shared_ptr<Pane>> Pane::_Split(SplitState splitType, const GUID& profile, const TermControl& control)
 {
     if (splitType == SplitState::None)
     {
@@ -1436,10 +1463,9 @@ std::pair<std::shared_ptr<Pane>, std::shared_ptr<Pane>> Pane::_Split(SplitState
     // control telling us that it's now focused, we want it telling its new
     // parent.
     _gotFocusRevoker.revoke();
-    _lostFocusRevoker.revoke();
 
     _splitState = actualSplitType;
-    _desiredSplitPosition = 1.0f - splitSize;
+    _desiredSplitPosition = Half;
 
     // Remove any children we currently have. We can't add the existing
     // TermControl to a new grid until we do this.
@@ -1550,9 +1576,9 @@ void Pane::Restore(std::shared_ptr<Pane> zoomedPane)
 //   otherwise the ID value will not make sense (leaves have IDs, parents do not)
 // Return Value:
 // - The ID of this pane
-std::optional<uint16_t> Pane::Id() noexcept
+uint16_t Pane::Id() noexcept
 {
-    return _id;
+    return _id.value();
 }
 
 // Method Description:
@@ -2086,5 +2112,4 @@ std::optional<SplitState> Pane::PreCalculateAutoSplit(const std::shared_ptr<Pane
 }
 
 DEFINE_EVENT(Pane, GotFocus, _GotFocusHandlers, winrt::delegate<std::shared_ptr<Pane>>);
-DEFINE_EVENT(Pane, LostFocus, _LostFocusHandlers, winrt::delegate<std::shared_ptr<Pane>>);
-DEFINE_EVENT(Pane, PaneRaiseBell, _PaneRaiseBellHandlers, winrt::Windows::Foundation::EventHandler<bool>);
+DEFINE_EVENT(Pane, PaneRaiseVisualBell, _PaneRaiseVisualBellHandlers, winrt::delegate<std::shared_ptr<Pane>>);

src/cascadia/TerminalApp/Pane.h

@@ -58,16 +58,14 @@ public:
     bool ResizePane(const winrt::Microsoft::Terminal::Settings::Model::ResizeDirection& direction);
     bool NavigateFocus(const winrt::Microsoft::Terminal::Settings::Model::FocusDirection& direction);
 
+    bool CanSplit(winrt::Microsoft::Terminal::Settings::Model::SplitState splitType);
     std::pair<std::shared_ptr<Pane>, std::shared_ptr<Pane>> Split(winrt::Microsoft::Terminal::Settings::Model::SplitState splitType,
-                                                                  const float splitSize,
                                                                   const GUID& profile,
                                                                   const winrt::Microsoft::Terminal::TerminalControl::TermControl& control);
     float CalcSnappedDimension(const bool widthOrHeight, const float dimension) const;
-    std::optional<winrt::Microsoft::Terminal::Settings::Model::SplitState> PreCalculateAutoSplit(const std::shared_ptr<Pane> target,
-                                                                                                 const winrt::Windows::Foundation::Size parentSize) const;
+    std::optional<winrt::Microsoft::Terminal::Settings::Model::SplitState> PreCalculateAutoSplit(const std::shared_ptr<Pane> target, const winrt::Windows::Foundation::Size parentSize) const;
     std::optional<bool> PreCalculateCanSplit(const std::shared_ptr<Pane> target,
                                              winrt::Microsoft::Terminal::Settings::Model::SplitState splitType,
-                                             const float splitSize,
                                              const winrt::Windows::Foundation::Size availableSpace) const;
     void Shutdown();
     void Close();
@@ -77,14 +75,13 @@ public:
     void Maximize(std::shared_ptr<Pane> zoomedPane);
     void Restore(std::shared_ptr<Pane> zoomedPane);
 
-    std::optional<uint16_t> Id() noexcept;
+    uint16_t Id() noexcept;
     void Id(uint16_t id) noexcept;
     void FocusPane(const uint16_t id);
 
     WINRT_CALLBACK(Closed, winrt::Windows::Foundation::EventHandler<winrt::Windows::Foundation::IInspectable>);
     DECLARE_EVENT(GotFocus, _GotFocusHandlers, winrt::delegate<std::shared_ptr<Pane>>);
-    DECLARE_EVENT(LostFocus, _LostFocusHandlers, winrt::delegate<std::shared_ptr<Pane>>);
-    DECLARE_EVENT(PaneRaiseBell, _PaneRaiseBellHandlers, winrt::Windows::Foundation::EventHandler<bool>);
+    DECLARE_EVENT(PaneRaiseVisualBell, _PaneRaiseVisualBellHandlers, winrt::delegate<std::shared_ptr<Pane>>);
 
 private:
     struct SnapSizeResult;
@@ -112,7 +109,6 @@ private:
     winrt::event_token _warningBellToken{ 0 };
 
     winrt::Windows::UI::Xaml::UIElement::GotFocus_revoker _gotFocusRevoker;
-    winrt::Windows::UI::Xaml::UIElement::LostFocus_revoker _lostFocusRevoker;
 
     std::shared_mutex _createCloseLock{};
 
@@ -124,8 +120,8 @@ private:
     bool _HasFocusedChild() const noexcept;
     void _SetupChildCloseHandlers();
 
+    bool _CanSplit(winrt::Microsoft::Terminal::Settings::Model::SplitState splitType);
     std::pair<std::shared_ptr<Pane>, std::shared_ptr<Pane>> _Split(winrt::Microsoft::Terminal::Settings::Model::SplitState splitType,
-                                                                   const float splitSize,
                                                                    const GUID& profile,
                                                                    const winrt::Microsoft::Terminal::TerminalControl::TermControl& control);
 
@@ -146,8 +142,6 @@ private:
                                     winrt::Windows::Foundation::IInspectable const& e);
     void _ControlGotFocusHandler(winrt::Windows::Foundation::IInspectable const& sender,
                                  winrt::Windows::UI::Xaml::RoutedEventArgs const& e);
-    void _ControlLostFocusHandler(winrt::Windows::Foundation::IInspectable const& sender,
-                                  winrt::Windows::UI::Xaml::RoutedEventArgs const& e);
 
     std::pair<float, float> _CalcChildrenSizes(const float fullSize) const;
     SnapChildrenSizeResult _CalcSnappedChildrenSizes(const bool widthOrHeight, const float fullSize) const;

src/cascadia/TerminalApp/Resources/en-US/Resources.resw

@@ -226,9 +226,6 @@
     <value>&#x2022; Found a keybinding with too many strings for the "keys" array. There should only be one string value in the "keys" array.</value>
     <comment>{Locked="\"keys\"","&#x2022;"} This glyph is a bullet, used in a bulleted list.</comment>
   </data>
-  <data name="FailedToParseSubCommands" xml:space="preserve">
-    <value>&#x2022; Failed to parse all subcommands of nested command.</value>
-  </data>
   <data name="MissingRequiredParameter" xml:space="preserve">
     <value>&#x2022; Found a keybinding that was missing a required parameter value. This keybinding will be ignored.</value>
     <comment>{Locked="&#x2022;"} This glyph is a bullet, used in a bulleted list.</comment>
@@ -252,14 +249,6 @@
     <value>Found a command with an invalid "colorScheme". This command will be ignored. Make sure that when setting a "colorScheme", the value matches the "name" of a color scheme in the "schemes" list.</value>
     <comment>{Locked="\"colorScheme\"","\"name\"","\"schemes\""}</comment>
   </data>
-  <data name="InvalidSplitSize" xml:space="preserve">
-    <value>Found a "splitPane" command with an invalid "size". This command will be ignored. Make sure the size is between 0 and 1, exclusive.</value>
-    <comment>{Locked="\"splitPane\"","\"size\""}</comment>
-  </data>
-  <data name="FailedToParseStartupActions" xml:space="preserve">
-    <value>Failed to parse "startupActions".</value>
-    <comment>{Locked="\"startupActions\""}</comment>
-  </data>
   <data name="CmdCommandArgDesc" xml:space="preserve">
     <value>An optional command, with arguments, to be spawned in the new tab or pane</value>
   </data>
@@ -279,9 +268,6 @@
   <data name="CmdFocusTabTargetArgDesc" xml:space="preserve">
     <value>Move focus the tab at the given index</value>
   </data>
-  <data name="CmdSplitPaneSizeArgDesc" xml:space="preserve">
-    <value>Specify the size as a percentage of the parent pane. Valid values are between (0,1), exclusive.</value>
-  </data>
   <data name="CmdNewTabDesc" xml:space="preserve">
     <value>Create a new tab</value>
   </data>
@@ -325,16 +311,6 @@
   <data name="CmdFullscreenDesc" xml:space="preserve">
     <value>Launch the window in fullscreen mode</value>
   </data>
-  <data name="CmdMoveFocusDesc" xml:space="preserve">
-    <value>Move focus to the adjacent pane in the specified direction</value>
-  </data>
-  <data name="CmdMFDesc" xml:space="preserve">
-    <value>An alias for the "move-focus" subcommand.</value>
-    <comment>{Locked="\"move-focus\""}</comment>
-  </data>
-  <data name="CmdMoveFocusDirectionArgDesc" xml:space="preserve">
-    <value>The direction to move focus in</value>
-  </data>
   <data name="CmdFocusDesc" xml:space="preserve">
     <value>Launch the window in focus mode</value>
   </data>
@@ -359,6 +335,9 @@
   <data name="WindowMaximizeButton.[using:Windows.UI.Xaml.Automation]AutomationProperties.Name" xml:space="preserve">
     <value>Maximize</value>
   </data>
+  <data name="WindowMaximizeButton.[using:Windows.UI.Xaml.Controls]ToolTipService.ToolTip" xml:space="preserve">
+    <value>Maximize</value>
+  </data>
   <data name="WindowMinimizeButton.[using:Windows.UI.Xaml.Automation]AutomationProperties.Name" xml:space="preserve">
     <value>Minimize</value>
   </data>
@@ -419,7 +398,7 @@
   <data name="MultiLinePasteDialog.CloseButtonText" xml:space="preserve">
     <value>Cancel</value>
   </data>
-  <data name="MultiLineWarningText.Text" xml:space="preserve">
+  <data name="MultiLinePasteDialog.Content" xml:space="preserve">
     <value>You are about to paste text that contains multiple lines. If you paste this text into your shell, it may result in the unexpected execution of commands. Do you wish to continue?</value>
   </data>
   <data name="MultiLinePasteDialog.PrimaryButtonText" xml:space="preserve">
@@ -436,7 +415,7 @@
   </data>
   <data name="CommandPalette_ParsedCommandLine" xml:space="preserve">
     <value>Executing command line will invoke the following commands:</value>
-    <comment>Will be followed by a list of strings describing parsed commands</comment>
+	<comment>Will be followed by a list of strings describing parsed commands</comment>
   </data>
   <data name="CommandPalette_FailedParsingCommandLine" xml:space="preserve">
     <value>Failed parsing command line:</value>
@@ -541,16 +520,4 @@
   <data name="NoticeWarning" xml:space="preserve">
     <value>Warning</value>
   </data>
-  <data name="ClipboardTextHeader.Text" xml:space="preserve">
-    <value>Clipboard contents (preview):</value>
-  </data>
-  <data name="CommandPalette_MoreOptions.[using:Windows.UI.Xaml.Automation]AutomationProperties.HelpText" xml:space="preserve">
-    <value>More options</value>
-  </data>
-  <data name="WindowMaximizeButtonToolTip" xml:space="preserve">
-    <value>Maximize</value>
-  </data>
-  <data name="WindowRestoreDownButtonToolTip" xml:space="preserve">
-    <value>Restore Down</value>
-  </data>
-</root>
+</root>

src/cascadia/TerminalApp/ShortcutActionDispatch.cpp

@@ -22,11 +22,6 @@ namespace winrt::TerminalApp::implementation
     // - true if we handled the event was handled, else false.
     bool ShortcutActionDispatch::DoAction(const ActionAndArgs& actionAndArgs)
     {
-        if (!actionAndArgs)
-        {
-            return false;
-        }
-
         const auto& action = actionAndArgs.Action();
         const auto& args = actionAndArgs.Args();
         auto eventArgs = args ? ActionEventArgs{ args } :

src/cascadia/TerminalApp/TabBase.cpp

@@ -49,7 +49,7 @@ namespace winrt::TerminalApp::implementation
         Controls::MenuFlyoutItem closeTabMenuItem;
         Controls::FontIcon closeSymbol;
         closeSymbol.FontFamily(Media::FontFamily{ L"Segoe MDL2 Assets" });
-        closeSymbol.Glyph(L"\xE711");
+        closeSymbol.Glyph(L"\xE8BB");
 
         closeTabMenuItem.Click([weakThis](auto&&, auto&&) {
             if (auto tab{ weakThis.get() })
@@ -62,6 +62,7 @@ namespace winrt::TerminalApp::implementation
 
         // Build the menu
         Controls::MenuFlyout newTabFlyout;
+        newTabFlyout.Items().Append(_CreateCloseSubMenu());
         newTabFlyout.Items().Append(closeTabMenuItem);
         TabViewItem().ContextFlyout(newTabFlyout);
     }
@@ -137,88 +138,10 @@ namespace winrt::TerminalApp::implementation
         TabViewIndex(idx);
         TabViewNumTabs(numTabs);
         _EnableCloseMenuItems();
-        _UpdateSwitchToTabKeyChord();
     }
 
     void TabBase::SetDispatch(const winrt::TerminalApp::ShortcutActionDispatch& dispatch)
     {
         _dispatch = dispatch;
     }
-
-    void TabBase::SetKeyMap(const Microsoft::Terminal::Settings::Model::KeyMapping& keymap)
-    {
-        _keymap = keymap;
-        _UpdateSwitchToTabKeyChord();
-    }
-
-    // Method Description:
-    // - Sets the key chord resulting in switch to the current tab.
-    // Updates tool tip if required
-    // Arguments:
-    // - keyChord - string representation of the key chord that switches to the current tab
-    // Return Value:
-    // - <none>
-    winrt::fire_and_forget TabBase::_UpdateSwitchToTabKeyChord()
-    {
-        SwitchToTabArgs args{ _TabViewIndex };
-        ActionAndArgs switchToTab{ ShortcutAction::SwitchToTab, args };
-        const auto keyChord = _keymap ? _keymap.GetKeyBindingForActionWithArgs(switchToTab) : nullptr;
-        const auto keyChordText = keyChord ? KeyChordSerialization::ToString(keyChord) : L"";
-
-        if (_keyChord == keyChordText)
-        {
-            return;
-        }
-
-        _keyChord = keyChordText;
-
-        auto weakThis{ get_weak() };
-
-        co_await winrt::resume_foreground(TabViewItem().Dispatcher());
-
-        if (auto tab{ weakThis.get() })
-        {
-            _UpdateToolTip();
-        }
-    }
-
-    // Method Description:
-    // - Creates a text for the title run in the tool tip by returning tab title
-    // Arguments:
-    // - <none>
-    // Return Value:
-    // - The value to populate in the title run of the tool tip
-    winrt::hstring TabBase::_CreateToolTipTitle()
-    {
-        return _Title;
-    }
-
-    // Method Description:
-    // - Sets tab tool tip to a concatenation of title and key chord
-    // Arguments:
-    // - <none>
-    // Return Value:
-    // - <none>
-    void TabBase::_UpdateToolTip()
-    {
-        auto titleRun = WUX::Documents::Run();
-        titleRun.Text(_CreateToolTipTitle());
-
-        auto textBlock = WUX::Controls::TextBlock{};
-        textBlock.TextAlignment(WUX::TextAlignment::Center);
-        textBlock.Inlines().Append(titleRun);
-
-        if (!_keyChord.empty())
-        {
-            auto keyChordRun = WUX::Documents::Run();
-            keyChordRun.Text(_keyChord);
-            keyChordRun.FontStyle(winrt::Windows::UI::Text::FontStyle::Italic);
-            textBlock.Inlines().Append(WUX::Documents::LineBreak{});
-            textBlock.Inlines().Append(keyChordRun);
-        }
-
-        WUX::Controls::ToolTip toolTip{};
-        toolTip.Content(textBlock);
-        WUX::Controls::ToolTipService::SetToolTip(TabViewItem(), toolTip);
-    }
 }

src/cascadia/TerminalApp/TabBase.h

@@ -23,7 +23,6 @@ namespace winrt::TerminalApp::implementation
         void SetDispatch(const winrt::TerminalApp::ShortcutActionDispatch& dispatch);
 
         void UpdateTabViewIndex(const uint32_t idx, const uint32_t numTabs);
-        void SetKeyMap(const Microsoft::Terminal::Settings::Model::KeyMapping& keymap);
 
         WINRT_CALLBACK(Closed, winrt::Windows::Foundation::EventHandler<winrt::Windows::Foundation::IInspectable>);
         WINRT_CALLBACK(PropertyChanged, Windows::UI::Xaml::Data::PropertyChangedEventHandler);
@@ -44,18 +43,12 @@ namespace winrt::TerminalApp::implementation
         winrt::Windows::UI::Xaml::Controls::MenuFlyoutItem _closeOtherTabsMenuItem{};
         winrt::Windows::UI::Xaml::Controls::MenuFlyoutItem _closeTabsAfterMenuItem{};
         winrt::TerminalApp::ShortcutActionDispatch _dispatch;
-        Microsoft::Terminal::Settings::Model::KeyMapping _keymap{ nullptr };
-        winrt::hstring _keyChord{};
 
         virtual void _CreateContextMenu();
-        virtual winrt::hstring _CreateToolTipTitle();
-
         winrt::Windows::UI::Xaml::Controls::MenuFlyoutSubItem _CreateCloseSubMenu();
         void _EnableCloseMenuItems();
         void _CloseTabsAfter();
         void _CloseOtherTabs();
-        winrt::fire_and_forget _UpdateSwitchToTabKeyChord();
-        void _UpdateToolTip();
 
         friend class ::TerminalAppLocalTests::TabTests;
     };

src/cascadia/TerminalApp/TabHeaderControl.cpp

@@ -65,7 +65,7 @@ namespace winrt::TerminalApp::implementation
             "TabRenamerOpened",
             TraceLoggingDescription("Event emitted when the tab renamer is opened"),
             TraceLoggingKeyword(MICROSOFT_KEYWORD_MEASURES),
-            TelemetryPrivacyDataTag(PDT_ProductAndServiceUsage));
+            TelemetryPrivacyDataTag(PDT_ProductAndServicePerformance));
     }
 
     // Method Description:
@@ -75,14 +75,6 @@ namespace winrt::TerminalApp::implementation
     void TabHeaderControl::RenameBoxLostFocusHandler(Windows::Foundation::IInspectable const& /*sender*/,
                                                      Windows::UI::Xaml::RoutedEventArgs const& /*e*/)
     {
-        // If the context menu associated with the renamer text box is open we know it gained the focus.
-        // In this case we ignore this event (we will regain the focus once the menu will be closed).
-        const auto flyout = HeaderRenamerTextBox().ContextFlyout();
-        if (flyout && flyout.IsOpen())
-        {
-            return;
-        }
-
         // Log the data here, rather than in _CloseRenameBox. If we do it there,
         // it'll get fired twice, once when the key is pressed to commit/cancel,
         // and then again when the focus is lost
@@ -93,7 +85,7 @@ namespace winrt::TerminalApp::implementation
             TraceLoggingDescription("Event emitted when the tab renamer is closed"),
             TraceLoggingBoolean(_renameCancelled, "CancelledRename", "True if the user cancelled the rename, false if they committed."),
             TraceLoggingKeyword(MICROSOFT_KEYWORD_MEASURES),
-            TelemetryPrivacyDataTag(PDT_ProductAndServiceUsage));
+            TelemetryPrivacyDataTag(PDT_ProductAndServicePerformance));
 
         _CloseRenameBox();
         if (!_renameCancelled)
@@ -106,11 +98,7 @@ namespace winrt::TerminalApp::implementation
     // - Hides the rename box and displays the title text block
     void TabHeaderControl::_CloseRenameBox()
     {
-        if (HeaderRenamerTextBox().Visibility() == Windows::UI::Xaml::Visibility::Visible)
-        {
-            HeaderRenamerTextBox().Visibility(Windows::UI::Xaml::Visibility::Collapsed);
-            HeaderTextBlock().Visibility(Windows::UI::Xaml::Visibility::Visible);
-            _RenameEndedHandlers(*this, nullptr);
-        }
+        HeaderRenamerTextBox().Visibility(Windows::UI::Xaml::Visibility::Collapsed);
+        HeaderTextBlock().Visibility(Windows::UI::Xaml::Visibility::Visible);
     }
 }

src/cascadia/TerminalApp/TabHeaderControl.h

@@ -23,14 +23,10 @@ namespace winrt::TerminalApp::implementation
         WINRT_CALLBACK(PropertyChanged, Windows::UI::Xaml::Data::PropertyChangedEventHandler);
         OBSERVABLE_GETSET_PROPERTY(winrt::hstring, Title, _PropertyChangedHandlers);
         OBSERVABLE_GETSET_PROPERTY(bool, IsPaneZoomed, _PropertyChangedHandlers);
-        OBSERVABLE_GETSET_PROPERTY(double, RenamerMaxWidth, _PropertyChangedHandlers);
         OBSERVABLE_GETSET_PROPERTY(bool, IsProgressRingActive, _PropertyChangedHandlers);
         OBSERVABLE_GETSET_PROPERTY(bool, IsProgressRingIndeterminate, _PropertyChangedHandlers);
-        OBSERVABLE_GETSET_PROPERTY(bool, BellIndicator, _PropertyChangedHandlers);
         OBSERVABLE_GETSET_PROPERTY(uint32_t, ProgressValue, _PropertyChangedHandlers);
 
-        TYPED_EVENT(RenameEnded, winrt::Windows::Foundation::IInspectable, winrt::Windows::Foundation::IInspectable);
-
     private:
         bool _receivedKeyDown{ false };
         bool _renameCancelled{ false };

src/cascadia/TerminalApp/TabHeaderControl.idl

@@ -9,16 +9,13 @@ namespace TerminalApp
     {
         String Title { get; set; };
         Boolean IsPaneZoomed { get; set; };
-        Double RenamerMaxWidth { get; set; };
         Boolean IsProgressRingActive { get; set; };
         Boolean IsProgressRingIndeterminate { get; set; };
-        Boolean BellIndicator { get; set; };
         UInt32 ProgressValue { get; set; };
 
         TabHeaderControl();
         void BeginRename();
 
         event TitleChangeRequestedArgs TitleChangeRequested;
-        event Windows.Foundation.TypedEventHandler<Object, Object> RenameEnded;
     }
 }

src/cascadia/TerminalApp/TabHeaderControl.xaml

@@ -9,25 +9,8 @@ the MIT License. See LICENSE in the project root for license information. -->
     xmlns:mux="using:Microsoft.UI.Xaml.Controls"
     xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
     xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
-    mc:Ignorable="d"
-    MinHeight="16">
+    mc:Ignorable="d">
 
-    <UserControl.Resources>
-        <ResourceDictionary>
-            <ResourceDictionary.ThemeDictionaries>
-                <ResourceDictionary x:Key="Light">
-                    <Thickness x:Key="TextControlBorderThemeThicknessFocused">0,0,0,1</Thickness>
-                </ResourceDictionary>
-                <ResourceDictionary x:Key="Dark">
-                    <Thickness x:Key="TextControlBorderThemeThicknessFocused">0,0,0,1</Thickness>
-                </ResourceDictionary>
-                <ResourceDictionary x:Key="HighContrast">
-                    <Thickness x:Key="TextControlBorderThemeThicknessFocused">0,0,0,1</Thickness>
-                </ResourceDictionary>
-            </ResourceDictionary.ThemeDictionaries>
-        </ResourceDictionary>
-    </UserControl.Resources>
-    
     <StackPanel x:Name="HeaderStackPanel"
                 Orientation="Horizontal">
         <mux:ProgressRing x:Name="HeaderProgressRing"
@@ -43,12 +26,6 @@ the MIT License. See LICENSE in the project root for license information. -->
         <!--We want the progress ring to 'replace' the tab icon, but we don't have control
         over the tab icon here (the tab view item does) - so we hide the tab icon there
         and use a negative margin for the progress ring here to put it where the icon would be-->
-        <FontIcon x:Name="HeaderBellIndicator"
-                  FontFamily="Segoe MDL2 Assets"
-                  Visibility="{x:Bind BellIndicator, Mode=OneWay}"
-                  Glyph="&#xEA8F;"
-                  FontSize="12"
-                  Margin="0,0,8,0"/>
         <FontIcon x:Name="HeaderZoomIcon"
                   FontFamily="Segoe MDL2 Assets"
                   Visibility="{x:Bind IsPaneZoomed, Mode=OneWay}"
@@ -62,11 +39,8 @@ the MIT License. See LICENSE in the project root for license information. -->
                  Visibility="Collapsed"
                  MinHeight="0"
                  Padding="4,0,4,0"
+                 Margin="0,-8,0,-8"
                  MaxLength="1024"
-                 LostFocus="RenameBoxLostFocusHandler"
-                 Height="16"
-                 FontSize="12"
-                 IsSpellCheckEnabled="False"
-                 MaxWidth="{x:Bind RenamerMaxWidth, Mode=OneWay}"/>
+                 LostFocus="RenameBoxLostFocusHandler"/>
     </StackPanel>
 </UserControl>

src/cascadia/TerminalApp/TabPaletteItem.cpp

@@ -19,7 +19,7 @@ using namespace winrt::Microsoft::Terminal::Settings::Model;
 namespace winrt::TerminalApp::implementation
 {
     TabPaletteItem::TabPaletteItem(winrt::TerminalApp::TabBase const& tab) :
-        _tab(tab)
+        _Tab(tab)
     {
         Name(tab.Title());
         Icon(tab.Icon());

src/cascadia/TerminalApp/TabPaletteItem.h

@@ -14,13 +14,9 @@ namespace winrt::TerminalApp::implementation
         TabPaletteItem() = default;
         TabPaletteItem(winrt::TerminalApp::TabBase const& tab);
 
-        winrt::TerminalApp::TabBase Tab() const noexcept
-        {
-            return _tab.get();
-        }
+        GETSET_PROPERTY(winrt::TerminalApp::TabBase, Tab, nullptr);
 
     private:
-        winrt::weak_ref<winrt::TerminalApp::TabBase> _tab;
         Windows::UI::Xaml::Data::INotifyPropertyChanged::PropertyChanged_revoker _tabChangedRevoker;
     };
 }

src/cascadia/TerminalApp/TerminalPage.cpp

@@ -4,6 +4,7 @@
 #include "pch.h"
 #include "TerminalPage.h"
 #include "Utils.h"
+#include "AppLogic.h"
 #include "../../types/inc/utils.hpp"
 
 #include <LibraryResources.h>
@@ -43,7 +44,7 @@ namespace winrt::TerminalApp::implementation
 {
     TerminalPage::TerminalPage() :
         _tabs{ winrt::single_threaded_observable_vector<TerminalApp::TabBase>() },
-        _mruTabs{ winrt::single_threaded_observable_vector<TerminalApp::TabBase>() },
+        _mruTabs{ winrt::single_threaded_vector<TerminalApp::TabBase>() },
         _startupActions{ winrt::single_threaded_vector<ActionAndArgs>() },
         _hostingHwnd{}
     {
@@ -107,7 +108,7 @@ namespace winrt::TerminalApp::implementation
         if (auto page{ weakThis.get() })
         {
             _UpdateCommandsForPalette();
-            CommandPalette().SetKeyMap(_settings.KeyMap());
+            CommandPalette().SetKeyBindings(*_bindings);
         }
     }
 
@@ -135,8 +136,6 @@ namespace winrt::TerminalApp::implementation
         }
         CATCH_LOG();
 
-        _tabRow.PointerMoved({ this, &TerminalPage::_RestorePointerCursorHandler });
-
         _tabView.CanReorderTabs(!isElevated);
         _tabView.CanDragTabs(!isElevated);
 
@@ -210,7 +209,6 @@ namespace winrt::TerminalApp::implementation
                 {
                     page->_SplitPane(SplitState::Automatic,
                                      SplitType::Manual,
-                                     0.5f,
                                      nullptr);
                 }
                 else
@@ -255,13 +253,6 @@ namespace winrt::TerminalApp::implementation
         _layoutUpdatedRevoker = _tabContent.LayoutUpdated(winrt::auto_revoke, { this, &TerminalPage::_OnFirstLayout });
 
         _isAlwaysOnTop = _settings.GlobalSettings().AlwaysOnTop();
-
-        // Setup mouse vanish attributes
-        SystemParametersInfoW(SPI_GETMOUSEVANISH, 0, &_shouldMouseVanish, false);
-
-        // Store cursor, so we can restore it, e.g., after mouse vanishing
-        // (we'll need to adapt this logic once we make cursor context aware)
-        _defaultPointerCursor = CoreWindow::GetForCurrentThread().PointerCursor();
     }
 
     // Method Description:
@@ -340,7 +331,7 @@ namespace winrt::TerminalApp::implementation
             }
             else
             {
-                ProcessStartupActions(_startupActions, true);
+                _ProcessStartupActions(_startupActions, true);
             }
         }
     }
@@ -356,8 +347,8 @@ namespace winrt::TerminalApp::implementation
     //   should fire an Initialized event.
     // Return Value:
     // - <none>
-    winrt::fire_and_forget TerminalPage::ProcessStartupActions(Windows::Foundation::Collections::IVector<ActionAndArgs> actions,
-                                                               const bool initial)
+    winrt::fire_and_forget TerminalPage::_ProcessStartupActions(Windows::Foundation::Collections::IVector<ActionAndArgs> actions,
+                                                                const bool initial)
     {
         // If there are no actions left, do nothing.
         if (actions.Size() == 0)
@@ -569,7 +560,6 @@ namespace winrt::TerminalApp::implementation
                     {
                         page->_SplitPane(SplitState::Automatic,
                                          SplitType::Manual,
-                                         0.5f,
                                          newTerminalArgs);
                     }
                     else
@@ -610,9 +600,7 @@ namespace winrt::TerminalApp::implementation
                 settingsItem.Click({ this, &TerminalPage::_SettingsButtonOnClick });
                 newTabFlyout.Items().Append(settingsItem);
 
-                Microsoft::Terminal::Settings::Model::OpenSettingsArgs args{ SettingsTarget::SettingsFile };
-                Microsoft::Terminal::Settings::Model::ActionAndArgs settingsAction{ ShortcutAction::OpenSettings, args };
-                const auto settingsKeyChord{ keyBindings.GetKeyBindingForActionWithArgs(settingsAction) };
+                auto settingsKeyChord = keyBindings.GetKeyBindingForAction(ShortcutAction::OpenSettings);
                 if (settingsKeyChord)
                 {
                     _SetAcceleratorForMenuItem(settingsItem, settingsKeyChord);
@@ -758,7 +746,6 @@ namespace winrt::TerminalApp::implementation
         _mruTabs.Append(*newTabImpl);
 
         newTabImpl->SetDispatch(*_actionDispatch);
-        newTabImpl->SetKeyMap(_settings.KeyMap());
 
         // Give the tab its index in the _tabs vector so it can manage its own SwitchToTab command.
         _UpdateTabIndices();
@@ -817,25 +804,12 @@ namespace winrt::TerminalApp::implementation
             }
         });
 
-        newTabImpl->TabRenamerDeactivated([weakThis{ get_weak() }](auto&& /*s*/, auto&& /*e*/) {
-            if (const auto page{ weakThis.get() })
-            {
-                if (!page->_newTabButton.Flyout().IsOpen())
-                {
-                    if (const auto tab{ page->_GetFocusedTab() })
-                    {
-                        tab.Focus(FocusState::Programmatic);
-                    }
-                }
-            }
-        });
-
         if (debugConnection) // this will only be set if global debugging is on and tap is active
         {
             TermControl newControl{ settings, debugConnection };
             _RegisterTerminalEvents(newControl, *newTabImpl);
             // Split (auto) with the debug tap.
-            newTabImpl->SplitPane(SplitState::Automatic, 0.5f, profileGuid, newControl);
+            newTabImpl->SplitPane(SplitState::Automatic, profileGuid, newControl);
         }
 
         // This kicks off TabView::SelectionChanged, in response to which
@@ -953,56 +927,6 @@ namespace winrt::TerminalApp::implementation
         _ShowAboutDialog();
     }
 
-    // Method Description:
-    // Called when the users pressed keyBindings while CommandPalette is open.
-    // Arguments:
-    // - e: the KeyRoutedEventArgs containing info about the keystroke.
-    // Return Value:
-    // - <none>
-    void TerminalPage::_KeyDownHandler(Windows::Foundation::IInspectable const& /*sender*/, Windows::UI::Xaml::Input::KeyRoutedEventArgs const& e)
-    {
-        auto key = e.OriginalKey();
-        auto const ctrlDown = WI_IsFlagSet(CoreWindow::GetForCurrentThread().GetKeyState(winrt::Windows::System::VirtualKey::Control), CoreVirtualKeyStates::Down);
-        auto const altDown = WI_IsFlagSet(CoreWindow::GetForCurrentThread().GetKeyState(winrt::Windows::System::VirtualKey::Menu), CoreVirtualKeyStates::Down);
-        auto const shiftDown = WI_IsFlagSet(CoreWindow::GetForCurrentThread().GetKeyState(winrt::Windows::System::VirtualKey::Shift), CoreVirtualKeyStates::Down);
-
-        winrt::Microsoft::Terminal::TerminalControl::KeyChord kc{ ctrlDown, altDown, shiftDown, static_cast<int32_t>(key) };
-        const auto actionAndArgs = _settings.KeyMap().TryLookup(kc);
-        if (actionAndArgs)
-        {
-            if (CommandPalette().Visibility() == Visibility::Visible && actionAndArgs.Action() != ShortcutAction::ToggleCommandPalette)
-            {
-                CommandPalette().Visibility(Visibility::Collapsed);
-            }
-            _actionDispatch->DoAction(actionAndArgs);
-            e.Handled(true);
-        }
-    }
-
-    // Method Description:
-    // Handles preview key on the SUI tab, by handling close tab / next tab / previous tab
-    // This is a temporary solution - we need to fix all key-bindings work from SUI as long as they don't harm
-    // the SUI behavior
-    // Arguments:
-    // - e: the KeyRoutedEventArgs containing info about the keystroke.
-    // Return Value:
-    // - <none>
-    void TerminalPage::_SUIPreviewKeyDownHandler(Windows::Foundation::IInspectable const& /*sender*/, Windows::UI::Xaml::Input::KeyRoutedEventArgs const& e)
-    {
-        auto key = e.OriginalKey();
-        auto const ctrlDown = WI_IsFlagSet(CoreWindow::GetForCurrentThread().GetKeyState(winrt::Windows::System::VirtualKey::Control), CoreVirtualKeyStates::Down);
-        auto const altDown = WI_IsFlagSet(CoreWindow::GetForCurrentThread().GetKeyState(winrt::Windows::System::VirtualKey::Menu), CoreVirtualKeyStates::Down);
-        auto const shiftDown = WI_IsFlagSet(CoreWindow::GetForCurrentThread().GetKeyState(winrt::Windows::System::VirtualKey::Shift), CoreVirtualKeyStates::Down);
-
-        winrt::Microsoft::Terminal::TerminalControl::KeyChord kc{ ctrlDown, altDown, shiftDown, static_cast<int32_t>(key) };
-        const auto actionAndArgs = _settings.KeyMap().TryLookup(kc);
-        if (actionAndArgs && (actionAndArgs.Action() == ShortcutAction::CloseTab || actionAndArgs.Action() == ShortcutAction::NextTab || actionAndArgs.Action() == ShortcutAction::PrevTab || actionAndArgs.Action() == ShortcutAction::ClosePane))
-        {
-            _actionDispatch->DoAction(actionAndArgs);
-            e.Handled(true);
-        }
-    }
-
     // Method Description:
     // - Configure the AppKeyBindings to use our ShortcutActionDispatch and the updated KeyMapping
     // as the object to handle dispatching ShortcutAction events.
@@ -1080,7 +1004,8 @@ namespace winrt::TerminalApp::implementation
     {
         auto newTabTitle = tab.Title();
 
-        if (_settings.GlobalSettings().ShowTitleInTitlebar() && tab == _GetFocusedTab())
+        if (_settings.GlobalSettings().ShowTitleInTitlebar() &&
+            tab.FocusState() != FocusState::Unfocused)
         {
             _titleChangeHandlers(*this, newTabTitle);
         }
@@ -1140,38 +1065,34 @@ namespace winrt::TerminalApp::implementation
     // - Duplicates the current focused tab
     void TerminalPage::_DuplicateTabViewItem()
     {
-        if (const auto terminalTab{ _GetFocusedTabImpl() })
+        if (auto index{ _GetFocusedTabIndex() })
         {
-            try
+            if (auto terminalTab = _GetTerminalTabImpl(_tabs.GetAt(*index)))
             {
-                // TODO: GH#5047 - In the future, we should get the Profile of
-                // the focused pane, and use that to build a new instance of the
-                // settings so we can duplicate this tab/pane.
-                //
-                // Currently, if the profile doesn't exist anymore in our
-                // settings, we'll silently do nothing.
-                //
-                // In the future, it will be preferable to just duplicate the
-                // current control's settings, but we can't do that currently,
-                // because we won't be able to create a new instance of the
-                // connection without keeping an instance of the original Profile
-                // object around.
-
-                const auto& profileGuid = terminalTab->GetFocusedProfile();
-                if (profileGuid.has_value())
+                try
                 {
-                    const auto settings{ winrt::make<TerminalSettings>(_settings, profileGuid.value(), *_bindings) };
-                    const auto workingDirectory = terminalTab->GetActiveTerminalControl().WorkingDirectory();
-                    const auto validWorkingDirectory = !workingDirectory.empty();
-                    if (validWorkingDirectory)
-                    {
-                        settings.StartingDirectory(workingDirectory);
-                    }
+                    // TODO: GH#5047 - In the future, we should get the Profile of
+                    // the focused pane, and use that to build a new instance of the
+                    // settings so we can duplicate this tab/pane.
+                    //
+                    // Currently, if the profile doesn't exist anymore in our
+                    // settings, we'll silently do nothing.
+                    //
+                    // In the future, it will be preferable to just duplicate the
+                    // current control's settings, but we can't do that currently,
+                    // because we won't be able to create a new instance of the
+                    // connection without keeping an instance of the original Profile
+                    // object around.
 
-                    _CreateNewTabFromSettings(profileGuid.value(), settings);
+                    const auto& profileGuid = terminalTab->GetFocusedProfile();
+                    if (profileGuid.has_value())
+                    {
+                        const auto settings{ winrt::make<TerminalSettings>(_settings, profileGuid.value(), *_bindings) };
+                        _CreateNewTabFromSettings(profileGuid.value(), settings);
+                    }
                 }
+                CATCH_LOG();
             }
-            CATCH_LOG();
         }
     }
 
@@ -1196,13 +1117,6 @@ namespace winrt::TerminalApp::implementation
     // - tabIndex: the index of the tab to be removed
     void TerminalPage::_RemoveTabViewItemByIndex(uint32_t tabIndex)
     {
-        // We use _removing flag to suppress _OnTabSelectionChanged events
-        // that might get triggered while removing
-        _removing = true;
-        auto unsetRemoving = wil::scope_exit([&]() noexcept { _removing = false; });
-
-        const auto focusedTabIndex{ _GetFocusedTabIndex() };
-
         // Removing the tab from the collection should destroy its control and disconnect its connection,
         // but it doesn't always do so. The UI tree may still be holding the control and preventing its destruction.
         auto tab{ _tabs.GetAt(tabIndex) };
@@ -1223,51 +1137,43 @@ namespace winrt::TerminalApp::implementation
         {
             _lastTabClosedHandlers(*this, nullptr);
         }
-        else if (focusedTabIndex.has_value() && focusedTabIndex.value() == gsl::narrow_cast<uint32_t>(tabIndex))
+        else if (_isFullscreen || _rearranging || _isInFocusMode)
         {
-            // Manually select the new tab to get focus, rather than relying on TabView since:
-            // 1. We want to customize this behavior (e.g., use MRU logic)
-            // 2. In fullscreen (GH#5799) and focus (GH#7916) modes the _OnTabItemsChanged is not fired
-            // 3. When rearranging tabs (GH#7916) _OnTabItemsChanged is suppressed
-            const auto tabSwitchMode = _settings.GlobalSettings().TabSwitcherMode();
+            // GH#5799 - If we're fullscreen, the TabView isn't visible. If it's
+            // not Visible, it's _not_ going to raise a SelectionChanged event,
+            // which is what we usually use to focus another tab. Instead, we'll
+            // have to do it manually here.
+            //
+            // GH#7916 - Similarly, TabView isn't visible in focus mode.
+            // We need to focus another tab manually from the same considerations as above.
+            //
+            // GH#5559 Similarly, we suppress _OnTabItemsChanged events during a
+            // rearrange, so if a tab is closed while we're rearranging tabs, do
+            // this manually.
+            //
+            // We can't use
+            //   auto selectedIndex = _tabView.SelectedIndex();
+            // Because this will always return -1 in this scenario unfortunately.
+            //
+            // So, what we're going to try to do is move the focus to the tab
+            // to the left, within the bounds of how many tabs we have.
+            //
+            // EX: we have 4 tabs: [A, B, C, D]. If we close:
+            // * A (tabIndex=0): We'll want to focus tab B (now in index 0)
+            // * B (tabIndex=1): We'll want to focus tab A (now in index 0)
+            // * C (tabIndex=2): We'll want to focus tab B (now in index 1)
+            // * D (tabIndex=3): We'll want to focus tab C (now in index 2)
+            const auto newSelectedIndex = std::clamp<int32_t>(tabIndex - 1, 0, _tabs.Size());
+            // _UpdatedSelectedTab will do the work of setting up the new tab as
+            // the focused one, and unfocusing all the others.
+            _UpdatedSelectedTab(newSelectedIndex);
 
-            if (tabSwitchMode == TabSwitcherMode::MostRecentlyUsed)
-            {
-                const auto newSelectedTab = _mruTabs.GetAt(0);
-
-                uint32_t newSelectedIndex;
-                if (_tabs.IndexOf(newSelectedTab, newSelectedIndex))
-                {
-                    _UpdatedSelectedTab(newSelectedIndex);
-                    _tabView.SelectedItem(newSelectedTab.TabViewItem());
-                }
-            }
-            else
-            {
-                // We can't use
-                //   auto selectedIndex = _tabView.SelectedIndex();
-                // Because this will always return -1 in this scenario unfortunately.
-                //
-                // So, what we're going to try to do is move the focus to the tab
-                // to the left, within the bounds of how many tabs we have.
-                //
-                // EX: we have 4 tabs: [A, B, C, D]. If we close:
-                // * A (tabIndex=0): We'll want to focus tab B (now in index 0)
-                // * B (tabIndex=1): We'll want to focus tab A (now in index 0)
-                // * C (tabIndex=2): We'll want to focus tab B (now in index 1)
-                // * D (tabIndex=3): We'll want to focus tab C (now in index 2)
-                const auto newSelectedIndex = std::clamp<int32_t>(tabIndex - 1, 0, _tabs.Size());
-                // _UpdatedSelectedTab will do the work of setting up the new tab as
-                // the focused one, and unfocusing all the others.
-                _UpdatedSelectedTab(newSelectedIndex);
-
-                // Also, we need to _manually_ set the SelectedItem of the tabView
-                // here. If we don't, then the TabView will technically not have a
-                // selected item at all, which can make things like ClosePane not
-                // work correctly.
-                auto newSelectedTab{ _tabs.GetAt(newSelectedIndex) };
-                _tabView.SelectedItem(newSelectedTab.TabViewItem());
-            }
+            // Also, we need to _manually_ set the SelectedItem of the tabView
+            // here. If we don't, then the TabView will technically not have a
+            // selected item at all, which can make things like ClosePane not
+            // work correctly.
+            auto newSelectedTab{ _tabs.GetAt(newSelectedIndex) };
+            _tabView.SelectedItem(newSelectedTab.TabViewItem());
         }
 
         // GH#5559 - If we were in the middle of a drag/drop, end it by clearing
@@ -1305,9 +1211,6 @@ namespace winrt::TerminalApp::implementation
         // Add an event handler for when the terminal wants to set a progress indicator on the taskbar
         term.SetTaskbarProgress({ this, &TerminalPage::_SetTaskbarProgressHandler });
 
-        term.HidePointerCursor({ this, &TerminalPage::_HidePointerCursorHandler });
-        term.RestorePointerCursor({ this, &TerminalPage::_RestorePointerCursorHandler });
-
         // Bind Tab events to the TermControl and the Tab's Pane
         hostingTab.Initialize(term);
 
@@ -1371,27 +1274,57 @@ namespace winrt::TerminalApp::implementation
     // - Sets focus to the tab to the right or left the currently selected tab.
     void TerminalPage::_SelectNextTab(const bool bMoveRight)
     {
-        const auto index{ _GetFocusedTabIndex().value_or(0) };
-        const auto tabSwitchMode = _settings.GlobalSettings().TabSwitcherMode();
-        if (tabSwitchMode == TabSwitcherMode::Disabled)
+        if (CommandPalette().Visibility() == Visibility::Visible)
         {
-            uint32_t tabCount = _tabs.Size();
-            // Wraparound math. By adding tabCount and then calculating
-            // modulo tabCount, we clamp the values to the range [0,
-            // tabCount) while still supporting moving leftward from 0 to
-            // tabCount - 1.
-            const auto newTabIndex = ((tabCount + index + (bMoveRight ? 1 : -1)) % tabCount);
-            _SelectTab(newTabIndex);
+            // If the tab switcher is currently open, don't change its mode.
+            // Just select the new tab.
+            CommandPalette().SelectNextItem(bMoveRight);
+            return;
+        }
+
+        const auto tabSwitchMode = _settings.GlobalSettings().TabSwitcherMode();
+        const bool useInOrderTabIndex = tabSwitchMode != TabSwitcherMode::MostRecentlyUsed;
+
+        // First, determine what the index of the newly selected tab should be.
+        // This changes if we're doing an in-order traversal vs a MRU traversal.
+        auto newTabIndex = 0;
+        if (useInOrderTabIndex)
+        {
+            // Determine what the next in-order tab index is
+            if (auto index{ _GetFocusedTabIndex() })
+            {
+                uint32_t tabCount = _tabs.Size();
+                // Wraparound math. By adding tabCount and then calculating
+                // modulo tabCount, we clamp the values to the range [0,
+                // tabCount) while still supporting moving leftward from 0 to
+                // tabCount - 1.
+                newTabIndex = ((tabCount + *index + (bMoveRight ? 1 : -1)) % tabCount);
+            }
         }
         else
         {
-            CommandPalette().SetTabs(_tabs, _mruTabs);
+            // Determine what the next "most recently used" index is.
+            // In this case, our focused tab index (in the MRU ordering) is
+            // always 0. So, going next should go to index 1, and going prev
+            // should wrap to the end.
+            uint32_t tabCount = _mruTabs.Size();
+            newTabIndex = ((tabCount + (bMoveRight ? 1 : -1)) % tabCount);
+        }
+
+        const bool useTabSwitcher = tabSwitchMode != TabSwitcherMode::Disabled;
+
+        if (useTabSwitcher)
+        {
+            CommandPalette().SetTabs(useInOrderTabIndex ? _tabs : _mruTabs, true);
 
             // Otherwise, set up the tab switcher in the selected mode, with
             // the given ordering, and make it visible.
-            CommandPalette().EnableTabSwitcherMode(index, tabSwitchMode);
+            CommandPalette().EnableTabSwitcherMode(false, newTabIndex);
             CommandPalette().Visibility(Visibility::Visible);
-            CommandPalette().SelectNextItem(bMoveRight);
+        }
+        else if (auto index{ _GetFocusedTabIndex() })
+        {
+            _SelectTab(newTabIndex);
         }
     }
 
@@ -1440,17 +1373,20 @@ namespace winrt::TerminalApp::implementation
     // - <none>
     void TerminalPage::_UnZoomIfNeeded()
     {
-        if (const auto activeTab{ _GetFocusedTabImpl() })
+        if (auto focusedTab = _GetFocusedTab())
         {
-            if (activeTab->IsZoomed())
+            if (auto activeTab = _GetTerminalTabImpl(focusedTab))
             {
-                // Remove the content from the tab first, so Pane::UnZoom can
-                // re-attach the content to the tree w/in the pane
-                _tabContent.Children().Clear();
-                // In ExitZoom, we'll change the Tab's Content(), triggering the
-                // content changed event, which will re-attach the tab's new content
-                // root to the tree.
-                activeTab->ExitZoom();
+                if (activeTab->IsZoomed())
+                {
+                    // Remove the content from the tab first, so Pane::UnZoom can
+                    // re-attach the content to the tree w/in the pane
+                    _tabContent.Children().Clear();
+                    // In ExitZoom, we'll change the Tab's Content(), triggering the
+                    // content changed event, which will re-attach the tab's new content
+                    // root to the tree.
+                    activeTab->ExitZoom();
+                }
             }
         }
     }
@@ -1465,18 +1401,24 @@ namespace winrt::TerminalApp::implementation
     // - <none>
     void TerminalPage::_MoveFocus(const FocusDirection& direction)
     {
-        if (const auto terminalTab{ _GetFocusedTabImpl() })
+        if (auto index{ _GetFocusedTabIndex() })
         {
-            _UnZoomIfNeeded();
-            terminalTab->NavigateFocus(direction);
+            if (auto terminalTab = _GetTerminalTabImpl(_tabs.GetAt(*index)))
+            {
+                _UnZoomIfNeeded();
+                terminalTab->NavigateFocus(direction);
+            }
         }
     }
 
     TermControl TerminalPage::_GetActiveControl()
     {
-        if (const auto terminalTab{ _GetFocusedTabImpl() })
+        if (auto index{ _GetFocusedTabIndex() })
         {
-            return terminalTab->GetActiveTerminalControl();
+            if (auto terminalTab = _GetTerminalTabImpl(_tabs.GetAt(*index)))
+            {
+                return terminalTab->GetActiveTerminalControl();
+            }
         }
         return nullptr;
     }
@@ -1501,7 +1443,7 @@ namespace winrt::TerminalApp::implementation
     // Method Description:
     // - returns a com_ptr to the currently focused tab. This might return null,
     //   so make sure to check the result!
-    winrt::TerminalApp::TabBase TerminalPage::_GetFocusedTab() const noexcept
+    winrt::TerminalApp::TabBase TerminalPage::_GetFocusedTab()
     {
         if (auto index{ _GetFocusedTabIndex() })
         {
@@ -1510,18 +1452,6 @@ namespace winrt::TerminalApp::implementation
         return nullptr;
     }
 
-    // Method Description:
-    // - returns a com_ptr to the currently focused tab implementation. This might return null,
-    //   so make sure to check the result!
-    winrt::com_ptr<TerminalTab> TerminalPage::_GetFocusedTabImpl() const noexcept
-    {
-        if (auto tab{ _GetFocusedTab() })
-        {
-            return _GetTerminalTabImpl(tab);
-        }
-        return nullptr;
-    }
-
     // Method Description:
     // - An async method for changing the focused tab on the UI thread. This
     //   method will _only_ set the selected item of the TabView, which will
@@ -1563,16 +1493,12 @@ namespace winrt::TerminalApp::implementation
     //   tab's Closed event.
     void TerminalPage::_CloseFocusedPane()
     {
-        if (const auto terminalTab{ _GetFocusedTabImpl() })
+        if (auto index{ _GetFocusedTabIndex() })
         {
-            _UnZoomIfNeeded();
-            terminalTab->ClosePane();
-        }
-        else if (auto index{ _GetFocusedTabIndex() })
-        {
-            if (_tabs.GetAt(*index).try_as<TerminalApp::SettingsTab>())
+            if (auto terminalTab = _GetTerminalTabImpl(_tabs.GetAt(*index)))
             {
-                _RemoveTabViewItemByIndex(*index);
+                _UnZoomIfNeeded();
+                terminalTab->ClosePane();
             }
         }
     }
@@ -1616,23 +1542,26 @@ namespace winrt::TerminalApp::implementation
     // - rowsToScroll: a number of lines to move the viewport. If not provided we will use a system default.
     void TerminalPage::_Scroll(ScrollDirection scrollDirection, const Windows::Foundation::IReference<uint32_t>& rowsToScroll)
     {
-        if (const auto terminalTab{ _GetFocusedTabImpl() })
+        if (auto index{ _GetFocusedTabIndex() })
         {
-            uint32_t realRowsToScroll;
-            if (rowsToScroll == nullptr)
+            if (auto terminalTab = _GetTerminalTabImpl(_tabs.GetAt(*index)))
             {
-                // The magic value of WHEEL_PAGESCROLL indicates that we need to scroll the entire page
-                realRowsToScroll = _systemRowsToScroll == WHEEL_PAGESCROLL ?
-                                       terminalTab->GetActiveTerminalControl().GetViewHeight() :
-                                       _systemRowsToScroll;
+                uint32_t realRowsToScroll;
+                if (rowsToScroll == nullptr)
+                {
+                    // The magic value of WHEEL_PAGESCROLL indicates that we need to scroll the entire page
+                    realRowsToScroll = _systemRowsToScroll == WHEEL_PAGESCROLL ?
+                                           terminalTab->GetActiveTerminalControl().GetViewHeight() :
+                                           _systemRowsToScroll;
+                }
+                else
+                {
+                    // use the custom value specified in the command
+                    realRowsToScroll = rowsToScroll.Value();
+                }
+                auto scrollDelta = _ComputeScrollDelta(scrollDirection, realRowsToScroll);
+                terminalTab->Scroll(scrollDelta);
             }
-            else
-            {
-                // use the custom value specified in the command
-                realRowsToScroll = rowsToScroll.Value();
-            }
-            auto scrollDelta = _ComputeScrollDelta(scrollDirection, realRowsToScroll);
-            terminalTab->Scroll(scrollDelta);
         }
     }
 
@@ -1649,7 +1578,6 @@ namespace winrt::TerminalApp::implementation
     //   configurations. See CascadiaSettings::BuildSettings for more details.
     void TerminalPage::_SplitPane(const SplitState splitType,
                                   const SplitType splitMode,
-                                  const float splitSize,
                                   const NewTerminalArgs& newTerminalArgs)
     {
         // Do nothing if we're requesting no split.
@@ -1658,9 +1586,17 @@ namespace winrt::TerminalApp::implementation
             return;
         }
 
-        const auto focusedTab{ _GetFocusedTabImpl() };
+        auto indexOpt = _GetFocusedTabIndex();
 
-        // Do nothing if no TerminalTab is focused
+        // Do nothing if for some reason, there's no tab in focus. We don't want to crash.
+        if (!indexOpt)
+        {
+            return;
+        }
+
+        auto focusedTab = _GetTerminalTabImpl(_tabs.GetAt(*indexOpt));
+
+        // Do nothing if the focused tab isn't a TerminalTab
         if (!focusedTab)
         {
             return;
@@ -1679,12 +1615,6 @@ namespace winrt::TerminalApp::implementation
                 {
                     profileFound = true;
                     controlSettings = { winrt::make<TerminalSettings>(_settings, current_guid.value(), *_bindings) };
-                    const auto workingDirectory = focusedTab->GetActiveTerminalControl().WorkingDirectory();
-                    const auto validWorkingDirectory = !workingDirectory.empty();
-                    if (validWorkingDirectory)
-                    {
-                        controlSettings.StartingDirectory(workingDirectory);
-                    }
                     realGuid = current_guid.value();
                 }
                 // TODO: GH#5047 - In the future, we should get the Profile of
@@ -1717,7 +1647,7 @@ namespace winrt::TerminalApp::implementation
                 realSplitType = focusedTab->PreCalculateAutoSplit(availableSpace);
             }
 
-            const auto canSplit = focusedTab->PreCalculateCanSplit(realSplitType, splitSize, availableSpace);
+            const auto canSplit = focusedTab->PreCalculateCanSplit(realSplitType, availableSpace);
             if (!canSplit)
             {
                 return;
@@ -1730,7 +1660,7 @@ namespace winrt::TerminalApp::implementation
 
             _UnZoomIfNeeded();
 
-            focusedTab->SplitPane(realSplitType, splitSize, realGuid, newControl);
+            focusedTab->SplitPane(realSplitType, realGuid, newControl);
         }
         CATCH_LOG();
     }
@@ -1745,10 +1675,13 @@ namespace winrt::TerminalApp::implementation
     // - <none>
     void TerminalPage::_ResizePane(const ResizeDirection& direction)
     {
-        if (const auto terminalTab{ _GetFocusedTabImpl() })
+        if (auto index{ _GetFocusedTabIndex() })
         {
-            _UnZoomIfNeeded();
-            terminalTab->ResizePane(direction);
+            if (auto terminalTab = _GetTerminalTabImpl(_tabs.GetAt(*index)))
+            {
+                _UnZoomIfNeeded();
+                terminalTab->ResizePane(direction);
+            }
         }
     }
 
@@ -1759,8 +1692,14 @@ namespace winrt::TerminalApp::implementation
     // - scrollDirection: ScrollUp will move the viewport up, ScrollDown will move the viewport down
     void TerminalPage::_ScrollPage(ScrollDirection scrollDirection)
     {
-        // Do nothing if for some reason, there's no terminal tab in focus. We don't want to crash.
-        if (const auto terminalTab{ _GetFocusedTabImpl() })
+        auto indexOpt = _GetFocusedTabIndex();
+        // Do nothing if for some reason, there's no tab in focus. We don't want to crash.
+        if (!indexOpt)
+        {
+            return;
+        }
+
+        if (auto terminalTab = _GetTerminalTabImpl(_tabs.GetAt(*indexOpt)))
         {
             const auto control = _GetActiveControl();
             const auto termHeight = control.GetViewHeight();
@@ -1771,10 +1710,13 @@ namespace winrt::TerminalApp::implementation
 
     void TerminalPage::_ScrollToBufferEdge(ScrollDirection scrollDirection)
     {
-        if (const auto terminalTab{ _GetFocusedTabImpl() })
+        if (const auto indexOpt = _GetFocusedTabIndex())
         {
-            auto scrollDelta = _ComputeScrollDelta(scrollDirection, INT_MAX);
-            terminalTab->Scroll(scrollDelta);
+            if (auto terminalTab = _GetTerminalTabImpl(_tabs.GetAt(*indexOpt)))
+            {
+                auto scrollDelta = _ComputeScrollDelta(scrollDirection, INT_MAX);
+                terminalTab->Scroll(scrollDelta);
+            }
         }
     }
 
@@ -1884,9 +1826,12 @@ namespace winrt::TerminalApp::implementation
     {
         if (_settings && _settings.GlobalSettings().SnapToGridOnResize())
         {
-            if (const auto terminalTab{ _GetFocusedTabImpl() })
+            if (auto index{ _GetFocusedTabIndex() })
             {
-                return terminalTab->CalcSnappedDimension(widthOrHeight, dimension);
+                if (auto terminalTab = _GetTerminalTabImpl(_tabs.GetAt(*index)))
+                {
+                    return terminalTab->CalcSnappedDimension(widthOrHeight, dimension);
+                }
             }
         }
         return dimension;
@@ -1982,9 +1927,8 @@ namespace winrt::TerminalApp::implementation
                 }
             }
 
-            const auto isNewLineLambda = [](auto c) { return c == L'\n' || c == L'\r'; };
-            const auto hasNewLine = std::find_if(text.cbegin(), text.cend(), isNewLineLambda) != text.cend();
-            const auto warnMultiLine = hasNewLine && _settings.GlobalSettings().WarnAboutMultiLinePaste();
+            const bool hasNewLine = std::find(text.cbegin(), text.cend(), L'\n') != text.cend();
+            const bool warnMultiLine = hasNewLine && _settings.GlobalSettings().WarnAboutMultiLinePaste();
 
             constexpr const std::size_t minimumSizeForWarning = 1024 * 5; // 5 KiB
             const bool warnLargeText = text.size() > minimumSizeForWarning &&
@@ -1994,13 +1938,6 @@ namespace winrt::TerminalApp::implementation
             {
                 co_await winrt::resume_foreground(Dispatcher());
 
-                // We have to initialize the dialog here to be able to change the text of the text block within it
-                FindName(L"MultiLinePasteDialog").try_as<WUX::Controls::ContentDialog>();
-                ClipboardText().Text(text);
-
-                // The vertical offset on the scrollbar does not reset automatically, so reset it manually
-                ClipboardContentScrollViewer().ScrollToVerticalOffset(0);
-
                 ContentDialogResult warningResult;
                 if (warnMultiLine)
                 {
@@ -2011,9 +1948,6 @@ namespace winrt::TerminalApp::implementation
                     warningResult = co_await _ShowLargePasteWarningDialog();
                 }
 
-                // Clear the clipboard text so it doesn't lie around in memory
-                ClipboardText().Text(L"");
-
                 if (warningResult != ContentDialogResult::Primary)
                 {
                     // user rejected the paste
@@ -2254,7 +2188,7 @@ namespace winrt::TerminalApp::implementation
                 // here, then the user won't be able to navigate the ATS any
                 // longer.
                 //
-                // When the tab switcher is eventually dismissed, the focus will
+                // When the tab swither is eventually dismissed, the focus will
                 // get tossed back to the focused terminal control, so we don't
                 // need to worry about focus getting lost.
                 if (CommandPalette().Visibility() != Visibility::Visible)
@@ -2263,13 +2197,8 @@ namespace winrt::TerminalApp::implementation
                     _UpdateMRUTab(index);
                 }
 
-                tab.TabViewItem().StartBringIntoView();
-
                 // Raise an event that our title changed
-                if (_settings.GlobalSettings().ShowTitleInTitlebar())
-                {
-                    _titleChangeHandlers(*this, tab.Title());
-                }
+                _titleChangeHandlers(*this, tab.Title());
             }
             CATCH_LOG();
         }
@@ -2283,7 +2212,7 @@ namespace winrt::TerminalApp::implementation
     // - eventArgs: the event's constituent arguments
     void TerminalPage::_OnTabSelectionChanged(const IInspectable& sender, const WUX::Controls::SelectionChangedEventArgs& /*eventArgs*/)
     {
-        if (!_rearranging && !_removing)
+        if (!_rearranging)
         {
             auto tabView = sender.as<MUX::Controls::TabView>();
             auto selectedIndex = tabView.SelectedIndex();
@@ -2380,9 +2309,6 @@ namespace winrt::TerminalApp::implementation
             {
                 settingsTab.UpdateSettings(_settings);
             }
-
-            auto tabImpl{ winrt::get_self<TabBase>(tab) };
-            tabImpl->SetKeyMap(_settings.KeyMap());
         }
 
         auto weakThis{ get_weak() };
@@ -2427,7 +2353,7 @@ namespace winrt::TerminalApp::implementation
                                                                 IVectorView<Profile> profiles,
                                                                 IMapView<winrt::hstring, ColorScheme> schemes)
     {
-        IVector<SettingsLoadWarnings> warnings{ winrt::single_threaded_vector<SettingsLoadWarnings>() };
+        IVector<SettingsLoadWarnings> warnings;
 
         std::vector<ColorScheme> sortedSchemes;
         sortedSchemes.reserve(schemes.Size());
@@ -2855,8 +2781,6 @@ namespace winrt::TerminalApp::implementation
                 sui.SetHostingWindow(reinterpret_cast<uint64_t>(*_hostingHwnd));
             }
 
-            sui.PreviewKeyDown({ this, &TerminalPage::_SUIPreviewKeyDownHandler });
-
             sui.OpenJson([weakThis{ get_weak() }](auto&& /*s*/, winrt::Microsoft::Terminal::Settings::Model::SettingsTarget e) {
                 if (auto page{ weakThis.get() })
                 {
@@ -2871,7 +2795,6 @@ namespace winrt::TerminalApp::implementation
             _mruTabs.Append(*newTabImpl);
 
             newTabImpl->SetDispatch(*_actionDispatch);
-            newTabImpl->SetKeyMap(_settings.KeyMap());
 
             // Give the tab its index in the _tabs vector so it can manage its own SwitchToTab command.
             _UpdateTabIndices();
@@ -2914,7 +2837,7 @@ namespace winrt::TerminalApp::implementation
     // Return Value:
     // - If the tab is a TerminalTab, a com_ptr to the implementation type.
     //   If the tab is not a TerminalTab, nullptr
-    winrt::com_ptr<TerminalTab> TerminalPage::_GetTerminalTabImpl(const TerminalApp::TabBase& tab)
+    winrt::com_ptr<TerminalTab> TerminalPage::_GetTerminalTabImpl(const TerminalApp::TabBase& tab) const
     {
         if (auto terminalTab = tab.try_as<TerminalApp::TerminalTab>())
         {
@@ -3074,32 +2997,6 @@ namespace winrt::TerminalApp::implementation
         return text;
     }
 
-    // Method Description:
-    // - Hides cursor if required
-    // Return Value:
-    // - <none>
-    void TerminalPage::_HidePointerCursorHandler(const IInspectable& /*sender*/, const IInspectable& /*eventArgs*/)
-    {
-        if (_shouldMouseVanish && !_isMouseHidden)
-        {
-            CoreWindow::GetForCurrentThread().PointerCursor(nullptr);
-            _isMouseHidden = true;
-        }
-    }
-
-    // Method Description:
-    // - Restores cursor if required
-    // Return Value:
-    // - <none>
-    void TerminalPage::_RestorePointerCursorHandler(const IInspectable& /*sender*/, const IInspectable& /*eventArgs*/)
-    {
-        if (_isMouseHidden)
-        {
-            CoreWindow::GetForCurrentThread().PointerCursor(_defaultPointerCursor);
-            _isMouseHidden = false;
-        }
-    }
-
     // -------------------------------- WinRT Events ---------------------------------
     // Winrt events need a method for adding a callback to the event and removing the callback.
     // These macros will define them both for you.

src/cascadia/TerminalApp/TerminalPage.h

@@ -81,8 +81,6 @@ namespace winrt::TerminalApp::implementation
         void ShowKeyboardServiceWarning();
         winrt::hstring KeyboardServiceDisabledText();
 
-        winrt::fire_and_forget ProcessStartupActions(Windows::Foundation::Collections::IVector<Microsoft::Terminal::Settings::Model::ActionAndArgs> actions, const bool initial);
-
         // -------------------------------- WinRT Events ---------------------------------
         DECLARE_EVENT_WITH_TYPED_EVENT_HANDLER(TitleChanged, _titleChangeHandlers, winrt::Windows::Foundation::IInspectable, winrt::hstring);
         DECLARE_EVENT_WITH_TYPED_EVENT_HANDLER(LastTabClosed, _lastTabClosedHandlers, winrt::Windows::Foundation::IInspectable, winrt::TerminalApp::LastTabClosedEventArgs);
@@ -112,8 +110,8 @@ namespace winrt::TerminalApp::implementation
         Microsoft::Terminal::Settings::Model::CascadiaSettings _settings{ nullptr };
 
         Windows::Foundation::Collections::IObservableVector<TerminalApp::TabBase> _tabs;
-        Windows::Foundation::Collections::IObservableVector<TerminalApp::TabBase> _mruTabs;
-        static winrt::com_ptr<TerminalTab> _GetTerminalTabImpl(const TerminalApp::TabBase& tab);
+        Windows::Foundation::Collections::IVector<TerminalApp::TabBase> _mruTabs;
+        winrt::com_ptr<TerminalTab> _GetTerminalTabImpl(const TerminalApp::TabBase& tab) const;
 
         void _UpdateTabIndices();
 
@@ -126,7 +124,6 @@ namespace winrt::TerminalApp::implementation
         bool _rearranging;
         std::optional<int> _rearrangeFrom;
         std::optional<int> _rearrangeTo;
-        bool _removing{ false };
 
         uint32_t _systemRowsToScroll{ DefaultRowsToScroll };
 
@@ -140,6 +137,7 @@ namespace winrt::TerminalApp::implementation
         StartupState _startupState{ StartupState::NotInitialized };
 
         Windows::Foundation::Collections::IVector<Microsoft::Terminal::Settings::Model::ActionAndArgs> _startupActions;
+        winrt::fire_and_forget _ProcessStartupActions(Windows::Foundation::Collections::IVector<Microsoft::Terminal::Settings::Model::ActionAndArgs> actions, const bool initial);
 
         void _ShowAboutDialog();
         winrt::Windows::Foundation::IAsyncOperation<winrt::Windows::UI::Xaml::Controls::ContentDialogResult> _ShowCloseWarningDialog();
@@ -158,8 +156,6 @@ namespace winrt::TerminalApp::implementation
         void _AboutButtonOnClick(const IInspectable& sender, const Windows::UI::Xaml::RoutedEventArgs& eventArgs);
         void _ThirdPartyNoticesOnClick(const IInspectable& sender, const Windows::UI::Xaml::RoutedEventArgs& eventArgs);
 
-        void _KeyDownHandler(Windows::Foundation::IInspectable const& sender, Windows::UI::Xaml::Input::KeyRoutedEventArgs const& e);
-        void _SUIPreviewKeyDownHandler(Windows::Foundation::IInspectable const& sender, Windows::UI::Xaml::Input::KeyRoutedEventArgs const& e);
         void _HookupKeyBindings(const Microsoft::Terminal::Settings::Model::KeyMapping& keymap) noexcept;
         void _RegisterActionCallbacks();
 
@@ -185,9 +181,7 @@ namespace winrt::TerminalApp::implementation
 
         winrt::Microsoft::Terminal::TerminalControl::TermControl _GetActiveControl();
         std::optional<uint32_t> _GetFocusedTabIndex() const noexcept;
-        TerminalApp::TabBase _GetFocusedTab() const noexcept;
-        winrt::com_ptr<TerminalTab> _GetFocusedTabImpl() const noexcept;
-
+        TerminalApp::TabBase _GetFocusedTab();
         winrt::fire_and_forget _SetFocusedTabIndex(const uint32_t tabIndex);
         void _CloseFocusedTab();
         void _CloseFocusedPane();
@@ -198,13 +192,8 @@ namespace winrt::TerminalApp::implementation
         // Todo: add more event implementations here
         // MSFT:20641986: Add keybindings for New Window
         void _Scroll(ScrollDirection scrollDirection, const Windows::Foundation::IReference<uint32_t>& rowsToScroll);
-
-        void _SplitPane(const Microsoft::Terminal::Settings::Model::SplitState splitType,
-                        const Microsoft::Terminal::Settings::Model::SplitType splitMode = Microsoft::Terminal::Settings::Model::SplitType::Manual,
-                        const float splitSize = 0.5f,
-                        const Microsoft::Terminal::Settings::Model::NewTerminalArgs& newTerminalArgs = nullptr);
+        void _SplitPane(const Microsoft::Terminal::Settings::Model::SplitState splitType, const Microsoft::Terminal::Settings::Model::SplitType splitMode = Microsoft::Terminal::Settings::Model::SplitType::Manual, const Microsoft::Terminal::Settings::Model::NewTerminalArgs& newTerminalArgs = nullptr);
         void _ResizePane(const Microsoft::Terminal::Settings::Model::ResizeDirection& direction);
-
         void _ScrollPage(ScrollDirection scrollDirection);
         void _ScrollToBufferEdge(ScrollDirection scrollDirection);
         void _SetAcceleratorForMenuItem(Windows::UI::Xaml::Controls::MenuFlyoutItem& menuItem, const winrt::Microsoft::Terminal::TerminalControl::KeyChord& keyChord);
@@ -255,19 +244,16 @@ namespace winrt::TerminalApp::implementation
 
         void _OpenSettingsUI();
 
+        void _MakeSwitchToTabCommand(const TerminalApp::TabBase& tab, const uint32_t index);
+
         static int _ComputeScrollDelta(ScrollDirection scrollDirection, const uint32_t rowsToScroll);
         static uint32_t _ReadSystemRowsToScroll();
 
+        void _UpdateTabSwitcherCommands(const bool mru);
         void _UpdateMRUTab(const uint32_t index);
 
         void _TryMoveTab(const uint32_t currentTabIndex, const int32_t suggestedNewTabIndex);
 
-        bool _shouldMouseVanish{ false };
-        bool _isMouseHidden{ false };
-        Windows::UI::Core::CoreCursor _defaultPointerCursor{ nullptr };
-        void _HidePointerCursorHandler(const IInspectable& sender, const IInspectable& eventArgs);
-        void _RestorePointerCursorHandler(const IInspectable& sender, const IInspectable& eventArgs);
-
 #pragma region ActionHandlers
         // These are all defined in AppActionHandlers.cpp
         void _HandleOpenNewTabDropdown(const IInspectable& sender, const Microsoft::Terminal::Settings::Model::ActionEventArgs& args);

src/cascadia/TerminalApp/TerminalPage.xaml

@@ -58,26 +58,6 @@ the MIT License. See LICENSE in the project root for license information. -->
             x:Name="MultiLinePasteDialog"
             x:Uid="MultiLinePasteDialog"
             DefaultButton="Primary">
-            <StackPanel>
-                <TextBlock
-                    x:Uid="MultiLineWarningText"
-                    TextWrapping="Wrap">
-                </TextBlock>
-                <TextBlock
-                    x:Uid="ClipboardTextHeader"
-                    Margin="0,16,0,0">
-                </TextBlock>
-                <ScrollViewer
-                    Margin="0,8,0,0"
-                    x:Name="ClipboardContentScrollViewer"
-                    MaxHeight="100">
-                    <TextBlock
-                        x:Name="ClipboardText"
-                        TextWrapping="Wrap"
-                        FontFamily="Cascadia Mono">
-                    </TextBlock>
-                </ScrollViewer>
-            </StackPanel>
         </ContentDialog>
 
         <ContentDialog
@@ -115,7 +95,6 @@ the MIT License. See LICENSE in the project root for license information. -->
             x:Name="CommandPalette"
             Grid.Row="1"
             Visibility="Collapsed"
-            PreviewKeyDown ="_KeyDownHandler"
             VerticalAlignment="Stretch" />
 
         <mux:InfoBar x:Name="KeyboardWarningInfoBar"

src/cascadia/TerminalApp/TerminalTab.cpp

@@ -50,29 +50,10 @@ namespace winrt::TerminalApp::implementation
                 tab->SetTabText(title);
             }
         });
-
-        _UpdateHeaderControlMaxWidth();
-
         // Use our header control as the TabViewItem's header
         TabViewItem().Header(_headerControl);
     }
 
-    // Method Description:
-    // - Called when the timer for the bell indicator in the tab header fires
-    // - Removes the bell indicator from the tab header
-    // Arguments:
-    // - sender, e: not used
-    void TerminalTab::_BellIndicatorTimerTick(Windows::Foundation::IInspectable const& /*sender*/, Windows::Foundation::IInspectable const& /*e*/)
-    {
-        ShowBellIndicator(false);
-        // Just do a sanity check that the timer still exists before we stop it
-        if (_bellIndicatorTimer.has_value())
-        {
-            _bellIndicatorTimer->Stop();
-            _bellIndicatorTimer = std::nullopt;
-        }
-    }
-
     // Method Description:
     // - Initializes a TabViewItem for this Tab instance.
     // Arguments:
@@ -94,24 +75,11 @@ namespace winrt::TerminalApp::implementation
         _RecalculateAndApplyTabColor();
     }
 
-    winrt::fire_and_forget TerminalTab::_UpdateHeaderControlMaxWidth()
+    void TerminalTab::_SetToolTip(const winrt::hstring& tabTitle)
     {
-        auto weakThis{ get_weak() };
-
-        co_await winrt::resume_foreground(TabViewItem().Dispatcher());
-
-        if (auto tab{ weakThis.get() })
-        {
-            const auto settings{ winrt::TerminalApp::implementation::AppLogic::CurrentAppSettings() };
-            if (settings.GlobalSettings().TabWidthMode() == winrt::Microsoft::UI::Xaml::Controls::TabViewWidthMode::SizeToContent)
-            {
-                tab->_headerControl.RenamerMaxWidth(HeaderRenameBoxWidthTitleLength);
-            }
-            else
-            {
-                tab->_headerControl.RenamerMaxWidth(HeaderRenameBoxWidthDefault);
-            }
-        }
+        WUX::Controls::ToolTip toolTip{};
+        toolTip.Content(winrt::box_value(tabTitle));
+        WUX::Controls::ToolTipService::SetToolTip(TabViewItem(), toolTip);
     }
 
     // Method Description:
@@ -161,11 +129,6 @@ namespace winrt::TerminalApp::implementation
                 lastFocusedControl.Focus(_focusState);
                 lastFocusedControl.TaskbarProgressChanged();
             }
-            // When we gain focus, remove the bell indicator if it is active
-            if (_headerControl.BellIndicator())
-            {
-                ShowBellIndicator(false);
-            }
         }
     }
 
@@ -206,9 +169,6 @@ namespace winrt::TerminalApp::implementation
     void TerminalTab::UpdateSettings(const winrt::TerminalApp::TerminalSettings& settings, const GUID& profile)
     {
         _rootPane->UpdateSettings(settings, profile);
-
-        // The tabWidthMode may have changed, update the header control accordingly
-        _UpdateHeaderControlMaxWidth();
     }
 
     // Method Description:
@@ -259,57 +219,17 @@ namespace winrt::TerminalApp::implementation
 
         if (auto tab{ weakThis.get() })
         {
-            if (tab->_iconHidden != hide)
+            if (hide)
             {
-                if (hide)
-                {
-                    Icon({});
-                    TabViewItem().IconSource(IconPathConverter::IconSourceMUX({}));
-                }
-                else
-                {
-                    Icon(_lastIconPath);
-                    TabViewItem().IconSource(IconPathConverter::IconSourceMUX(_lastIconPath));
-                }
-                tab->_iconHidden = hide;
+                Icon({});
+                TabViewItem().IconSource(IconPathConverter::IconSourceMUX({}));
+                tab->_iconHidden = true;
             }
-        }
-    }
-
-    // Method Description:
-    // - Hide or show the bell indicator in the tab header
-    // Arguments:
-    // - show: if true, we show the indicator; if false, we hide the indicator
-    winrt::fire_and_forget TerminalTab::ShowBellIndicator(const bool show)
-    {
-        auto weakThis{ get_weak() };
-
-        co_await winrt::resume_foreground(TabViewItem().Dispatcher());
-
-        if (auto tab{ weakThis.get() })
-        {
-            tab->_headerControl.BellIndicator(show);
-        }
-    }
-
-    // Method Description:
-    // - Activates the timer for the bell indicator in the tab
-    // - Called if a bell raised when the tab already has focus
-    winrt::fire_and_forget TerminalTab::ActivateBellIndicatorTimer()
-    {
-        auto weakThis{ get_weak() };
-
-        co_await winrt::resume_foreground(TabViewItem().Dispatcher());
-
-        if (auto tab{ weakThis.get() })
-        {
-            if (!tab->_bellIndicatorTimer.has_value())
+            else
             {
-                DispatcherTimer bellIndicatorTimer;
-                bellIndicatorTimer.Interval(std::chrono::milliseconds(2000));
-                bellIndicatorTimer.Tick({ get_weak(), &TerminalTab::_BellIndicatorTimerTick });
-                bellIndicatorTimer.Start();
-                tab->_bellIndicatorTimer.emplace(std::move(bellIndicatorTimer));
+                Icon(_lastIconPath);
+                TabViewItem().IconSource(IconPathConverter::IconSourceMUX(_lastIconPath));
+                tab->_iconHidden = false;
             }
         }
     }
@@ -351,8 +271,7 @@ namespace winrt::TerminalApp::implementation
 
             // Update the control to reflect the changed title
             _headerControl.Title(activeTitle);
-            Automation::AutomationProperties::SetName(tab->TabViewItem(), activeTitle);
-            _UpdateToolTip();
+            _SetToolTip(activeTitle);
         }
     }
 
@@ -371,7 +290,18 @@ namespace winrt::TerminalApp::implementation
         co_await winrt::resume_foreground(control.Dispatcher());
 
         const auto currentOffset = control.GetScrollOffset();
-        control.ScrollViewport(::base::ClampAdd(currentOffset, delta));
+        control.ScrollViewport(currentOffset + delta);
+    }
+
+    // Method Description:
+    // - Determines whether the focused pane has sufficient space to be split.
+    // Arguments:
+    // - splitType: The type of split we want to create.
+    // Return Value:
+    // - True if the focused pane can be split. False otherwise.
+    bool TerminalTab::CanSplitPane(SplitState splitType)
+    {
+        return _activePane->CanSplit(splitType);
     }
 
     // Method Description:
@@ -383,27 +313,14 @@ namespace winrt::TerminalApp::implementation
     // - control: A TermControl to use in the new pane.
     // Return Value:
     // - <none>
-    void TerminalTab::SplitPane(SplitState splitType,
-                                const float splitSize,
-                                const GUID& profile,
-                                TermControl& control)
+    void TerminalTab::SplitPane(SplitState splitType, const GUID& profile, TermControl& control)
     {
         // Make sure to take the ID before calling Split() - Split() will clear out the active pane's ID
         const auto activePaneId = _activePane->Id();
-        auto [first, second] = _activePane->Split(splitType, splitSize, profile, control);
-        if (activePaneId)
-        {
-            first->Id(activePaneId.value());
-            second->Id(_nextPaneId);
-            ++_nextPaneId;
-        }
-        else
-        {
-            first->Id(_nextPaneId);
-            ++_nextPaneId;
-            second->Id(_nextPaneId);
-            ++_nextPaneId;
-        }
+        auto [first, second] = _activePane->Split(splitType, profile, control);
+        first->Id(activePaneId);
+        second->Id(_nextPaneId);
+        ++_nextPaneId;
         _activePane = first;
         _AttachEventHandlersToControl(control);
 
@@ -621,18 +538,16 @@ namespace winrt::TerminalApp::implementation
 
         // We need to move the pane to the top of our mru list
         // If its already somewhere in the list, remove it first
-        if (const auto paneId = pane->Id())
+        const auto paneId = pane->Id();
+        for (auto i = _mruPanes.begin(); i != _mruPanes.end(); ++i)
         {
-            for (auto i = _mruPanes.begin(); i != _mruPanes.end(); ++i)
+            if (*i == paneId)
             {
-                if (*i == paneId.value())
-                {
-                    _mruPanes.erase(i);
-                    break;
-                }
+                _mruPanes.erase(i);
+                break;
             }
-            _mruPanes.insert(_mruPanes.begin(), paneId.value());
         }
+        _mruPanes.insert(_mruPanes.begin(), paneId);
         // Raise our own ActivePaneChanged event.
         _ActivePaneChangedHandlers();
     }
@@ -655,30 +570,10 @@ namespace winrt::TerminalApp::implementation
             // Do nothing if the Tab's lifetime is expired or pane isn't new.
             auto tab{ weakThis.get() };
 
-            if (tab)
+            if (tab && sender != tab->_activePane)
             {
-                if (sender != tab->_activePane)
-                {
-                    tab->_UpdateActivePane(sender);
-                    tab->_RecalculateAndApplyTabColor();
-                }
-                tab->_focusState = WUX::FocusState::Programmatic;
-                // This tab has gained focus, remove the bell indicator if it is active
-                if (tab->_headerControl.BellIndicator())
-                {
-                    tab->ShowBellIndicator(false);
-                }
-            }
-        });
-
-        pane->LostFocus([weakThis](std::shared_ptr<Pane> /*sender*/) {
-            // Do nothing if the Tab's lifetime is expired or pane isn't new.
-            auto tab{ weakThis.get() };
-
-            if (tab)
-            {
-                // update this tab's focus state
-                tab->_focusState = WUX::FocusState::Unfocused;
+                tab->_UpdateActivePane(sender);
+                tab->_RecalculateAndApplyTabColor();
             }
         });
 
@@ -709,27 +604,13 @@ namespace winrt::TerminalApp::implementation
             }
         });
 
-        // Add a PaneRaiseBell event handler to the Pane
-        pane->PaneRaiseBell([weakThis](auto&& /*s*/, auto&& visual) {
+        // Add a PaneRaiseVisualBell event handler to the Pane. When the pane emits this event,
+        // we need to bubble it all the way to app host. In this part of the chain we bubble it
+        // from the hosting tab to the page.
+        pane->PaneRaiseVisualBell([weakThis](auto&& /*s*/) {
             if (auto tab{ weakThis.get() })
             {
-                if (visual)
-                {
-                    // If visual is set, we need to bubble this event all the way to app host to flash the taskbar
-                    // In this part of the chain we bubble it from the hosting tab to the page
-                    tab->_TabRaiseVisualBellHandlers();
-                }
-
-                // Show the bell indicator in the tab header
-                tab->ShowBellIndicator(true);
-
-                // If this tab is focused, activate the bell indicator timer, which will
-                // remove the bell indicator once it fires
-                // (otherwise, the indicator is removed when the tab gets focus)
-                if (tab->_focusState != WUX::FocusState::Unfocused)
-                {
-                    tab->ActivateBellIndicatorTimer();
-                }
+                tab->_TabRaiseVisualBellHandlers();
             }
         });
     }
@@ -814,6 +695,7 @@ namespace winrt::TerminalApp::implementation
         newTabFlyout.Items().Append(chooseColorMenuItem);
         newTabFlyout.Items().Append(renameTabMenuItem);
         newTabFlyout.Items().Append(menuSeparator);
+        newTabFlyout.Items().Append(_CreateCloseSubMenu());
         newTabFlyout.Items().Append(closeTabMenuItem);
         TabViewItem().ContextFlyout(newTabFlyout);
     }
@@ -1061,11 +943,9 @@ namespace winrt::TerminalApp::implementation
         return _rootPane->PreCalculateAutoSplit(_activePane, availableSpace).value_or(SplitState::Vertical);
     }
 
-    bool TerminalTab::PreCalculateCanSplit(SplitState splitType,
-                                           const float splitSize,
-                                           winrt::Windows::Foundation::Size availableSpace) const
+    bool TerminalTab::PreCalculateCanSplit(SplitState splitType, winrt::Windows::Foundation::Size availableSpace) const
     {
-        return _rootPane->PreCalculateCanSplit(_activePane, splitType, splitSize, availableSpace).value_or(false);
+        return _rootPane->PreCalculateCanSplit(_activePane, splitType, availableSpace).value_or(false);
     }
 
     // Method Description:
@@ -1111,27 +991,6 @@ namespace winrt::TerminalApp::implementation
         return _zoomedPane != nullptr;
     }
 
-    // Method Description:
-    // - Creates a text for the title run in the tool tip by returning tab title
-    // or <profile name>: <tab title> in the case the profile name differs from the title
-    // Arguments:
-    // - <none>
-    // Return Value:
-    // - The value to populate in the title run of the tool tip
-    winrt::hstring TerminalTab::_CreateToolTipTitle()
-    {
-        if (const auto& control{ GetActiveTerminalControl() })
-        {
-            const auto profileName{ control.Settings().ProfileName() };
-            if (profileName != Title())
-            {
-                return fmt::format(L"{}: {}", profileName, Title()).data();
-            }
-        }
-
-        return Title();
-    }
-
     DEFINE_EVENT(TerminalTab, ActivePaneChanged, _ActivePaneChangedHandlers, winrt::delegate<>);
     DEFINE_EVENT(TerminalTab, ColorSelected, _colorSelected, winrt::delegate<winrt::Windows::UI::Color>);
     DEFINE_EVENT(TerminalTab, ColorCleared, _colorCleared, winrt::delegate<>);

src/cascadia/TerminalApp/TerminalTab.h

@@ -7,9 +7,6 @@
 #include "TabBase.h"
 #include "TerminalTab.g.h"
 
-static constexpr double HeaderRenameBoxWidthDefault{ 165 };
-static constexpr double HeaderRenameBoxWidthTitleLength{ std::numeric_limits<double>::infinity() };
-
 // fwdecl unittest classes
 namespace TerminalAppLocalTests
 {
@@ -33,22 +30,15 @@ namespace winrt::TerminalApp::implementation
 
         winrt::fire_and_forget Scroll(const int delta);
 
-        void SplitPane(winrt::Microsoft::Terminal::Settings::Model::SplitState splitType,
-                       const float splitSize,
-                       const GUID& profile,
-                       winrt::Microsoft::Terminal::TerminalControl::TermControl& control);
+        bool CanSplitPane(winrt::Microsoft::Terminal::Settings::Model::SplitState splitType);
+        void SplitPane(winrt::Microsoft::Terminal::Settings::Model::SplitState splitType, const GUID& profile, winrt::Microsoft::Terminal::TerminalControl::TermControl& control);
 
         winrt::fire_and_forget UpdateIcon(const winrt::hstring iconPath);
         winrt::fire_and_forget HideIcon(const bool hide);
 
-        winrt::fire_and_forget ShowBellIndicator(const bool show);
-        winrt::fire_and_forget ActivateBellIndicatorTimer();
-
         float CalcSnappedDimension(const bool widthOrHeight, const float dimension) const;
         winrt::Microsoft::Terminal::Settings::Model::SplitState PreCalculateAutoSplit(winrt::Windows::Foundation::Size rootSize) const;
-        bool PreCalculateCanSplit(winrt::Microsoft::Terminal::Settings::Model::SplitState splitType,
-                                  const float splitSize,
-                                  winrt::Windows::Foundation::Size availableSpace) const;
+        bool PreCalculateCanSplit(winrt::Microsoft::Terminal::Settings::Model::SplitState splitType, winrt::Windows::Foundation::Size availableSpace) const;
 
         void ResizeContent(const winrt::Windows::Foundation::Size& newSize);
         void ResizePane(const winrt::Microsoft::Terminal::Settings::Model::ResizeDirection& direction);
@@ -81,7 +71,6 @@ namespace winrt::TerminalApp::implementation
         DECLARE_EVENT(ColorSelected, _colorSelected, winrt::delegate<winrt::Windows::UI::Color>);
         DECLARE_EVENT(ColorCleared, _colorCleared, winrt::delegate<>);
         DECLARE_EVENT(TabRaiseVisualBell, _TabRaiseVisualBellHandlers, winrt::delegate<>);
-        FORWARDED_TYPED_EVENT(TabRenamerDeactivated, winrt::Windows::Foundation::IInspectable, winrt::Windows::Foundation::IInspectable, (&_headerControl), RenameEnded);
 
     private:
         std::shared_ptr<Pane> _rootPane{ nullptr };
@@ -107,15 +96,11 @@ namespace winrt::TerminalApp::implementation
 
         winrt::TerminalApp::ShortcutActionDispatch _dispatch;
 
-        std::optional<Windows::UI::Xaml::DispatcherTimer> _bellIndicatorTimer;
-        void _BellIndicatorTimerTick(Windows::Foundation::IInspectable const& sender, Windows::Foundation::IInspectable const& e);
-
         void _MakeTabViewItem();
 
-        winrt::fire_and_forget _UpdateHeaderControlMaxWidth();
+        void _SetToolTip(const winrt::hstring& tabTitle);
 
         void _CreateContextMenu() override;
-        virtual winrt::hstring _CreateToolTipTitle() override;
 
         void _RefreshVisualState();
 

src/cascadia/TerminalApp/packages.config

@@ -2,5 +2,5 @@
 <packages>
   <package id="Microsoft.Toolkit.Win32.UI.XamlApplication" version="6.1.2" targetFramework="native" />
   <package id="Microsoft.UI.Xaml" version="2.5.0-prerelease.201202003" targetFramework="native" />
-  <package id="Microsoft.Windows.CppWinRT" version="2.0.210309.3" targetFramework="native" />
+  <package id="Microsoft.Windows.CppWinRT" version="2.0.201017.1" targetFramework="native" />
 </packages>

src/cascadia/TerminalAzBridge/packages.config

@@ -1,4 +1,4 @@
 <?xml version="1.0" encoding="utf-8"?>
 <packages>
-  <package id="Microsoft.Windows.CppWinRT" version="2.0.210309.3" targetFramework="native" />
+  <package id="Microsoft.Windows.CppWinRT" version="2.0.201017.1" targetFramework="native" />
 </packages>

src/cascadia/TerminalConnection/ConptyConnection.cpp

@@ -6,6 +6,7 @@
 #include "ConptyConnection.h"
 
 #include <windows.h>
+#include <userenv.h>
 
 #include "ConptyConnection.g.cpp"
 
@@ -93,8 +94,11 @@ namespace winrt::Microsoft::Terminal::TerminalConnection::implementation
             environment.clear();
         });
 
-        // Populate the environment map with the current environment.
-        RETURN_IF_FAILED(Utils::UpdateEnvironmentMapW(environment));
+        {
+            const auto newEnvironmentBlock{ Utils::CreateEnvironmentBlock() };
+            // Populate the environment map with the current environment.
+            RETURN_IF_FAILED(Utils::UpdateEnvironmentMapW(environment, newEnvironmentBlock.get()));
+        }
 
         {
             // Convert connection Guid to string and ignore the enclosing '{}'.

src/cascadia/TerminalConnection/TerminalConnection.vcxproj

@@ -81,5 +81,6 @@
       <AdditionalDependencies>$(OpenConsoleCommonOutDir)\conptylib.lib;%(AdditionalDependencies)</AdditionalDependencies>
     </Link>
   </ItemDefinitionGroup>
+
   <Import Project="$(SolutionDir)build\rules\CollectWildcardResources.targets" />
 </Project>

src/cascadia/TerminalConnection/packages.config

@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
 <packages>
-  <package id="Microsoft.Windows.CppWinRT" version="2.0.210309.3" targetFramework="native" />
+  <package id="Microsoft.Windows.CppWinRT" version="2.0.201017.1" targetFramework="native" />
   <package id="vcpkg-cpprestsdk" version="2.10.14" targetFramework="native" />
 </packages>

src/cascadia/TerminalControl/TermControl.cpp

@@ -78,7 +78,6 @@ namespace winrt::Microsoft::Terminal::TerminalControl::implementation
         _blinkTimer{},
         _lastMouseClickTimestamp{},
         _lastMouseClickPos{},
-        _lastMouseClickPosNoSelection{},
         _selectionNeedsToBeCopied{ false },
         _searchBox{ nullptr }
     {
@@ -87,9 +86,6 @@ namespace winrt::Microsoft::Terminal::TerminalControl::implementation
 
         _terminal = std::make_unique<::Microsoft::Terminal::Core::Terminal>();
 
-        // GH#8969: pre-seed working directory to prevent potential races
-        _terminal->SetWorkingDirectory(_settings.StartingDirectory());
-
         auto pfnWarningBell = std::bind(&TermControl::_TerminalWarningBell, this);
         _terminal->SetWarningBellCallback(pfnWarningBell);
 
@@ -192,7 +188,7 @@ namespace winrt::Microsoft::Terminal::TerminalControl::implementation
         _autoScrollTimer.Interval(AutoScrollUpdateInterval);
         _autoScrollTimer.Tick({ this, &TermControl::_UpdateAutoScroll });
 
-        _ApplyUISettings(_settings);
+        _ApplyUISettings();
     }
 
     // Method Description:
@@ -278,73 +274,6 @@ namespace winrt::Microsoft::Terminal::TerminalControl::implementation
         this->Focus(FocusState::Programmatic);
     }
 
-    // Method Description:
-    // - Given new settings for this profile, applies the settings to the current terminal.
-    // - This method is separate from UpdateSettings because there is an apparent optimizer
-    //   issue that causes one of our hstring -> wstring_view conversions to result in garbage,
-    //   but only from a coroutine context. See GH#8723.
-    // - INVARIANT: This method must be called from the UI thread.
-    // Arguments:
-    // - newSettings: New settings values for the profile in this terminal.
-    // Return Value:
-    // - <none>
-    void TermControl::_UpdateSettingsOnUIThread(const IControlSettings& newSettings)
-    {
-        if (_closing)
-        {
-            return;
-        }
-
-        auto lock = _terminal->LockForWriting();
-
-        // First, store the new settings in the instance.
-        _settings = newSettings;
-
-        // Update our control settings
-        _ApplyUISettings(_settings);
-
-        // Update the terminal core with its new Core settings
-        _terminal->UpdateSettings(_settings);
-
-        if (!_initializedTerminal)
-        {
-            // If we haven't initialized, there's no point in continuing.
-            // Initialization will handle the renderer settings.
-            return;
-        }
-
-        // Update DxEngine settings under the lock
-        _renderEngine->SetSelectionBackground(_settings.SelectionBackground());
-
-        _renderEngine->SetRetroTerminalEffect(_settings.RetroTerminalEffect());
-        _renderEngine->SetPixelShaderPath(_settings.PixelShaderPath());
-        _renderEngine->SetForceFullRepaintRendering(_settings.ForceFullRepaintRendering());
-        _renderEngine->SetSoftwareRendering(_settings.SoftwareRendering());
-
-        switch (_settings.AntialiasingMode())
-        {
-        case TextAntialiasingMode::Cleartype:
-            _renderEngine->SetAntialiasingMode(D2D1_TEXT_ANTIALIAS_MODE_CLEARTYPE);
-            break;
-        case TextAntialiasingMode::Aliased:
-            _renderEngine->SetAntialiasingMode(D2D1_TEXT_ANTIALIAS_MODE_ALIASED);
-            break;
-        case TextAntialiasingMode::Grayscale:
-        default:
-            _renderEngine->SetAntialiasingMode(D2D1_TEXT_ANTIALIAS_MODE_GRAYSCALE);
-            break;
-        }
-
-        // Refresh our font with the renderer
-        const auto actualFontOldSize = _actualFont.GetSize();
-        _UpdateFont();
-        const auto actualFontNewSize = _actualFont.GetSize();
-        if (actualFontNewSize != actualFontOldSize)
-        {
-            _RefreshSizeUnderLock();
-        }
-    }
-
     // Method Description:
     // - Given new settings for this profile, applies the settings to the current terminal.
     // Arguments:
@@ -353,6 +282,7 @@ namespace winrt::Microsoft::Terminal::TerminalControl::implementation
     // - <none>
     winrt::fire_and_forget TermControl::UpdateSettings(IControlSettings newSettings)
     {
+        _settings = newSettings;
         auto weakThis{ get_weak() };
 
         // Dispatch a call to the UI thread to apply the new settings to the
@@ -362,7 +292,49 @@ namespace winrt::Microsoft::Terminal::TerminalControl::implementation
         // If 'weakThis' is locked, then we can safely work with 'this'
         if (auto control{ weakThis.get() })
         {
-            _UpdateSettingsOnUIThread(newSettings);
+            if (_closing)
+            {
+                co_return;
+            }
+
+            // Update our control settings
+            _ApplyUISettings();
+
+            // Update the terminal core with its new Core settings
+            _terminal->UpdateSettings(_settings);
+
+            auto lock = _terminal->LockForWriting();
+
+            // Update DxEngine settings under the lock
+            _renderEngine->SetSelectionBackground(_settings.SelectionBackground());
+
+            _renderEngine->SetRetroTerminalEffect(_settings.RetroTerminalEffect());
+            _renderEngine->SetPixelShaderPath(_settings.PixelShaderPath());
+            _renderEngine->SetForceFullRepaintRendering(_settings.ForceFullRepaintRendering());
+            _renderEngine->SetSoftwareRendering(_settings.SoftwareRendering());
+
+            switch (_settings.AntialiasingMode())
+            {
+            case TextAntialiasingMode::Cleartype:
+                _renderEngine->SetAntialiasingMode(D2D1_TEXT_ANTIALIAS_MODE_CLEARTYPE);
+                break;
+            case TextAntialiasingMode::Aliased:
+                _renderEngine->SetAntialiasingMode(D2D1_TEXT_ANTIALIAS_MODE_ALIASED);
+                break;
+            case TextAntialiasingMode::Grayscale:
+            default:
+                _renderEngine->SetAntialiasingMode(D2D1_TEXT_ANTIALIAS_MODE_GRAYSCALE);
+                break;
+            }
+
+            // Refresh our font with the renderer
+            const auto actualFontOldSize = _actualFont.GetSize();
+            _UpdateFont();
+            const auto actualFontNewSize = _actualFont.GetSize();
+            if (actualFontNewSize != actualFontOldSize)
+            {
+                _RefreshSizeUnderLock();
+            }
         }
     }
 
@@ -412,21 +384,21 @@ namespace winrt::Microsoft::Terminal::TerminalControl::implementation
     // - <none>
     // Return Value:
     // - <none>
-    void TermControl::_ApplyUISettings(const IControlSettings& newSettings)
+    void TermControl::_ApplyUISettings()
     {
         _InitializeBackgroundBrush();
 
-        COLORREF bg = newSettings.DefaultBackground();
+        COLORREF bg = _settings.DefaultBackground();
         _BackgroundColorChanged(bg);
 
         // Apply padding as swapChainPanel's margin
-        auto newMargin = _ParseThicknessFromPadding(newSettings.Padding());
+        auto newMargin = _ParseThicknessFromPadding(_settings.Padding());
         SwapChainPanel().Margin(newMargin);
 
         // Initialize our font information.
-        const auto fontFace = newSettings.FontFace();
-        const short fontHeight = gsl::narrow_cast<short>(newSettings.FontSize());
-        const auto fontWeight = newSettings.FontWeight();
+        const auto fontFace = _settings.FontFace();
+        const short fontHeight = gsl::narrow_cast<short>(_settings.FontSize());
+        const auto fontWeight = _settings.FontWeight();
         // The font width doesn't terribly matter, we'll only be using the
         //      height to look it up
         // The other params here also largely don't matter.
@@ -438,12 +410,12 @@ namespace winrt::Microsoft::Terminal::TerminalControl::implementation
 
         // set TSF Foreground
         Media::SolidColorBrush foregroundBrush{};
-        foregroundBrush.Color(static_cast<til::color>(newSettings.DefaultForeground()));
+        foregroundBrush.Color(static_cast<til::color>(_settings.DefaultForeground()));
         TSFInputControl().Foreground(foregroundBrush);
         TSFInputControl().Margin(newMargin);
 
         // Apply settings for scrollbar
-        if (newSettings.ScrollState() == ScrollbarState::Hidden)
+        if (_settings.ScrollState() == ScrollbarState::Hidden)
         {
             // In the scenario where the user has turned off the OS setting to automatically hide scrollbars, the
             // Terminal scrollbar would still be visible; so, we need to set the control's visibility accordingly to
@@ -897,8 +869,6 @@ namespace winrt::Microsoft::Terminal::TerminalControl::implementation
             return;
         }
 
-        _HidePointerCursorHandlers(*this, nullptr);
-
         const auto ch = e.Character();
         const auto scanCode = gsl::narrow_cast<WORD>(e.KeyStatus().ScanCode);
         auto modifiers = _GetPressedModifierKeys();
@@ -1117,18 +1087,8 @@ namespace winrt::Microsoft::Terminal::TerminalControl::implementation
         // selection.
         if (_terminal->IsSelectionActive() && !KeyEvent::IsModifierKey(vkey) && vkey != VK_SNAPSHOT)
         {
-            const CoreWindow window = CoreWindow::GetForCurrentThread();
-            const auto leftWinKeyState = window.GetKeyState(VirtualKey::LeftWindows);
-            const auto rightWinKeyState = window.GetKeyState(VirtualKey::RightWindows);
-            const auto isLeftWinKeyDown = WI_IsFlagSet(leftWinKeyState, CoreVirtualKeyStates::Down);
-            const auto isRightWinKeyDown = WI_IsFlagSet(rightWinKeyState, CoreVirtualKeyStates::Down);
-
-            // GH#8791 - don't dismiss selection if Windows key was also pressed as a key-combination.
-            if (!isLeftWinKeyDown && !isRightWinKeyDown)
-            {
-                _terminal->ClearSelection();
-                _renderer->TriggerSelection();
-            }
+            _terminal->ClearSelection();
+            _renderer->TriggerSelection();
 
             if (vkey == VK_ESCAPE)
             {
@@ -1253,8 +1213,6 @@ namespace winrt::Microsoft::Terminal::TerminalControl::implementation
             return;
         }
 
-        _RestorePointerCursorHandlers(*this, nullptr);
-
         _CapturePointer(sender, args);
 
         const auto ptr = args.Pointer();
@@ -1280,31 +1238,24 @@ namespace winrt::Microsoft::Terminal::TerminalControl::implementation
             const auto shiftEnabled = WI_IsFlagSet(modifiers, static_cast<uint32_t>(VirtualKeyModifiers::Shift));
             const auto ctrlEnabled = WI_IsFlagSet(modifiers, static_cast<uint32_t>(VirtualKeyModifiers::Control));
 
-            auto lock = _terminal->LockForWriting();
-            const auto cursorPosition = point.Position();
-            const auto terminalPosition = _GetTerminalPosition(cursorPosition);
-
-            // GH#9396: we prioritize hyper-link over VT mouse events
-            if (point.Properties().IsLeftButtonPressed() && ctrlEnabled && !_terminal->GetHyperlinkAtPosition(terminalPosition).empty())
-            {
-                // Handle hyper-link only on the first click to prevent multiple activations
-                const auto clickCount = _NumberOfClicks(cursorPosition, point.Timestamp());
-                if (clickCount == 1)
-                {
-                    _HyperlinkHandler(_terminal->GetHyperlinkAtPosition(terminalPosition));
-                }
-            }
-            else if (_CanSendVTMouseInput())
+            if (_CanSendVTMouseInput())
             {
                 _TrySendMouseEvent(point);
+                args.Handled(true);
+                return;
             }
-            else if (point.Properties().IsLeftButtonPressed())
+
+            if (point.Properties().IsLeftButtonPressed())
             {
-                // Update the selection appropriately
+                auto lock = _terminal->LockForWriting();
+
+                const auto cursorPosition = point.Position();
+                const auto terminalPosition = _GetTerminalPosition(cursorPosition);
+
                 // handle ALT key
                 _terminal->SetBlockSelection(altEnabled);
 
-                const auto clickCount = _NumberOfClicks(cursorPosition, point.Timestamp());
+                auto clickCount = _NumberOfClicks(cursorPosition, point.Timestamp());
 
                 // This formula enables the number of clicks to cycle properly between single-, double-, and triple-click.
                 // To increase the number of acceptable click states, simply increment MAX_CLICK_COUNT and add another if-statement
@@ -1325,48 +1276,41 @@ namespace winrt::Microsoft::Terminal::TerminalControl::implementation
                     mode = ::Terminal::SelectionExpansionMode::Line;
                 }
 
-                // Capture the position of the first click when no selection is active
-                if (mode == ::Terminal::SelectionExpansionMode::Cell && !_terminal->IsSelectionActive())
+                // Update the selection appropriately
+                if (ctrlEnabled && multiClickMapper == 1 &&
+                    !(_terminal->GetHyperlinkAtPosition(terminalPosition).empty()))
                 {
-                    _singleClickTouchdownPos = cursorPosition;
-                    _lastMouseClickPosNoSelection = cursorPosition;
+                    _HyperlinkHandler(_terminal->GetHyperlinkAtPosition(terminalPosition));
                 }
-
-                // We reset the active selection if one of the conditions apply:
-                // - shift is not held
-                // - GH#9384: the position is the same as of the first click starting the selection
-                // (we need to reset selection on double-click or triple-click, so it captures the word or the line,
-                // rather than extending the selection)
-                if (_terminal->IsSelectionActive() && (!shiftEnabled || _lastMouseClickPosNoSelection == cursorPosition))
+                else if (shiftEnabled && _terminal->IsSelectionActive())
                 {
-                    // Reset the selection
-                    _terminal->ClearSelection();
-                    _selectionNeedsToBeCopied = false; // there's no selection, so there's nothing to update
-                }
-
-                if (shiftEnabled && _terminal->IsSelectionActive())
-                {
-                    // If shift is pressed and there is a selection we extend it using the selection mode
-                    // (expand the "end"selection point)
+                    // Shift+Click: only set expand on the "end" selection point
                     _terminal->SetSelectionEnd(terminalPosition, mode);
                     _selectionNeedsToBeCopied = true;
                 }
-                else if (mode != ::Terminal::SelectionExpansionMode::Cell || shiftEnabled)
+                else if (mode == ::Terminal::SelectionExpansionMode::Cell)
                 {
-                    // If we are handling a double / triple-click or shift+single click
-                    // we establish selection using the selected mode
-                    // (expand both "start" and "end" selection points)
+                    // Single Click: reset the selection and begin a new one
+                    _terminal->ClearSelection();
+                    _singleClickTouchdownPos = cursorPosition;
+                    _selectionNeedsToBeCopied = false; // there's no selection, so there's nothing to update
+                }
+                else
+                {
+                    // Multi-Click Selection: expand both "start" and "end" selection points
                     _terminal->MultiClickSelection(terminalPosition, mode);
                     _selectionNeedsToBeCopied = true;
                 }
 
+                _lastMouseClickTimestamp = point.Timestamp();
+                _lastMouseClickPos = cursorPosition;
                 _renderer->TriggerSelection();
             }
             else if (point.Properties().IsRightButtonPressed())
             {
+                // CopyOnSelect right click always pastes
                 if (_settings.CopyOnSelect() || !_terminal->IsSelectionActive())
                 {
-                    // CopyOnSelect right click always pastes
                     PasteTextFromClipboard();
                 }
                 else
@@ -1398,23 +1342,30 @@ namespace winrt::Microsoft::Terminal::TerminalControl::implementation
             return;
         }
 
-        _RestorePointerCursorHandlers(*this, nullptr);
-
         const auto ptr = args.Pointer();
         const auto point = args.GetCurrentPoint(*this);
-        const auto cursorPosition = point.Position();
-        const auto terminalPosition = _GetTerminalPosition(cursorPosition);
+
+        if (!_focused)
+        {
+            args.Handled(true);
+            return;
+        }
 
         if (ptr.PointerDeviceType() == Windows::Devices::Input::PointerDeviceType::Mouse || ptr.PointerDeviceType() == Windows::Devices::Input::PointerDeviceType::Pen)
         {
-            if (_focused && _CanSendVTMouseInput())
+            if (_CanSendVTMouseInput())
             {
                 _TrySendMouseEvent(point);
+                args.Handled(true);
+                return;
             }
-            else if (_focused && point.Properties().IsLeftButtonPressed())
+
+            if (point.Properties().IsLeftButtonPressed())
             {
                 auto lock = _terminal->LockForWriting();
 
+                const auto cursorPosition = point.Position();
+
                 if (_singleClickTouchdownPos)
                 {
                     // Figure out if the user's moved a quarter of a cell's smaller axis away from the clickdown point
@@ -1456,10 +1407,51 @@ namespace winrt::Microsoft::Terminal::TerminalControl::implementation
                     _TryStopAutoScroll(ptr.PointerId());
                 }
             }
+            const auto terminalPos = _GetTerminalPosition(point.Position());
+            if (terminalPos != _lastHoveredCell)
+            {
+                const auto uri = _terminal->GetHyperlinkAtPosition(terminalPos);
+                if (!uri.empty())
+                {
+                    // Update the tooltip with the URI
+                    HoveredUri().Text(uri);
 
-            _UpdateHoveredCell(terminalPosition);
+                    // Set the border thickness so it covers the entire cell
+                    const auto charSizeInPixels = CharacterDimensions();
+                    const auto htInDips = charSizeInPixels.Height / SwapChainPanel().CompositionScaleY();
+                    const auto wtInDips = charSizeInPixels.Width / SwapChainPanel().CompositionScaleX();
+                    const Thickness newThickness{ wtInDips, htInDips, 0, 0 };
+                    HyperlinkTooltipBorder().BorderThickness(newThickness);
+
+                    // Compute the location of the top left corner of the cell in DIPS
+                    const til::size marginsInDips{ til::math::rounding, GetPadding().Left, GetPadding().Top };
+                    const til::point startPos{ terminalPos.X, terminalPos.Y };
+                    const til::size fontSize{ _actualFont.GetSize() };
+                    const til::point posInPixels{ startPos * fontSize };
+                    const til::point posInDIPs{ posInPixels / SwapChainPanel().CompositionScaleX() };
+                    const til::point locationInDIPs{ posInDIPs + marginsInDips };
+
+                    // Move the border to the top left corner of the cell
+                    OverlayCanvas().SetLeft(HyperlinkTooltipBorder(), (locationInDIPs.x() - SwapChainPanel().ActualOffset().x));
+                    OverlayCanvas().SetTop(HyperlinkTooltipBorder(), (locationInDIPs.y() - SwapChainPanel().ActualOffset().y));
+                }
+                _lastHoveredCell = terminalPos;
+
+                const auto newId = _terminal->GetHyperlinkIdAtPosition(terminalPos);
+                const auto newInterval = _terminal->GetHyperlinkIntervalFromPosition(terminalPos);
+                // If the hyperlink ID changed or the interval changed, trigger a redraw all
+                // (so this will happen both when we move onto a link and when we move off a link)
+                if (newId != _lastHoveredId || (newInterval != _lastHoveredInterval))
+                {
+                    _lastHoveredId = newId;
+                    _lastHoveredInterval = newInterval;
+                    _renderEngine->UpdateHyperlinkHoveredId(newId);
+                    _renderer->UpdateLastHoveredInterval(newInterval);
+                    _renderer->TriggerRedrawAll();
+                }
+            }
         }
-        else if (_focused && ptr.PointerDeviceType() == Windows::Devices::Input::PointerDeviceType::Touch && _touchAnchor)
+        else if (ptr.PointerDeviceType() == Windows::Devices::Input::PointerDeviceType::Touch && _touchAnchor)
         {
             const auto contactRect = point.Properties().ContactRect();
             winrt::Windows::Foundation::Point newTouchPoint{ contactRect.X, contactRect.Y };
@@ -1557,8 +1549,6 @@ namespace winrt::Microsoft::Terminal::TerminalControl::implementation
             return;
         }
 
-        _RestorePointerCursorHandlers(*this, nullptr);
-
         const auto point = args.GetCurrentPoint(*this);
         const auto props = point.Properties();
         const TerminalInput::MouseButtonState state{ props.IsLeftButtonPressed(), props.IsMiddleButtonPressed(), props.IsRightButtonPressed() };
@@ -1990,8 +1980,6 @@ namespace winrt::Microsoft::Terminal::TerminalControl::implementation
             return;
         }
 
-        _RestorePointerCursorHandlers(*this, nullptr);
-
         _focused = false;
 
         if (_uiaEngine.get())
@@ -2037,7 +2025,6 @@ namespace winrt::Microsoft::Terminal::TerminalControl::implementation
     // - Pre-process text pasted (presumably from the clipboard)
     //   before sending it over the terminal's connection, converting
     //   Windows-space \r\n line-endings to \r line-endings
-    // - Also converts \n line-endings to \r line-endings
     void TermControl::_SendPastedTextToConnection(const std::wstring& wstr)
     {
         // Some notes on this implementation:
@@ -2047,52 +2034,20 @@ namespace winrt::Microsoft::Terminal::TerminalControl::implementation
         //   performance guarantees aren't exactly stellar)
         // - The STL doesn't have a simple string search/replace method.
         //   This fact is lamentable.
-        // - We search for \n, and when we find it we copy the string up to
-        //   the \n (but not including it). Then, we check the if the
-        //   previous character is \r, if its not, then we had a lone \n
-        //   and so we append our own \r
+        // - This line-ending conversion is intentionally fairly
+        //   conservative, to avoid stripping out lone \n characters
+        //   where they could conceivably be intentional.
 
-        std::wstring stripped;
-        stripped.reserve(wstr.length());
+        std::wstring stripped{ wstr };
 
         std::wstring::size_type pos = 0;
-        std::wstring::size_type begin = 0;
 
-        while ((pos = wstr.find(L"\n", pos)) != std::wstring::npos)
+        while ((pos = stripped.find(L"\r\n", pos)) != std::wstring::npos)
         {
-            // copy up to but not including the \n
-            stripped.append(wstr.cbegin() + begin, wstr.cbegin() + pos);
-            if (!(pos > 0 && (wstr.at(pos - 1) == L'\r')))
-            {
-                // there was no \r before the \n we did not copy,
-                // so append our own \r (this effectively replaces the \n
-                // with a \r)
-                stripped.push_back(L'\r');
-            }
-            ++pos;
-            begin = pos;
+            stripped.replace(pos, 2, L"\r");
         }
 
-        // If we entered the while loop even once, begin would be non-zero
-        // (because we set begin = pos right after incrementing pos)
-        // So, if begin is still zero at this point it means we never found a newline
-        // and we can just write the original string
-        if (begin == 0)
-        {
-            _connection.WriteInput(wstr);
-        }
-        else
-        {
-            // copy over the part after the last \n
-            stripped.append(wstr.cbegin() + begin, wstr.cend());
-
-            // we may have removed some characters, so we may not need as much space
-            // as we reserved earlier
-            stripped.shrink_to_fit();
-            _connection.WriteInput(stripped);
-        }
-
-        _terminal->ClearSelection();
+        _connection.WriteInput(stripped);
         _terminal->TrySnapOnInput();
     }
 
@@ -2473,12 +2428,6 @@ namespace winrt::Microsoft::Terminal::TerminalControl::implementation
         return _settings.ProfileName();
     }
 
-    hstring TermControl::WorkingDirectory() const
-    {
-        hstring hstr{ _terminal->GetWorkingDirectory() };
-        return hstr;
-    }
-
     // Method Description:
     // - Given a copy-able selection, get the selected text from the buffer and send it to the
     //     Windows Clipboard (CascadiaWin32:main.cpp).
@@ -2584,8 +2533,6 @@ namespace winrt::Microsoft::Terminal::TerminalControl::implementation
     {
         if (!_closing.exchange(true))
         {
-            _RestorePointerCursorHandlers(*this, nullptr);
-
             // Stop accepting new output and state changes before we disconnect everything.
             _connection.TerminalOutput(_connectionOutputEventToken);
             _connectionStateChangedRevoker.revoke();
@@ -2600,17 +2547,6 @@ namespace winrt::Microsoft::Terminal::TerminalControl::implementation
             // closed. We can just do it whenever.
             _AsyncCloseConnection();
 
-            {
-                // GH#8734:
-                // We lock the terminal here to make sure it isn't still being
-                // used in the connection thread before we destroy the renderer.
-                // However, we must unlock it again prior to triggering the
-                // teardown, to avoid the render thread being deadlocked. The
-                // renderer may be waiting to acquire the terminal lock, while
-                // we're waiting for the renderer to finish.
-                auto lock = _terminal->LockForWriting();
-            }
-
             if (auto localRenderEngine{ std::exchange(_renderEngine, nullptr) })
             {
                 if (auto localRenderer{ std::exchange(_renderer, nullptr) })
@@ -2909,7 +2845,7 @@ namespace winrt::Microsoft::Terminal::TerminalControl::implementation
     // - The Microsoft::Terminal::Core::ControlKeyStates representing the modifier key states.
     ControlKeyStates TermControl::_GetPressedModifierKeys() const
     {
-        const CoreWindow window = CoreWindow::GetForCurrentThread();
+        CoreWindow window = CoreWindow::GetForCurrentThread();
         // DONT USE
         //      != CoreVirtualKeyStates::None
         // OR
@@ -3032,8 +2968,7 @@ namespace winrt::Microsoft::Terminal::TerminalControl::implementation
     }
 
     // Method Description:
-    // - Returns the number of clicks that occurred (double and triple click support).
-    // Every call to this function registers a click.
+    // - Returns the number of clicks that occurred (double and triple click support)
     // Arguments:
     // - clickPos: the (x,y) position of a given cursor (i.e.: mouse cursor).
     //    NOTE: origin (0,0) is top-left.
@@ -3048,15 +2983,13 @@ namespace winrt::Microsoft::Terminal::TerminalControl::implementation
         THROW_IF_FAILED(UInt64Sub(clickTime, _lastMouseClickTimestamp, &delta));
         if (clickPos != _lastMouseClickPos || delta > _multiClickTimer)
         {
+            // exit early. This is a single click.
             _multiClickCounter = 1;
         }
         else
         {
             _multiClickCounter++;
         }
-
-        _lastMouseClickTimestamp = clickTime;
-        _lastMouseClickPos = clickPos;
         return _multiClickCounter;
     }
 
@@ -3295,74 +3228,6 @@ namespace winrt::Microsoft::Terminal::TerminalControl::implementation
         return _terminal->GetTaskbarProgress();
     }
 
-    // Method description:
-    // - Updates last hovered cell, renders / removes rendering of hyper-link if required
-    // Arguments:
-    // - terminalPosition: The terminal position of the pointer
-    void TermControl::_UpdateHoveredCell(const std::optional<COORD>& terminalPosition)
-    {
-        if (terminalPosition == _lastHoveredCell)
-        {
-            return;
-        }
-
-        _lastHoveredCell = terminalPosition;
-
-        if (terminalPosition.has_value())
-        {
-            const auto uri = _terminal->GetHyperlinkAtPosition(*terminalPosition);
-            if (!uri.empty())
-            {
-                // Update the tooltip with the URI
-                HoveredUri().Text(uri);
-
-                // Set the border thickness so it covers the entire cell
-                const auto charSizeInPixels = CharacterDimensions();
-                const auto htInDips = charSizeInPixels.Height / SwapChainPanel().CompositionScaleY();
-                const auto wtInDips = charSizeInPixels.Width / SwapChainPanel().CompositionScaleX();
-                const Thickness newThickness{ wtInDips, htInDips, 0, 0 };
-                HyperlinkTooltipBorder().BorderThickness(newThickness);
-
-                // Compute the location of the top left corner of the cell in DIPS
-                const til::size marginsInDips{ til::math::rounding, GetPadding().Left, GetPadding().Top };
-                const til::point startPos{ terminalPosition->X, terminalPosition->Y };
-                const til::size fontSize{ _actualFont.GetSize() };
-                const til::point posInPixels{ startPos * fontSize };
-                const til::point posInDIPs{ posInPixels / SwapChainPanel().CompositionScaleX() };
-                const til::point locationInDIPs{ posInDIPs + marginsInDips };
-
-                // Move the border to the top left corner of the cell
-                OverlayCanvas().SetLeft(HyperlinkTooltipBorder(), (locationInDIPs.x() - SwapChainPanel().ActualOffset().x));
-                OverlayCanvas().SetTop(HyperlinkTooltipBorder(), (locationInDIPs.y() - SwapChainPanel().ActualOffset().y));
-            }
-        }
-
-        const uint16_t newId = terminalPosition.has_value() ? _terminal->GetHyperlinkIdAtPosition(*terminalPosition) : 0u;
-        const auto newInterval = terminalPosition.has_value() ? _terminal->GetHyperlinkIntervalFromPosition(*terminalPosition) : std::nullopt;
-
-        // If the hyperlink ID changed or the interval changed, trigger a redraw all
-        // (so this will happen both when we move onto a link and when we move off a link)
-        if (newId != _lastHoveredId || (newInterval != _lastHoveredInterval))
-        {
-            _lastHoveredId = newId;
-            _lastHoveredInterval = newInterval;
-            _renderEngine->UpdateHyperlinkHoveredId(newId);
-            _renderer->UpdateLastHoveredInterval(newInterval);
-            _renderer->TriggerRedrawAll();
-        }
-    }
-
-    // Method Description:
-    // - Handle a mouse exited event, specifically clearing last hovered cell
-    // and removing selection from hyper link if exists
-    // Arguments:
-    // - sender: not used
-    // - args: event data
-    void TermControl::_PointerExitedHandler(Windows::Foundation::IInspectable const& /*sender*/, Windows::UI::Xaml::Input::PointerRoutedEventArgs const& /*e*/)
-    {
-        _UpdateHoveredCell(std::nullopt);
-    }
-
     // -------------------------------- WinRT Events ---------------------------------
     // Winrt events need a method for adding a callback to the event and removing the callback.
     // These macros will define them both for you.

src/cascadia/TerminalControl/TermControl.h

@@ -106,7 +106,6 @@ namespace winrt::Microsoft::Terminal::TerminalControl::implementation
 
         hstring Title();
         hstring GetProfileName() const;
-        hstring WorkingDirectory() const;
 
         bool CopySelectionToClipboard(bool singleLine, const Windows::Foundation::IReference<CopyFormat>& formats);
         void PasteTextFromClipboard();
@@ -180,8 +179,6 @@ namespace winrt::Microsoft::Terminal::TerminalControl::implementation
         TYPED_EVENT(ConnectionStateChanged, TerminalControl::TermControl, IInspectable);
         TYPED_EVENT(Initialized, TerminalControl::TermControl, Windows::UI::Xaml::RoutedEventArgs);
         TYPED_EVENT(TabColorChanged, IInspectable, IInspectable);
-        TYPED_EVENT(HidePointerCursor, IInspectable, IInspectable);
-        TYPED_EVENT(RestorePointerCursor, IInspectable, IInspectable);
         // clang-format on
 
     private:
@@ -240,7 +237,7 @@ namespace winrt::Microsoft::Terminal::TerminalControl::implementation
         std::optional<winrt::Windows::Foundation::Point> _touchAnchor;
 
         // Track the last cell we hovered over (used in pointerMovedHandler)
-        std::optional<COORD> _lastHoveredCell;
+        COORD _lastHoveredCell;
         // Track the last hyperlink ID we hovered over
         uint16_t _lastHoveredId;
 
@@ -254,7 +251,6 @@ namespace winrt::Microsoft::Terminal::TerminalControl::implementation
         unsigned int _multiClickCounter;
         Timestamp _lastMouseClickTimestamp;
         std::optional<winrt::Windows::Foundation::Point> _lastMouseClickPos;
-        std::optional<winrt::Windows::Foundation::Point> _lastMouseClickPosNoSelection;
         std::optional<winrt::Windows::Foundation::Point> _singleClickTouchdownPos;
         // This field tracks whether the selection has changed meaningfully
         // since it was last copied. It's generally used to prevent copyOnSelect
@@ -264,8 +260,7 @@ namespace winrt::Microsoft::Terminal::TerminalControl::implementation
 
         winrt::Windows::UI::Xaml::Controls::SwapChainPanel::LayoutUpdated_revoker _layoutUpdatedRevoker;
 
-        void _ApplyUISettings(const IControlSettings&);
-        void _UpdateSettingsOnUIThread(const IControlSettings& newSettings);
+        void _ApplyUISettings();
         void _UpdateSystemParameterSettings() noexcept;
         void _InitializeBackgroundBrush();
         winrt::fire_and_forget _BackgroundColorChanged(const COLORREF color);
@@ -279,7 +274,6 @@ namespace winrt::Microsoft::Terminal::TerminalControl::implementation
         void _PointerPressedHandler(Windows::Foundation::IInspectable const& sender, Windows::UI::Xaml::Input::PointerRoutedEventArgs const& e);
         void _PointerMovedHandler(Windows::Foundation::IInspectable const& sender, Windows::UI::Xaml::Input::PointerRoutedEventArgs const& e);
         void _PointerReleasedHandler(Windows::Foundation::IInspectable const& sender, Windows::UI::Xaml::Input::PointerRoutedEventArgs const& e);
-        void _PointerExitedHandler(Windows::Foundation::IInspectable const& sender, Windows::UI::Xaml::Input::PointerRoutedEventArgs const& e);
         void _MouseWheelHandler(Windows::Foundation::IInspectable const& sender, Windows::UI::Xaml::Input::PointerRoutedEventArgs const& e);
         void _ScrollbarChangeHandler(Windows::Foundation::IInspectable const& sender, Windows::UI::Xaml::Controls::Primitives::RangeBaseValueChangedEventArgs const& e);
         void _GotFocusHandler(Windows::Foundation::IInspectable const& sender, Windows::UI::Xaml::RoutedEventArgs const& e);
@@ -340,8 +334,6 @@ namespace winrt::Microsoft::Terminal::TerminalControl::implementation
         void _FontInfoHandler(const IInspectable& sender, const FontInfoEventArgs& eventArgs);
 
         winrt::fire_and_forget _AsyncCloseConnection();
-
-        void _UpdateHoveredCell(const std::optional<COORD>& terminalPosition);
     };
 }
 

src/cascadia/TerminalControl/TermControl.idl

@@ -77,8 +77,6 @@ namespace Microsoft.Terminal.TerminalControl
         event Windows.Foundation.TypedEventHandler<TermControl, Object> SetTaskbarProgress;
         event Windows.Foundation.TypedEventHandler<TermControl, NoticeEventArgs> RaiseNotice;
         event Windows.Foundation.TypedEventHandler<Object, Object> WarningBell;
-        event Windows.Foundation.TypedEventHandler<Object, Object> HidePointerCursor;
-        event Windows.Foundation.TypedEventHandler<Object, Object> RestorePointerCursor;
 
         event Windows.Foundation.TypedEventHandler<TermControl, Windows.UI.Xaml.RoutedEventArgs> Initialized;
         // This is an event handler forwarder for the underlying connection.
@@ -112,8 +110,6 @@ namespace Microsoft.Terminal.TerminalControl
         UInt64 TaskbarState { get; };
         UInt64 TaskbarProgress { get; };
 
-        String WorkingDirectory { get; };
-
         Windows.Foundation.IReference<Windows.UI.Color> TabColor { get; };
         event Windows.Foundation.TypedEventHandler<Object, Object> TabColorChanged;
     }

src/cascadia/TerminalControl/TermControl.xaml

@@ -43,8 +43,7 @@
                   Background="Transparent"
                   PointerPressed="_PointerPressedHandler"
                   PointerMoved="_PointerMovedHandler"
-                  PointerReleased="_PointerReleasedHandler"
-                  PointerExited="_PointerExitedHandler">
+                  PointerReleased="_PointerReleasedHandler">
 
                 <SwapChainPanel x:Name="SwapChainPanel"
                                 SizeChanged="_SwapChainSizeChanged"