+++ /dev/null
-// Copyright (c) 2011-2016 Ryan Prichard
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to
-// deal in the Software without restriction, including without limitation the
-// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
-// sell copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
-// IN THE SOFTWARE.
-
-#include "Scraper.h"
-
-#include <windows.h>
-
-#include <stdint.h>
-
-#include <algorithm>
-#include <utility>
-
-#include "../shared/WinptyAssert.h"
-#include "../shared/winpty_snprintf.h"
-
-#include "ConsoleFont.h"
-#include "Win32Console.h"
-#include "Win32ConsoleBuffer.h"
-
-namespace {
-
-template <typename T>
-T constrained(T min, T val, T max) {
- ASSERT(min <= max);
- return std::min(std::max(min, val), max);
-}
-
-} // anonymous namespace
-
-Scraper::Scraper(
- Win32Console &console,
- Win32ConsoleBuffer &buffer,
- std::unique_ptr<Terminal> terminal,
- Coord initialSize) :
- m_console(console),
- m_terminal(std::move(terminal)),
- m_ptySize(initialSize)
-{
- m_consoleBuffer = &buffer;
-
- resetConsoleTracking(Terminal::OmitClear, buffer.windowRect().top());
-
- m_bufferData.resize(BUFFER_LINE_COUNT);
-
- // Setup the initial screen buffer and window size.
- //
- // Use SetConsoleWindowInfo to shrink the console window as much as
- // possible -- to a 1x1 cell at the top-left. This call always succeeds.
- // Prior to the new Windows 10 console, it also actually resizes the GUI
- // window to 1x1 cell. Nevertheless, even though the GUI window can
- // therefore be narrower than its minimum, calling
- // SetConsoleScreenBufferSize with a 1x1 size still fails.
- //
- // While the small font intends to support large buffers, a user could
- // still hit a limit imposed by their monitor width, so cap the new window
- // size to GetLargestConsoleWindowSize().
- setSmallFont(buffer.conout(), initialSize.X, m_console.isNewW10());
- buffer.moveWindow(SmallRect(0, 0, 1, 1));
- buffer.resizeBufferRange(Coord(initialSize.X, BUFFER_LINE_COUNT));
- const auto largest = GetLargestConsoleWindowSize(buffer.conout());
- buffer.moveWindow(SmallRect(
- 0, 0,
- std::min(initialSize.X, largest.X),
- std::min(initialSize.Y, largest.Y)));
- buffer.setCursorPosition(Coord(0, 0));
-
- // For the sake of the color translation heuristic, set the console color
- // to LtGray-on-Black.
- buffer.setTextAttribute(Win32ConsoleBuffer::kDefaultAttributes);
- buffer.clearAllLines(m_consoleBuffer->bufferInfo());
-
- m_consoleBuffer = nullptr;
-}
-
-Scraper::~Scraper()
-{
-}
-
-// Whether or not the agent is frozen on entry, it will be frozen on exit.
-void Scraper::resizeWindow(Win32ConsoleBuffer &buffer,
- Coord newSize,
- ConsoleScreenBufferInfo &finalInfoOut)
-{
- m_consoleBuffer = &buffer;
- m_ptySize = newSize;
- syncConsoleContentAndSize(true, finalInfoOut);
- m_consoleBuffer = nullptr;
-}
-
-// This function may freeze the agent, but it will not unfreeze it.
-void Scraper::scrapeBuffer(Win32ConsoleBuffer &buffer,
- ConsoleScreenBufferInfo &finalInfoOut)
-{
- m_consoleBuffer = &buffer;
- syncConsoleContentAndSize(false, finalInfoOut);
- m_consoleBuffer = nullptr;
-}
-
-void Scraper::resetConsoleTracking(
- Terminal::SendClearFlag sendClear, int64_t scrapedLineCount)
-{
- for (ConsoleLine &line : m_bufferData) {
- line.reset();
- }
- m_syncRow = -1;
- m_scrapedLineCount = scrapedLineCount;
- m_scrolledCount = 0;
- m_maxBufferedLine = -1;
- m_dirtyWindowTop = -1;
- m_dirtyLineCount = 0;
- m_terminal->reset(sendClear, m_scrapedLineCount);
-}
-
-// Detect window movement. If the window moves down (presumably as a
-// result of scrolling), then assume that all screen buffer lines down to
-// the bottom of the window are dirty.
-void Scraper::markEntireWindowDirty(const SmallRect &windowRect)
-{
- m_dirtyLineCount = std::max(m_dirtyLineCount,
- windowRect.top() + windowRect.height());
-}
-
-// Scan the screen buffer and advance the dirty line count when we find
-// non-empty lines.
-void Scraper::scanForDirtyLines(const SmallRect &windowRect)
-{
- const int w = m_readBuffer.rect().width();
- ASSERT(m_dirtyLineCount >= 1);
- const CHAR_INFO *const prevLine =
- m_readBuffer.lineData(m_dirtyLineCount - 1);
- WORD prevLineAttr = prevLine[w - 1].Attributes;
- const int stopLine = windowRect.top() + windowRect.height();
-
- for (int line = m_dirtyLineCount; line < stopLine; ++line) {
- const CHAR_INFO *lineData = m_readBuffer.lineData(line);
- for (int col = 0; col < w; ++col) {
- const WORD colAttr = lineData[col].Attributes;
- if (lineData[col].Char.UnicodeChar != L' ' ||
- colAttr != prevLineAttr) {
- m_dirtyLineCount = line + 1;
- break;
- }
- }
- prevLineAttr = lineData[w - 1].Attributes;
- }
-}
-
-// Clear lines in the line buffer. The `firstRow` parameter is in
-// screen-buffer coordinates.
-void Scraper::clearBufferLines(
- const int firstRow,
- const int count)
-{
- ASSERT(!m_directMode);
- for (int row = firstRow; row < firstRow + count; ++row) {
- const int64_t bufLine = row + m_scrolledCount;
- m_maxBufferedLine = std::max(m_maxBufferedLine, bufLine);
- m_bufferData[bufLine % BUFFER_LINE_COUNT].blank(
- Win32ConsoleBuffer::kDefaultAttributes);
- }
-}
-
-static bool cursorInWindow(const ConsoleScreenBufferInfo &info)
-{
- return info.dwCursorPosition.Y >= info.srWindow.Top &&
- info.dwCursorPosition.Y <= info.srWindow.Bottom;
-}
-
-void Scraper::resizeImpl(const ConsoleScreenBufferInfo &origInfo)
-{
- ASSERT(m_console.frozen());
- const int cols = m_ptySize.X;
- const int rows = m_ptySize.Y;
- Coord finalBufferSize;
-
- {
- //
- // To accommodate Windows 10, erase all lines up to the top of the
- // visible window. It's hard to tell whether this is strictly
- // necessary. It ensures that the sync marker won't move downward,
- // and it ensures that we won't repeat lines that have already scrolled
- // up into the scrollback.
- //
- // It *is* possible for these blank lines to reappear in the visible
- // window (e.g. if the window is made taller), but because we blanked
- // the lines in the line buffer, we still don't output them again.
- //
- const Coord origBufferSize = origInfo.bufferSize();
- const SmallRect origWindowRect = origInfo.windowRect();
-
- if (m_directMode) {
- for (ConsoleLine &line : m_bufferData) {
- line.reset();
- }
- } else {
- m_consoleBuffer->clearLines(0, origWindowRect.Top, origInfo);
- clearBufferLines(0, origWindowRect.Top);
- if (m_syncRow != -1) {
- createSyncMarker(std::min(
- m_syncRow,
- BUFFER_LINE_COUNT - rows
- - SYNC_MARKER_LEN
- - SYNC_MARKER_MARGIN));
- }
- }
-
- finalBufferSize = Coord(
- cols,
- // If there was previously no scrollback (e.g. a full-screen app
- // in direct mode) and we're reducing the window height, then
- // reduce the console buffer's height too.
- (origWindowRect.height() == origBufferSize.Y)
- ? rows
- : std::max<int>(rows, origBufferSize.Y));
-
- // Reset the console font size. We need to do this before shrinking
- // the window, because we might need to make the font bigger to permit
- // a smaller window width. Making the font smaller could expand the
- // screen buffer, which would hang the conhost process in the
- // Windows 10 (10240 build) if the console selection is in progress, so
- // unfreeze it first.
- m_console.setFrozen(false);
- setSmallFont(m_consoleBuffer->conout(), cols, m_console.isNewW10());
- }
-
- // We try to make the font small enough so that the entire screen buffer
- // fits on the monitor, but it can't be guaranteed.
- const auto largest =
- GetLargestConsoleWindowSize(m_consoleBuffer->conout());
- const short visibleCols = std::min<short>(cols, largest.X);
- const short visibleRows = std::min<short>(rows, largest.Y);
-
- {
- // Make the window small enough. We want the console frozen during
- // this step so we don't accidentally move the window above the cursor.
- m_console.setFrozen(true);
- const auto info = m_consoleBuffer->bufferInfo();
- const auto &bufferSize = info.dwSize;
- const int tmpWindowWidth = std::min(bufferSize.X, visibleCols);
- const int tmpWindowHeight = std::min(bufferSize.Y, visibleRows);
- SmallRect tmpWindowRect(
- 0,
- std::min<int>(bufferSize.Y - tmpWindowHeight,
- info.windowRect().Top),
- tmpWindowWidth,
- tmpWindowHeight);
- if (cursorInWindow(info)) {
- tmpWindowRect = tmpWindowRect.ensureLineIncluded(
- info.cursorPosition().Y);
- }
- m_consoleBuffer->moveWindow(tmpWindowRect);
- }
-
- {
- // Resize the buffer to the final desired size.
- m_console.setFrozen(false);
- m_consoleBuffer->resizeBufferRange(finalBufferSize);
- }
-
- {
- // Expand the window to its full size.
- m_console.setFrozen(true);
- const ConsoleScreenBufferInfo info = m_consoleBuffer->bufferInfo();
-
- SmallRect finalWindowRect(
- 0,
- std::min<int>(info.bufferSize().Y - visibleRows,
- info.windowRect().Top),
- visibleCols,
- visibleRows);
-
- //
- // Once a line in the screen buffer is "dirty", it should stay visible
- // in the console window, so that we continue to update its content in
- // the terminal. This code is particularly (only?) necessary on
- // Windows 10, where making the buffer wider can rewrap lines and move
- // the console window upward.
- //
- if (!m_directMode && m_dirtyLineCount > finalWindowRect.Bottom + 1) {
- // In theory, we avoid ensureLineIncluded, because, a massive
- // amount of output could have occurred while the console was
- // unfrozen, so that the *top* of the window is now below the
- // dirtiest tracked line.
- finalWindowRect = SmallRect(
- 0, m_dirtyLineCount - visibleRows,
- visibleCols, visibleRows);
- }
-
- // Highest priority constraint: ensure that the cursor remains visible.
- if (cursorInWindow(info)) {
- finalWindowRect = finalWindowRect.ensureLineIncluded(
- info.cursorPosition().Y);
- }
-
- m_consoleBuffer->moveWindow(finalWindowRect);
- m_dirtyWindowTop = finalWindowRect.Top;
- }
-
- ASSERT(m_console.frozen());
-}
-
-void Scraper::syncConsoleContentAndSize(
- bool forceResize,
- ConsoleScreenBufferInfo &finalInfoOut)
-{
- // We'll try to avoid freezing the console by reading large chunks (or
- // all!) of the screen buffer without otherwise attempting to synchronize
- // with the console application. We can only do this on Windows 10 and up
- // because:
- // - Prior to Windows 8, the size of a ReadConsoleOutputW call was limited
- // by the ~32KB RPC buffer.
- // - Prior to Windows 10, an out-of-range read region crashes the caller.
- // (See misc/WindowsBugCrashReader.cc.)
- //
- if (!m_console.isNewW10() || forceResize) {
- m_console.setFrozen(true);
- }
-
- const ConsoleScreenBufferInfo info = m_consoleBuffer->bufferInfo();
- bool cursorVisible = true;
- CONSOLE_CURSOR_INFO cursorInfo = {};
- if (!GetConsoleCursorInfo(GetStdHandle(STD_OUTPUT_HANDLE), &cursorInfo)) {
- trace("GetConsoleCursorInfo failed");
- } else {
- cursorVisible = cursorInfo.bVisible != 0;
- }
-
- // If an app resizes the buffer height, then we enter "direct mode", where
- // we stop trying to track incremental console changes.
- const bool newDirectMode = (info.bufferSize().Y != BUFFER_LINE_COUNT);
- if (newDirectMode != m_directMode) {
- trace("Entering %s mode", newDirectMode ? "direct" : "scrolling");
- resetConsoleTracking(Terminal::SendClear,
- newDirectMode ? 0 : info.windowRect().top());
- m_directMode = newDirectMode;
-
- // When we switch from direct->scrolling mode, make sure the console is
- // the right size.
- if (!m_directMode) {
- m_console.setFrozen(true);
- forceResize = true;
- }
- }
-
- if (m_directMode) {
- // In direct-mode, resizing the console redraws the terminal, so do it
- // before scraping.
- if (forceResize) {
- resizeImpl(info);
- }
- directScrapeOutput(info, cursorVisible);
- } else {
- if (!m_console.frozen()) {
- if (!scrollingScrapeOutput(info, cursorVisible, true)) {
- m_console.setFrozen(true);
- }
- }
- if (m_console.frozen()) {
- scrollingScrapeOutput(info, cursorVisible, false);
- }
- // In scrolling mode, we want to scrape before resizing, because we'll
- // erase everything in the console buffer up to the top of the console
- // window.
- if (forceResize) {
- resizeImpl(info);
- }
- }
-
- finalInfoOut = forceResize ? m_consoleBuffer->bufferInfo() : info;
-}
-
-// Try to match Windows' behavior w.r.t. to the LVB attribute flags. In some
-// situations, Windows ignores the LVB flags on a character cell because of
-// backwards compatibility -- apparently some programs set the flags without
-// intending to enable reverse-video or underscores.
-//
-// [rprichard 2017-01-15] I haven't actually noticed any old programs that need
-// this treatment -- the motivation for this function comes from the MSDN
-// documentation for SetConsoleMode and ENABLE_LVB_GRID_WORLDWIDE.
-WORD Scraper::attributesMask()
-{
- const auto WINPTY_ENABLE_VIRTUAL_TERMINAL_PROCESSING = 0x4u;
- const auto WINPTY_ENABLE_LVB_GRID_WORLDWIDE = 0x10u;
- const auto WINPTY_COMMON_LVB_REVERSE_VIDEO = 0x4000u;
- const auto WINPTY_COMMON_LVB_UNDERSCORE = 0x8000u;
-
- const auto cp = GetConsoleOutputCP();
- const auto isCjk = (cp == 932 || cp == 936 || cp == 949 || cp == 950);
-
- const DWORD outputMode = [this]{
- ASSERT(this->m_consoleBuffer != nullptr);
- DWORD mode = 0;
- if (!GetConsoleMode(this->m_consoleBuffer->conout(), &mode)) {
- mode = 0;
- }
- return mode;
- }();
- const bool hasEnableLvbGridWorldwide =
- (outputMode & WINPTY_ENABLE_LVB_GRID_WORLDWIDE) != 0;
- const bool hasEnableVtProcessing =
- (outputMode & WINPTY_ENABLE_VIRTUAL_TERMINAL_PROCESSING) != 0;
-
- // The new Windows 10 console (as of 14393) seems to respect
- // COMMON_LVB_REVERSE_VIDEO even in CP437 w/o the other enabling modes, so
- // try to match that behavior.
- const auto isReverseSupported =
- isCjk || hasEnableLvbGridWorldwide || hasEnableVtProcessing || m_console.isNewW10();
- const auto isUnderscoreSupported =
- isCjk || hasEnableLvbGridWorldwide || hasEnableVtProcessing;
-
- WORD mask = ~0;
- if (!isReverseSupported) { mask &= ~WINPTY_COMMON_LVB_REVERSE_VIDEO; }
- if (!isUnderscoreSupported) { mask &= ~WINPTY_COMMON_LVB_UNDERSCORE; }
- return mask;
-}
-
-void Scraper::directScrapeOutput(const ConsoleScreenBufferInfo &info,
- bool consoleCursorVisible)
-{
- const SmallRect windowRect = info.windowRect();
-
- const SmallRect scrapeRect(
- windowRect.left(), windowRect.top(),
- std::min<SHORT>(std::min(windowRect.width(), m_ptySize.X),
- MAX_CONSOLE_WIDTH),
- std::min<SHORT>(std::min(windowRect.height(), m_ptySize.Y),
- BUFFER_LINE_COUNT));
- const int w = scrapeRect.width();
- const int h = scrapeRect.height();
-
- const Coord cursor = info.cursorPosition();
- const bool showTerminalCursor =
- consoleCursorVisible && scrapeRect.contains(cursor);
- const int cursorColumn = !showTerminalCursor ? -1 : cursor.X - scrapeRect.Left;
- const int cursorLine = !showTerminalCursor ? -1 : cursor.Y - scrapeRect.Top;
-
- if (!showTerminalCursor) {
- m_terminal->hideTerminalCursor();
- }
-
- largeConsoleRead(m_readBuffer, *m_consoleBuffer, scrapeRect, attributesMask());
-
- for (int line = 0; line < h; ++line) {
- const CHAR_INFO *const curLine =
- m_readBuffer.lineData(scrapeRect.top() + line);
- ConsoleLine &bufLine = m_bufferData[line];
- if (bufLine.detectChangeAndSetLine(curLine, w)) {
- const int lineCursorColumn =
- line == cursorLine ? cursorColumn : -1;
- m_terminal->sendLine(line, curLine, w, lineCursorColumn);
- }
- }
-
- if (showTerminalCursor) {
- m_terminal->showTerminalCursor(cursorColumn, cursorLine);
- }
-}
-
-bool Scraper::scrollingScrapeOutput(const ConsoleScreenBufferInfo &info,
- bool consoleCursorVisible,
- bool tentative)
-{
- const Coord cursor = info.cursorPosition();
- const SmallRect windowRect = info.windowRect();
-
- if (m_syncRow != -1) {
- // If a synchronizing marker was placed into the history, look for it
- // and adjust the scroll count.
- const int markerRow = findSyncMarker();
- if (markerRow == -1) {
- if (tentative) {
- // I *think* it's possible to keep going, but it's simple to
- // bail out.
- return false;
- }
- // Something has happened. Reset the terminal.
- trace("Sync marker has disappeared -- resetting the terminal"
- " (m_syncCounter=%u)",
- m_syncCounter);
- resetConsoleTracking(Terminal::SendClear, windowRect.top());
- } else if (markerRow != m_syncRow) {
- ASSERT(markerRow < m_syncRow);
- m_scrolledCount += (m_syncRow - markerRow);
- m_syncRow = markerRow;
- // If the buffer has scrolled, then the entire window is dirty.
- markEntireWindowDirty(windowRect);
- }
- }
-
- // Creating a new sync row requires clearing part of the console buffer, so
- // avoid doing it if there's already a sync row that's good enough.
- const int newSyncRow =
- static_cast<int>(windowRect.top()) - SYNC_MARKER_LEN - SYNC_MARKER_MARGIN;
- const bool shouldCreateSyncRow =
- newSyncRow >= m_syncRow + SYNC_MARKER_LEN + SYNC_MARKER_MARGIN;
- if (tentative && shouldCreateSyncRow) {
- // It's difficult even in principle to put down a new marker if the
- // console can scroll an arbitrarily amount while we're writing.
- return false;
- }
-
- // Update the dirty line count:
- // - If the window has moved, the entire window is dirty.
- // - Everything up to the cursor is dirty.
- // - All lines above the window are dirty.
- // - Any non-blank lines are dirty.
- if (m_dirtyWindowTop != -1) {
- if (windowRect.top() > m_dirtyWindowTop) {
- // The window has moved down, presumably as a result of scrolling.
- markEntireWindowDirty(windowRect);
- } else if (windowRect.top() < m_dirtyWindowTop) {
- if (tentative) {
- // I *think* it's possible to keep going, but it's simple to
- // bail out.
- return false;
- }
- // The window has moved upward. This is generally not expected to
- // happen, but the CMD/PowerShell CLS command will move the window
- // to the top as part of clearing everything else in the console.
- trace("Window moved upward -- resetting the terminal"
- " (m_syncCounter=%u)",
- m_syncCounter);
- resetConsoleTracking(Terminal::SendClear, windowRect.top());
- }
- }
- m_dirtyWindowTop = windowRect.top();
- m_dirtyLineCount = std::max(m_dirtyLineCount, cursor.Y + 1);
- m_dirtyLineCount = std::max(m_dirtyLineCount, (int)windowRect.top());
-
- // There will be at least one dirty line, because there is a cursor.
- ASSERT(m_dirtyLineCount >= 1);
-
- // The first line to scrape, in virtual line coordinates.
- const int64_t firstVirtLine = std::min(m_scrapedLineCount,
- windowRect.top() + m_scrolledCount);
-
- // Read all the data we will need from the console. Start reading with the
- // first line to scrape, but adjust the the read area upward to account for
- // scanForDirtyLines' need to read the previous attribute. Read to the
- // bottom of the window. (It's not clear to me whether the
- // m_dirtyLineCount adjustment here is strictly necessary. It isn't
- // necessary so long as the cursor is inside the current window.)
- const int firstReadLine = std::min<int>(firstVirtLine - m_scrolledCount,
- m_dirtyLineCount - 1);
- const int stopReadLine = std::max(windowRect.top() + windowRect.height(),
- m_dirtyLineCount);
- ASSERT(firstReadLine >= 0 && stopReadLine > firstReadLine);
- largeConsoleRead(m_readBuffer,
- *m_consoleBuffer,
- SmallRect(0, firstReadLine,
- std::min<SHORT>(info.bufferSize().X,
- MAX_CONSOLE_WIDTH),
- stopReadLine - firstReadLine),
- attributesMask());
-
- // If we're scraping the buffer without freezing it, we have to query the
- // buffer position data separately from the buffer content, so the two
- // could easily be out-of-sync. If they *are* out-of-sync, abort the
- // scrape operation and restart it frozen. (We may have updated the
- // dirty-line high-water-mark, but that should be OK.)
- if (tentative) {
- const auto infoCheck = m_consoleBuffer->bufferInfo();
- if (info.bufferSize() != infoCheck.bufferSize() ||
- info.windowRect() != infoCheck.windowRect() ||
- info.cursorPosition() != infoCheck.cursorPosition()) {
- return false;
- }
- if (m_syncRow != -1 && m_syncRow != findSyncMarker()) {
- return false;
- }
- }
-
- if (shouldCreateSyncRow) {
- ASSERT(!tentative);
- createSyncMarker(newSyncRow);
- }
-
- // At this point, we're finished interacting (reading or writing) the
- // console, and we just need to convert our collected data into terminal
- // output.
-
- scanForDirtyLines(windowRect);
-
- // Note that it's possible for all the lines on the current window to
- // be non-dirty.
-
- // The line to stop scraping at, in virtual line coordinates.
- const int64_t stopVirtLine =
- std::min(m_dirtyLineCount, windowRect.top() + windowRect.height()) +
- m_scrolledCount;
-
- const bool showTerminalCursor =
- consoleCursorVisible && windowRect.contains(cursor);
- const int64_t cursorLine = !showTerminalCursor ? -1 : cursor.Y + m_scrolledCount;
- const int cursorColumn = !showTerminalCursor ? -1 : cursor.X;
-
- if (!showTerminalCursor) {
- m_terminal->hideTerminalCursor();
- }
-
- bool sawModifiedLine = false;
-
- const int w = m_readBuffer.rect().width();
- for (int64_t line = firstVirtLine; line < stopVirtLine; ++line) {
- const CHAR_INFO *curLine =
- m_readBuffer.lineData(line - m_scrolledCount);
- ConsoleLine &bufLine = m_bufferData[line % BUFFER_LINE_COUNT];
- if (line > m_maxBufferedLine) {
- m_maxBufferedLine = line;
- sawModifiedLine = true;
- }
- if (sawModifiedLine) {
- bufLine.setLine(curLine, w);
- } else {
- sawModifiedLine = bufLine.detectChangeAndSetLine(curLine, w);
- }
- if (sawModifiedLine) {
- const int lineCursorColumn =
- line == cursorLine ? cursorColumn : -1;
- m_terminal->sendLine(line, curLine, w, lineCursorColumn);
- }
- }
-
- m_scrapedLineCount = windowRect.top() + m_scrolledCount;
-
- if (showTerminalCursor) {
- m_terminal->showTerminalCursor(cursorColumn, cursorLine);
- }
-
- return true;
-}
-
-void Scraper::syncMarkerText(CHAR_INFO (&output)[SYNC_MARKER_LEN])
-{
- // XXX: The marker text generated here could easily collide with ordinary
- // console output. Does it make sense to try to avoid the collision?
- char str[SYNC_MARKER_LEN + 1];
- winpty_snprintf(str, "S*Y*N*C*%08x", m_syncCounter);
- for (int i = 0; i < SYNC_MARKER_LEN; ++i) {
- output[i].Char.UnicodeChar = str[i];
- output[i].Attributes = 7;
- }
-}
-
-int Scraper::findSyncMarker()
-{
- ASSERT(m_syncRow >= 0);
- CHAR_INFO marker[SYNC_MARKER_LEN];
- CHAR_INFO column[BUFFER_LINE_COUNT];
- syncMarkerText(marker);
- SmallRect rect(0, 0, 1, m_syncRow + SYNC_MARKER_LEN);
- m_consoleBuffer->read(rect, column);
- int i;
- for (i = m_syncRow; i >= 0; --i) {
- int j;
- for (j = 0; j < SYNC_MARKER_LEN; ++j) {
- if (column[i + j].Char.UnicodeChar != marker[j].Char.UnicodeChar)
- break;
- }
- if (j == SYNC_MARKER_LEN)
- return i;
- }
- return -1;
-}
-
-void Scraper::createSyncMarker(int row)
-{
- ASSERT(row >= 1);
-
- // Clear the lines around the marker to ensure that Windows 10's rewrapping
- // does not affect the marker.
- m_consoleBuffer->clearLines(row - 1, SYNC_MARKER_LEN + 1,
- m_consoleBuffer->bufferInfo());
-
- // Write a new marker.
- m_syncCounter++;
- CHAR_INFO marker[SYNC_MARKER_LEN];
- syncMarkerText(marker);
- m_syncRow = row;
- SmallRect markerRect(0, m_syncRow, 1, SYNC_MARKER_LEN);
- m_consoleBuffer->write(markerRect, marker);
-}
projects / VSoRC / .git / blobdiff