[FarGroup/FarManager] master: Another workaround for Windows 10 console, more logging (beb819a3c)

[farg...@farmanager.com]

Repository : https://github.com/FarGroup/FarManager
On branch : master
Link : https://github.com/FarGroup/FarManager/commit/beb819a3c2670e03cbe1c4c1d4b9ac33c73a2e21

>---------------------------------------------------------------

commit beb819a3c2670e03cbe1c4c1d4b9ac33c73a2e21
Author: Alex Alabuzhev <alab...@gmail.com>
Date: Fri Jun 3 22:49:44 2022 +0100

Another workaround for Windows 10 console, more logging


>---------------------------------------------------------------

beb819a3c2670e03cbe1c4c1d4b9ac33c73a2e21
far/changelog | 7 ++
far/console.cpp | 285 +++++++++++++++++++++++++++++++++++++++++++++-------
far/new_handler.cpp | 39 ++++++-
far/savescr.cpp | 6 +-
far/vbuild.m4 | 2 +-
5 files changed, 295 insertions(+), 44 deletions(-)

diff --git a/far/changelog b/far/changelog
index e4ee9dbba..72b25eda9 100644
--- a/far/changelog
+++ b/far/changelog
@@ -1,3 +1,10 @@
+--------------------------------------------------------------------------------
+drkns 03.06.2022 22:47:43 +0100 - build 5975
+
+1. Another day, another workaround for Windows 10 console.
+
+2. More logging.
+
--------------------------------------------------------------------------------
yjh 01.06.2022 17:39:33 +0300 - build 5974

diff --git a/far/console.cpp b/far/console.cpp
index 7af582d05..854fa2518 100644
--- a/far/console.cpp
+++ b/far/console.cpp
@@ -45,6 +45,7 @@ THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include "palette.hpp"
#include "encoding.hpp"
#include "char_width.hpp"
+#include "log.hpp"

// Platform:
#include "platform.version.hpp"
@@ -217,21 +218,44 @@ void sanitise_pair(FAR_CHAR_INFO& First, FAR_CHAR_INFO& Second)
bool get_console_screen_buffer_info(HANDLE ConsoleOutput, CONSOLE_SCREEN_BUFFER_INFO* ConsoleScreenBufferInfo)
{
if (!GetConsoleScreenBufferInfo(ConsoleOutput, ConsoleScreenBufferInfo))
+ {
+ LOGWARNING(L"GetConsoleScreenBufferInfo(): {}"sv, last_error());
return false;
+ }

const auto& Window = ConsoleScreenBufferInfo->srWindow;

// Mantis#3919: Windows 10 is a PITA
- if (Window.Left > Window.Right)
+ if (Window.Left > Window.Right || Window.Top > Window.Bottom)
{
+ LOGERROR(L"Console window state is broken, trying to repair"sv);
+
auto NewWindow = Window;
- NewWindow.Left = 0;
- NewWindow.Right = ConsoleScreenBufferInfo->dwSize.X - 1;

- SetConsoleWindowInfo(ConsoleOutput, true, &NewWindow);
+ if (Window.Left > Window.Right)
+ {
+ NewWindow.Left = 0;
+ NewWindow.Right = std::min(ConsoleScreenBufferInfo->dwMaximumWindowSize.X - 1, ConsoleScreenBufferInfo->dwSize.X - 1);
+ }
+
+ // https://forum.farmanager.com/viewtopic.php?p=170779#p170779
+ if (Window.Top > Window.Bottom)
+ {
+ NewWindow.Bottom = ConsoleScreenBufferInfo->dwSize.Y - 1;
+ NewWindow.Top = std::clamp(NewWindow.Top, short{}, NewWindow.Bottom);
+ }
+
+ if (!SetConsoleWindowInfo(ConsoleOutput, true, &NewWindow))
+ {
+ LOGWARNING(L"SetConsoleWindowInfo(): {}"sv, last_error());
+ return false;
+ }

if (!GetConsoleScreenBufferInfo(ConsoleOutput, ConsoleScreenBufferInfo))
+ {
+ LOGWARNING(L"GetConsoleScreenBufferInfo(): {}"sv, last_error());
return false;
+ }
}

return true;
@@ -313,12 +337,24 @@ namespace console_detail

bool console::Allocate() const
{
- return AllocConsole() != FALSE;
+ if (!AllocConsole())
+ {
+ LOGWARNING(L"AllocConsole(): {}"sv, last_error());
+ return false;
+ }
+
+ return true;
}

bool console::Free() const
{
- return FreeConsole() != FALSE;
+ if (!FreeConsole())
+ {
+ LOGWARNING(L"FreeConsole(): {}"sv, last_error());
+ return false;
+ }
+
+ return true;
}

HANDLE console::GetInputHandle() const
@@ -388,7 +424,8 @@ namespace console_detail
{
WindowCoord.x = std::max(WindowCoord.x, static_cast<int>(csbi.dwSize.X));
WindowCoord.y = std::max(WindowCoord.y, static_cast<int>(csbi.dwSize.Y));
- SetScreenBufferSize(WindowCoord);
+ if (!SetScreenBufferSize(WindowCoord))
+ return false;

if (WindowCoord.x > csbi.dwSize.X)
{
@@ -416,13 +453,17 @@ namespace console_detail
// Make sure the cursor is within the new buffer
if (!(Info.dwCursorPosition.X < Size.x && Info.dwCursorPosition.Y < Size.y))
{
- SetConsoleCursorPosition(
+ if (!SetConsoleCursorPosition(
Out,
{
std::min(Info.dwCursorPosition.X, static_cast<SHORT>(Size.x - 1)),
std::min(Info.dwCursorPosition.Y, static_cast<SHORT>(Size.y - 1))
}
- );
+ ))
+ {
+ LOGWARNING(L"SetConsoleCursorPosition(): {}"sv, last_error());
+ return false;
+ }
}

// Make sure the window is within the new buffer:
@@ -435,12 +476,17 @@ namespace console_detail
Rect.top = std::max(0, Rect.bottom - Height);
Rect.left = std::max(0, Rect.right - Width);

- SetWindowRect(Rect);
+ if (!SetWindowRect(Rect))
+ return false;
}
}
}

