Adjusts High DPI scaling to enable differential rendering (#5345)

## Summary of the Pull Request
- Adjusts scaling practices in `DxEngine` (and related scaling practices in `TerminalControl`) for pixel-perfect row baselines and spacing at High DPI such that differential row-by-row rendering can be applied at High DPI.

## References
- #5185 

## PR Checklist
* [x] Closes #5320, closes #3515, closes #1064
* [x] I work here.
* [x] Manually tested.
* [x] No doc.
* [x] Am core contributor. Also discussed with some of them already via Teams.

## Detailed Description of the Pull Request / Additional comments

**WAS:**
- We were using implicit DPI scaling on the `ID2D1RenderTarget` and running all of our processing in DIPs (Device-Independent Pixels). That's all well and good for getting things bootstrapped quickly, but it leaves the actual scaling of the draw commands up to the discretion of the rendering target.
- When we don't get to explicitly choose exactly how many pixels tall/wide and our X/Y placement perfectly, the nature of floating point multiplication and division required to do the presentation can cause us to drift off slightly out of our control depending on what the final display resolution actually is.
- Differential drawing cannot work unless we can know the exact integer pixels that need to be copied/moved/preserved/replaced between frames to give to the `IDXGISwapChain1::Present1` method. If things spill into fractional pixels or the sizes of rows/columns vary as they are rounded up and down implicitly, then we cannot do the differential rendering.

**NOW:**
- When deciding on a font, the `DxEngine` will take the scale factor into account and adjust the proposed height of the requested font. Then the remainder of the existing code that adjusts the baseline and integer-ifies each character cell will run naturally from there. That code already works correctly to align the height at normal DPI and scale out the font heights and advances to take an exact integer of pixels.
- `TermControl` has to use the scale now, in some places, and stop scaling in other places. This has to do with how the target's nature used to be implicit and is now explicit. For instance, determining where the cursor click hits must be scaled now. And determining the pixel size of the display canvas must no longer be scaled.
- `DxEngine` will no longer attempt to scale the invalid regions per my attempts in #5185 because the cell size is scaled. So it should work the same as at 96 DPI.
- The block is removed from the `DxEngine` that was causing a full invalidate on every frame at High DPI.
- A TODO was removed from `TermControl` that was invalidating everything when the DPI changed because the underlying renderer will already do that.

## Validation Steps Performed
* [x] Check at 150% DPI. Print text, scroll text down and up, do selection.
* [x] Check at 100% DPI. Print text, scroll text down and up, do selection.
* [x] Span two different DPI monitors and drag between them.
* [x] Giant pile of tests in microsoft/terminal#5345 (comment)

Co-authored-by: Dustin Howett <duhowett@microsoft.com>
Co-authored-by: Mike Griese <migrie@microsoft.com>

src/cascadia/PublicTerminalCore/HwndTerminal.cpp

@@ -724,7 +724,7 @@ HRESULT HwndTerminal::_CopyTextToSystemClipboard(const TextBuffer::TextAndColor&
         if (fAlsoCopyFormatting)
         {
             const auto& fontData = _actualFont;
-            int const iFontHeightPoints = fontData.GetUnscaledSize().Y * 72 / this->_currentDpi;
+            int const iFontHeightPoints = fontData.GetUnscaledSize().Y; // this renderer uses points already
             const COLORREF bgColor = _terminal->GetBackgroundColor(_terminal->GetDefaultBrushColors());
 
             std::string HTMLToPlaceOnClip = TextBuffer::GenHTML(rows, iFontHeightPoints, fontData.GetFaceName(), bgColor, "Hwnd Console Host");

src/cascadia/TerminalControl/TSFInputControl.cpp

@@ -175,52 +175,69 @@ namespace winrt::Microsoft::Terminal::TerminalControl::implementation
         auto fontArgs = winrt::make_self<FontInfoEventArgs>();
         _CurrentFontInfoHandlers(*this, *fontArgs);
 
-        const auto fontWidth = fontArgs->FontSize().Width;
-        const auto fontHeight = fontArgs->FontSize().Height;
+        const til::size fontSize{ til::math::flooring, fontArgs->FontSize() };
 
-        // Convert text buffer cursor position to client coordinate position within the window
-        COORD clientCursorPos;
-        clientCursorPos.X = ::base::ClampMul(_currentTerminalCursorPos.x(), ::base::ClampedNumeric<ptrdiff_t>(fontWidth));
-        clientCursorPos.Y = ::base::ClampMul(_currentTerminalCursorPos.y(), ::base::ClampedNumeric<ptrdiff_t>(fontHeight));
+        // Convert text buffer cursor position to client coordinate position
+        // within the window. This point is in _pixels_
+        const til::point clientCursorPos{ _currentTerminalCursorPos * fontSize };
 
-        // position textblock to cursor position
-        Canvas().SetLeft(TextBlock(), clientCursorPos.X);
-        Canvas().SetTop(TextBlock(), clientCursorPos.Y);
+        // Get scale factor for view
+        const double scaleFactor = DisplayInformation::GetForCurrentView().RawPixelsPerViewPixel();
+
+        const til::point clientCursorInDips{ clientCursorPos / scaleFactor };
+
+        // Position our TextBlock at the cursor position
+        Canvas().SetLeft(TextBlock(), clientCursorInDips.x<double>());
+        Canvas().SetTop(TextBlock(), clientCursorInDips.y<double>());
+
+        // calculate FontSize in pixels from Points
+        const double fontSizePx = (fontSize.height<double>() * 72) / USER_DEFAULT_SCREEN_DPI;
 
-        // calculate FontSize in pixels from DPIs
-        const double fontSizePx = (fontHeight * 72) / USER_DEFAULT_SCREEN_DPI;
-        TextBlock().FontSize(fontSizePx);
+        // Make sure to unscale the font size to correct for DPI! XAML needs
+        // things in DIPs, and the fontSize is in pixels.
+        TextBlock().FontSize(fontSizePx / scaleFactor);
         TextBlock().FontFamily(Media::FontFamily(fontArgs->FontFace()));
 
-        const auto widthToTerminalEnd = _currentCanvasWidth - ::base::ClampedNumeric<double>(clientCursorPos.X);
+        const auto widthToTerminalEnd = _currentCanvasWidth - clientCursorInDips.x<double>();
         // Make sure that we're setting the MaxWidth to a positive number - a
         // negative number here will crash us in mysterious ways with a useless
         // stack trace
         const auto newMaxWidth = std::max<double>(0.0, widthToTerminalEnd);
         TextBlock().MaxWidth(newMaxWidth);
 
-        // Get window in screen coordinates, this is the entire window including tabs
-        const auto windowBounds = CoreWindow::GetForCurrentThread().Bounds();
+        // Get window in screen coordinates, this is the entire window including
+        // tabs. THIS IS IN DIPs
+        const auto windowBounds{ CoreWindow::GetForCurrentThread().Bounds() };
+        const til::point windowOrigin{ til::math::flooring, windowBounds };
 
-        // Convert from client coordinate to screen coordinate by adding window position
-        COORD screenCursorPos;
-        screenCursorPos.X = ::base::ClampAdd(clientCursorPos.X, ::base::ClampedNumeric<short>(windowBounds.X));
-        screenCursorPos.Y = ::base::ClampAdd(clientCursorPos.Y, ::base::ClampedNumeric<short>(windowBounds.Y));
+        // Get the offset (margin + tabs, etc..) of the control within the window
+        const til::point controlOrigin{ til::math::flooring,
+                                        this->TransformToVisual(nullptr).TransformPoint(Point(0, 0)) };
 
-        // get any offset (margin + tabs, etc..) of the control within the window
-        const auto offsetPoint = this->TransformToVisual(nullptr).TransformPoint(winrt::Windows::Foundation::Point(0, 0));
+        // The controlAbsoluteOrigin is the origin of the control relative to
+        // the origin of the displays. THIS IS IN DIPs
+        const til::point controlAbsoluteOrigin{ windowOrigin + controlOrigin };
 
-        // add the margin offsets if any
-        screenCursorPos.X = ::base::ClampAdd(screenCursorPos.X, ::base::ClampedNumeric<short>(offsetPoint.X));
-        screenCursorPos.Y = ::base::ClampAdd(screenCursorPos.Y, ::base::ClampedNumeric<short>(offsetPoint.Y));
+        // Convert the control origin to pixels
+        const til::point scaledFrameOrigin = controlAbsoluteOrigin * scaleFactor;
 
-        // Get scale factor for view
-        const double scaleFactor = DisplayInformation::GetForCurrentView().RawPixelsPerViewPixel();
-        const auto yOffset = ::base::ClampedNumeric<float>(_currentTextBlockHeight) - fontHeight;
-        const auto textBottom = ::base::ClampedNumeric<float>(screenCursorPos.Y) + yOffset;
+        // Get the location of the cursor in the display, in pixels.
+        til::point screenCursorPos{ scaledFrameOrigin + clientCursorPos };
+
+        // GH #5007 - make sure to account for wrapping the IME composition at
+        // the right side of the viewport.
+        const ptrdiff_t textBlockHeight = ::base::ClampMul(_currentTextBlockHeight, scaleFactor);
+
+        // Get the bounds of the composition text, in pixels.
+        const til::rectangle textBounds{ til::point{ screenCursorPos.x(), screenCursorPos.y() },
+                                         til::size{ 0, textBlockHeight } };
+
+        _currentTextBounds = textBounds;
 
-        _currentTextBounds = ScaleRect(Rect(screenCursorPos.X, textBottom, 0, fontHeight), scaleFactor);
-        _currentControlBounds = ScaleRect(Rect(screenCursorPos.X, screenCursorPos.Y, 0, fontHeight), scaleFactor);
+        _currentControlBounds = Rect(screenCursorPos.x<float>(),
+                                     screenCursorPos.y<float>(),
+                                     0,
+                                     fontSize.height<float>());
     }
 
     // Method Description: