#767

Committed 09 Feb 2026 11:49PM UTC coverage: 69.07%. Remained the same

Build # #767

Build Type

push

travis-ci

Committed by

gansm

Commit Message

More iterators and further code improvements

Run Details

126 of 129 new or added lines in 7 files covered. (97.67%)

161 existing lines in 3 files now uncovered.

37625 of 54474 relevant lines covered (69.07%)

250.26 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

85.69

/final/vterm/fvterm.cpp

/***********************************************************************
* fvterm.cpp - Virtual terminal implementation                         *
*                                                                      *
* This file is part of the FINAL CUT widget toolkit                    *
*                                                                      *
* Copyright 2016-2026 Markus Gans                                      *
*                                                                      *
* FINAL CUT is free software; you can redistribute it and/or modify    *
* it under the terms of the GNU Lesser General Public License as       *
* published by the Free Software Foundation; either version 3 of       *
* the License, or (at your option) any later version.                  *
*                                                                      *
* FINAL CUT is distributed in the hope that it will be useful, but     *
* WITHOUT ANY WARRANTY; without even the implied warranty of           *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the        *
* GNU Lesser General Public License for more details.                  *
*                                                                      *
* You should have received a copy of the GNU Lesser General Public     *
* License along with this program.  If not, see                        *
* <http://www.gnu.org/licenses/>.                                      *
***********************************************************************/

#include <algorithm>
#include <numeric>
#include <string>
#include <unordered_set>
#include <vector>

#include "final/fapplication.h"
#include "final/fc.h"
#include "final/ftypes.h"
#include "final/output/tty/ftermoutput.h"
#include "final/util/flog.h"
#include "final/util/fpoint.h"
#include "final/util/frect.h"
#include "final/util/fsize.h"
#include "final/util/fsystem.h"
#include "final/vterm/fcolorpair.h"
#include "final/vterm/fstyle.h"
#include "final/vterm/fvterm.h"