- const auto Result = SetConsoleScreenBufferSize(Out, make_coord(Size)) != FALSE;
+ if (!SetConsoleScreenBufferSize(Out, make_coord(Size)))
+ {
+ LOGWARNING(L"SetConsoleScreenBufferSize(): {}"sv, last_error());
+ return false;
+ }

// After changing the buffer size the window size is not always correct
if (IsVtSupported())
@@ -452,7 +498,7 @@ namespace console_detail
}
}

- return Result;
+ return true;
}

bool console::GetWindowRect(rectangle& ConsoleWindow) const
@@ -468,7 +514,13 @@ namespace console_detail
bool console::SetWindowRect(rectangle const& ConsoleWindow) const
{
const auto Rect = make_rect(ConsoleWindow);
- return SetConsoleWindowInfo(GetOutputHandle(), true, &Rect) != FALSE;
+ if (!SetConsoleWindowInfo(GetOutputHandle(), true, &Rect))
+ {
+ LOGWARNING(L"SetConsoleWindowInfo(): {}"sv, last_error());
+ return false;
+ }
+
+ return true;
}

bool console::GetWorkingRect(rectangle& WorkingRect) const
@@ -488,7 +540,11 @@ namespace console_detail
{
// Don't use GetConsoleTitle here, it's buggy.
string Title;
- os::GetWindowText(GetWindow(), Title);
+ if (!os::GetWindowText(GetWindow(), Title))
+ {
+ LOGWARNING(L"GetWindowText(): {}"sv, last_error());
+ }
+
return Title;
}

@@ -500,14 +556,23 @@ namespace console_detail
bool console::SetTitle(string_view const Title) const
{
m_Title = Title;
- return SetConsoleTitle(m_Title.c_str()) != FALSE;
+ if (!SetConsoleTitle(m_Title.c_str()))
+ {
+ LOGWARNING(L"SetConsoleTitle(): {}"sv, last_error());
+ return false;
+ }
+
+ return true;
}

