{

try

{

const auto& gci = ServiceLocator::LocateGlobals().getConsoleInformation();

LockConsole();

auto Unlock = wil::scope_exit([&] { UnlockConsole(); });

mode = context.InputMode;

if (WI_IsFlagSet(gci.Flags, CONSOLE_USE_PRIVATE_FLAGS))

{

WI_SetFlag(mode, ENABLE_EXTENDED_FLAGS);

WI_SetFlagIf(mode, ENABLE_INSERT_MODE, gci.GetInsertMode());

WI_SetFlagIf(mode, ENABLE_QUICK_EDIT_MODE, WI_IsFlagSet(gci.Flags, CONSOLE_QUICK_EDIT_MODE));

WI_SetFlagIf(mode, ENABLE_AUTO_POSITION, WI_IsFlagSet(gci.Flags, CONSOLE_AUTO_POSITION));

}

}

CATCH_LOG();

{

try

{

LockConsole();

auto Unlock = wil::scope_exit([&] { UnlockConsole(); });

mode = context.GetActiveBuffer().OutputMode;

}

CATCH_LOG();

{

try

{

LockConsole();

auto Unlock = wil::scope_exit([&] { UnlockConsole(); });

const auto readyEventCount = context.GetNumberOfReadyEvents();

RETURN_IF_FAILED(SizeTToULong(readyEventCount, &events));

return S_OK;

}

CATCH_RETURN();

CONSOLE_SCREEN_BUFFER_INFOEX& data) noexcept

{

try

{

LockConsole();

auto Unlock = wil::scope_exit([&] { UnlockConsole(); });

data.bFullscreenSupported = FALSE; // traditional full screen with the driver support is no longer supported.

// see MSFT: 19918103

// Make sure to use the active buffer here. There are clients that will

// use WINDOW_SIZE_EVENTs as a signal to then query the console

// with GetConsoleScreenBufferInfoEx to get the actual viewport

// size.

// If they're in the alt buffer, then when they query in that way, the

// value they'll get is the main buffer's size, which isn't updated

// until we switch back to it.

til::size dwSize;

til::point dwCursorPosition;

til::inclusive_rect srWindow;

til::size dwMaximumWindowSize;

context.GetActiveBuffer().GetScreenBufferInformation(&dwSize,

&dwCursorPosition,

&srWindow,

&data.wAttributes,

&dwMaximumWindowSize,

&data.wPopupAttributes,

data.ColorTable);

// Callers of this function expect to receive an exclusive rect, not an

// inclusive one. The driver will mangle this value for us

// - For GetConsoleScreenBufferInfoEx, it will re-decrement these values

// to return an inclusive rect.

// - For GetConsoleScreenBufferInfo, it will leave these values

// untouched, returning an exclusive rect.

srWindow.right += 1;

srWindow.bottom += 1;

data.dwSize = til::unwrap_coord_size(dwSize);

data.dwCursorPosition = til::unwrap_coord(dwCursorPosition);

data.srWindow = til::unwrap_small_rect(srWindow);

data.dwMaximumWindowSize = til::unwrap_coord_size(dwMaximumWindowSize);

}

CATCH_LOG();

ULONG& size,

bool& isVisible) noexcept

{

try

{

LockConsole();

auto Unlock = wil::scope_exit([&] { UnlockConsole(); });

size = context.GetActiveBuffer().GetTextBuffer().GetCursor().GetSize();

isVisible = context.GetTextBuffer().GetCursor().IsVisible();

}

CATCH_LOG();

{

try

{

LockConsole();

auto Unlock = wil::scope_exit([&] { UnlockConsole(); });

const auto& selection = Selection::Instance();

if (selection.IsInSelectingState())

{

consoleSelectionInfo.dwFlags = selection.GetPublicSelectionFlags();

WI_SetFlag(consoleSelectionInfo.dwFlags, CONSOLE_SELECTION_IN_PROGRESS);

consoleSelectionInfo.dwSelectionAnchor = til::unwrap_coord(selection.GetSelectionAnchor());

consoleSelectionInfo.srSelection = til::unwrap_small_rect(selection.GetSelectionRectangle());

}

else

{

ZeroMemory(&consoleSelectionInfo, sizeof(consoleSelectionInfo));

}

}

CATCH_LOG();

{

try

{

LockConsole();

auto Unlock = wil::scope_exit([&] { UnlockConsole(); });

buttons = ServiceLocator::LocateSystemConfigurationProvider()->GetNumberOfMouseButtons();

}

CATCH_LOG();

const DWORD index,

til::size& size) noexcept

{

try

{

LockConsole();

auto Unlock = wil::scope_exit([&] { UnlockConsole(); });

if (index == 0)

{

// As of the November 2015 renderer system, we only have a single font at index 0.

size = context.GetActiveBuffer().GetCurrentFont().GetUnscaledSize();

return S_OK;

}

else

{

// Invalid font is 0,0 with STATUS_INVALID_PARAMETER

size = {};

return E_INVALIDARG;

}

}

CATCH_RETURN();

const bool isForMaximumWindowSize,

CONSOLE_FONT_INFOEX& consoleFontInfoEx) noexcept

{

try

{

LockConsole();

auto Unlock = wil::scope_exit([&] { UnlockConsole(); });

const auto& activeScreenInfo = context.GetActiveBuffer();

til::size WindowSize;

if (isForMaximumWindowSize)

{

WindowSize = activeScreenInfo.GetMaxWindowSizeInCharacters();

}

else

{

WindowSize = activeScreenInfo.GetCurrentFont().GetUnscaledSize();

}

consoleFontInfoEx.dwFontSize = til::unwrap_coord_size(WindowSize);

consoleFontInfoEx.nFont = 0;

const auto& fontInfo = activeScreenInfo.GetCurrentFont();

consoleFontInfoEx.FontFamily = fontInfo.GetFamily();

consoleFontInfoEx.FontWeight = fontInfo.GetWeight();

fontInfo.FillLegacyNameBuffer(consoleFontInfoEx.FaceName);

return S_OK;

}

CATCH_RETURN();

const bool /*isForMaximumWindowSize*/,

const CONSOLE_FONT_INFOEX& consoleFontInfoEx) noexcept

{

try

{

const auto& gci = ServiceLocator::LocateGlobals().getConsoleInformation();

LockConsole();

auto Unlock = wil::scope_exit([&] { UnlockConsole(); });

auto& activeScreenInfo = context.GetActiveBuffer();

WCHAR FaceName[ARRAYSIZE(consoleFontInfoEx.FaceName)];

RETURN_IF_FAILED(StringCchCopyW(FaceName, ARRAYSIZE(FaceName), consoleFontInfoEx.FaceName));

FontInfo fi(FaceName,

gsl::narrow_cast<unsigned char>(consoleFontInfoEx.FontFamily),

consoleFontInfoEx.FontWeight,

til::wrap_coord_size(consoleFontInfoEx.dwFontSize),

gci.OutputCP);

// TODO: MSFT: 9574827 - should this have a failure case?

activeScreenInfo.UpdateFont(&fi);

return S_OK;

}

CATCH_RETURN();

{

try

{

auto& gci = ServiceLocator::LocateGlobals().getConsoleInformation();

LockConsole();

auto Unlock = wil::scope_exit([&] { UnlockConsole(); });

const auto oldQuickEditMode{ WI_IsFlagSet(gci.Flags, CONSOLE_QUICK_EDIT_MODE) };

if (WI_IsAnyFlagSet(mode, PRIVATE_MODES))

{

WI_SetFlag(gci.Flags, CONSOLE_USE_PRIVATE_FLAGS);

WI_UpdateFlag(gci.Flags, CONSOLE_QUICK_EDIT_MODE, WI_IsFlagSet(mode, ENABLE_QUICK_EDIT_MODE));

WI_UpdateFlag(gci.Flags, CONSOLE_AUTO_POSITION, WI_IsFlagSet(mode, ENABLE_AUTO_POSITION));

const auto PreviousInsertMode = gci.GetInsertMode();

gci.SetInsertMode(WI_IsFlagSet(mode, ENABLE_INSERT_MODE));

if (gci.GetInsertMode() != PreviousInsertMode)

{

gci.GetActiveOutputBuffer().SetCursorDBMode(false);

if (gci.HasPendingCookedRead())

{

gci.CookedReadData().SetInsertMode(gci.GetInsertMode());

}

}

}

else

{

WI_ClearFlag(gci.Flags, CONSOLE_USE_PRIVATE_FLAGS);

}

if (auto writer = gci.GetVtWriter())

{

auto oldMode = context.InputMode;

auto newMode = mode;

// Mouse input should be received when mouse mode is on and quick edit mode is off

// (for more information regarding the quirks of mouse mode and why/how it relates

// to quick edit mode, see GH#9970)

const auto newQuickEditMode{ WI_IsFlagSet(gci.Flags, CONSOLE_QUICK_EDIT_MODE) };

WI_ClearFlagIf(oldMode, ENABLE_MOUSE_INPUT, oldQuickEditMode);

WI_ClearFlagIf(newMode, ENABLE_MOUSE_INPUT, newQuickEditMode);

if (const auto diff = oldMode ^ newMode)

{

if (WI_IsFlagSet(diff, ENABLE_MOUSE_INPUT))

{

writer.WriteSGR1006(WI_IsFlagSet(newMode, ENABLE_MOUSE_INPUT));

}

}

writer.Submit();

}

context.InputMode = mode;

WI_ClearAllFlags(context.InputMode, PRIVATE_MODES);

// NOTE: For compatibility reasons, we need to set the modes and then return the error codes, not the other way around

// as might be expected.

// This is a bug from a long time ago and some applications depend on this functionality to operate properly.

// ---

// A prime example of this is that PSReadline module in Powershell will set the invalid mode 0x1e4

// which includes 0x4 for ECHO_INPUT but turns off 0x2 for LINE_INPUT. This is invalid, but PSReadline

// relies on it to properly receive the ^C printout and make a new line when the user presses Ctrl+C.

{

// Flags we don't understand are invalid.

RETURN_HR_IF(E_INVALIDARG, WI_IsAnyFlagSet(mode, ~(INPUT_MODES | PRIVATE_MODES)));

// ECHO on with LINE off is invalid.

RETURN_HR_IF_EXPECTED(E_INVALIDARG, WI_IsFlagSet(mode, ENABLE_ECHO_INPUT) && WI_IsFlagClear(mode, ENABLE_LINE_INPUT));

}

return S_OK;

}

CATCH_RETURN();

{

try

{

LockConsole();

auto Unlock = wil::scope_exit([&] { UnlockConsole(); });

// Flags we don't understand are invalid.

RETURN_HR_IF(E_INVALIDARG, WI_IsAnyFlagSet(mode, ~OUTPUT_MODES));

auto& screenInfo = context.GetActiveBuffer();

const auto dwOldMode = screenInfo.OutputMode;

const auto dwNewMode = mode;

const auto diff = dwOldMode ^ dwNewMode;

screenInfo.OutputMode = dwNewMode;

// if we're moving from VT on->off

if (WI_IsFlagClear(dwNewMode, ENABLE_VIRTUAL_TERMINAL_PROCESSING) &&

WI_IsFlagSet(dwOldMode, ENABLE_VIRTUAL_TERMINAL_PROCESSING))

{

// jiggle the handle

screenInfo.GetStateMachine().ResetState();

}

// if we changed rendering modes then redraw the output buffer.

if (WI_IsAnyFlagSet(diff, ENABLE_VIRTUAL_TERMINAL_PROCESSING | ENABLE_LVB_GRID_WORLDWIDE))

{

if (const auto pRender = ServiceLocator::LocateGlobals().pRender)

{

pRender->TriggerRedrawAll();

}

}

auto& gci = ServiceLocator::LocateGlobals().getConsoleInformation();

if (auto writer = gci.GetVtWriterForBuffer(&context))

{

if (WI_IsFlagSet(diff, ENABLE_WRAP_AT_EOL_OUTPUT))

{

writer.WriteDECAWM(WI_IsFlagSet(dwNewMode, ENABLE_WRAP_AT_EOL_OUTPUT));

}

writer.Submit();

}

return S_OK;

}

CATCH_RETURN();

{

try

{

LockConsole();

auto Unlock = wil::scope_exit([&] { UnlockConsole(); });

auto& gci = ServiceLocator::LocateGlobals().getConsoleInformation();

if (&newContext.GetActiveBuffer() == &gci.GetActiveOutputBuffer())

{

return;

}

if (auto writer = gci.GetVtWriter())

{

const auto oldSize = gci.GetActiveOutputBuffer().GetBufferSize().Dimensions();

writer.WriteScreenInfo(newContext, oldSize);

writer.Submit();

}

SetActiveScreenBuffer(newContext.GetActiveBuffer());

}

CATCH_LOG();

{

try

{

LockConsole();

auto Unlock = wil::scope_exit([&] { UnlockConsole(); });

context.Flush();

}

CATCH_LOG();

til::size& size) noexcept

{

try

{

LockConsole();

auto Unlock = wil::scope_exit([&] { UnlockConsole(); });

const auto& screenInfo = context.GetActiveBuffer();

size = screenInfo.GetLargestWindowSizeInCharacters();

}

CATCH_LOG();

const til::size size) noexcept

{

try

{

LockConsole();

auto Unlock = wil::scope_exit([&] { UnlockConsole(); });

auto& screenInfo = context.GetActiveBuffer();

// microsoft/terminal#3907 - We shouldn't resize the buffer to be

// smaller than the viewport. This was previously erroneously checked

// when the host was not in conpty mode.

RETURN_HR_IF(E_INVALIDARG, (size.width < screenInfo.GetViewport().Width() || size.height < screenInfo.GetViewport().Height()));

// see MSFT:17415266

// We only really care about the minimum window size if we have a head.

if (!ServiceLocator::LocateGlobals().IsHeadless())

{

const auto coordMin = screenInfo.GetMinWindowSizeInCharacters();

// Make sure requested screen buffer size isn't smaller than the window.

RETURN_HR_IF(E_INVALIDARG, (size.height < coordMin.height || size.width < coordMin.width));

}

// Ensure the requested size isn't larger than we can handle in our data type.

RETURN_HR_IF(E_INVALIDARG, (size.width == SHORT_MAX || size.height == SHORT_MAX));

// Only do the resize if we're actually changing one of the dimensions

const auto coordScreenBufferSize = screenInfo.GetBufferSize().Dimensions();

if (size.width != coordScreenBufferSize.width || size.height != coordScreenBufferSize.height)

{

RETURN_IF_NTSTATUS_FAILED(screenInfo.ResizeScreenBuffer(size, TRUE));

}

// Make sure the viewport doesn't now overflow the buffer dimensions.

auto overflow = screenInfo.GetViewport().BottomRightExclusive() - screenInfo.GetBufferSize().Dimensions();

if (overflow.x > 0 || overflow.y > 0)

{

overflow = { -std::max(overflow.x, 0), -std::max(overflow.y, 0) };

RETURN_IF_NTSTATUS_FAILED(screenInfo.SetViewportOrigin(false, overflow, false));

}

// And also that the cursor position is clamped within the buffer boundaries.

auto& cursor = screenInfo.GetTextBuffer().GetCursor();

auto clampedCursorPosition = cursor.GetPosition();

screenInfo.GetBufferSize().Clamp(clampedCursorPosition);

if (clampedCursorPosition != cursor.GetPosition())

{

cursor.SetPosition(clampedCursorPosition);

}

// TODO GH#5094: This could use xterm's XTWINOPS "\e[8;<height>;<width>t" escape sequence here.

return S_OK;

}

CATCH_RETURN();

const CONSOLE_SCREEN_BUFFER_INFOEX& data) noexcept

{

try

{

// clang-format off

RETURN_HR_IF(E_INVALIDARG, (data.dwSize.X == 0 ||

data.dwSize.Y == 0 ||

data.dwSize.X == SHRT_MAX ||

data.dwSize.Y == SHRT_MAX));

// clang-format on

LockConsole();

auto Unlock = wil::scope_exit([&] { UnlockConsole(); });

auto& g = ServiceLocator::LocateGlobals();

auto& gci = g.getConsoleInformation();

const auto coordScreenBufferSize = context.GetBufferSize().Dimensions();

const auto requestedBufferSize = til::wrap_coord_size(data.dwSize);

if (requestedBufferSize != coordScreenBufferSize)

{

LOG_IF_FAILED(context.ResizeScreenBuffer(requestedBufferSize, TRUE));

}

const auto newBufferSize = context.GetBufferSize().Dimensions();

bool changedOneTableEntry = false;

for (size_t i = 0; i < std::size(data.ColorTable); i++)

{

// Check if we actually changed a palette color

const auto& newColor{ data.ColorTable[i] };

changedOneTableEntry = changedOneTableEntry || (newColor != gci.GetColorTableEntry(i));

// Set the new value.

gci.SetLegacyColorTableEntry(i, newColor);

}

// GH#399: Trigger a redraw, so that updated colors are repainted, but

// only do this if we're not in conpty mode. ConPTY will update the

// colors of the palette elsewhere (after TODO GH#10639)

//

// Only do this if we actually changed the value of the palette though -

// this API gets called all the time to change all sorts of things, but

// not necessarily the palette.

if (changedOneTableEntry)

{

if (auto* pRender{ ServiceLocator::LocateGlobals().pRender })

{

pRender->TriggerRedrawAll();

}

}

context.SetDefaultAttributes(TextAttribute{ data.wAttributes }, TextAttribute{ data.wPopupAttributes });

const auto requestedViewport = Viewport::FromExclusive(til::wrap_exclusive_small_rect(data.srWindow));

auto NewSize = requestedViewport.Dimensions();

// If we have a window, clamp the requested viewport to the max window size

if (!ServiceLocator::LocateGlobals().IsHeadless())

{

NewSize.width = std::min<til::CoordType>(NewSize.width, data.dwMaximumWindowSize.X);

NewSize.height = std::min<til::CoordType>(NewSize.height, data.dwMaximumWindowSize.Y);

}

// If wrap text is on, then the window width must be the same size as the buffer width

if (gci.GetWrapText())

{

NewSize.width = newBufferSize.width;

}

if (NewSize.width != context.GetViewport().Width() ||

NewSize.height != context.GetViewport().Height())

{

context.SetViewportSize(&NewSize);

const auto pWindow = ServiceLocator::LocateConsoleWindow();

if (pWindow != nullptr)

{

pWindow->UpdateWindowSize(NewSize);

}

}

// Despite the fact that this API takes in a srWindow for the viewport, it traditionally actually doesn't set

// anything using that member - for moving the viewport, you need SetConsoleWindowInfo

// (see https://msdn.microsoft.com/en-us/library/windows/desktop/ms686125(v=vs.85).aspx and DoSrvSetConsoleWindowInfo)

// Note that it also doesn't set cursor position.

// However, we do need to make sure the viewport doesn't now overflow the buffer dimensions.

auto overflow = context.GetViewport().BottomRightExclusive() - context.GetBufferSize().Dimensions();

if (overflow.x > 0 || overflow.y > 0)

{

overflow = { -std::max(overflow.x, 0), -std::max(overflow.y, 0) };

RETURN_IF_NTSTATUS_FAILED(context.SetViewportOrigin(false, overflow, false));

}

// And also that the cursor position is clamped within the buffer boundaries.

auto& cursor = context.GetTextBuffer().GetCursor();

auto clampedCursorPosition = cursor.GetPosition();

context.GetBufferSize().Clamp(clampedCursorPosition);

if (clampedCursorPosition != cursor.GetPosition())

{

cursor.SetPosition(clampedCursorPosition);

}

// TODO GH#5094: This could use xterm's XTWINOPS "\e[8;<height>;<width>t" escape sequence here.

return S_OK;

}

CATCH_RETURN();

const til::point position) noexcept

{

try

{

LockConsole();

auto Unlock = wil::scope_exit([&] { UnlockConsole(); });

auto& buffer = context.GetActiveBuffer();

const auto coordScreenBufferSize = buffer.GetBufferSize().Dimensions();

// clang-format off

RETURN_HR_IF(E_INVALIDARG, (position.x >= coordScreenBufferSize.width ||

position.y >= coordScreenBufferSize.height ||

position.x < 0 ||

position.y < 0));

// clang-format on

// MSFT: 15813316 - Try to use this SetCursorPosition call to inherit the cursor position.

auto& gci = ServiceLocator::LocateGlobals().getConsoleInformation();

if (auto writer = gci.GetVtWriterForBuffer(&context))

{

writer.WriteCUP(position);

writer.Submit();

}

RETURN_IF_NTSTATUS_FAILED(buffer.SetCursorPosition(position));

// Attempt to "snap" the viewport to the cursor position. If the cursor

// is not in the current viewport, we'll try and move the viewport so

// that the cursor is visible.

// GH#1222 and GH#9754 - Use the "virtual" viewport here, so that the

// viewport snaps back to the virtual viewport's location.

const auto currentViewport = buffer.GetVirtualViewport().ToInclusive();

til::point delta;

{

// When evaluating the X offset, we must convert the buffer position to

// equivalent screen coordinates, taking line rendition into account.

const auto lineRendition = buffer.GetTextBuffer().GetLineRendition(position.y);

const auto screenPosition = BufferToScreenLine(til::inclusive_rect{ position.x, position.y, position.x, position.y }, lineRendition);

if (currentViewport.left > screenPosition.left)

{

delta.x = screenPosition.left - currentViewport.left;

}

else if (currentViewport.right < screenPosition.right)

{

delta.x = screenPosition.right - currentViewport.right;

}

if (currentViewport.top > position.y)

{

delta.y = position.y - currentViewport.top;

}

else if (currentViewport.bottom < position.y)

{

delta.y = position.y - currentViewport.bottom;

}

}

til::point newWindowOrigin;

newWindowOrigin.x = currentViewport.left + delta.x;

newWindowOrigin.y = currentViewport.top + delta.y;

// SetViewportOrigin will worry about clamping these values to the

// buffer for us.

RETURN_IF_NTSTATUS_FAILED(buffer.SetViewportOrigin(true, newWindowOrigin, true));

// SetViewportOrigin will only move the virtual bottom down, but in

// this particular case we also need to allow the virtual bottom to

// be moved up, so we have to call UpdateBottom explicitly. This is

// how the cmd shell's CLS command resets the buffer.

buffer.UpdateBottom();

auto& an = ServiceLocator::LocateGlobals().accessibilityNotifier;

an.CursorChanged(buffer.GetTextBuffer().GetCursor().GetPosition(), false);

return S_OK;

}

CATCH_RETURN();

const ULONG size,

const bool isVisible) noexcept

{

try

{

LockConsole();

auto Unlock = wil::scope_exit([&] { UnlockConsole(); });

// If more than 100% or less than 0% cursor height, reject it.

RETURN_HR_IF(E_INVALIDARG, (size > 100 || size == 0));

context.SetCursorInformation(size, isVisible);

auto& gci = ServiceLocator::LocateGlobals().getConsoleInformation();

if (auto writer = gci.GetVtWriterForBuffer(&context))

{

writer.WriteDECTCEM(isVisible);

writer.Submit();

}

return S_OK;

}

CATCH_RETURN();

const bool isAbsolute,

const til::inclusive_rect& windowRect) noexcept

{

try

{

LockConsole();

auto Unlock = wil::scope_exit([&] { UnlockConsole(); });

auto& g = ServiceLocator::LocateGlobals();

auto Window = windowRect;

if (!isAbsolute)

{

auto currentViewport = context.GetViewport().ToInclusive();

Window.left += currentViewport.left;

Window.right += currentViewport.right;

Window.top += currentViewport.top;

Window.bottom += currentViewport.bottom;

}

RETURN_HR_IF(E_INVALIDARG, (Window.right < Window.left || Window.bottom < Window.top));

til::size NewWindowSize;

NewWindowSize.width = CalcWindowSizeX(Window);

NewWindowSize.height = CalcWindowSizeY(Window);

// see MSFT:17415266

// If we have an actual head, we care about the maximum size the window can be.

// if we're headless, not so much. However, GetMaxWindowSizeInCharacters

// will only return the buffer size, so we can't use that to clip the arg here.

// So only clip the requested size if we're not headless

if (g.getConsoleInformation().IsInVtIoMode())

{

// SetViewportRect doesn't cause the buffer to resize. Manually resize the buffer.

RETURN_IF_NTSTATUS_FAILED(context.ResizeScreenBuffer(Viewport::FromInclusive(Window).Dimensions(), false));

}

if (!g.IsHeadless())

{

const auto coordMax = context.GetMaxWindowSizeInCharacters();

RETURN_HR_IF(E_INVALIDARG, (NewWindowSize.width > coordMax.width || NewWindowSize.height > coordMax.height));

}

// Even if it's the same size, we need to post an update in case the scroll bars need to go away.

context.SetViewport(Viewport::FromInclusive(Window), true);

if (context.IsActiveScreenBuffer())

{

// TODO: MSFT: 9574827 - shouldn't we be looking at or at least logging the failure codes here? (Or making them non-void?)

context.PostUpdateWindowSize();

// Use WriteToScreen to invalidate the viewport with the renderer.

WriteToScreen(context, context.GetViewport());

}

return S_OK;

}

CATCH_RETURN();

const til::inclusive_rect& source,

const til::point target,

std::optional<til::inclusive_rect> clip,

const char fillCharacter,

const WORD fillAttribute) noexcept

{

try

{

const auto unicodeFillCharacter = CharToWchar(&fillCharacter, 1);

return ScrollConsoleScreenBufferWImpl(context, source, target, clip, unicodeFillCharacter, fillAttribute);

}

CATCH_RETURN();

const til::inclusive_rect& source,

const til::point target,

std::optional<til::inclusive_rect> clip,

wchar_t fillCharacter,

WORD fillAttribute,

const bool enableCmdShim) noexcept

{

try

{

// Just in case if the client application didn't check if this request is useless.

// Checking if the source is empty also prevents bugs where we use the size of calculations.

if ((source.left == target.x && source.top == target.y) ||

source.left > source.right || source.top > source.bottom)

{

return S_OK;

}

LockConsole();

auto Unlock = wil::scope_exit([&] { UnlockConsole(); });

auto& gci = ServiceLocator::LocateGlobals().getConsoleInformation();

auto& buffer = context.GetActiveBuffer();

const auto bufferSize = buffer.GetBufferSize();

auto writer = gci.GetVtWriterForBuffer(&context);

// Applications like to pass 0/0 for the fill char/attribute.

// What they want is the whitespace and current attributes.

if (fillCharacter == UNICODE_NULL && fillAttribute == 0)

{

fillAttribute = buffer.GetAttributes().GetLegacyAttributes();

}

// Avoid writing control characters into the buffer.

// A null character will get translated to whitespace.

fillCharacter = Microsoft::Console::VirtualTerminal::VtIo::SanitizeUCS2(fillCharacter);

// GH#3126 - This is a shim for cmd's `cls` function. In the

// legacy console, `cls` is supposed to clear the entire buffer.

// We always use a VT sequence, even if ConPTY isn't used, because those are faster nowadays.

if (enableCmdShim &&

source.left <= 0 && source.top <= 0 &&

source.right >= bufferSize.RightInclusive() && source.bottom >= bufferSize.BottomInclusive() &&

target.x == 0 && target.y <= -bufferSize.BottomExclusive() &&

!clip &&

fillCharacter == UNICODE_SPACE && fillAttribute == buffer.GetAttributes().GetLegacyAttributes())

{

WriteClearScreen(context);

}

else if (writer)

{

const auto clipViewport = clip ? Viewport::FromInclusive(*clip).Clamp(bufferSize) : bufferSize;

const auto sourceViewport = Viewport::FromInclusive(source);