This pull request replaces all of HwndTerminal, which used to be a thin
layer on top of TerminalCore.lib, with a new implementation that relies
on the Interactivity and Core layers in TerminalControl.lib.
We used to spend a lot of time reimplementing interactivity components
for HwndTerminal or--if I'm being honest--letting it rot and never
giving it the improvements the rest of the application got.
Among those improvements:
- Automatic scrolling finally works (as of #20710)
- Selection works the same way as it does in Terminal proper (starts on
the half-cell, uses an exclusive range)
- Consistent double- and triple-click behavior without having to
reimplement word- and line-wise expansion
- Scroll wheel behavior
- Shift+Click to suppress VT mouse mode
- Scrolling and focus handling move down into the Win32 message loop
from WPF
This pull request seeks to get HwndTerminal back to where it was (plus
the things we naturally get from switching over). In the future, we can
more easily add:
- title reporting (surprised we didn't have this)
- clickable URLs
- automatic copy-to-clipboard
- right-click menu support
- DTTERM window manipulation
- shaders
- Ctrl+Scroll zoom
Implementation Details
----------------------
The WPF control is backed by a flat "C" API, which takes in a `void*`
and does some stuff to it. We call that a `PTERM`. References to "Flat
C" in this commit body describe the body of work below WPF.
X-macros are used to fill out the definintions of every C API and bridge
it to a properly typed C++ member function. Ugh. No more crap where we
split the implementation into half C export and half C++ member.
ControlCore and ControlInteractivity require something that looks like
TerminalSettings. The WPF control only supports the most basic settings,
in `struct TerminalTheme`, and so I've added a bridge WinRT type to
adapt TerminalTheme to
IXxxSettings. Most of the values it returns are our "defaults", and some
of them are overridden.
Core requires an `ITerminalConnection`, but the WPF API uses a pair of
"write output" and "send input" callbacks. Flat C provides an
ITerminalConnection that bridges those callbacks. It does not
communicate connection state or anything else. Resizing is probably
going to be a problem.
Core requires a dispatcher queue to ensure that some operations happen
on the UI thread. I have stubbed out an implementation of
`IDispatcherQueue` that calls a couple function pointers with a context
pointer; the WPF code hooks up to that and bridges it into the WPF
dispatcher. Yes, the Core's dispatcher queue _is_ the WPF main UI
thread. It has to be, otherwise we'll explode the first time we try to
update the scroll bar. Prep work was done in #20713.
To make the above easier, I removed all use of DispatcherTimer (see
#20711). Attempts to use it will almost certainly cause the WPF control
to implode.
Core needed to be taught a couple tricks to start up targeting an HWND
instead of a composition handle. See #20722 for more.
Refs #20710
Refs #20711
Refs #20713
Refs #20722
Required #20721
Refs #20745
Related to #6999
adds "interaction" setting to allow enable/disable of tab
drag/drop/rearrange/tear
Refs #15689
## Validation Steps Performed
- ran as "clint" and verified the interaction setting can be toggled on
and drag/drop/tear works, and toggled off where it doesn't (gifs of both
at the end)
Okay, so this is a very niche case.
We want to light up TermControl in places where we cannot be certain
there is a resources.pri.
In Debug builds, we load up and check that all referenced resources are
present. In Release, we don't.
This prevents us from failing on startup when resources.pri is
unavailable. _However,_ any code that tries to resolve a resource will
crash later.
This is taken as an acceptable risk, because it reveals programmer
error.
This will cause issues in the future if we want to add resource uses to
the Core or Interactivity layers[^1].
In the future, we should either use MRT core (ew) or switch to MUI (ew)
or do something else entirely for resources.
[^1]: we have some right now, but they are only actually referenced by
the XAML layer
Prevents us from incorrectly encoding `65535` into an input record when
a character has no virtual key mapping in the active keyboard layout.
- `VkKeyScanW` returns a signed `SHORT` `-1` on failure when the
character does not exist in the active keyboard layout).
- When injected characters without key-down/scan-code information (e.g.
via VNC or remote inputs) passed through `SendCharEvent`, this caused
.NET `Console.ReadKey()` to throw an unhandled
`System.ArgumentOutOfRangeException: Console key values must be
between 0 and 255 inclusive.` and crash PowerShell.
Closes#20797
We have a bunch of edge cases in our settings that had to have manual
accounting for in the settings search index or weren't being handled at
all (controls being wrapped in stack panels, settings that shouldn't
show up in the defaults profile but should for regular profiles, etc).
This PR adds an xml namespace (which gets ignored at compile time) just
for the purpose of telling our index generating script how various
control elements should be treated.
One of those properties is used to indicate which check box contains the
label for a stack panel.
#20055 only migrated the old `confirmCloseAllTabs` key, but since #17933
we've written `warning.confirmCloseAllTabs`, so on 1.26 users who turned
the close warning off get the dialog back. This migrates both names
(`warning.confirmOnClose` still wins) and stops a `null` value from
throwing and failing the whole settings load. Adds a regression test;
SettingsModel tests pass (159/159).
Throwing an exception all the way out of COOKED_READ_DATA::Read is
deleterious for the health of the application. We fail to unbind the
waiter and may leave a dangling pointer around for some applications
(and for some NPC security researchers to think provides an EoP, but
does not.)
This also moves us away from std::stoi in the history pop-up path
entirely.
- Fixed#20772 by fully committing to lazy DA1 capabilities path via
`VtIo::SetDeviceAttributes`. It accidentally only did so with enabled
cursor inheritance before.
- Fixed#20773 by fixing the source/destination rectangle alignment
in the non-DECCRA path of `ScrollConsoleScreenBuffer`.
Also closes MSFT-64450466.
As a drive-by:
- Fixed the DECCRA path not restoring cursor attributes in conhost.
- Reduced memory use in the non-DECCRA path.
- Added a `IL/DL` sequence fast-pass for `ScrollConsoleScreenBuffer`.
- Fixed a broken bounds checks in `Read/WriteConsoleOutputWImplHelper`.
- Fixed the TraceLogging definition for `SMALL_RECT`.
Consumers have no need to know about these, and can instead deal with a
new opaque `IContentHandle`. Exposing them offered too much latitude to
do the "wrong thing" with TermControl's constituent types. Even _if_ we
were doing something cross-process, the upper layer doesn't need to use
our implementation details.
In doing this, I've also removed the unused Content::Attached event.
Our window message intercepts Alt key-up (and F7 key-down) to handle
them before XAML messes them up. These events get forwarded through
IDirectKeyListener, but the ENHANCED_KEY bit from `lParam` was being
lost.
Verified manually.
Closes#18120
This reverts a large part of #10051 and moves us back to using the
native `implementation`-namespace types from TermControl to talk to
ControlInteractivity and ControlCore.
I started down this rabbit hole because I was trying to get rid of
InteractivityAutomationPeer, and I learned that we introduced it as a
go-between for the process-split TermControl/Interactivity.
InteractviityAutomationPeer is not required, and removing it lets us get
rid of some other mild annoyances:
- We don't need to _push_ the bounds of the control down into
Interactivity any longer
- Likewise for padding
Bounds and padding can simply be read directly from the control.
I also undid the move from HANDLE to uint64_t which was only required
for projecting HANDLEs.
The only thing we risked losing out on was automatic event revokers, but
this pull request adds `winrt::auto_revoke` support directly to
`til::event`. It is suitably terrifying. It is certainly UB.
For experimental settings, display a bright yellow badge next to it. So,
as part of this, removed "experimental" from the descriptions since the
badge is indicating that already.
Closes#20687
`_kittyFlags` represents the current buffer flags. When you enable the
ASB, we reset `_kittyFlags` to 0. When you disable the ASB, we restore
the flags from the `_kittyMainStack`. Boom, broken. We never pushed
anything into the `_kittyMainStack` in the first place.
The gets rid of `_kittyFlags`. To make it neat, I also replaced
the heap vector with a static array + length.
Closes#20763
It didn't have one before, so screen readers were just reading out
"button". This commit fixes that, screen readers now read out "delete
shortcut button"
Closes#20601
This reverts commit 1507c46524.
The root cause of the PGO failure is documented in #20749. Also, the PR
#20560 didn't actually _fix_ them. :P
Note that this DOES NOT FIX the PGO build.
OpenCWD now no-ops unless the terminal working directory is an existing
directory, then opens that folder. It no longer passes the raw OSC
string to `explorer.exe` as parameters.
Refs #12859 (the original action asked to do nothing when no CWD is set)
OpenCWD was introduced in #18013.
`ControlCore::OpenCWD` is the command-palette action `Terminal.OpenCWD`.
It used:
```cpp
ShellExecute(nullptr, nullptr, L"explorer", workingDirectory.c_str(), nullptr, SW_SHOW);
```
The working-directory string comes from OSC 7 (`file:` URI, then
`PathCreateFromUrlW`) or OSC 9;9. Both only require
`til::is_legal_path`, which allows `:` and `/`. So a remote host can set
CWD to `https://example.com`, `shell:...`, or `/select,...`. Invoking
Open CWD then ran Explorer with that text as `lpParameters`.
Duplicate-tab and related paths already call `Utils::IsValidDirectory`
before trusting this string (`TerminalPage.cpp`,
`TerminalPaneContent.cpp`). Open CWD now does the same, then
`ShellExecute`s the directory path as `lpFile` so Explorer switches
cannot be supplied as parameters.
If the CWD is empty or not a directory, the action does nothing.
This pull request builds on the render timer infrastructure in #19330
and the pointer ID work in #20017 to move automatic scrolling down into
the Interactivity layer.
Leonard tells me that this is an acceptable use of the render timer
infrastructure because it directly results in a new frame or new content
being rendered (therefore, it does not spin the renderer for no reason.)
Much of the code is the same. I recommend reviewing with:
```
git diff --color-moved=dimmed-zebra --color-moved-ws=ignore-all-space (git merge-base origin/main origin/dev/duhowett/wpf-1-autoscroll-to-interactivity) origin/dev/duhowett/wpf-1-autoscroll-to-interactivity
```
Hilarious repro: `printf "\e]0;A\a\e]52;c;Qg==\a"`
This issue is exactly what happens when you Ctrl+X in a clean file in
msedit and it freezes Windows Terminal. It's because it puts a "•" in
the title and copies the text.
It triggers a title and clipboard change in the same frame which causes
the UI and VT thread to deadlock trying to get the console lock.
* D3D uses deferred execution where render commands are collected as
descriptors in a ring buffer before they're sent off to the GPU.
When you don't call `Flush()` (or `Present()` which implies `Flush()`)
it'll fill up 100s of MB of memory rapidly.
This PR solves it in two ways:
* Call `Flush()` whenever we can't call `Present()`
* Make calling `Flush()` unnecessary by checking if we need to render
anything in the first place.
* This immediately results in an issue: Not rendering means the frame
latency waitable object yields immediately (because we can't wait on
it twice). The solution is to wait 16ms before trying again.
* If the display is off, DWM will not deque frames. `Present1()` will
indicate this (`DXGI_STATUS_OCCLUDED`) but it's not a failure so we
don't handle it. Because of this we'll fill the queue to its maximum
(64 frames). Once the display is on again, DWM will deque at V-Sync
rate, but since we render as fast as the frame latency waitable
object, also signaled at V-Sync rate, we'll push frames at the same
rate they're dequeued, causing a 64-frame latency (~1.1s at 60Hz).
`SetMaximumFrameLatency(1)` doesn't change this.
The solution is that we don't limit waiting on the frame latency
waitable object to just 100ms, but `INFINITE`.
* Since that fix causes the renderer to wait potentially forever,
a mechanism to cancel waits on shutdown is necessary.
This also uncovered a flaw in the current design, wherein it blocks
the UI thread for up to 100ms every time you close or move a tab
on a low frame rate (or no active) display.
Closes#20226Closes#20342Closes#20716
## Validation Steps Performed
* Continuously render, scroll up -> no GPU use ✅
When ControlCore is set up to target an HWND, there will not be a swap
chain handle.
When there's not going to be a swap chain handle or a listener who cares
about it, don't bother with the event registration (save memory on a
useless object) and don't bother sending the event.
Supersedes #20712
This is in advance of the UWP/WPF unification work, where we need to
provide a dispatcher from the WPF side. It should be a no-op today, but
we could also move _loading_ the dispatcher up to TermControl (XAML).
This prevents retry builds from failing because `logs-x64-Release` (or
whatever) already exists.
`build-platform-config` is not published if the prior steps fail, and
furthermore its name is a contract with the later stages, so I've left
it alone.