bool console::GetKeyboardLayoutName(string &strName) const
{
wchar_t Buffer[KL_NAMELENGTH];
if (!imports.GetConsoleKeyboardLayoutNameW(Buffer))
+ {
+ LOGWARNING(L"GetConsoleKeyboardLayoutNameW(): {}"sv, last_error());
return false;
+ }

strName = Buffer;
return true;
@@ -520,7 +585,13 @@ namespace console_detail

bool console::SetInputCodepage(uintptr_t Codepage) const
{
- return SetConsoleCP(Codepage) != FALSE;
+ if (!SetConsoleCP(Codepage))
+ {
+ LOGWARNING(L"SetConsoleCP(): {}"sv, last_error());
+ return false;
+ }
+
+ return true;
}

uintptr_t console::GetOutputCodepage() const
@@ -530,22 +601,46 @@ namespace console_detail

bool console::SetOutputCodepage(uintptr_t Codepage) const
{
- return SetConsoleOutputCP(Codepage) != FALSE;
+ if (!SetConsoleOutputCP(Codepage))
+ {
+ LOGWARNING(L"SetConsoleOutputCP(): {}"sv, last_error());
+ return false;
+ }
+
+ return true;
}

bool console::SetControlHandler(PHANDLER_ROUTINE HandlerRoutine, bool Add) const
{
- return SetConsoleCtrlHandler(HandlerRoutine, Add) != FALSE;
+ if (!SetConsoleCtrlHandler(HandlerRoutine, Add))
+ {
+ LOGWARNING(L"SetConsoleCtrlHandler(): {}"sv, last_error());
+ return false;
+ }
+
+ return true;
}

bool console::GetMode(HANDLE ConsoleHandle, DWORD& Mode) const
{
- return GetConsoleMode(ConsoleHandle, &Mode) != FALSE;
+ if (!GetConsoleMode(ConsoleHandle, &Mode))
+ {
+ LOGWARNING(L"GetConsoleMode(): {}"sv, last_error());
+ return false;
+ }
+
+ return true;
}

bool console::SetMode(HANDLE ConsoleHandle, DWORD Mode) const
{
- return SetConsoleMode(ConsoleHandle, Mode) != FALSE;
+ if (!SetConsoleMode(ConsoleHandle, Mode))
+ {
+ LOGWARNING(L"SetConsoleMode(): {}"sv, last_error());
+ return false;
+ }
+
+ return true;
}

bool console::IsVtSupported() const
@@ -578,7 +673,10 @@ namespace console_detail
static bool get_current_console_font(HANDLE OutputHandle, CONSOLE_FONT_INFO& FontInfo)
{
if (!GetCurrentConsoleFont(OutputHandle, FALSE, &FontInfo))
+ {
+ LOGWARNING(L"GetCurrentConsoleFont(): {}"sv, last_error());
return false;
+ }

// in XP FontInfo.dwFontSize contains something else than the size in pixels.
FontInfo.dwFontSize = GetConsoleFontSize(OutputHandle, FontInfo.nFont);
@@ -599,13 +697,19 @@ namespace console_detail
// Note: using the current mouse position rather than what's in the wheel event
POINT CursorPos;
if (!GetCursorPos(&CursorPos))
+ {
+ LOGWARNING(L"GetCursorPos(): {}"sv, last_error());
return;
+ }

const auto WindowHandle = ::console.GetWindow();

auto RelativePos = CursorPos;
if (!ScreenToClient(WindowHandle, &RelativePos))
+ {
+ LOGWARNING(L"ScreenToClient(): {}"sv, last_error());
return;
+ }

const auto OutputHandle = ::console.GetOutputHandle();

@@ -653,7 +757,10 @@ namespace console_detail
{
DWORD dwNumberOfEventsRead = 0;
if (!PeekConsoleInput(GetInputHandle(), Buffer.data(), static_cast<DWORD>(Buffer.size()), &dwNumberOfEventsRead))
+ {
+ LOGWARNING(L"PeekConsoleInput(): {}"sv, last_error());
return false;
+ }

NumberOfEventsRead = dwNumberOfEventsRead;

@@ -674,7 +781,10 @@ namespace console_detail
{
DWORD dwNumberOfEventsRead = 0;
if (!ReadConsoleInput(GetInputHandle(), Buffer.data(), static_cast<DWORD>(Buffer.size()), &dwNumberOfEventsRead))
+ {
+ LOGWARNING(L"ReadConsoleInput(): {}"sv, last_error());
return false;
+ }

NumberOfEventsRead = dwNumberOfEventsRead;

@@ -707,17 +817,29 @@ namespace console_detail
}
}
DWORD dwNumberOfEventsWritten = 0;
- const auto Result = WriteConsoleInput(GetInputHandle(), Buffer.data(), static_cast<DWORD>(Buffer.size()), &dwNumberOfEventsWritten) != FALSE;
- NumberOfEventsWritten = dwNumberOfEventsWritten;
- return Result;
+ SCOPE_EXIT{ NumberOfEventsWritten = dwNumberOfEventsWritten; };
+
+ if (!WriteConsoleInput(GetInputHandle(), Buffer.data(), static_cast<DWORD>(Buffer.size()), &dwNumberOfEventsWritten))
+ {
+ LOGWARNING(L"WriteConsoleInput(): {}"sv, last_error());
+ return false;
+ }
+
+ return true;
}

static bool ReadOutputImpl(CHAR_INFO* const Buffer, point const BufferSize, rectangle& ReadRegion)
{
auto Rect = make_rect(ReadRegion);
- const auto Result = ReadConsoleOutput(::console.GetOutputHandle(), Buffer, make_coord(BufferSize), {}, &Rect) != FALSE;
- ReadRegion = Rect;
- return Result;
+ SCOPE_EXIT{ ReadRegion = Rect; };
+
+ if (!ReadConsoleOutput(::console.GetOutputHandle(), Buffer, make_coord(BufferSize), {}, &Rect))
+ {
+ LOGWARNING(L"ReadConsoleOutput(): {}"sv, last_error());
+ return false;
+ }
+
+ return true;
}

bool console::ReadOutput(matrix<FAR_CHAR_INFO>& Buffer, point const BufferCoord, rectangle const& ReadRegionRelative) const
@@ -949,6 +1071,10 @@ namespace console_detail
if (!::console.GetCursorInfo(SavedCursorInfo))
return false;

+ // Ideally this should be filtered out earlier
+ if (WriteRegion.left > csbi.dwSize.X - 1 || WriteRegion.top > csbi.dwSize.Y - 1)
+ return false;
+
if (
// Hide cursor
!::console.SetCursorInfo({1}) ||
@@ -1057,7 +1183,13 @@ namespace console_detail
CursorSuppressor.emplace();

auto SysWriteRegion = make_rect(WriteRegion);
- return WriteConsoleOutput(::console.GetOutputHandle(), Buffer, make_coord(BufferSize), {}, &SysWriteRegion) != FALSE;
+ if (!WriteConsoleOutput(::console.GetOutputHandle(), Buffer, make_coord(BufferSize), {}, &SysWriteRegion))
+ {
+ LOGWARNING(L"WriteConsoleOutput(): {}"sv, last_error());
+ return false;
+ }
+
+ return true;
}

static bool WriteOutputNTImplDebug(CHAR_INFO* const Buffer, point const BufferSize, rectangle const& WriteRegion)
@@ -1181,7 +1313,13 @@ namespace console_detail

static bool SetTextAttributesNT(const FarColor& Attributes)
{
- return SetConsoleTextAttribute(::console.GetOutputHandle(), colors::FarColorToConsoleColor(Attributes)) != FALSE;
+ if (!SetConsoleTextAttribute(::console.GetOutputHandle(), colors::FarColorToConsoleColor(Attributes)))
+ {
+ LOGWARNING(L"SetConsoleTextAttribute(): {}"sv, last_error());
+ return false;
+ }
+
+ return true;
}
};

@@ -1220,12 +1358,18 @@ namespace console_detail
if (GetMode(InputHandle, Mode))
{
if (!ReadConsole(InputHandle, Buffer.data(), static_cast<DWORD>(Buffer.size()), &NumberOfCharsRead, nullptr))
+ {
+ LOGWARNING(L"ReadConsole(): {}"sv, last_error());
return false;
+ }
}
else
{
if (!ReadFile(InputHandle, Buffer.data(), static_cast<DWORD>(Buffer.size() * sizeof(wchar_t)), &NumberOfCharsRead, nullptr))
+ {
+ LOGWARNING(L"ReadFile(): {}"sv, last_error());
return false;
+ }

NumberOfCharsRead /= sizeof(wchar_t);
}
@@ -1241,7 +1385,15 @@ namespace console_detail

DWORD Mode;
if (GetMode(OutputHandle, Mode))
- return WriteConsole(OutputHandle, Str.data(), static_cast<DWORD>(Str.size()), &NumberOfCharsWritten, nullptr) != FALSE;
+ {
+ if (!WriteConsole(OutputHandle, Str.data(), static_cast<DWORD>(Str.size()), &NumberOfCharsWritten, nullptr))
+ {
+ LOGWARNING(L"WriteConsole(): {}"sv, last_error());
+ return false;
+ }
+
+ return true;
+ }