namespace finalcut
{

namespace internal
{

constexpr auto getTransparentMask() noexcept -> uInt32
{
  FCharAttribute mask{};
  mask.transparent = true;
  mask.color_overlay = true;
  mask.inherit_background = true;
  return FCharAttribute_to_uInt32(mask);
}

constexpr auto getTransparent() noexcept -> uInt32
{
  FCharAttribute mask{};
  mask.transparent = true;
  return FCharAttribute_to_uInt32(mask);
}

constexpr auto getColorOverlay() noexcept -> uInt32
{
  FCharAttribute mask{};
  mask.color_overlay = true;
  return FCharAttribute_to_uInt32(mask);
}

constexpr auto getInheritBackground() noexcept -> uInt32
{
  FCharAttribute mask{};
  mask.inherit_background = true;
  return FCharAttribute_to_uInt32(mask);
}

constexpr auto getPrintTransparentMask() noexcept -> uInt32
{
  FCharAttribute mask{};
  mask.transparent = true;
  mask.color_overlay = true;
  mask.inherit_background = true;
  mask.no_changes = true;
  mask.printed = true;
  return FCharAttribute_to_uInt32(mask);
}

constexpr auto getResetMask() noexcept -> uInt32
{
  FCharAttribute mask{};
  mask.no_changes = true;
  mask.printed = true;
  return FCharAttribute_to_uInt32(mask);
}

constexpr auto getColorOverlayMask() noexcept -> uInt32
{
  FCharAttribute mask{};
  mask.color_overlay = true;
  mask.reverse = true;
  mask.standout = true;
  mask.no_changes = true;
  mask.printed = true;
  return FCharAttribute_to_uInt32(mask);
}

struct var
{
  static bool fvterm_initialized;  // Global init state
  static constexpr auto transparent_mask = getTransparentMask();
  static constexpr auto transparent = getTransparent();
  static constexpr auto color_overlay = getColorOverlay();
  static constexpr auto inherit_background = getInheritBackground();
  static constexpr auto print_transparent_mask = getPrintTransparentMask();
  static constexpr auto print_reset_mask = getResetMask();
  static constexpr auto color_overlay_mask = getColorOverlayMask();
};

bool             var::fvterm_initialized{false};
constexpr uInt32 var::transparent_mask;
constexpr uInt32 var::transparent;
constexpr uInt32 var::color_overlay;
constexpr uInt32 var::inherit_background;
constexpr uInt32 var::print_transparent_mask;
constexpr uInt32 var::print_reset_mask;
constexpr uInt32 var::color_overlay_mask;

}  // namespace internal

// static class attributes
bool                 FVTerm::draw_completed{false};
bool                 FVTerm::skip_one_vterm_update{false};
bool                 FVTerm::no_terminal_updates{false};
bool                 FVTerm::force_terminal_update{false};
FVTerm::FTermArea*   FVTerm::active_area{nullptr};
int                  FVTerm::tabstop{8};

using TransparentInvisibleLookupMap = std::unordered_set<wchar_t>;

//----------------------------------------------------------------------
static auto getTransparentInvisibleLookupMap() -> TransparentInvisibleLookupMap
{
  // Encapsulate global unordered_map object
  static const auto& trans_inv_lookup = std::make_unique<TransparentInvisibleLookupMap>
  (
    std::initializer_list<wchar_t>
    ({
      wchar_t(UniChar::LowerHalfBlock),
      wchar_t(UniChar::UpperHalfBlock),
      wchar_t(UniChar::LeftHalfBlock),
      wchar_t(UniChar::RightHalfBlock),
      wchar_t(UniChar::MediumShade),
      wchar_t(UniChar::FullBlock)
    })
  );

  return *trans_inv_lookup;
}

//----------------------------------------------------------------------
// class FVTerm
//----------------------------------------------------------------------

// constructors and destructor
//----------------------------------------------------------------------
FVTerm::FVTerm()
{
  init<FTermOutput>();
}

//----------------------------------------------------------------------
FVTerm::~FVTerm()  // destructor
{
  if ( getGlobalFVTermInstance() == this )
    finish();
}

//----------------------------------------------------------------------
auto FVTerm::operator << (FVTermBuffer& buffer) noexcept -> FVTerm&
{
  print (buffer);
  return *this;
}

//----------------------------------------------------------------------
auto FVTerm::operator << (const FVTermBuffer& buffer) noexcept -> FVTerm&
{
  print (buffer);
  return *this;
}


// public methods of FVTerm
//----------------------------------------------------------------------
auto FVTerm::getFOutput() -> std::shared_ptr<FOutput>
{
  static const auto& init_object = getGlobalFVTermInstance();
  return init_object->foutput;
}

//----------------------------------------------------------------------
auto FVTerm::getPrintCursor() -> FPoint
{
  const auto* win = getPrintArea();

  if ( win )
    return { win->position.x + win->cursor.x
           , win->position.y + win->cursor.y };

  return {0, 0};  // Fallback coordinates
}

//----------------------------------------------------------------------
void FVTerm::setTerminalUpdates (TerminalUpdate refresh_state) const
{
  if ( refresh_state == TerminalUpdate::Stop )
  {
    no_terminal_updates = true;
  }
  else if ( refresh_state == TerminalUpdate::Continue
         || refresh_state == TerminalUpdate::Start )
  {
    no_terminal_updates = false;
  }

  if ( refresh_state == TerminalUpdate::Start )
    updateTerminal();
}

//----------------------------------------------------------------------
void FVTerm::setCursor (const FPoint& pos) noexcept
{
  if ( auto* win = getPrintArea() )
  {
    win->setCursorPos ( pos.getX() - win->position.x
                      , pos.getY() - win->position.y );
  }
}

//----------------------------------------------------------------------
void FVTerm::setNonBlockingRead (bool enable)
{
  static const auto& init_object = getGlobalFVTermInstance();
  init_object->foutput->setNonBlockingRead (enable);
}

//----------------------------------------------------------------------
auto FVTerm::hasPreprocessingHandler (const FVTerm* instance) noexcept -> bool
{
  if ( ! print_area )
    getPrintArea();

  if ( ! instance || ! print_area || print_area->preproc_list.empty() )
    return false;

  auto iter = print_area->preproc_list.cbegin();

  while ( iter != print_area->preproc_list.cend() )
  {
    if ( iter->get()->instance.get() == instance )
      return true;

    ++iter;
  }

  return false;
}

//----------------------------------------------------------------------
void FVTerm::clearArea (wchar_t fillchar)
{
  clearArea (vwin.get(), fillchar);
}

//----------------------------------------------------------------------
void FVTerm::createVDesktop (const FSize& size) noexcept
{
  // Initialize virtual desktop area

  const FRect box{0, 0, size.getWidth(), size.getHeight()};
  vdesktop = createArea(box);
  vdesktop->visible = true;
}

//----------------------------------------------------------------------
void FVTerm::createVTerm (const FSize& size) noexcept
{
  // Initialize virtual terminal

  const FRect box{0, 0, size.getWidth(), size.getHeight()};
  vterm = createArea(box);
  vterm_old = createArea(box);
}

//----------------------------------------------------------------------
void FVTerm::resizeVTerm (const FSize& size) const noexcept
{
  // Resize virtual terminal

  const FRect box{0, 0, size.getWidth(), size.getHeight()};
  resizeArea (box, vterm.get());
  resizeArea (box, vterm_old.get());
}

//----------------------------------------------------------------------
void FVTerm::putVTerm() const
{
  // Update the entire terminal screen

  auto xmax = uInt(vterm->size.width - 1);
  auto ymax = uInt(vterm->size.height - 1);
  auto vterm_changes = vterm->changes_in_line.begin();
  std::for_each ( vterm_changes
                , vterm_changes + vterm->size.height
                , [&xmax] (auto& vterm_changes_line) noexcept
                  {
                    vterm_changes_line.xmin = 0;
                    vterm_changes_line.xmax = xmax;
                  } );
  vterm->changes_in_row = {0, ymax};
  updateTerminal();
}

//----------------------------------------------------------------------
auto FVTerm::updateTerminal() const -> bool
{
  // Update terminal screen when modified

  auto terminal_updated = canUpdateTerminalNow()
                        ? foutput->updateTerminal()
                        : false;

  if ( terminal_updated )
    saveCurrentVTerm();

  return terminal_updated;
}

//----------------------------------------------------------------------
void FVTerm::reduceTerminalLineUpdates (uInt y)
{
  static const auto& init_object = getGlobalFVTermInstance();
  static const auto& vterm = init_object->vterm;
  static const auto& vterm_old = init_object->vterm_old;
  auto& vterm_changes = vterm->changes_in_line[unsigned(y)];
  uInt& xmin = vterm_changes.xmin;
  uInt& xmax = vterm_changes.xmax;

  if ( xmin > xmax )  // No changes
    return;

  auto first = vterm->getFCharIterator(int(xmin), int(y));
  auto first_old = vterm_old->getFCharIterator(int(xmin), int(y));
  auto last = vterm->getFCharIterator(int(xmax), int(y));
  auto last_old = vterm_old->getFCharIterator(int(xmax), int(y));

  while ( xmin < xmax && *first == *first_old )
  {
    xmin++;
    ++first;
    ++first_old;
  }

  while ( last >= first && *last == *last_old )
  {
    xmax--;
    --last;
    --last_old;
  }

  while ( last > first )
  {
    if ( *last == *last_old )
      last->attr.bit.no_changes = true;

    --last;
    --last_old;
  }
}

//----------------------------------------------------------------------
void FVTerm::addPreprocessingHandler ( const FVTerm* instance
                                     , FPreprocessingFunction&& function )
{
  if ( ! print_area )
    getPrintArea();

  if ( ! instance || ! print_area )
    return;

  delPreprocessingHandler (instance);
  auto obj = std::make_unique<FVTermPreprocessing> \
      (instance, std::move(function));
  print_area->preproc_list.emplace_back(std::move(obj));
}

//----------------------------------------------------------------------
void FVTerm::delPreprocessingHandler (const FVTerm* instance)
{
  if ( ! print_area )
    getPrintArea();

  if ( ! instance || ! print_area || print_area->preproc_list.empty() )
    return;

  auto iter = print_area->preproc_list.cbegin();

  while ( iter != print_area->preproc_list.cend() )
  {
    if ( iter->get()->instance.get() == instance )
      iter = print_area->preproc_list.erase(iter);
    else
      ++iter;
  }
}

//----------------------------------------------------------------------
auto FVTerm::print (const FString& string) noexcept -> int
{
  if ( string.isEmpty() )
    return 0;

  vterm_buffer.print(string);
  return print (vterm_buffer);
}

//----------------------------------------------------------------------
auto FVTerm::print (FTermArea* area, const FString& string) noexcept -> int
{
  if ( ! area || string.isEmpty() )
    return -1;

  vterm_buffer.print(string);
  return print (area, vterm_buffer);
}

//----------------------------------------------------------------------
auto FVTerm::print (const std::vector<FChar>& term_string) noexcept -> int
{
  if ( term_string.empty() )
    return -1;

  vterm_buffer.assign(term_string.cbegin(), term_string.cend());
  return print (vterm_buffer);
}

//----------------------------------------------------------------------
auto FVTerm::print (FTermArea* area, const std::vector<FChar>& term_string) noexcept -> int
{
  if ( ! area || term_string.empty() )
    return -1;

  vterm_buffer.assign(term_string.cbegin(), term_string.cend());
  return print (area, vterm_buffer);
}

//----------------------------------------------------------------------
auto FVTerm::print (FVTermBuffer& buffer) noexcept -> int
{
  if ( buffer.isEmpty() )
    return -1;

  auto* area = getPrintArea();
  return area ? print (area, buffer) : -1;
}

//----------------------------------------------------------------------
auto FVTerm::print (const FVTermBuffer& buffer) noexcept -> int
{
  if ( buffer.isEmpty() )
    return -1;

  auto* area = getPrintArea();
  return area ? print (area, buffer) : -1;
}

//----------------------------------------------------------------------
auto FVTerm::print (FTermArea* area, FVTermBuffer& buffer) const noexcept -> int
{
  auto len = print (area, static_cast<const FVTermBuffer&>(buffer));
  buffer.clear();  // Clear FVTermBuffer after printing
  return len;
}

//----------------------------------------------------------------------
auto FVTerm::print (FTermArea* area, const FVTermBuffer& buffer) const noexcept -> int
{
  int len{0};

  if ( ! area || buffer.isEmpty() )
    return -1;

  auto ac = area->getFCharIterator( area->cursor.x - 1
                                  , area->cursor.y - 1 );  // area character iterator

  for (const auto& fchar : buffer)
  {
    if ( printCharacter(area, ac, fchar) == -1 )  // Print next character
      break;  // No area or end of area reached

    len++;
  }

  return len;
}

//----------------------------------------------------------------------
auto FVTerm::print (wchar_t c) noexcept -> int
{
  auto* area = getPrintArea();
  return area ? print (area, c) : -1;
}

//----------------------------------------------------------------------
auto FVTerm::print (FTermArea* area, wchar_t c) noexcept -> int
{
  if ( ! area )
    return -1;

  static const auto& next_attr = getAttribute();
  nc.color.data = next_attr.color.data;
  nc.attr.byte[0] = next_attr.attr.byte[0];
  nc.attr.byte[1] = next_attr.attr.byte[1];
  nc.attr.byte[2] = 0;
  nc.attr.byte[3] = 0;
  nc.ch[0] = c;
  nc.ch[1] = L'\0';
  return print (area, nc);
}

//----------------------------------------------------------------------
auto FVTerm::print (const FChar& term_char) noexcept -> int
{
  auto* area = getPrintArea();
  return area ? print (area, term_char) : -1;
}

//----------------------------------------------------------------------
auto FVTerm::print (FTermArea* area, const FChar& term_char) const noexcept -> int
{
  if ( ! area )
    return -1;  // No area

  auto ac = area->getFCharIterator( area->cursor.x - 1
                                  , area->cursor.y - 1 );  // area character iterator
  return printCharacter(area, ac, term_char);
}

//----------------------------------------------------------------------
void FVTerm::flush() const
{
  foutput->flush();
}


// protected methods of FVTerm
//----------------------------------------------------------------------
auto FVTerm::getPrintArea() -> FTermArea*
{
  // returns the print area of this object

  if ( print_area )
    return print_area;

  if ( vwin )
  {
    print_area = vwin.get();
    return print_area;
  }

  if ( child_print_area )
  {
    print_area = child_print_area;
    return print_area;
  }

  return vdesktop.get();
}

//----------------------------------------------------------------------
auto FVTerm::createArea (const FShadowBox& shadowbox) -> std::unique_ptr<FTermArea>
{
  // initialize virtual window

  auto area = std::make_unique<FTermArea>();
  area->setOwner<FVTerm*>(this);
  area->encoding = foutput->getEncoding();
  resizeArea (shadowbox, area.get());
  return area;
}

//----------------------------------------------------------------------
auto FVTerm::createArea (const FRect& box) -> std::unique_ptr<FTermArea>
{
  // initialize virtual window

  const auto no_shadow = FSize(0, 0);
  return createArea ({box, no_shadow});
}

//----------------------------------------------------------------------
void FVTerm::resizeArea ( const FShadowBox& shadowbox
                        , FTermArea* area ) const
{
  // Resize the virtual window to a new size

  assert ( isAreaValid(shadowbox) );

  if ( ! area )
    return;

  if ( isSizeEqual(area, shadowbox) )
  {
    area->position.x = shadowbox.box.getX();
    area->position.y = shadowbox.box.getY();
    return;  // Move only
  }

  const auto full_width  = shadowbox.box.getWidth()
                         + shadowbox.shadow.getWidth();
  const auto full_height = shadowbox.box.getHeight()
                         + shadowbox.shadow.getHeight();

  if ( ! tryResizeArea(area, full_width, full_height) )
    return;

  updateAreaProperties (area, shadowbox);
  // Set default FChar in area
  resetTextAreaToDefault (area, { FSize{full_width, full_height} });
}

//----------------------------------------------------------------------
void FVTerm::resizeArea (const FRect& box, FTermArea* area) const
{
  // Resize the virtual window to a new size

  const auto no_shadow = FSize(0, 0);
  resizeArea ({box, no_shadow}, area);
}

//----------------------------------------------------------------------
void FVTerm::restoreVTerm (const FRect& box) const noexcept
{
  if ( ! vterm || box.getWidth() == 0 || box.getHeight() == 0 )
    return;

  const auto* vterm_win_list = getWindowList();

  if ( ! vterm_win_list || vterm_win_list->empty() )
    return;

  const FSize vterm_size{ static_cast<std::size_t>(vterm->size.width)
                        , static_cast<std::size_t>(vterm->size.height) };

  if ( vdesktop && vdesktop->reprint(box, vterm_size) )
    addLayer(vdesktop.get());

  for (const auto& vterm_obj : *vterm_win_list)
  {
    if ( ! vterm_obj )
      continue;

    auto* win = vterm_obj->getVWin();

    if ( win && win->visible && win->layer > 0 && win->reprint(box, vterm_size) )
      addLayer(win);
  }
}

//----------------------------------------------------------------------
auto FVTerm::updateVTermCursor (const FTermArea* area) const noexcept -> bool
{
  if ( ! (area && isActive(area) && area->visible) )
    return false;

  if ( area->input_cursor_visible )
  {
    // area cursor position
    const int cx = area->input_cursor.x;
    const int cy = area->input_cursor.y;
    // terminal position = area position + area cursor position
    const int x  = area->position.x + cx;
    const int y  = area->position.y + cy;

    if ( isInsideArea (FPoint{cx, cy}, area)
      && isInsideTerminal (FPoint{x, y})
      && isCovered (FPoint{x, y}, area) == CoveredState::None )
    {
      vterm->setInputCursorPos(x, y);
      vterm->input_cursor_visible = true;
      vterm->has_changes = true;
      return true;
    }
  }

  vterm->input_cursor_visible = false;
  return false;
}

//----------------------------------------------------------------------
auto FVTerm::isCursorHideable() const noexcept -> bool
{
  return foutput->isCursorHideable();
}

//----------------------------------------------------------------------
void FVTerm::setAreaCursor ( const FPoint& pos
                           , bool visible
                           , FTermArea* area ) const noexcept
{
  if ( ! area )
    return;

  area->setInputCursorPos (pos.getX() - 1, pos.getY() - 1);
  area->input_cursor_visible = visible;
}

//----------------------------------------------------------------------
void FVTerm::getArea (const FPoint& pos, FTermArea* area) const noexcept
{
  // Copies a block from the virtual terminal position to the given area

  if ( ! area )
    return;

  const int ax = pos.getX() - 1;
  const int ay = pos.getY() - 1;

  if ( ax < 0 || ay < 0 )
    return;

  const int y_end  = std::min(vterm->size.height - ay, area->size.height);
  const int length = std::min(vterm->size.width - ax, area->size.width);
  const auto area_width = getFullAreaWidth(area);
  const auto vterm_width = getFullAreaWidth(vterm.get());
  auto line_changes = area->changes_in_line.begin();
  auto ac = area->data.begin();  // area character
  auto tc = vterm->data.cbegin() + (ay * vterm_width);  // terminal character

  for (auto y{0}; y < y_end; y++)  // line loop
  {
    putAreaLine (*(tc + unsigned(ax)), *ac, unsigned(length));
    line_changes->xmin = 0;
    line_changes->xmax = uInt(length - 1);
    ++line_changes;
    ac += area_width;
    tc += vterm_width;
  }

  auto& changes_in_row = area->changes_in_row;
  changes_in_row.ymin = 0;
  changes_in_row.ymax = std::max(changes_in_row.ymax, uInt(y_end - 1));
}

//----------------------------------------------------------------------
void FVTerm::getArea (const FRect& box, FTermArea* area) const noexcept
{
  // Copies a block from the virtual terminal rectangle to the given area

  if ( ! area )
    return;

  int x = box.getX() - 1;
  int y = box.getY() - 1;
  int dx = x - area->position.x;
  int dy = y - area->position.y;
  auto w = std::min(area->size.width - dx, int(box.getWidth()));
  auto h = std::min(area->size.height - dy, int(box.getHeight()));

  if ( x < 0 || y < 0 )
    return;

  if ( dx < 0 ) { w += dx; x -= dx; dx = 0; }
  if ( dy < 0 ) { h += dy; y -= dy; dy = 0; }
  const int y_end = std::min(vterm->size.height - y, h);
  const int length = std::min(vterm->size.width - x, w);
  const auto area_width = getFullAreaWidth(area);
  const auto vterm_width = getFullAreaWidth(vterm.get());
  auto ac = area->data.begin() + (dy * area_width);  // area character
  auto tc = vterm->data.cbegin() + (y * vterm_width);  // terminal character

  if ( length < 1 )
    return;

  auto line_changes = area->changes_in_line.begin() + dy;

  for (auto line{0}; line < y_end; line++)  // line loop
  {
    putAreaLine (*(tc + x), *(ac + dx), unsigned(length));
    line_changes->xmin = std::min(line_changes->xmin, uInt(dx));
    line_changes->xmax = std::max(line_changes->xmax, uInt(dx + length - 1));
    ++line_changes;
    ac += area_width;
    tc += vterm_width;
  }

  auto& changes_in_row = area->changes_in_row;
  changes_in_row.ymin = 0;
  changes_in_row.ymax = std::max(changes_in_row.ymax, uInt(y_end - 1));
}

//----------------------------------------------------------------------
void FVTerm::addLayer (FTermArea* area) const noexcept
{
  // Transmit changes in area to the virtual terminal (add layer to vterm)

  if ( ! area || ! area->visible )
    return;

  // Compute geometry and decide early whether to render
  LayerGeometry geometry = computeLayerGeometry(area);

  // Early exit if area is completely outside vterm
  if ( ! isLayerOutsideVTerm(geometry) )
    return;

  // Call the preprocessing handler methods (child area change handling)
  callPreprocessingHandler(area);

  // Create a stack by combining identical rows in sequence
  line_changes_batch.clear();  // Clear buffer
  buildLineChangeBatch(area, geometry);

  if ( line_changes_batch.empty() )
    return;

  // Apply the batches to vterm data
  applyLineBatch(area, geometry);

  // Update the range of changed rows and the cursor on vterm
  updateVTermChangesFromBatch(geometry);
  updateVTermCursor(area);
}

//----------------------------------------------------------------------
void FVTerm::putArea (const FPoint& pos, FTermArea* area) const noexcept
{
  // Copies the given area block to the virtual terminal position

  if ( ! area || ! area->visible )
    return;

  copyArea (vterm.get(), pos, area);
}

//----------------------------------------------------------------------
void FVTerm::copyArea (FTermArea* dst, const FPoint& pos, FTermArea* src) const noexcept
{
  // Copies the src area to the dst area position

  if ( ! dst || ! src )
    return;

  if ( dst == vterm.get() )
    skip_one_vterm_update = true;

  const int src_width = getFullAreaWidth(src);
  const int dst_width = getFullAreaWidth(dst);
  const int src_height = src->minimized ? src->min_size.height : getFullAreaHeight(src);
  const int ax = std::max(0, pos.getX() - 1);
  const int ay = std::max(0, pos.getY() - 1);
  const int ol = std::max(0, 1 - pos.getX());  // outside left
  const int ot = std::max(0, 1 - pos.getY());  // outside top
  const int y_end = std::min(dst->size.height - ay, src_height - ot);
  const int length = std::min(dst->size.width - ax, src_width - ol);

  if ( length < 1 || y_end < 1 )
    return;

  auto src_changes = src->changes_in_line.cbegin();
  auto dst_changes = dst->changes_in_line.begin() + ay;
  auto sc = src->data.cbegin() + (src_width * ot) + ol;  // src character ptr
  auto dc = dst->data.begin() + (dst_width * ay) + ax;  // dst character ptr

  if ( skip_one_vterm_update )  // dst is the virtual terminal
    determineCoveredAreas(src);

  for (int y{0}; y < y_end; y++)  // line loop
  {
    if ( skip_one_vterm_update && src_changes->trans_count > 0 )
    {
      // Line with hidden and transparent characters
      putAreaLineWithTransparency (&sc[0], &dc[0], length, {ax, ay + y}, src_changes->covered);
    }
    else
    {
      // Line has only covered characters
      putAreaLine (sc[0], *dc, unsigned(length));
    }

    dst_changes->xmin = std::min(dst_changes->xmin, uInt(ax));
    dst_changes->xmax = std::max(dst_changes->xmax, uInt(ax + length - 1));
    ++src_changes;
    ++dst_changes;
    sc += src_width;
    dc += dst_width;
  }

  dst->changes_in_row.ymin = std::min(dst->changes_in_row.ymin, uInt(ay));
  dst->changes_in_row.ymax = std::max(dst->changes_in_row.ymax, uInt(ay + y_end - 1));
  dst->has_changes = true;
}

//----------------------------------------------------------------------
void FVTerm::determineWindowLayers() noexcept
{
  // Determination of the window layer for all virtual windows

  const auto* vterm_win_list = getWindowList();

  if ( ! vterm_win_list || vterm_win_list->empty() )
    return;

  const auto& begin = vterm_win_list->cbegin();
  const auto& end = vterm_win_list->cend();
  auto iter = begin;

  while ( iter != end )
  {
    (*iter)->getPrintArea()->layer = int(std::distance(begin, iter) + 1);
    ++iter;
  }
}

//----------------------------------------------------------------------
void FVTerm::scrollAreaForward (FTermArea* area)
{
  // Scrolls the entire area on line up

  if ( ! area || area->size.height <= 1 )
    return;

  const int y_max = area->size.height - 1;
  const int x_max = area->size.width - 1;
  auto line_changes = area->changes_in_line.begin();
  const auto area_width = getFullAreaWidth(area);
  auto sc = area->data.cbegin() + area_width;  // source character
  auto dc = area->data.begin();  // destination character

  for (auto y{0}; y < y_max; y++)
  {
    putAreaLine (*sc, *dc, unsigned(area->size.width));
    line_changes->xmin = 0;
    line_changes->xmax = uInt(x_max);
    ++line_changes;
    sc += area_width;
    dc += area_width;
  }

  // insert a new line below
  const auto& lc = area->getFChar(x_max, area->size.height - 2);  // last character
  nc.color.data = lc.color.data;
  nc.attr = lc.attr;
  nc.ch[0] = L' ';
  nc.ch[1] = L'\0';
  dc = area->data.begin() + (area_width * y_max);  // destination character
  std::fill (dc, dc + area->size.width, nc);
  auto new_line_changes = area->changes_in_line.begin() + y_max;
  new_line_changes->xmin = 0;
  new_line_changes->xmax = uInt(x_max);
  area->changes_in_row = {0, uInt(y_max)};
  area->has_changes = true;

  if ( area == vdesktop.get() )
    scrollTerminalForward();  // Scrolls the terminal up one line
}

//----------------------------------------------------------------------
void FVTerm::scrollAreaReverse (FTermArea* area)
{
  // Scrolls the entire area one line down

  if ( ! area || area->size.height <= 1 )
    return;

  const int y_max = area->size.height - 1;
  const int x_max = area->size.width - 1;
  auto line_changes = area->changes_in_line.begin() + y_max;
  const auto area_width = getFullAreaWidth(area);
  auto sc = area->data.cbegin() + (area_width * (y_max - 1));  // source character
  auto dc = area->data.begin() + (area_width * y_max);  // destination character

  for (auto y = y_max; y > 0; y--)
  {
    putAreaLine (*sc, *dc, unsigned(area->size.width));
    line_changes->xmin = 0;
    line_changes->xmax = uInt(x_max);
    --line_changes;
    sc -= area_width;
    dc -= area_width;
  }

  // insert a new line above
  const auto& lc = area->getFChar(0, 1);  // last character
  nc.color.data = lc.color.data;
  nc.attr = lc.attr;
  nc.ch[0] = L' ';
  nc.ch[1] = L'\0';
  dc = area->data.begin();  // destination character
  std::fill (dc, dc + area->size.width, nc);
  auto new_line_changes = area->changes_in_line.begin() + y_max;
  new_line_changes->xmin = 0;
  new_line_changes->xmax = uInt(x_max);
  area->changes_in_row = {0, uInt(y_max)};
  area->has_changes = true;

  if ( area == vdesktop.get() )
    scrollTerminalReverse();  // Scrolls the terminal down one line
}

//----------------------------------------------------------------------
void FVTerm::clearArea (FTermArea* area, wchar_t fillchar) noexcept
{
  // Clear the area with the current attributes

  static const auto& next_attr = getAttribute();
  nc.color.data = next_attr.color.data;
  nc.attr = next_attr.attr;
  nc.ch[0] = fillchar;  // Current attributes with the fill character
  nc.ch[1] = L'\0';
  nc.attr.bit.char_width = getColumnWidth(nc.ch[0]) & 0x03;

  if ( ! area || area->data.empty() )
  {
    foutput->clearTerminal (fillchar);
    return;
  }

  const auto width = uInt(getFullAreaWidth(area));

  if ( area->shadow.width == 0 )
  {
    if ( clearFullArea(area, nc) )
      return;
  }
  else
    clearAreaWithShadow(area, nc);

  auto line_changes = area->changes_in_line.begin();

  for (auto i{0}; i < area->size.height; i++)
  {
    line_changes->xmin = 0;
    line_changes->xmax = width - 1;

    if ( nc.attr.bit.transparent
      || nc.attr.bit.color_overlay
      || nc.attr.bit.inherit_background )
      line_changes->trans_count = width;
    else if ( area->shadow.width != 0 )
      line_changes->trans_count = uInt(area->shadow.width);
    else
      line_changes->trans_count = 0;

    ++line_changes;
  }

  line_changes = area->changes_in_line.begin() + area->size.height;

  for (auto i{0}; i < area->shadow.height; i++)
  {
    line_changes->xmin = 0;
    line_changes->xmax = width - 1;
    line_changes->trans_count = width;
    ++line_changes;
  }

  area->changes_in_row = {0, uInt(getFullAreaHeight(area) - 1)};
  area->has_changes = true;
}

//----------------------------------------------------------------------
void FVTerm::forceTerminalUpdate() const
{
  force_terminal_update = true;
  processTerminalUpdate();
  flush();
  force_terminal_update = false;
}

//----------------------------------------------------------------------
auto FVTerm::processTerminalUpdate() const -> bool
{
  // Checks if the resizing of the terminal is not finished

  if ( foutput->hasTerminalResized() )
    return false;

  // Update data on VTerm
  if ( skip_one_vterm_update )
    skip_one_vterm_update = false;
  else
    updateVTerm();

  // Update the visible terminal
  return updateTerminal();
}

//----------------------------------------------------------------------
void FVTerm::startDrawing() noexcept
{
  // Pauses the terminal updates for the printing phase
  draw_completed = false;
}

//----------------------------------------------------------------------
void FVTerm::finishDrawing() noexcept
{
  // After the printing phase is completed, the terminal will be updated
  draw_completed = true;
}

//----------------------------------------------------------------------
void FVTerm::initTerminal()
{
  foutput->initTerminal(vterm.get());
  tabstop = foutput->getTabstop();
  resetAreaEncoding();
}


// private methods of FVTerm
//----------------------------------------------------------------------
void FVTerm::setGlobalFVTermInstance (FVTerm* ptr) noexcept
{
  getGlobalFVTermInstance() = ptr;
}

//----------------------------------------------------------------------
auto FVTerm::getGlobalFVTermInstance() noexcept -> FVTerm*&
{
  static FVTerm* init_object{nullptr};
  return init_object;
}

//----------------------------------------------------------------------
auto FVTerm::isInitialized() noexcept -> bool
{
  return internal::var::fvterm_initialized;
}

//----------------------------------------------------------------------
void FVTerm::resetAreaEncoding() const
{
  auto encoding = foutput->getEncoding();
  vdesktop->encoding = encoding;
  vterm->encoding = encoding;

  for (auto&& vterm_obj : *vterm_window_list)
  {
    auto v_win = vterm_obj->getVWin();

    if ( ! v_win )
      continue;

    v_win->encoding = encoding;

    for (const auto& pcall : v_win->preproc_list)
    {
      if ( pcall->instance && pcall->instance->child_print_area )
        pcall->instance->child_print_area->encoding = encoding;
    }
  }
}

//----------------------------------------------------------------------
inline void FVTerm::resetTextAreaToDefault ( FTermArea* area
                                           , const FSize& size ) const noexcept
{
  static constexpr FChar default_char
  {
    { L' ',  L'\0', L'\0', L'\0', L'\0' },
    { L'\0', L'\0', L'\0', L'\0', L'\0' },
    { { FColor::Default, FColor::Default } },
    { { 0x00, 0x00, 0x08, 0x00} }  // byte 0..3 (byte 2 = 0x08 = char_width 1)
  };
  std::fill (area->data.begin(), area->data.end(), default_char);

  const FTermArea::FLineChanges unchanged { uInt(size.getWidth())
                                          , 0, 0, false };
  std::fill (area->changes_in_line.begin(), area->changes_in_line.end(), unchanged);
  area->changes_in_row = { uInt(size.getHeight()), 0};
}

//----------------------------------------------------------------------
inline auto FVTerm::resizeTextArea ( FTermArea* area
                                   , std::size_t height
                                   , std::size_t size ) const -> bool
{
  // Set the number of lines for changes to "height"
  // and resize the text area to "size" elements

  area->changes_in_line.resize(height);
  resizeTextArea (area, size);
  return true;
}

//----------------------------------------------------------------------
inline auto FVTerm::resizeTextArea (FTermArea* area, std::size_t size) const -> bool
{
  // Resize text area to "size" FChar elements

  area->data.resize(size);
  return true;
}

//----------------------------------------------------------------------
auto FVTerm::isCovered (const FPoint& pos, const FTermArea* area) const noexcept -> CoveredState
{
  // Determines the covered state for the given position

  const auto* vterm_win_list{getWindowList()};

  if ( ! area || ! vterm_win_list || vterm_win_list->empty()
    || vterm_win_list->back()->getVWin() == area )  // Top window can't be covered
    return CoveredState::None;

  const auto pos_x = pos.getX();
  const auto pos_y = pos.getY();

  auto is_covered{CoveredState::None};  // Initial state: no coverage
  bool found{ area == vdesktop.get() };

  for (const auto& vterm_obj : *vterm_win_list)  // Iteration through window list
  {
    const auto* win = vterm_obj->getVWin();

    if ( ! win || ! win->visible )
      continue;

    if ( ! found )  // Check if we've found the target area yet
    {
      found = ( area == win );
      continue;
    }

    const int win_x_min = win->position.x;
    const int win_y_min = win->position.y;

    if ( pos_x < win_x_min || pos_y < win_y_min )
      continue;

    const int current_height = win->minimized ? win->min_size.height
                                              : getFullAreaHeight(win);
    const int win_x_max = win_x_min + getFullAreaWidth(win);
    const int win_y_max = win_y_min + current_height;

    if ( pos_x >= win_x_max || pos_y >= win_y_max )
      continue;

    // Position is covered by this window - check for transparency
    const auto delta_x = pos_x - win->position.x;
    const auto delta_y = pos_y - win->position.y;
    const auto width = getFullAreaWidth(win);
    const auto index = unsigned(delta_y) * unsigned(width) + unsigned(delta_x);
    const auto& character = win->data[index];

    if ( character.attr.bit.transparent )
      continue;

    if ( character.attr.bit.color_overlay )  // Color overlay = half covered
      is_covered = CoveredState::Half;  // Mark as partially covered
    else
      return CoveredState::Full;  // Fully covered
  }

  return is_covered;
}

//----------------------------------------------------------------------
inline auto FVTerm::isAreaValid (const FShadowBox& shadowbox) const noexcept -> bool
{
  return shadowbox.box.getY() >= 0
      && shadowbox.box.getWidth() > 0
      && shadowbox.box.getHeight() > 0;
}

//----------------------------------------------------------------------
inline auto FVTerm::isSizeEqual (const FTermArea* area, const FShadowBox& shadowbox) const noexcept -> bool
{
  return area->size.width == int(shadowbox.box.getWidth())
      && area->size.height == int(shadowbox.box.getHeight())
      && area->shadow.width == int(shadowbox.shadow.getWidth())
      && area->shadow.height == int(shadowbox.shadow.getHeight());
}

//----------------------------------------------------------------------
constexpr auto FVTerm::needsHeightResize ( const FTermArea* area
                                         , const std::size_t full_height ) const noexcept -> bool
{
  return getFullAreaHeight(area) != int(full_height);
}

//----------------------------------------------------------------------
constexpr auto FVTerm::needsWidthResize ( const FTermArea* area
                                        , const std::size_t full_width ) const noexcept -> bool
{
  return getFullAreaWidth(area) != int(full_width);
}

//----------------------------------------------------------------------
inline auto FVTerm::tryResizeArea ( FTermArea* area
                                  , const std::size_t width
                                  , const std::size_t height ) const -> bool
{
  if ( needsHeightResize(area, height) )
    return resizeTextArea(area, height, width * height);

  if ( needsWidthResize(area, width) )
    return resizeTextArea(area, width * height);

  return false;
}

//----------------------------------------------------------------------
inline void FVTerm::updateAreaProperties (FTermArea* area, const FShadowBox& shadowbox) const noexcept
{
  area->position.x      = shadowbox.box.getX();
  area->position.y      = shadowbox.box.getY();
  area->size.width      = int(shadowbox.box.getWidth());
  area->size.height     = int(shadowbox.box.getHeight());
  area->min_size.width  = area->size.width;
  area->min_size.height = DEFAULT_MINIMIZED_HEIGHT;
  area->shadow.width    = int(shadowbox.shadow.getWidth());
  area->shadow.height   = int(shadowbox.shadow.getHeight());
  area->has_changes     = false;
}

//----------------------------------------------------------------------
constexpr auto FVTerm::getFullAreaWidth (const FTermArea* area) const noexcept -> int
{
  return area->size.width + area->shadow.width;
}

//----------------------------------------------------------------------
constexpr auto FVTerm::getFullAreaHeight (const FTermArea* area) const noexcept -> int
{
  return area->size.height + area->shadow.height;
}

//----------------------------------------------------------------------
void FVTerm::passChangesToOverlap (const FTermArea* area) const
{
  const auto* vterm_win_list = getWindowList();

  if ( ! area || ! vterm_win_list || vterm_win_list->empty() )
    return;

  processOverlappingWindows (area, *vterm_win_list);
}

//----------------------------------------------------------------------
inline void FVTerm::processOverlappingWindows ( const FTermArea* area
                                              , const FVTermList& vterm_win_list ) const
{
  bool found{false};

  if ( ! area )
    return;

  for (const auto& vterm_obj : vterm_win_list)
  {
    auto* win = vterm_obj->getVWin();

    if ( found && win && win->visible && win->isOverlapped(area) )
    {
      // Pass changes to the found window
      passChangesToOverlappingWindow (win, area);
    }

    if ( area == win )
      found = true;
  }
}

//----------------------------------------------------------------------
inline void FVTerm::passChangesToOverlappingWindow (FTermArea* win, const FTermArea* area) const noexcept
{
  win->has_changes = true;

  // Boundaries
  const int win_y_min = win->position.y;
  const int win_height = win->minimized ? win->min_size.height : getFullAreaHeight(win);
  const int win_y_max = win_y_min + win_height - 1;
  const int area_y_min = area->position.y;
  const int area_height = area->minimized ? area->min_size.height : getFullAreaHeight(area);
  const int area_y_max = area_y_min + area_height - 1;
  const int vterm_y_max = vterm->size.height - 1;

  // Calculate start and end line
  const int y_start = calculateStartCoordinate (area_y_min, win_y_min);
  const int y_end = calculateEndCoordinate (vterm_y_max, area_y_max, win_y_min, win_y_max);

  for (auto y{y_start}; y <= y_end; y++)  // Line loop
  {
    passChangesToOverlappingWindowLine (win, y, area);
  }

  win->changes_in_row = {uInt(y_start), uInt(y_end)};
}

//----------------------------------------------------------------------
inline void FVTerm::passChangesToOverlappingWindowLine (FTermArea* win, int y, const FTermArea* area) const noexcept
{
  // Boundaries
  const int win_x_min = win->position.x;
  const int win_x_max = win_x_min + getFullAreaWidth(win) - 1;
  const int area_x_min = area->position.x;
  const int area_x_max = area_x_min + getFullAreaWidth(area) - 1;
  const int vterm_x_max = vterm->size.width - 1;

  // Calculate start and end position
  const int x_start = calculateStartCoordinate (area_x_min, win_x_min);
  const int x_end = calculateEndCoordinate (vterm_x_max, area_x_max, win_x_min, win_x_max);

  // Sets the new change boundaries
  auto& line_changes = win->changes_in_line[unsigned(y)];
  line_changes.xmin = uInt(std::min(int(line_changes.xmin), x_start));
  line_changes.xmax = uInt(std::max(int(line_changes.xmax), x_end));
}

//----------------------------------------------------------------------
inline auto FVTerm::calculateStartCoordinate (int area_min, int win_min) const noexcept -> int
{
  return std::max({0, area_min, win_min}) - win_min;
}

//----------------------------------------------------------------------
inline auto FVTerm::calculateEndCoordinate (int vterm_max, int area_max, int win_min, int win_max) const noexcept -> int
{
  return std::min({vterm_max, area_max, win_max}) - win_min;
}

//----------------------------------------------------------------------
void FVTerm::updateVTerm() const
{
  // Updates the character data from all areas to VTerm

  updateVTermDesktop();

  if ( ! vterm_window_list || vterm_window_list->empty() )
    return;

  for (const auto& vterm_obj : *vterm_window_list)  // List from bottom to top
  {
    auto v_win = vterm_obj->getVWin();

    if ( ! (v_win && v_win->visible && v_win->layer > 0) )
      continue;

    updateVTermWindow(v_win);
  }
}

//----------------------------------------------------------------------
inline void FVTerm::updateVTermDesktop() const
{
  if ( ! hasPendingUpdates(vdesktop.get()) )
    return;

  addLayer(vdesktop.get());  // Add vdesktop changes to vterm
  vdesktop->has_changes = false;
}

//----------------------------------------------------------------------
inline void FVTerm::updateVTermWindow (FTermArea* v_win) const
{
  if ( hasPendingUpdates(v_win) )
  {
    passChangesToOverlap(v_win);
    addLayer(v_win);  // Add v_win changes to vterm
    v_win->has_changes = false;
  }
  else if ( hasChildAreaChanges(v_win) )
  {
    passChangesToOverlap(v_win);
    addLayer(v_win);  // and call the child area processing handler there
    clearChildAreaChanges(v_win);
  }
}
//----------------------------------------------------------------------
inline auto FVTerm::computeLayerGeometry (const FTermArea* area) const noexcept -> LayerGeometry
{
  // Compute the geometry values used throughout the rendering process

  const auto area_x = area->position.x;
  const auto area_y = area->position.y;
  const auto vterm_width = unsigned(vterm->size.width);
  const auto vterm_height = unsigned(vterm->size.height);
  const auto height = area->minimized ? area->min_size.height : getFullAreaHeight(area);

  return LayerGeometry
  {
    area_x,
    area_y,
    std::max(0, -area_x),
    vterm_width,
    vterm_height,
    static_cast<unsigned>(std::max(area_x, 0)),
    getFullAreaWidth(area),
    height,
    static_cast<int>(vterm_width) - area_x - 1,
    // Calculate actual rendering range (clipped to vterm)
    std::max(0, -area_y),
    std::min(static_cast<int>(vterm_height) - area_y, height)
  };
}

//----------------------------------------------------------------------
inline auto FVTerm::isLayerOutsideVTerm (const LayerGeometry& geo) const noexcept -> bool
{
  if ( geo.area_y >= static_cast<int>(geo.vterm_height) )
    return false;

  if ( geo.ax >= geo.vterm_width )
    return false;

  if ( geo.area_y + geo.height <= 0 )
    return false;

  return true;
}

//----------------------------------------------------------------------
inline void FVTerm::buildLineChangeBatch ( const FTermArea* area
                                         , const LayerGeometry& geo ) const noexcept
{
  int prev_xmin{-1};
  int prev_xmax{-1};
  NoTrans prev_has_no_trans{NoTrans::Undefined};

  auto line_changes = &area->changes_in_line[unsigned(geo.y_start)];

  for (auto y{geo.y_start}; y < geo.y_end; y++)  // Line loop
  {
    const auto line_xmin_raw = int(line_changes->xmin);
    const auto line_xmax_raw = int(line_changes->xmax);

    if ( line_xmin_raw > line_xmax_raw )
    {
      ++line_changes;
      prev_xmin = -1;
      prev_xmax = -1;
      prev_has_no_trans = NoTrans::Undefined;
      continue;
    }

    const auto line_xmin = std::max(line_xmin_raw, geo.ol);
    const auto line_xmax = std::min(line_xmax_raw, geo.xmax_inside_vterm);

    if ( line_xmin > line_xmax )
    {
      ++line_changes;
      prev_xmin = -1;
      prev_xmax = -1;
      prev_has_no_trans = NoTrans::Undefined;
      continue;
    }

    const NoTrans has_no_trans = line_changes->trans_count == 0 ? NoTrans::Set : NoTrans::Unset;
    ++line_changes;

    if ( prev_xmin == line_xmin
      && prev_xmax == line_xmax
      && prev_has_no_trans == has_no_trans )
    {
      line_changes_batch.back().count++;
      continue;
    }

    line_changes_batch.push_back({1, y, line_xmin, line_xmax, has_no_trans});
    prev_xmin = line_xmin;
    prev_xmax = line_xmax;
    prev_has_no_trans = has_no_trans;
  }
}

//----------------------------------------------------------------------
inline void FVTerm::applyLineBatch ( FTermArea* area
                                   , const LayerGeometry& geo ) const noexcept
{
  for (const auto& line : line_changes_batch)
  {
    const auto line_xmin = static_cast<unsigned>(line.xmin);
    const auto line_xmax = static_cast<unsigned>(line.xmax);
    const auto has_no_trans = line.has_no_transparency == NoTrans::Set;
    const auto tx = unsigned(geo.area_x) + line_xmin;  // Global terminal x-position
    const std::size_t length = line_xmax - line_xmin + 1;

    // Process all lines in batch with same operation
    for (int i = 0; i < line.count; ++i)
    {
      const auto y = static_cast<unsigned>(line.ypos + i);
      auto line_changes = &area->changes_in_line[y];
      const auto ty = unsigned(geo.area_y) + y;         // Global terminal y-position
      const auto area_line_offset = y * unsigned(geo.width) + line_xmin;
      const auto vterm_line_offset = ty * geo.vterm_width + tx;
      const auto* ac = &area->data[area_line_offset];   // Area character
      auto* tc = &vterm->data[vterm_line_offset];       // Terminal character

      if ( has_no_trans )
      {
        // Line has only covered characters
        putAreaLine (*ac, *tc, length);
      }
      else
      {
        // Line with hidden and transparent characters
        addAreaLineWithTransparency (ac, tc, length);
      }

      auto& vterm_changes = vterm->changes_in_line[ty];
      const auto tx_start = uInt(tx);
      const auto tx_end   = uInt(std::min( geo.ax + line_xmax
                                         , geo.vterm_width - 1 ));
      vterm_changes.xmin = std::min(vterm_changes.xmin, tx_start);
      vterm_changes.xmax = std::max(vterm_changes.xmax, tx_end);

      line_changes->xmin = uInt(geo.width);
      line_changes->xmax = 0;
      ++line_changes;
    }
  }
}

//----------------------------------------------------------------------
inline void FVTerm::updateVTermChangesFromBatch (const LayerGeometry& geo) const noexcept
{
  const auto& first = line_changes_batch.front();
  const auto& last  = line_changes_batch.back();
  const auto begin = uInt(geo.area_y + first.ypos - geo.y_start);
  const auto end = uInt(geo.area_y + last.ypos + last.count - 1 - geo.y_start);

  auto& changes_in_row = vterm->changes_in_row;
  changes_in_row.ymin = std::min(changes_in_row.ymin, begin);
  changes_in_row.ymax = std::max(changes_in_row.ymax, end);
  vterm->has_changes = true;
}

//----------------------------------------------------------------------
inline void FVTerm::scrollTerminalForward() const
{
  // Scrolls the terminal up one line

  foutput->flush();  // Empty buffer before scrolling

  if ( ! foutput->scrollTerminalForward() )
    return;

  // Avoid update lines from 0 to (height - 2)
  auto* vdesktop_changes = &vdesktop->changes_in_line[0];
  const auto* vdesktop_changes_end = vdesktop_changes
                                   + unsigned(vdesktop->size.height - 1);

  while ( vdesktop_changes < vdesktop_changes_end )
  {
    vdesktop_changes->xmin = uInt(vdesktop->size.width - 1);
    vdesktop_changes->xmax = 0;
    ++vdesktop_changes;
  }

  vdesktop->changes_in_row = {0, uInt(vdesktop->size.height - 2)};
  putArea (FPoint{1, 1}, vdesktop.get());
  saveCurrentVTerm();  // Ensure that the current terminal is comparable
  forceTerminalUpdate();
}

//----------------------------------------------------------------------
inline void FVTerm::scrollTerminalReverse() const
{
  // Scrolls the terminal down one line

  foutput->flush();  // Empty buffer before scrolling

  if ( ! foutput->scrollTerminalReverse() )
    return;

  // avoid update lines from 1 to (height - 1)
  auto* vdesktop_changes = &vdesktop->changes_in_line[1];
  const auto* vdesktop_changes_end = vdesktop_changes
                                   + unsigned(vdesktop->size.height);

  while ( vdesktop_changes < vdesktop_changes_end )
  {
    vdesktop_changes->xmin = uInt(vdesktop->size.width - 1);
    vdesktop_changes->xmax = 0;
    ++vdesktop_changes;
  }

  vdesktop->changes_in_row = {1, uInt(vdesktop->size.height - 1)};
  putArea (FPoint{1, 1}, vdesktop.get());
  saveCurrentVTerm();  // Ensure that the current terminal is comparable
  forceTerminalUpdate();
}

//----------------------------------------------------------------------
void FVTerm::callPreprocessingHandler (const FTermArea* area) const
{
  // Call preprocessing handler

  if ( ! area || area->preproc_list.empty() )
    return;

  for (const auto& pcall : area->preproc_list)
  {
    // call the preprocessing handler
    const auto& preprocessingHandler = pcall->function;
    preprocessingHandler();
  }
}

//----------------------------------------------------------------------
auto FVTerm::hasChildAreaChanges (const FTermArea* area) const -> bool
{
  if ( ! area || area->preproc_list.empty() )
    return false;

  return std::any_of ( area->preproc_list.cbegin()
                     , area->preproc_list.cend()
                     , [] (const auto& pcall) noexcept
                       {
                         return pcall->instance
                             && pcall->instance->child_print_area
                             && pcall->instance->child_print_area->has_changes;
                       }
                     );
}

//----------------------------------------------------------------------
void FVTerm::clearChildAreaChanges (const FTermArea* area) const
{
  if ( ! area || area->preproc_list.empty() )
    return;

  for (const auto& pcall : area->preproc_list)
  {
    if ( pcall->instance && pcall->instance->child_print_area )
      pcall->instance->child_print_area->has_changes = false;
  }
}

//----------------------------------------------------------------------
constexpr auto FVTerm::isInsideArea (const FPoint& pos, const FTermArea* area) noexcept -> bool
{
  // Check whether the coordinates are within the area

  const int x = pos.getX();
  const int y = pos.getY();
  return x >= 0 && x < area->size.width
      && y >= 0 && y < area->size.height;
}

//----------------------------------------------------------------------
inline auto FVTerm::isInsideTerminal (const FPoint& pos) const noexcept -> bool
{
  // Check whether the coordinates are within the virtual terminal

  const auto x = pos.getX();
  const auto y = pos.getY();
  return x >= 0 && x < int(foutput->getColumnNumber())
      && y >= 0 && y < int(foutput->getLineNumber());
}

//----------------------------------------------------------------------
constexpr auto FVTerm::isFCharTransparent (const FChar& fchar) noexcept -> bool
{
  return (fchar.attr.data & internal::var::transparent_mask) != 0;
}

//----------------------------------------------------------------------
inline auto FVTerm::isTransparentInvisible (const FChar& fchar) const noexcept -> bool
{
  static const auto& trans_inv_chars = getTransparentInvisibleLookupMap();
  const auto& fist_char = fchar.ch.unicode_data[0];
  return trans_inv_chars.find(fist_char) != trans_inv_chars.end();
}

//----------------------------------------------------------------------
void FVTerm::initSettings()
{
  // Presetting of the current locale for full-width character support.
  // The final setting is made later in FTerm::init_locale().
  std::setlocale (LC_ALL, "");

  // Initialize the printing attribute
  FVTermAttribute::initAttribute();

  // Create virtual terminal
  FSize term_size {foutput->getColumnNumber(), foutput->getLineNumber()};
  createVTerm (term_size);

  // Create virtual desktop area
  createVDesktop (term_size);
  active_area = vdesktop.get();

  // Reserving a typical number of changes
  line_changes_batch.reserve(32);

  // Reservation of capacity for at least 16 areas
  covered_areas_buffer.reserve(16);

  // fvterm is now initialized
  internal::var::fvterm_initialized = true;
}

//----------------------------------------------------------------------
void FVTerm::finish() const
{
  // Reset the FINAL CUT terminal settings and
  // return to the normal terminal mode
  setNormal();
  foutput->finishTerminal();
  forceTerminalUpdate();
  internal::var::fvterm_initialized = false;
  setGlobalFVTermInstance(nullptr);
}

//----------------------------------------------------------------------
inline void FVTerm::saveCurrentVTerm() const noexcept
{
  // Save the content of the virtual terminal
  std::memcpy(vterm_old->data.data(), vterm->data.data(), vterm->data.size() * sizeof(FChar));
}

//----------------------------------------------------------------------
inline void FVTerm::putAreaLine ( const FChar& src_char
                                , FChar& dst_char
                                , const std::size_t length ) const noexcept
{
  // copy "length" characters from area to terminal

  std::memcpy (&dst_char, &src_char, length * sizeof(dst_char));
}

//----------------------------------------------------------------------
inline void FVTerm::applyColorOverlay (const FChar& src_char, FChar& dst_char) const
{
  dst_char.ch = src_char.ch;  // Get covered character
  dst_char.attr.data &= ~internal::var::color_overlay_mask;

  if ( isTransparentInvisible(dst_char) )
    dst_char.ch[0] = L' ';
}

//----------------------------------------------------------------------
inline void FVTerm::inheritBackground (const FChar& src_char, FChar& dst_char) const
{
  // Add the covered background to this character
  dst_char.color.pair.bg = src_char.color.pair.bg;
}

//----------------------------------------------------------------------
inline void FVTerm::putMultiLayerAreaLine ( FChar* dst_char
                                          , const std::size_t length
                                          , const FPoint& pos ) const noexcept
{
  if ( length == 0 )
    return;

  if ( overlay_search_buffer.size() < length )  // Resize only if needed
    overlay_search_buffer.resize(length);

  auto search_buffer = overlay_search_buffer.data();
  std::fill_n(search_buffer, length, SearchState::start);
  const auto term_x = pos.getX();
  const auto term_y = pos.getY();

  overlay_line_buffer.clear();  // Clear buffer

  for (const auto* win : covered_areas_buffer)
  {
    // Precalculate window boundaries
    const int current_height = win->minimized ? win->min_size.height
                                              : getFullAreaHeight(win);
    const int x_min = win->position.x;
    const int x_max = x_min + getFullAreaWidth(win);
    const int y_min = win->position.y;
    const int y_max = y_min + current_height;

    // Early rejection if the line is completely outside the window
    if ( term_y < y_min
      || term_y >= y_max
      || term_x >= x_max
      || term_x + int(length) <= x_min )
      continue;

    // Precalculate array indexing values for getFChar
    const auto x = term_x - x_min;
    const auto y = term_y - y_min;
    const auto width = getFullAreaWidth(win);
    const auto index = unsigned(y) * unsigned(width) + unsigned(x);

    // Calculate the intersection of the line with the window
    const auto start_idx = std::size_t(std::max(0, x_min - term_x));
    const auto end_idx = std::size_t(std::min(int(length), x_max - term_x));

    // Store pre-calculated area line data
    overlay_line_buffer.push_back
    (
      { win->data.data(), unsigned(index), start_idx, end_idx }
    );
  }

  for (const auto& line : overlay_line_buffer)
  {
    auto win_char = &line.data[unsigned(line.offset) + unsigned(line.start_idx)];
    auto dst = &dst_char[unsigned(line.start_idx)];

    // Process only the intersecting part of the line
    for (std::size_t idx{line.start_idx}; idx < line.end_idx; ++idx, ++win_char, ++dst)
    {
      auto& char_search = search_buffer[idx];

      if ( char_search == SearchState::ready )
        continue;

      const auto transparency = win_char->attr.data
                              & internal::var::transparent_mask;

      if ( transparency  == internal::var::transparent )  // Transparent
      {
        if ( char_search == SearchState::start )
          char_search = SearchState::printable;

        continue;
      }

      if ( transparency == internal::var::color_overlay )  // Color overlay
      {
        if ( char_search == SearchState::background )
        {
          inheritBackground(*win_char, *dst);
          char_search = SearchState::ready;
        }
        else if ( char_search != SearchState::overlay )
        {
          std::memcpy (dst, win_char, sizeof(FChar));
          char_search = SearchState::overlay;
        }

        continue;
      }

      if ( transparency == internal::var::inherit_background )  // Inherit background color
      {
        if ( char_search == SearchState::overlay )
        {
          applyColorOverlay(*win_char, *dst);
          char_search = SearchState::ready;
        }
        else if ( char_search != SearchState::background )
        {
          std::memcpy (dst, win_char, sizeof(FChar));
          char_search = SearchState::background;
        }

        continue;
      }

      // transparency = 0
      if ( char_search == SearchState::overlay )  // Color overlay
      {
        applyColorOverlay(*win_char, *dst);
      }
      else if ( char_search == SearchState::background )  // Inherit background color
      {
        inheritBackground(*win_char, *dst);
      }
      else  // Non-transparent
      {
        std::memcpy (dst, win_char, sizeof(FChar));
      }

      char_search = SearchState::ready;
    }
  }
}

//----------------------------------------------------------------------
inline void FVTerm::putAreaLineWithTransparency ( const FChar* src_char
                                                , FChar* dst_char
                                                , const int length
                                                , FPoint pos
                                                , bool line_covered) const
{
  if ( length < 1 )
    return;

  bool is_region_transparent = isFCharTransparent(*src_char);
  std::size_t region_count{1};
  const auto* const end_char = src_char + length;
  const auto* region_start = src_char;
  const auto* current_char = src_char + 1;
  const auto* unroll_end = end_char - 3;

  while ( current_char < unroll_end )  // Main unrolled loop
  {
    const std::array<bool, 4> trans_data
    {{
      isFCharTransparent(*current_char),
      isFCharTransparent(*(current_char + 1)),
      isFCharTransparent(*(current_char + 2)),
      isFCharTransparent(*(current_char + 3))
    }};

    if ( trans_data[0] == is_region_transparent
      && trans_data[1] == is_region_transparent
      && trans_data[2] == is_region_transparent
      && trans_data[3] == is_region_transparent )
    {
      region_count += 4;
      current_char += 4;
      continue;
    }

    for (uInt i = 0; i < 4; ++i)
    {
      const bool is_current_char_transparent = trans_data[i];

      if ( is_current_char_transparent == is_region_transparent )
      {
        ++region_count;
      }
      else
      {
        // Process completed region
        if ( is_region_transparent || line_covered )
          putMultiLayerAreaLine (dst_char, region_count, pos);
        else
          putAreaLine (*region_start, *dst_char, region_count);

        pos.x_ref() += int(region_count);
        dst_char += region_count;

        // Reset for the next region
        is_region_transparent = is_current_char_transparent;
        region_start = current_char;
        region_count = 1;
      }

      ++current_char;
    }
  }

  while ( current_char < end_char )  // Process remaining characters (tail)
  {
    const bool is_current_transparent = isFCharTransparent(*current_char);

    if ( is_current_transparent == is_region_transparent )
    {
      ++region_count;
    }
    else
    {
      // Process completed region
      if ( is_region_transparent || line_covered )
        putMultiLayerAreaLine (dst_char, region_count, pos);
      else
        putAreaLine (*region_start, *dst_char, region_count);

      pos.x_ref() += int(region_count);
      dst_char += region_count;

      // Start new region
      is_region_transparent = is_current_transparent;
      region_start = current_char;
      region_count = 1;
    }

    ++current_char;
  }

  // Handle the final region
  if ( is_region_transparent || line_covered )
    putMultiLayerAreaLine (dst_char, region_count, pos);
  else
    putAreaLine (*region_start, *dst_char, region_count);
}

//----------------------------------------------------------------------
inline void FVTerm::addAreaLineWithTransparency ( const FChar* src_char
                                                , FChar* dst_char
                                                , const std::size_t length ) const
{
  if ( length == 0 )
    return;

  const auto handle_region = \
      [this, &dst_char] ( bool transparent
                        , std::size_t count
                        , const FChar* start )
  {
    if ( transparent )
      addTransparent (start, dst_char, count);
    else
      putNonTransparent (start, dst_char, count);
  };

  const auto* end_char{src_char + length};
  const auto* region_start{src_char};
  std::size_t region_count{1};
  bool is_region_transparent{isFCharTransparent(*src_char)};

  for (const auto* current_char = src_char + 1; current_char < end_char; ++current_char)
  {
    const bool is_current_char_transparent = isFCharTransparent(*current_char);

    if ( is_current_char_transparent == is_region_transparent )
      ++region_count;
    else
    {
      handle_region (is_region_transparent, region_count, region_start);
      // Reset for the next region
      is_region_transparent = is_current_char_transparent;
      region_start = current_char;
      region_count = 1;
    }
  }

  // Handle the final region
  handle_region (is_region_transparent, region_count, region_start);
}

//----------------------------------------------------------------------
inline void FVTerm::addTransparentAreaLine ( const FChar& src_char
                                           , FChar& dst_char
                                           , const std::size_t length ) const
{
  const auto* src = &src_char;
  auto* dst = &dst_char;
  const auto* end = src + length;

  while ( src < end )  // column loop
  {
    addTransparentAreaChar (*src, *dst);
    ++src;  // src character
    ++dst;  // dst character
  }
}

//----------------------------------------------------------------------
inline void FVTerm::addTransparentAreaChar (const FChar& src_char, FChar& dst_char) const
{
  if ( src_char.attr.bit.transparent )  // Transparent
    return;  // Leave character on vterm untouched

  if ( src_char.attr.bit.color_overlay )  // Color overlay
  {
    // Get covered character + add the current color
    dst_char.color.data = src_char.color.data;
    dst_char.attr.data = src_char.attr.data & ~internal::var::color_overlay_mask;

    if ( isTransparentInvisible(dst_char) )
      dst_char.ch[0] = L' ';

    return;
  }

  if ( src_char.attr.bit.inherit_background )
  {
    // Add the covered background to this character
    auto bg_color = dst_char.color.pair.bg;
    dst_char = src_char;
    dst_char.color.pair.bg = bg_color;
    dst_char.attr.data &= ~internal::var::print_reset_mask;
    return;
  }

  // Default
  dst_char = src_char;
}

//----------------------------------------------------------------------
auto FVTerm::clearFullArea (FTermArea* area, FChar& fillchar) const -> bool
{
  // Clear area
  std::fill (area->data.begin(), area->data.end(), fillchar);

  if ( area != vdesktop.get() )  // Is the area identical to the desktop?
    return false;

  // Try to clear the terminal rapidly with a control sequence
  if ( foutput->clearTerminal (fillchar.ch[0]) )
  {
    fillchar.attr.bit.printed = true;
    std::fill (vterm->data.begin(), vterm->data.end(), fillchar);
    saveCurrentVTerm();
  }
  else
  {
    auto* vdesktop_changes = &vdesktop->changes_in_line[0];
    const auto* vdesktop_changes_end = vdesktop_changes
                                     + unsigned(vdesktop->size.height);

    while ( vdesktop_changes < vdesktop_changes_end )
    {
      vdesktop_changes->xmin = 0;
      vdesktop_changes->xmax = uInt(vdesktop->size.width) - 1;
      vdesktop_changes->trans_count = 0;
      ++vdesktop_changes;
    }

    vdesktop->changes_in_row = {0, uInt(vdesktop->size.height - 1)};
    vdesktop->has_changes = true;
  }

  return true;
}

//----------------------------------------------------------------------
void FVTerm::clearAreaWithShadow (FTermArea* area, const FChar& fillchar) const noexcept
{
  FChar t_char = fillchar;
  t_char.ch[0] = L'\0';
  t_char.attr.bit.transparent = true;
  t_char.attr.bit.char_width = 0;
  const auto total_width = unsigned(getFullAreaWidth(area));
  auto* area_pos = &area->data[0];
  auto* shadow_begin = &area->data[area->size.width];

  for (auto y{0}; y < area->size.height; y++)
  {
    // Clear area
    std::fill (area_pos, area_pos + area->size.width, fillchar);
    // Make right shadow transparent
    std::fill (shadow_begin, shadow_begin + area->shadow.width, t_char);
    area_pos += total_width;
    shadow_begin += total_width;
  }

  // Make bottom shadow transparent
  area_pos = &area->data[total_width * area->size.height];

  for (auto y{0}; y < area->shadow.height; y++)
  {
    std::fill (area_pos, area_pos + total_width, t_char);
    area_pos += total_width;
  }
}

//----------------------------------------------------------------------
inline auto FVTerm::printWrap (FTermArea* area, FChar_iterator& ac) const -> bool
{
  bool end_of_area{false};
  const int& width  = area->size.width;
  const int& height = area->size.height;
  const int& rsh    = area->shadow.width;
  const int& bsh    = area->shadow.height;

  // Line break at right margin
  if ( area->cursor.x > width + rsh )
  {
    area->cursor.x = 1;
    area->cursor.y++;
    ac = area->getFCharIterator(area->cursor.x - 1, area->cursor.y - 1);
  }

  // Prevent up scrolling
  if ( area->cursor.y > height + bsh )
  {
    area->cursor.y--;
    ac = area->getFCharIterator(area->cursor.x - 1, area->cursor.y - 1);
    end_of_area = true;
  }

  return end_of_area;
}

//----------------------------------------------------------------------
inline auto FVTerm::interpretControlCodes ( FTermArea* area
                                          , FChar_iterator& ac
                                          , const FChar& term_char ) const noexcept -> bool
{
  switch ( term_char.ch.unicode_data[0] )
  {
    case L'\n':
      area->cursor.y++;
      // fall through
    case L'\r':
      area->cursor.x = 1;
      break;

    case L'\t':
      area->cursor.x += tabstop - ((area->cursor.x - 1) % tabstop);
      break;

    case L'\b':
      area->cursor.x--;
      break;

    case L'\a':
      foutput->beep();
      break;

    default:
      return false;
  }

  ac = area->getFCharIterator(area->cursor.x - 1, area->cursor.y - 1);
  return true;
}

//----------------------------------------------------------------------
inline auto FVTerm::printCharacter ( FTermArea* area
                                   , FChar_iterator& ac
                                   , const FChar& term_char ) const noexcept -> int
{
  if ( ! area )
    return -1;  // No area

  if ( interpretControlCodes(area, ac, term_char) )
    return 0;  // No printable character

  if ( ! area->isPrintPositionInsideArea() || printWrap(area, ac) )
    return -1;  // Cursor position out of range or end of area reached

  // Printing term_char on area at the current cursor position
  auto char_width = printCharacterOnCoordinate (area, ac, term_char);

  if ( char_width == 0 && ! term_char.attr.bit.fullwidth_padding )
    return 0;

  area->cursor.x++;
  ++ac;
  area->has_changes = true;

  // Line break at right margin
  if ( area->cursor.x > getFullAreaWidth(area) )
  {
    area->cursor.x = 1;
    area->cursor.y++;
  }
  else if ( char_width == 2 )
  {
    printPaddingCharacter (area, term_char);
    ++ac;
  }

  // Prevent up scrolling
  if ( area->cursor.y > getFullAreaHeight(area) )
    area->cursor.y--;

  return 1;
}

//----------------------------------------------------------------------
inline auto FVTerm::printCharacterOnCoordinate ( FTermArea* area
                                               , const FChar_iterator& ac
                                               , const FChar& ch ) const noexcept -> std::size_t
{
  const auto ax = unsigned(area->cursor.x - 1);
  const auto ay = unsigned(area->cursor.y - 1);

  if ( *ac == ch )  // compare with an overloaded operator
    return ac->attr.bit.char_width;

  const bool trans_old =
      (ac->attr.data & internal::var::print_transparent_mask) != 0;
  const bool trans_new =
      (ch.attr.data & internal::var::print_transparent_mask) != 0;
  const auto trans_changed = int(trans_new) - int(trans_old);

  if ( trans_changed != 0 )
    area->changes_in_line[ay].trans_count += uInt(trans_changed);

  // copy character to area
  *ac = ch;

  auto current_width = ac->attr.bit.char_width;

  if ( current_width == 0 )
  {
    const auto new_char_width = getColumnWidth(ac->ch[0]);

    if ( new_char_width == 0 )
      return 0;

    addColumnWidth(*ac, new_char_width);  // Add column width
    current_width = uInt8(new_char_width);
  }

  area->updateAreaChanges (ax, ay, current_width);
  return current_width;
}

//----------------------------------------------------------------------
inline void FVTerm::printPaddingCharacter ( FTermArea* area
                                          , const FChar& term_char ) const
{
  // Creates a padding-character from the current character (term_char)
  // and prints it. It is a placeholder for the column after
  // a full-width character.

  FChar pc{term_char};  // Copy character to padding character

  if ( area->encoding == Encoding::UTF8 )
  {
    pc.ch[0] = L'\0';
    pc.attr.bit.fullwidth_padding = true;
    pc.attr.bit.char_width = 0;
  }
  else
  {
    pc.ch[0] = L'.';
    pc.ch[1] = L'\0';
    pc.attr.bit.char_width = 1;
  }

  // Print the padding-character
  print (area, pc);
}

//----------------------------------------------------------------------
inline void FVTerm::putNonTransparent ( const FChar* start_char
                                      , FChar*& dst_char
                                      , std::size_t& non_trans_count ) const
{
  if ( non_trans_count == 0 )
    return;

  putAreaLine(*start_char, *dst_char, non_trans_count);
  dst_char += non_trans_count;  // dst character
  non_trans_count = 0;
}

//----------------------------------------------------------------------
inline void FVTerm::addTransparent ( const FChar* start_char
                                   , FChar*& dst_char
                                   , std::size_t& trans_count ) const
{
  if ( trans_count == 0 )
    return;

  addTransparentAreaLine (*start_char, *dst_char, trans_count);
  dst_char += trans_count;  // dst character
  trans_count = 0;
}

//----------------------------------------------------------------------
inline void FVTerm::addVDesktopToListIfExists (FTermAreaList& list) const
{
  // Adds the virtual desktop area, if it exists

  if ( vdesktop )
    list.push_back(vdesktop.get());
}

//----------------------------------------------------------------------
inline void FVTerm::determineCoveredAreas (FTermArea* src) const
{
  const auto* vterm_win_list = getWindowList();
  covered_areas_buffer.clear();
  resetLineCoveredState(src);

  if ( ! vterm_win_list || vterm_win_list->empty() )
  {
    addVDesktopToListIfExists(covered_areas_buffer);
    return;
  }

  const auto end = vterm_win_list->crend();
  const auto src_layer = src->layer;

  // Areas from top to bottom
  for (auto iter = vterm_win_list->crbegin(); iter < end; ++iter)
  {
    const auto& vterm_obj = *iter;

    if ( ! vterm_obj )
      continue;

    const auto* win = vterm_obj->getVWin();

    if ( ! win || ! win->visible || win->layer < 1
      || ! win->isOverlapped(src) )
      continue;

    covered_areas_buffer.push_back(win);

    if ( win->layer <= src_layer )
      continue;

    determineLineCoveredState(win, src);
  }

  addVDesktopToListIfExists(covered_areas_buffer);
}

//----------------------------------------------------------------------
inline void FVTerm::resetLineCoveredState (FTermArea* src) const
{
  auto* changes = src->changes_in_line.data();
  const auto* const changes_end = changes + src->changes_in_line.size();

  // Unrolled loop for better performance
  while ( changes + 4 < changes_end )
  {
    changes[0].covered = false;
    changes[1].covered = false;
    changes[2].covered = false;
    changes[3].covered = false;
    changes += 4;
  }

  while ( changes < changes_end )  // Handle remaining lines
  {
    changes->covered = false;
    ++changes;
  }
}

//----------------------------------------------------------------------
inline void FVTerm::determineLineCoveredState ( const FTermArea* const win
                                              , FTermArea* src ) const noexcept
{
  // Requirements: The two areas have been checked for overlap

  const int win_height = win->minimized ? win->min_size.height
                                        : getFullAreaHeight(win);
  const int src_height = src->minimized ? src->min_size.height
                                        : getFullAreaHeight(src);
  const int win_y_min = win->position.y;
  const int win_y_max = win_y_min + win_height;
  const int src_y_min = src->position.y;
  const int src_y_max = src_y_min + src_height;
  const int overlap_start = std::max(win_y_min, src_y_min);
  const int overlap_end = std::min(win_y_max, src_y_max);
  const auto start = static_cast<std::size_t>(overlap_start - src_y_min);
  const auto end = static_cast<std::size_t>(overlap_end - src_y_min);
  auto* changes_base = src->changes_in_line.data();
  auto* changes = changes_base + start;
  const auto* const changes_end = changes_base + end;

  // Unrolled loop for better performance
  while ( changes + 4 <= changes_end )
  {
    changes[0].covered = true;
    changes[1].covered = true;
    changes[2].covered = true;
    changes[3].covered = true;
    changes += 4;
  }

  while ( changes < changes_end )  // Handle remaining lines
  {
    changes->covered = true;
    ++changes;
  }
}

//----------------------------------------------------------------------
auto FVTerm::canUpdateTerminalNow() const -> bool
{
  // Check if terminal updates were stopped, application is stopping,
  // VTerm has no changes, or the drawing is not completed

  return  ! FVTerm::areTerminalUpdatesPaused()
       && ! FApplication::isQuit()
       && ( foutput->isFlushTimeout() || FVTerm::isTerminalUpdateForced() )
       && FVTerm::hasPendingTerminalUpdates()
       && FVTerm::isDrawingFinished();
}

//----------------------------------------------------------------------
auto FVTerm::hasPendingUpdates (const FTermArea* area) noexcept -> bool
{
  return (area && area->has_changes);
}

}  // namespace finalcut

gansm / finalcut / #767

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous