_In_ IWindowMetrics* pMetrics,

const TextAttribute popupAttributes,

FontInfoDesired fontInfoDesired,

FontInfo fontInfo) :

_pConsoleWindowMetrics{ pMetrics },

_PopupAttributes{ popupAttributes },

_currentFont{ std::move(fontInfo) }

{

// Check if VT mode should be enabled by default. This can be true if

// VirtualTerminalLevel is set to !=0 in the registry, or when conhost

// is started in conpty mode.

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

if (gci.GetDefaultVirtTermLevel() != 0)

{

OutputMode |= ENABLE_VIRTUAL_TERMINAL_PROCESSING;

}

_setDesiredFont(std::move(fontInfoDesired));

FontInfoDesired fontInfoDesired,

FontInfo fontInfo,

_In_ til::size coordScreenBufferSize,

const TextAttribute defaultAttributes,

const TextAttribute popupAttributes,

const UINT uiCursorSize,

_Outptr_ SCREEN_INFORMATION** const ppScreen)

{

*ppScreen = nullptr;

try

{

auto pMetrics = ServiceLocator::LocateWindowMetrics();

THROW_HR_IF_NULL(E_FAIL, pMetrics);

// It is possible for pNotifier to be null and that's OK.

// For instance, the PTY doesn't need to send events. Just pass it along

// and be sure that `SCREEN_INFORMATION` bypasses all event work if it's not there.

const auto pScreen = new SCREEN_INFORMATION(pMetrics, popupAttributes, std::move(fontInfoDesired), std::move(fontInfo));

// Set up viewport

pScreen->_viewport = Viewport::FromDimensions({ 0, 0 },

pScreen->_IsInPtyMode() ? coordScreenBufferSize : coordWindowSize);

pScreen->UpdateBottom();

// Set up text buffer

pScreen->_textBuffer = std::make_unique<TextBuffer>(coordScreenBufferSize,

defaultAttributes,

uiCursorSize,

pScreen->IsActiveScreenBuffer(),

ServiceLocator::LocateGlobals().pRender);

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

pScreen->_textBuffer->GetCursor().SetType(gci.GetCursorType());

const auto status = pScreen->_InitializeOutputStateMachine();

if (SUCCEEDED_NTSTATUS(status))

{

*ppScreen = pScreen;

}

LOG_IF_NTSTATUS_FAILED(status);

return status;

}

catch (...)

{

return NTSTATUS_FROM_HRESULT(wil::ResultFromCaughtException());

}

{

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

auto v = _textBuffer->GetSize();

if (gci.IsTerminalScrolling() && v.Height() > _virtualBottom)

{

v = Viewport::FromDimensions({}, { v.Width(), _virtualBottom + 1 });

}

return v;

{

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

FAIL_FAST_IF(!(gci.IsConsoleLocked()));

pScreenInfo->Next = gci.ScreenBuffers;

gci.ScreenBuffers = pScreenInfo;

{

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

gci.GetActiveInputBuffer()->WaitQueue.CancelWaitersForScreenBuffer(pScreenInfo);

if (pScreenInfo == gci.ScreenBuffers)

{

gci.ScreenBuffers = pScreenInfo->Next;

}

else

{

auto* Cur = gci.ScreenBuffers;

auto* Prev = Cur;

while (Cur != nullptr)

{

if (pScreenInfo == Cur)

{

break;

}

Prev = Cur;

Cur = Cur->Next;

}

FAIL_FAST_IF_NULL(Cur);

Prev->Next = Cur->Next;

}

if (pScreenInfo == gci.pCurrentScreenBuffer &&

gci.ScreenBuffers != gci.pCurrentScreenBuffer)

{

if (gci.ScreenBuffers != nullptr)

{

SetActiveScreenBuffer(*gci.ScreenBuffers);

}

else

{

gci.pCurrentScreenBuffer = nullptr;

}

}

delete pScreenInfo;

{

try

{

auto& g = ServiceLocator::LocateGlobals();

auto& gci = g.getConsoleInformation();

auto& renderSettings = gci.GetRenderSettings();

auto& terminalInput = gci.GetActiveInputBuffer()->GetTerminalInput();

auto adapter = std::make_unique<AdaptDispatch>(_api, g.pRender, renderSettings, terminalInput);

auto engine = std::make_unique<OutputStateMachineEngine>(std::move(adapter));

// Note that at this point in the setup, we haven't determined if we're

// in VtIo mode or not yet. We'll set the OutputStateMachine's

// TerminalConnection later, in VtIo::StartIfNeeded

_stateMachine = std::make_shared<StateMachine>(std::move(engine));

}

catch (...)

{

// if any part of initialization failed, free the allocated ones.

_FreeOutputStateMachine();

return NTSTATUS_FROM_HRESULT(wil::ResultFromCaughtException());

}

return STATUS_SUCCESS;

{

if (_psiMainBuffer == nullptr) // If this is a main buffer

{

if (_psiAlternateBuffer != nullptr)

{

s_RemoveScreenBuffer(_psiAlternateBuffer);

}

_stateMachine.reset();

}

{

// the following macro returns TRUE if the given screen buffer is the active screen buffer.

//#define ACTIVE_SCREEN_BUFFER(SCREEN_INFO) (gci.CurrentScreenBuffer == SCREEN_INFO)

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

return (gci.pCurrentScreenBuffer == this);

_Out_ til::point* pcoordCursorPosition,

_Out_ til::inclusive_rect* psrWindow,

_Out_ PWORD pwAttributes,

_Out_ til::size* pcoordMaximumWindowSize,

_Out_ PWORD pwPopupAttributes,

_Out_writes_(COLOR_TABLE_SIZE) LPCOLORREF lpColorTable) const

{

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

*pcoordSize = GetBufferSize().Dimensions();

*pcoordCursorPosition = _textBuffer->GetCursor().GetPosition();

*psrWindow = _viewport.ToInclusive();

*pwAttributes = GetAttributes().GetLegacyAttributes();

*pwPopupAttributes = _PopupAttributes.GetLegacyAttributes();

// the copy length must be constant for now to keep OACR happy with buffer overruns.

for (size_t i = 0; i < COLOR_TABLE_SIZE; i++)

{

lpColorTable[i] = gci.GetLegacyColorTableEntry(i);

}

*pcoordMaximumWindowSize = GetMaxWindowSizeInCharacters();

{

FAIL_FAST_IF(coordFontSize.width == 0);

FAIL_FAST_IF(coordFontSize.height == 0);

// prepare rectangle

const auto rcWindowInPixels = _pConsoleWindowMetrics->GetMinClientRectInPixels();

// assign the pixel widths and heights to the final output

til::size coordClientAreaSize;

coordClientAreaSize.width = rcWindowInPixels.width();

coordClientAreaSize.height = rcWindowInPixels.height();

// now retrieve the font size and divide the pixel counts into character counts

auto coordFont = coordFontSize; // by default, use the size we were given

// If text info has been set up, instead retrieve its font size

if (_textBuffer != nullptr)

{

coordFont = GetScreenFontSize();

}

FAIL_FAST_IF(coordFont.width == 0);

FAIL_FAST_IF(coordFont.height == 0);

coordClientAreaSize.width /= coordFont.width;

coordClientAreaSize.height /= coordFont.height;

return coordClientAreaSize;

{

FAIL_FAST_IF(coordFontSize.width == 0);

FAIL_FAST_IF(coordFontSize.height == 0);

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

auto coordClientAreaSize = coordScreenBufferSize;

// Important re: headless consoles on onecore (for telnetd, etc.)

// GetConsoleScreenBufferInfoEx hits this to get the max size of the display.

// Because we're headless, we don't really care about the max size of the display.

// In that case, we'll just return the buffer size as the "max" window size.

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

{

const auto coordWindowRestrictedSize = GetLargestWindowSizeInCharacters(coordFontSize);

// If the buffer is smaller than what the max window would allow, then the max client area can only be as big as the

// buffer we have.

coordClientAreaSize.width = std::min(coordScreenBufferSize.width, coordWindowRestrictedSize.width);

coordClientAreaSize.height = std::min(coordScreenBufferSize.height, coordWindowRestrictedSize.height);

}

return coordClientAreaSize;

{

FAIL_FAST_IF(coordFontSize.width == 0);

FAIL_FAST_IF(coordFontSize.height == 0);

const auto rcClientInPixels = _pConsoleWindowMetrics->GetMaxClientRectInPixels();

// first assign the pixel widths and heights to the final output

til::size coordClientAreaSize;

coordClientAreaSize.width = rcClientInPixels.width();

coordClientAreaSize.height = rcClientInPixels.height();

// now retrieve the font size and divide the pixel counts into character counts

auto coordFont = coordFontSize; // by default, use the size we were given

// If renderer has been set up, instead retrieve its font size

if (ServiceLocator::LocateGlobals().pRender != nullptr)

{

coordFont = GetScreenFontSize();

}

FAIL_FAST_IF(coordFont.width == 0);

FAIL_FAST_IF(coordFont.height == 0);

coordClientAreaSize.width /= coordFont.width;

coordClientAreaSize.height /= coordFont.height;

return coordClientAreaSize;

{

auto coordFont = GetScreenFontSize();

auto vScrollSize = ServiceLocator::LocateGlobals().sVerticalScrollSize;

auto hScrollSize = ServiceLocator::LocateGlobals().sHorizontalScrollSize;

til::size coordBarSizes;

coordBarSizes.width = (vScrollSize / coordFont.width) + ((vScrollSize % coordFont.width) != 0 ? 1 : 0);

coordBarSizes.height = (hScrollSize / coordFont.height) + ((hScrollSize % coordFont.height) != 0 ? 1 : 0);

return coordBarSizes;

{

const auto coordFontSize = GetCurrentFont().GetCellSizeInPhysicalPx();

// TODO: Assert valid size boundaries

pRequiredSize->width = GetViewport().Width() * coordFontSize.width;

pRequiredSize->height = GetViewport().Height() * coordFontSize.height;

{

// If we have no renderer, then we don't really need any sort of pixel math. so the "font size" for the scale factor

// (which is used almost everywhere around the code as * and / calls) should just be 1,1 so those operations will do

// effectively nothing.

til::size coordRet = { 1, 1 };

if (ServiceLocator::LocateGlobals().pRender != nullptr)

{

coordRet = GetCurrentFont().GetCellSizeInPhysicalPx();

}

// For sanity's sake, make sure not to leak 0 out as a possible value. These values are used in division operations.

coordRet.width = std::max(coordRet.width, 1);

coordRet.height = std::max(coordRet.height, 1);

return coordRet;

{

if (IsActiveScreenBuffer())

{

auto& globals = ServiceLocator::LocateGlobals();

const auto& gci = globals.getConsoleInformation();

// Hand the handle to our internal structure to the font change trigger in case it updates it based on what's appropriate.

if (globals.pRender != nullptr)

{

globals.pRender->TriggerFontChange(globals.dpi, GetDesiredFont(), GetCurrentFont());

}

TextMeasurementMode mode;

switch (gci.GetTextMeasurementMode())

{

case SettingsTextMeasurementMode::Wcswidth:

mode = TextMeasurementMode::Wcswidth;

break;

case SettingsTextMeasurementMode::Console:

mode = TextMeasurementMode::Console;

break;

default:

mode = TextMeasurementMode::Graphemes;

break;

}

CodepointWidthDetector::Singleton().Reset(mode);

}

{

auto& globals = ServiceLocator::LocateGlobals();

auto& gci = globals.getConsoleInformation();

newFont.SetEnableBuiltinGlyphs(gci.GetEnableBuiltinGlyphs());

if (newFont.GetFaceName() == DEFAULT_TT_FONT_FACENAME)

{

// GH#3123: Propagate font length changes up through Settings and propsheet

wchar_t faceName[LF_FACESIZE];

if (SUCCEEDED(TrueTypeFontList::s_SearchByCodePage(newFont.GetCodePage(), faceName, ARRAYSIZE(faceName))))

{

newFont.SetFaceName(faceName);

// If we're assigning a default true type font name, make sure the family is also set to TrueType

// to help GDI select the appropriate font when we actually create it.

newFont.SetFamily(TMPF_TRUETYPE);

}

}

_desiredFont = std::move(newFont);

{

_setDesiredFont(std::move(newFont));

RefreshFontWithRenderer();

// If we're the active screen buffer...

if (IsActiveScreenBuffer())

{

// If there is a window attached, let it know that it should try to update so the rows/columns are now accounting for the new font.

const auto pWindow = ServiceLocator::LocateConsoleWindow();

if (nullptr != pWindow)

{

auto coordViewport = GetViewport().Dimensions();

pWindow->UpdateWindowSize(coordViewport);

}

}

// If we're an alt buffer, also update our main buffer.

if (_psiMainBuffer)

{

_psiMainBuffer->UpdateFont(_desiredFont);

}

{

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

if (!IsActiveScreenBuffer())

{

return;

}

if (gci.Flags & CONSOLE_UPDATING_SCROLL_BARS || ServiceLocator::LocateConsoleWindow() == nullptr)

{

return;

}

gci.Flags |= CONSOLE_UPDATING_SCROLL_BARS;

LOG_IF_WIN32_BOOL_FALSE(ServiceLocator::LocateConsoleWindow()->PostUpdateScrollBars());

{

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

WI_ClearFlag(gci.Flags, CONSOLE_UPDATING_SCROLL_BARS);

// Fire off an event to let accessibility apps know the layout has changed.

ServiceLocator::LocateGlobals().accessibilityNotifier.Layout();

// The scrollbar state always tracks the main buffer, even when an

// alt buffer is active. This ensures that switching the alt buffer

// on/off doesn't shift the window or its contents around.

//

// Since we don't handle the deferred main buffer resize (`_fAltWindowChanged`)

// this results in some odd behavior when resizing a horizontally scrolling window.

// This can be fixed by running the _AdjustScreenBuffer arithmetic here.

// However, this complicates the design for a feature that is rarely used nowadays.

const auto& mainBuffer = GetMainBuffer();

const auto buffer = mainBuffer.GetBufferSize();

const auto isAltBuffer = _IsAltBuffer();

const auto maxSizeVer = gci.IsTerminalScrolling() ? mainBuffer._virtualBottom : buffer.BottomInclusive();

const auto maxSizeHor = buffer.RightInclusive();

const auto viewport = mainBuffer._viewport.ToExclusive();

return ScrollBarState{

.maxSize = { maxSizeHor, maxSizeVer },

.viewport = viewport,

.isAltBuffer = isAltBuffer,

};

{

// If this is the alt buffer or a VT I/O buffer:

// first resize ourselves to match the new viewport

// then also make sure that the main buffer gets the same call

// (if necessary)

if (_IsInPtyMode())

{

LOG_IF_FAILED(ResizeScreenBuffer(*pcoordSize, TRUE));

if (_psiMainBuffer)

{

_psiMainBuffer->_fAltWindowChanged = false;

_psiMainBuffer->_deferredPtyResize = GetBufferSize().Dimensions();

}

}

_InternalSetViewportSize(pcoordSize, false, false);

const til::point coordWindowOrigin,

const bool updateBottom)

{

// calculate window size

auto WindowSize = _viewport.Dimensions();

til::inclusive_rect NewWindow;

// if relative coordinates, figure out absolute coords.

if (!fAbsolute)

{

if (coordWindowOrigin.x == 0 && coordWindowOrigin.y == 0)

{

return STATUS_SUCCESS;

}

NewWindow.left = _viewport.Left() + coordWindowOrigin.x;

NewWindow.top = _viewport.Top() + coordWindowOrigin.y;

}

else

{

if (coordWindowOrigin == _viewport.Origin())

{

return STATUS_SUCCESS;

}

NewWindow.left = coordWindowOrigin.x;

NewWindow.top = coordWindowOrigin.y;

}

NewWindow.right = NewWindow.left + WindowSize.width - 1;

NewWindow.bottom = NewWindow.top + WindowSize.height - 1;

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

// If we're in terminal scrolling mode, and we're trying to set the viewport

// below the logical viewport, without updating our virtual bottom

// (the logical viewport's position), dont.

// Instead move us to the bottom of the logical viewport.

if (gci.IsTerminalScrolling() && !updateBottom && NewWindow.bottom > _virtualBottom)

{

const auto delta = _virtualBottom - NewWindow.bottom;

NewWindow.top += delta;

NewWindow.bottom += delta;

}

// see if new window origin would extend window beyond extent of screen buffer

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

if (NewWindow.left < 0 ||

NewWindow.top < 0 ||

NewWindow.right < 0 ||

NewWindow.bottom < 0 ||

NewWindow.right >= coordScreenBufferSize.width ||

NewWindow.bottom >= coordScreenBufferSize.height)

{

return STATUS_INVALID_PARAMETER;

}

if (IsActiveScreenBuffer() && ServiceLocator::LocateConsoleWindow() != nullptr)

{

// Tell the window that it needs to set itself to the new origin if we're the active buffer.

ServiceLocator::LocateConsoleWindow()->ChangeViewport(NewWindow);

}

else

{

// Otherwise, just store the new position and go on.

_CommitViewport(Viewport::FromInclusive(NewWindow));

}

// Update our internal virtual bottom tracker if requested. This helps keep

// the viewport's logical position consistent from the perspective of a

// VT client application, even if the user scrolls the viewport with the mouse.

// We typically only want to this to move the virtual bottom down, though,

// otherwise it can end up "truncating" the buffer if the user is viewing

// the scrollback at the time the viewport origin is updated.

if (updateBottom && _virtualBottom < _viewport.BottomInclusive())

{

UpdateBottom();

}

return STATUS_SUCCESS;

{

if (IsActiveScreenBuffer())

{

if (ServiceLocator::LocateConsoleWindow() != nullptr)

{

return ServiceLocator::LocateConsoleWindow()->SendNotifyBeep();

}

}

return false;

{

if (IsActiveScreenBuffer())

{

if (ServiceLocator::LocateConsoleWindow() != nullptr)

{

return ServiceLocator::LocateConsoleWindow()->PostUpdateWindowSize();

}

}

return false;

const til::rect* const prcClientOld)

{

if (_IsAltBuffer())

{

// Stash away the size of the window, we'll need to do this to the main when we pop back

// We set this on the main, so that main->alt(resize)->alt keeps the resize

_psiMainBuffer->_fAltWindowChanged = true;

_psiMainBuffer->_rcAltSavedClientNew = *prcClientNew;

_psiMainBuffer->_rcAltSavedClientOld = *prcClientOld;

}

// 1.a In some modes, the screen buffer size needs to change on window size,

// so do that first.

LOG_IF_FAILED(_AdjustScreenBuffer(prcClientNew));

// 2. Now calculate how large the new viewport should be

til::size coordViewportSize;

_CalculateViewportSize(prcClientNew, &coordViewportSize);

// 3. And adjust the existing viewport to match the same dimensions.

// The old/new comparison is to figure out which side the window was resized from.

_AdjustViewportSize(prcClientNew, prcClientOld, &coordViewportSize);

// 4. Finally, update the scroll bars.

UpdateScrollBars();

FAIL_FAST_IF(!(_viewport.Top() >= 0));

// TODO MSFT: 17663344 - Audit call sites for this precondition. Extremely tiny offscreen windows.

//FAIL_FAST_IF(!(_viewport.IsValid()));

const til::size coordBufferOld,

_Out_ til::size* const pcoordClientNewCharacters)

{

// Get the font size ready.

const auto coordFontSize = GetScreenFontSize();

// We cannot operate if the font size is 0. This shouldn't happen, but stop early if it does.

RETURN_HR_IF(E_NOT_VALID_STATE, 0 == coordFontSize.width || 0 == coordFontSize.height);

// Find out how much client space we have to work with in the new area.

til::size sizeClientNewPixels;

sizeClientNewPixels.width = prcClientNew->width();

sizeClientNewPixels.height = prcClientNew->height();

// Subtract out scroll bar space if scroll bars will be necessary.

auto fIsHorizontalVisible = false;

auto fIsVerticalVisible = false;

s_CalculateScrollbarVisibility(prcClientNew, &coordBufferOld, &coordFontSize, &fIsHorizontalVisible, &fIsVerticalVisible);

if (fIsHorizontalVisible)

{

sizeClientNewPixels.height -= ServiceLocator::LocateGlobals().sHorizontalScrollSize;

}

if (fIsVerticalVisible)

{

sizeClientNewPixels.width -= ServiceLocator::LocateGlobals().sVerticalScrollSize;

}

// Now with the scroll bars removed, calculate how many characters could fit into the new window area.

*pcoordClientNewCharacters = sizeClientNewPixels / coordFontSize;

// If the new client is too tiny, our viewport will be 1x1.

pcoordClientNewCharacters->width = std::max(pcoordClientNewCharacters->width, 1);

pcoordClientNewCharacters->height = std::max(pcoordClientNewCharacters->height, 1);

return S_OK;

{

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

// Prepare the buffer sizes.

// We need the main's size here to maintain the right scrollbar visibility.

const auto coordBufferSizeOld = _IsAltBuffer() ? _psiMainBuffer->GetBufferSize().Dimensions() : GetBufferSize().Dimensions();

auto coordBufferSizeNew = coordBufferSizeOld;

// First figure out how many characters we could fit into the new window given the old buffer size

til::size coordClientNewCharacters;

RETURN_IF_FAILED(_AdjustScreenBufferHelper(prcClientNew, coordBufferSizeOld, &coordClientNewCharacters));

// If we're in wrap text mode, then we want to be fixed to the window size. So use the character calculation we just got

// to fix the buffer and window width together.

if (gci.GetWrapText())

{

coordBufferSizeNew.width = coordClientNewCharacters.width;

}

// Reanalyze scroll bars in case we fixed the edge together for word wrap.

// Use the new buffer client size.

RETURN_IF_FAILED(_AdjustScreenBufferHelper(prcClientNew, coordBufferSizeNew, &coordClientNewCharacters));

// Now reanalyze the buffer size and grow if we can fit more characters into the window no matter the console mode.

if (_IsInPtyMode())

{

// The alt buffer always wants to be exactly the size of the screen, never more or less.

// This prevents scrollbars when you increase the alt buffer size, then decrease it.

// Can't have a buffer dimension of 0 - that'll cause divide by zeros in the future.

coordBufferSizeNew.width = std::max(coordClientNewCharacters.width, 1);

coordBufferSizeNew.height = std::max(coordClientNewCharacters.height, 1);

}

else

{

if (coordClientNewCharacters.width > coordBufferSizeNew.width)

{

coordBufferSizeNew.width = coordClientNewCharacters.width;

}

if (coordClientNewCharacters.height > coordBufferSizeNew.height)

{

coordBufferSizeNew.height = coordClientNewCharacters.height;

}

}

RETURN_IF_NTSTATUS_FAILED(ResizeScreenBuffer(coordBufferSizeNew, FALSE));

return S_OK;

{

const auto coordBufferSize = GetBufferSize().Dimensions();

const auto coordFontSize = GetScreenFontSize();

til::size sizeClientPixels;

sizeClientPixels.width = prcClientArea->width();

sizeClientPixels.height = prcClientArea->height();

bool fIsHorizontalVisible;

bool fIsVerticalVisible;

s_CalculateScrollbarVisibility(prcClientArea,

&coordBufferSize,

&coordFontSize,

&fIsHorizontalVisible,

&fIsVerticalVisible);

if (fIsHorizontalVisible)

{

sizeClientPixels.height -= ServiceLocator::LocateGlobals().sHorizontalScrollSize;

}

if (fIsVerticalVisible)

{

sizeClientPixels.width -= ServiceLocator::LocateGlobals().sVerticalScrollSize;

}

pcoordSize->width = (til::CoordType)(sizeClientPixels.width / coordFontSize.width);

pcoordSize->height = (til::CoordType)(sizeClientPixels.height / coordFontSize.height);

const bool fResizeFromTop,

const bool fResizeFromLeft)

{

const auto DeltaX = pcoordSize->width - _viewport.Width();

const auto DeltaY = pcoordSize->height - _viewport.Height();

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

if (DeltaX == 0 && DeltaY == 0)

{

return;

}

// do adjustments on a copy that's easily manipulated.

auto srNewViewport = _viewport.ToInclusive();

// Now we need to determine what our new Window size should

// be. Note that Window here refers to the character/row window.

if (fResizeFromLeft)

{

// we're being horizontally sized from the left border

const auto sLeftProposed = srNewViewport.left - DeltaX;

if (sLeftProposed >= 0)

{

// there's enough room in the backlog to just expand left

srNewViewport.left -= DeltaX;

}

else