// Redirected output

@@ -1293,12 +1445,24 @@ namespace console_detail

bool console::GetCursorInfo(CONSOLE_CURSOR_INFO& ConsoleCursorInfo) const
{
- return GetConsoleCursorInfo(GetOutputHandle(), &ConsoleCursorInfo) != FALSE;
+ if (!GetConsoleCursorInfo(GetOutputHandle(), &ConsoleCursorInfo))
+ {
+ LOGWARNING(L"GetConsoleCursorInfo(): {}"sv, last_error());
+ return false;
+ }
+
+ return true;
}

bool console::SetCursorInfo(const CONSOLE_CURSOR_INFO& ConsoleCursorInfo) const
{
- return SetConsoleCursorInfo(GetOutputHandle(), &ConsoleCursorInfo) != FALSE;
+ if (!SetConsoleCursorInfo(GetOutputHandle(), &ConsoleCursorInfo))
+ {
+ LOGWARNING(L"SetConsoleCursorInfo(): {}"sv, last_error());
+ return false;
+ }
+
+ return true;
}

bool console::GetCursorPosition(point& Position) const
@@ -1386,7 +1550,10 @@ namespace console_detail

std::vector<wchar_t> ExeBuffer(ExeLength / sizeof(wchar_t) + 1); // +1 for double \0
if (!GetConsoleAliasExes(ExeBuffer.data(), ExeLength))
+ {
+ LOGWARNING(L"GetConsoleAliasExes(): {}"sv, last_error());
return {};
+ }

auto Aliases = std::make_unique<console_aliases::data>();

@@ -1398,7 +1565,10 @@ namespace console_detail
const auto AliasesLength = GetConsoleAliasesLength(ExeNamePtr);
AliasesBuffer.resize(AliasesLength / sizeof(wchar_t) + 1); // +1 for double \0
if (!GetConsoleAliases(AliasesBuffer.data(), AliasesLength, ExeNamePtr))
+ {
+ LOGWARNING(L"GetConsoleAliases(): {}"sv, last_error());
continue;
+ }

std::pair<string, std::vector<std::pair<string, string>>> ExeData;
ExeData.first = ExeNamePtr;
@@ -1436,7 +1606,13 @@ namespace console_detail

bool console::GetDisplayMode(DWORD& Mode) const
{
- return GetConsoleDisplayMode(&Mode) != FALSE;
+ if (!GetConsoleDisplayMode(&Mode))
+ {
+ LOGWARNING(L"GetConsoleDisplayMode(): {}"sv, last_error());
+ return false;
+ }
+
+ return true;
}

point console::GetLargestWindowSize() const
@@ -1457,7 +1633,10 @@ namespace console_detail
bool console::SetActiveScreenBuffer(HANDLE ConsoleOutput)
{
if (!SetConsoleActiveScreenBuffer(ConsoleOutput))
+ {
+ LOGWARNING(L"SetConsoleActiveScreenBuffer(): {}"sv, last_error());
return false;
+ }

m_ActiveConsoleScreenBuffer = ConsoleOutput;
return true;
@@ -1581,11 +1760,17 @@ namespace console_detail
#ifdef _WIN64
return false;
#else
+ if (!imports.GetConsoleScreenBufferInfoEx)
+ return true;
+
CONSOLE_SCREEN_BUFFER_INFOEX csbiex{ sizeof(csbiex) };
- if (imports.GetConsoleScreenBufferInfoEx && imports.GetConsoleScreenBufferInfoEx(GetOutputHandle(), &csbiex))
- return csbiex.bFullscreenSupported != FALSE;
+ if (!imports.GetConsoleScreenBufferInfoEx(GetOutputHandle(), &csbiex))
+ {
+ LOGWARNING(L"GetConsoleScreenBufferInfoEx(): {}"sv, last_error());
+ return true;
+ }

- return true;
+ return csbiex.bFullscreenSupported != FALSE;
#endif
}

@@ -1739,17 +1924,34 @@ namespace console_detail
if (!m_WidthTestScreen)
{
m_WidthTestScreen.reset(CreateConsoleScreenBuffer(GENERIC_READ | GENERIC_WRITE, {}, {}, CONSOLE_TEXTMODE_BUFFER, {}));
- SetConsoleScreenBufferSize(m_WidthTestScreen.native_handle(), { 10, 1 });
+
+ const auto TestScreenX = 20, TestScreenY = 1;
+ const SMALL_RECT WindowInfo{ 0, 0, TestScreenX - 1, TestScreenY - 1 };
+ if (!SetConsoleWindowInfo(m_WidthTestScreen.native_handle(), true, &WindowInfo))
+ {
+ LOGWARNING(L"SetConsoleWindowInfo(): {}"sv, last_error());
+ }
+
+ if (!SetConsoleScreenBufferSize(m_WidthTestScreen.native_handle(), { TestScreenX, TestScreenY }))
+ {
+ LOGWARNING(L"SetConsoleScreenBufferSize(): {}"sv, last_error());
+ }
}

if (!SetConsoleCursorPosition(m_WidthTestScreen.native_handle(), {}))
+ {
+ LOGWARNING(L"SetConsoleCursorPosition(): {}"sv, last_error());
return false;
+ }

DWORD Written;
const auto Pair = encoding::utf16::to_surrogate(Codepoint);
const std::array Chars{ Pair.first, Pair.second };
if (!WriteConsole(m_WidthTestScreen.native_handle(), Chars.data(), Pair.second? 2 : 1, &Written, {}))
+ {
+ LOGWARNING(L"WriteConsole(): {}"sv, last_error());
return false;
+ }

CONSOLE_SCREEN_BUFFER_INFO Info;
if (!get_console_screen_buffer_info(m_WidthTestScreen.native_handle(), &Info))
@@ -1765,7 +1967,10 @@ namespace console_detail

CONSOLE_SCREEN_BUFFER_INFOEX csbi{ sizeof(csbi) };
if (!imports.GetConsoleScreenBufferInfoEx(GetOutputHandle(), &csbi))
+ {
+ LOGWARNING(L"GetConsoleScreenBufferInfoEx(): {}"sv, last_error());
return false;
+ }

std::copy(ALL_CONST_RANGE(csbi.ColorTable), Palette.begin());

@@ -1794,7 +1999,13 @@ namespace console_detail

bool console::SetCursorRealPosition(point const Position) const
{
- return SetConsoleCursorPosition(GetOutputHandle(), make_coord(Position)) != FALSE;
+ if (!SetConsoleCursorPosition(GetOutputHandle(), make_coord(Position)))
+ {
+ LOGWARNING(L"SetConsoleCursorPosition(): {}"sv, last_error());
+ return false;
+ }
+
+ return true;
}
}

diff --git a/far/new_handler.cpp b/far/new_handler.cpp
index 7c55b4690..ddab67e6a 100644
--- a/far/new_handler.cpp
+++ b/far/new_handler.cpp
@@ -169,28 +169,46 @@ new_handler::new_handler():
m_Screen(CreateConsoleScreenBuffer(GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, nullptr, CONSOLE_TEXTMODE_BUFFER, nullptr))
{
if (!m_Screen)
+ {
+ LOGWARNING(L"CreateConsoleScreenBuffer(): {}"sv, last_error());
return;
+ }

const COORD BufferSize{ X, Y };

const SMALL_RECT WindowInfo{ 0, 0, X - 1, Y - 1 };
if (!SetConsoleWindowInfo(m_Screen.native_handle(), true, &WindowInfo))
+ {
+ LOGWARNING(L"SetConsoleWindowInfo(): {}"sv, last_error());
return;
+ }

if (!SetConsoleScreenBufferSize(m_Screen.native_handle(), BufferSize))
+ {
+ LOGWARNING(L"SetConsoleScreenBufferSize(): {}"sv, last_error());
return;
+ }

const auto WhiteOnBlue = 0x9F;
if (!SetConsoleTextAttribute(m_Screen.native_handle(), WhiteOnBlue))
+ {
+ LOGWARNING(L"SetConsoleTextAttribute(): {}"sv, last_error());
return;
+ }

DWORD AttrWritten;
if (!FillConsoleOutputAttribute(m_Screen.native_handle(), WhiteOnBlue, BufferSize.X * BufferSize.Y, { 0, 0 }, &AttrWritten))
+ {
+ LOGWARNING(L"FillConsoleOutputAttribute(): {}"sv, last_error());
return;
+ }

const CONSOLE_CURSOR_INFO cci{ 1 };
if (!SetConsoleCursorInfo(m_Screen.native_handle(), &cci))
+ {
+ LOGWARNING(L"SetConsoleCursorInfo(): {}"sv, last_error());
return;
+ }

const string_view Strings[]
{
@@ -202,9 +220,20 @@ new_handler::new_handler():

const auto Write = [this](const string_view Str, size_t Y)
{
- SetConsoleCursorPosition(m_Screen.native_handle(), { static_cast<short>((m_BufferSize.X - Str.size()) / 2), static_cast<short>(Y) });
+ if (!SetConsoleCursorPosition(m_Screen.native_handle(), { static_cast<short>((m_BufferSize.X - Str.size()) / 2), static_cast<short>(Y) }))
+ {
+ LOGWARNING(L"SetConsoleCursorPosition(): {}"sv, last_error());
+ return false;
+ }
+
DWORD CharWritten;
- return WriteConsole(m_Screen.native_handle(), Str.data(), static_cast<DWORD>(Str.size()), &CharWritten, nullptr) && CharWritten == Str.size();
+ if (!WriteConsole(m_Screen.native_handle(), Str.data(), static_cast<DWORD>(Str.size()), &CharWritten, nullptr) && CharWritten == Str.size())
+ {
+ LOGWARNING(L"WriteConsole(): {}"sv, last_error());
+ return false;
+ }
+
+ return true;
};

auto InitialY = (m_BufferSize.Y - std::size(Strings)) / 2;
@@ -252,7 +281,10 @@ bool new_handler::retry() const
{
const auto CurrentBuffer = GetStdHandle(STD_OUTPUT_HANDLE);
if (!SetConsoleActiveScreenBuffer(m_Screen.native_handle()))
+ {
+ LOGWARNING(L"SetConsoleActiveScreenBuffer(): {}"sv, last_error());
return false;
+ }

SCOPE_EXIT { SetConsoleActiveScreenBuffer(CurrentBuffer); };

@@ -263,7 +295,10 @@ bool new_handler::retry() const
{
DWORD Read;
if (!ReadConsoleInput(GetStdHandle(STD_INPUT_HANDLE), &ir, 1, &Read) || Read != 1)
+ {
+ LOGWARNING(L"ReadConsoleInput(): {}"sv, last_error());
return false;
+ }
}
while (!(ir.EventType == KEY_EVENT && !KeyEvent.bKeyDown && (KeyEvent.wVirtualKeyCode == VK_RETURN || KeyEvent.wVirtualKeyCode == VK_ESCAPE)));

diff --git a/far/savescr.cpp b/far/savescr.cpp
index 837da19c6..285e0c902 100644
--- a/far/savescr.cpp
+++ b/far/savescr.cpp
@@ -203,9 +203,8 @@ void SaveScreen::Resize(int DesiredWidth, int DesiredHeight, bool SyncWithConsol
}
}
}
- else
+ else if (rectangle const WriteRegion{ 0, DesiredHeight - OriginalHeight, DesiredWidth - 1, -1 }; WriteRegion.left < ScrX && WriteRegion.top < ScrY)
{
- rectangle const WriteRegion{ 0, DesiredHeight - OriginalHeight, DesiredWidth - 1, -1 };
for (const auto& i: irange(Tmp.height()))
{
std::copy_n(ScreenBuf[i].data(), Tmp.width(), Tmp[i].data());
@@ -230,9 +229,8 @@ void SaveScreen::Resize(int DesiredWidth, int DesiredHeight, bool SyncWithConsol
}
}
}
- else
+ else if (rectangle const WriteRegion{ DesiredWidth, DesiredHeight - OriginalHeight, OriginalWidth - 1, DesiredHeight - 1 }; WriteRegion.left < ScrX && WriteRegion.top < ScrY)
{
- rectangle const WriteRegion{ DesiredWidth, DesiredHeight - OriginalHeight, OriginalWidth - 1, DesiredHeight - 1 };
for (const auto& i: irange(Tmp.height()))
{
if (static_cast<int>(i) < OriginalHeight)
diff --git a/far/vbuild.m4 b/far/vbuild.m4
index f00e8b46c..b84566bd3 100644
--- a/far/vbuild.m4
+++ b/far/vbuild.m4
@@ -1 +1 @@
-5974
+5975