app/term/term_model.cc - topaz - Git at Google

 // Copyright 2016 The Fuchsia Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 #include "topaz/app/term/term_model.h"

 #include <string.h>

 #include <algorithm>
 #include <limits>

 #include "src/lib/fxl/logging.h"

 namespace term {
 namespace {

 // Moterm -> teken conversions:

 teken_pos_t MotermToTekenSize(const TermModel::Size& size) {
   FXL_DCHECK(size.rows <= std::numeric_limits<teken_unit_t>::max());
   FXL_DCHECK(size.columns <= std::numeric_limits<teken_unit_t>::max());
   teken_pos_t rv = {static_cast<teken_unit_t>(size.rows),
                     static_cast<teken_unit_t>(size.columns)};
   return rv;
 }

 // Teken -> term conversions:

 TermModel::Position TekenToMotermPosition(const teken_pos_t& position) {
   return TermModel::Position(static_cast<int>(position.tp_row),
                              static_cast<int>(position.tp_col));
 }

 TermModel::Size TekenToMotermSize(const teken_pos_t& size) {
   return TermModel::Size(size.tp_row, size.tp_col);
 }

 TermModel::Rectangle TekenToMotermRectangle(const teken_rect_t& rectangle) {
   return TermModel::Rectangle(
       static_cast<int>(rectangle.tr_begin.tp_row),
       static_cast<int>(rectangle.tr_begin.tp_col),
       rectangle.tr_end.tp_row - rectangle.tr_begin.tp_row,
       rectangle.tr_end.tp_col - rectangle.tr_begin.tp_col);
 }

 TermModel::Color TekenToMotermColor(teken_color_t color, bool bold) {
   static const uint8_t rgb[TC_NCOLORS][3] = {
       {0x00, 0x00, 0x00},  // Black.
       {0x80, 0x00, 0x00},  // Red.
       {0x00, 0x80, 0x00},  // Green.
       {0x80, 0x80, 0x00},  // Yellow (even if teken thinks it's brown).
       {0x00, 0x00, 0x80},  // Blue.
       {0x80, 0x00, 0x80},  // Magenta.
       {0x00, 0x80, 0x80},  // Cyan.
       {0xc0, 0xc0, 0xc0}   // White.
   };
   static const uint8_t bold_rgb[TC_NCOLORS][3] = {
       {0x80, 0x80, 0x80},  // Black.
       {0xff, 0x00, 0x00},  // Red.
       {0x00, 0xff, 0x00},  // Green.
       {0xff, 0xff, 0x00},  // Yellow (even if teken thinks it's brown).
       {0x00, 0x00, 0xff},  // Blue.
       {0xff, 0x00, 0xff},  // Magenta.
       {0x00, 0xff, 0xff},  // Cyan.
       {0xff, 0xff, 0xff}   // White.
   };
   FXL_DCHECK(color < static_cast<unsigned>(TC_NCOLORS));
   return bold ? TermModel::Color(bold_rgb[color][0], bold_rgb[color][1],
                                  bold_rgb[color][2])
               : TermModel::Color(rgb[color][0], rgb[color][1], rgb[color][2]);
 }

 // Utility functions:

 TermModel::Rectangle EnclosingRectangle(const TermModel::Rectangle& rect1,
                                         const TermModel::Rectangle& rect2) {
   if (rect1.IsEmpty())
     return rect2;
   if (rect2.IsEmpty())
     return rect1;

   int start_row = std::min(rect1.position.row, rect2.position.row);
   int start_col = std::min(rect1.position.column, rect2.position.column);
   // TODO(vtl): Some theoretical overflows here.
   int end_row =
       std::max(rect1.position.row + static_cast<int>(rect1.size.rows),
                rect2.position.row + static_cast<int>(rect2.size.rows));
   int end_col =
       std::max(rect1.position.column + static_cast<int>(rect1.size.columns),
                rect2.position.column + static_cast<int>(rect2.size.columns));
   FXL_DCHECK(start_row <= end_row);
   FXL_DCHECK(start_col <= end_col);
   return TermModel::Rectangle(start_row, start_col,
                               static_cast<unsigned>(end_row - start_row),
                               static_cast<unsigned>(end_col - start_col));
 }

 }  // namespace

 const TermModel::Attributes TermModel::kAttributesBold;
 const TermModel::Attributes TermModel::kAttributesUnderline;
 const TermModel::Attributes TermModel::kAttributesBlink;

 TermModel::Delegate::~Delegate() = default;

 TermModel::TermModel(const Size& size, Delegate* delegate)
     : size_(size),
       delegate_(delegate),
       cursor_visible_(true),
       terminal_(),
       current_state_changes_() {
   FXL_DCHECK(size_.rows > 0u);
   FXL_DCHECK(size_.columns > 0u);

   num_chars_ = size_.rows * size_.columns;
   characters_.reset(new teken_char_t[num_chars_]);
   memset(characters_.get(), 0, num_chars_ * sizeof(teken_char_t));
   attributes_.reset(new teken_attr_t[num_chars_]);
   memset(attributes_.get(), 0, num_chars_ * sizeof(teken_attr_t));

   static const teken_funcs_t callbacks = {
       &TermModel::OnBellThunk,    &TermModel::OnCursorThunk,
       &TermModel::OnPutcharThunk, &TermModel::OnFillThunk,
       &TermModel::OnCopyThunk,    &TermModel::OnParamThunk,
       &TermModel::OnRespondThunk};
   teken_init(&terminal_, &callbacks, this);

   teken_pos_t s = MotermToTekenSize(size_);
   teken_set_winsize(&terminal_, &s);
 }

 TermModel::~TermModel() {}

 void TermModel::ProcessInput(const void* input_bytes,
                              size_t num_input_bytes,
                              StateChanges* state_changes) {
   FXL_DCHECK(state_changes);
   FXL_DCHECK(!current_state_changes_);
   current_state_changes_ = state_changes;

   // Get the initial cursor position, so we'll be able to tell if it moved.
   teken_pos_t initial_cursor_pos = *teken_get_cursor(&terminal_);

   // Note: This may call some of our callbacks.
   char cr = '\r';
   const char* buffer = static_cast<const char*>(input_bytes);
   for (size_t i = 0; i < num_input_bytes; i++) {
     if (*buffer == '\n') {
       teken_input(&terminal_, &cr, 1);
     }
     teken_input(&terminal_, buffer++, 1);
   }

   teken_pos_t final_cursor_pos = *teken_get_cursor(&terminal_);
   if (initial_cursor_pos.tp_row != final_cursor_pos.tp_row ||
       initial_cursor_pos.tp_col != final_cursor_pos.tp_col) {
     state_changes->cursor_changed = true;
     // Update dirty rect to include old and new cursor positions.
     current_state_changes_->dirty_rect = EnclosingRectangle(
         current_state_changes_->dirty_rect,
         Rectangle(initial_cursor_pos.tp_row, initial_cursor_pos.tp_col, 1, 1));
     current_state_changes_->dirty_rect = EnclosingRectangle(
         current_state_changes_->dirty_rect,
         Rectangle(final_cursor_pos.tp_row, final_cursor_pos.tp_col, 1, 1));
   }

   current_state_changes_ = nullptr;
 }

 TermModel::Size TermModel::GetSize() const {
   // Teken isn't const-correct, sadly.
   return TekenToMotermSize(
       *teken_get_winsize(const_cast<teken_t*>(&terminal_)));
 }

 TermModel::Position TermModel::GetCursorPosition() const {
   // Teken isn't const-correct, sadly.
   return TekenToMotermPosition(
       *teken_get_cursor(const_cast<teken_t*>(&terminal_)));
 }

 bool TermModel::GetCursorVisibility() const {
   return cursor_visible_;
 }

 TermModel::CharacterInfo TermModel::GetCharacterInfoAt(
     const Position& position) const {
   FXL_DCHECK(position.row >= 0);
   FXL_DCHECK(position.row < static_cast<int>(GetSize().rows));
   FXL_DCHECK(position.column >= 0);
   FXL_DCHECK(position.column < static_cast<int>(GetSize().columns));

   uint32_t ch = characters_[position.row * size_.columns + position.column];
   const teken_attr_t& teken_attr =
       attributes_[position.row * size_.columns + position.column];
   Color fg = TekenToMotermColor(teken_attr.ta_fgcolor,
                                 (teken_attr.ta_format & TF_BOLD));
   Color bg = TekenToMotermColor(teken_attr.ta_bgcolor, false);
   Attributes attr = 0;
   if ((teken_attr.ta_format & TF_BOLD))
     attr |= kAttributesBold;
   if ((teken_attr.ta_format & TF_UNDERLINE))
     attr |= kAttributesUnderline;
   if ((teken_attr.ta_format & TF_BLINK))
     attr |= kAttributesBlink;
   if ((teken_attr.ta_format & TF_REVERSE))
     std::swap(fg, bg);
   return CharacterInfo(ch, attr, fg, bg);
 }

 void TermModel::SetSize(const Size& size, bool reset) {
   FXL_DCHECK(size.rows > 0u);
   FXL_DCHECK(size.columns > 0u);
   Size old_size = size_;
   size_ = size;
   size_t new_num_chars = size_.rows * size_.columns;
   if (num_chars_ != new_num_chars) {
     teken_char_t* new_characters = new teken_char_t[new_num_chars];
     memset(new_characters, 0, new_num_chars * sizeof(teken_char_t));

     teken_attr_t* new_attributes = new teken_attr_t[new_num_chars];
     memset(new_attributes, 0, new_num_chars * sizeof(teken_attr_t));

     // FIXME(jpoichet) copy from bottom to top instead
     for (size_t r = 0; r < old_size.rows; ++r) {
       size_t bytes = old_size.columns * sizeof(teken_char_t);
       if (r * size_.columns + bytes > new_num_chars) {
         // Until we copy bottom to top, ignore the last line.
         break;
       }
       memcpy(new_characters + r * size_.columns,
              characters_.get() + r * old_size.columns,
              old_size.columns * sizeof(teken_char_t));
       memcpy(new_attributes + r * size_.columns,
              attributes_.get() + r * old_size.columns,
              old_size.columns * sizeof(teken_attr_t));
     }
     characters_.reset(new_characters);
     attributes_.reset(new_attributes);
     num_chars_ = new_num_chars;
   }

   teken_pos_t teken_size = {static_cast<teken_unit_t>(size.rows),
                             static_cast<teken_unit_t>(size.columns)};
   if (reset) {
     teken_set_winsize_noreset(&terminal_, &teken_size);
   } else {
     // We'll try a bit harder to keep a sensible cursor position.
     teken_pos_t cursor_pos =
         *teken_get_cursor(const_cast<teken_t*>(&terminal_));
     teken_set_winsize(&terminal_, &teken_size);
     if (cursor_pos.tp_row >= teken_size.tp_row)
       cursor_pos.tp_row = teken_size.tp_row - 1;
     if (cursor_pos.tp_col >= teken_size.tp_col)
       cursor_pos.tp_col = teken_size.tp_col - 1;
     teken_set_cursor(&terminal_, &cursor_pos);
   }
 }

 void TermModel::OnBell() {
   FXL_DCHECK(current_state_changes_);
   current_state_changes_->bell_count++;
 }

 void TermModel::OnCursor(const teken_pos_t* pos) {
   FXL_DCHECK(current_state_changes_);
   // Don't do anything. We'll just compare initial and final cursor positions.
 }

 void TermModel::OnPutchar(const teken_pos_t* pos,
                           teken_char_t ch,
                           const teken_attr_t* attr) {
   character_at(pos->tp_row, pos->tp_col) = ch;
   attribute_at(pos->tp_row, pos->tp_col) = *attr;

   // Update dirty rect.
   FXL_DCHECK(current_state_changes_);
   current_state_changes_->dirty_rect =
       EnclosingRectangle(current_state_changes_->dirty_rect,
                          Rectangle(pos->tp_row, pos->tp_col, 1, 1));
 }

 void TermModel::OnFill(const teken_rect_t* rect,
                        teken_char_t ch,
                        const teken_attr_t* attr) {
   for (size_t row = rect->tr_begin.tp_row; row < rect->tr_end.tp_row; row++) {
     for (size_t col = rect->tr_begin.tp_col; col < rect->tr_end.tp_col; col++) {
       character_at(row, col) = ch;
       attribute_at(row, col) = *attr;
     }
   }

   // Update dirty rect.
   FXL_DCHECK(current_state_changes_);
   current_state_changes_->dirty_rect = EnclosingRectangle(
       current_state_changes_->dirty_rect, TekenToMotermRectangle(*rect));
 }

 void TermModel::OnCopy(const teken_rect_t* rect, const teken_pos_t* pos) {
   unsigned height = rect->tr_end.tp_row - rect->tr_begin.tp_row;
   unsigned width = rect->tr_end.tp_col - rect->tr_begin.tp_col;

   // This is really a "move" (like |memmove()|) -- overlaps are likely. Process
   // the rows depending on which way (vertically) we're moving.
   if (pos->tp_row <= rect->tr_begin.tp_row) {
     // Start from the top row.
     for (unsigned row = 0; row < height; row++) {
       // Use |memmove()| here, to in case we're not moving vertically.
       memmove(&character_at(pos->tp_row + row, pos->tp_col),
               &character_at(rect->tr_begin.tp_row + row, pos->tp_col),
               width * sizeof(characters_[0]));
       memmove(&attribute_at(pos->tp_row + row, pos->tp_col),
               &attribute_at(rect->tr_begin.tp_row + row, pos->tp_col),
               width * sizeof(attributes_[0]));
     }
   } else {
     // Start from the bottom row.
     for (unsigned row = height; row > 0;) {
       row--;
       // We can use |memcpy()| here.
       memcpy(&character_at(pos->tp_row + row, pos->tp_col),
              &character_at(rect->tr_begin.tp_row + row, pos->tp_col),
              width * sizeof(characters_[0]));
       memcpy(&attribute_at(pos->tp_row + row, pos->tp_col),
              &attribute_at(rect->tr_begin.tp_row + row, pos->tp_col),
              width * sizeof(attributes_[0]));
     }
   }

   // Update dirty rect.
   FXL_DCHECK(current_state_changes_);
   current_state_changes_->dirty_rect = EnclosingRectangle(
       current_state_changes_->dirty_rect,
       Rectangle(static_cast<int>(pos->tp_row), static_cast<int>(pos->tp_col),
                 width, height));
 }

 void TermModel::OnParam(int cmd, unsigned val) {
   FXL_DCHECK(current_state_changes_);

   // Note: |val| is usually a "boolean", except for |TP_SETBELLPD| (for which
   // |val| can be decomposed using |TP_SETBELLPD_{PITCH, DURATION}()|).
   switch (cmd) {
     case TP_SHOWCURSOR:
       cursor_visible_ = !!val;
       current_state_changes_->cursor_changed = true;
       break;
     case TP_KEYPADAPP:
       if (delegate_)
         delegate_->OnSetKeypadMode(!!val);
       break;
     case TP_AUTOREPEAT:
     case TP_SWITCHVT:
     case TP_132COLS:
     case TP_SETBELLPD:
     case TP_MOUSE:
       // TODO(vtl): TP_KEYPADAPP seems especially common.
       FXL_NOTIMPLEMENTED() << "OnParam(" << cmd << ", " << val << ")";
       break;
     default:
       FXL_NOTREACHED() << "OnParam(): unknown command: " << cmd;
       break;
   }
 }

 void TermModel::OnRespond(const void* buf, size_t size) {
   if (delegate_)
     delegate_->OnResponse(buf, size);
   else
     FXL_LOG(WARNING) << "Ignoring response: no delegate";
 }

 // static
 void TermModel::OnBellThunk(void* ctx) {
   FXL_DCHECK(ctx);
   return static_cast<TermModel*>(ctx)->OnBell();
 }

 // static
 void TermModel::OnCursorThunk(void* ctx, const teken_pos_t* pos) {
   FXL_DCHECK(ctx);
   return static_cast<TermModel*>(ctx)->OnCursor(pos);
 }

 // static
 void TermModel::OnPutcharThunk(void* ctx,
                                const teken_pos_t* pos,
                                teken_char_t ch,
                                const teken_attr_t* attr) {
   FXL_DCHECK(ctx);
   return static_cast<TermModel*>(ctx)->OnPutchar(pos, ch, attr);
 }

 // static
 void TermModel::OnFillThunk(void* ctx,
                             const teken_rect_t* rect,
                             teken_char_t ch,
                             const teken_attr_t* attr) {
   FXL_DCHECK(ctx);
   return static_cast<TermModel*>(ctx)->OnFill(rect, ch, attr);
 }

 // static
 void TermModel::OnCopyThunk(void* ctx,
                             const teken_rect_t* rect,
                             const teken_pos_t* pos) {
   FXL_DCHECK(ctx);
   return static_cast<TermModel*>(ctx)->OnCopy(rect, pos);
 }

 // static
 void TermModel::OnParamThunk(void* ctx, int cmd, unsigned val) {
   FXL_DCHECK(ctx);
   return static_cast<TermModel*>(ctx)->OnParam(cmd, val);
 }

 // static
 void TermModel::OnRespondThunk(void* ctx, const void* buf, size_t size) {
   FXL_DCHECK(ctx);
   return static_cast<TermModel*>(ctx)->OnRespond(buf, size);
 }

 }  // namespace term
	// Copyright 2016 The Fuchsia Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	#include "topaz/app/term/term_model.h"

	#include <string.h>

	#include <algorithm>
	#include <limits>

	#include "src/lib/fxl/logging.h"

	namespace term {
	namespace {

	// Moterm -> teken conversions:

	teken_pos_t MotermToTekenSize(const TermModel::Size& size) {
	FXL_DCHECK(size.rows <= std::numeric_limits<teken_unit_t>::max());
	FXL_DCHECK(size.columns <= std::numeric_limits<teken_unit_t>::max());
	teken_pos_t rv = {static_cast<teken_unit_t>(size.rows),
	static_cast<teken_unit_t>(size.columns)};
	return rv;
	}

	// Teken -> term conversions:

	TermModel::Position TekenToMotermPosition(const teken_pos_t& position) {
	return TermModel::Position(static_cast<int>(position.tp_row),
	static_cast<int>(position.tp_col));
	}

	TermModel::Size TekenToMotermSize(const teken_pos_t& size) {
	return TermModel::Size(size.tp_row, size.tp_col);
	}

	TermModel::Rectangle TekenToMotermRectangle(const teken_rect_t& rectangle) {
	return TermModel::Rectangle(
	static_cast<int>(rectangle.tr_begin.tp_row),
	static_cast<int>(rectangle.tr_begin.tp_col),
	rectangle.tr_end.tp_row - rectangle.tr_begin.tp_row,
	rectangle.tr_end.tp_col - rectangle.tr_begin.tp_col);
	}

	TermModel::Color TekenToMotermColor(teken_color_t color, bool bold) {
	static const uint8_t rgb[TC_NCOLORS][3] = {
	{0x00, 0x00, 0x00}, // Black.
	{0x80, 0x00, 0x00}, // Red.
	{0x00, 0x80, 0x00}, // Green.
	{0x80, 0x80, 0x00}, // Yellow (even if teken thinks it's brown).
	{0x00, 0x00, 0x80}, // Blue.
	{0x80, 0x00, 0x80}, // Magenta.
	{0x00, 0x80, 0x80}, // Cyan.
	{0xc0, 0xc0, 0xc0} // White.
	};
	static const uint8_t bold_rgb[TC_NCOLORS][3] = {
	{0x80, 0x80, 0x80}, // Black.
	{0xff, 0x00, 0x00}, // Red.
	{0x00, 0xff, 0x00}, // Green.
	{0xff, 0xff, 0x00}, // Yellow (even if teken thinks it's brown).
	{0x00, 0x00, 0xff}, // Blue.
	{0xff, 0x00, 0xff}, // Magenta.
	{0x00, 0xff, 0xff}, // Cyan.
	{0xff, 0xff, 0xff} // White.
	};
	FXL_DCHECK(color < static_cast<unsigned>(TC_NCOLORS));
	return bold ? TermModel::Color(bold_rgb[color][0], bold_rgb[color][1],
	bold_rgb[color][2])
	: TermModel::Color(rgb[color][0], rgb[color][1], rgb[color][2]);
	}

	// Utility functions:

	TermModel::Rectangle EnclosingRectangle(const TermModel::Rectangle& rect1,
	const TermModel::Rectangle& rect2) {
	if (rect1.IsEmpty())
	return rect2;
	if (rect2.IsEmpty())
	return rect1;

	int start_row = std::min(rect1.position.row, rect2.position.row);
	int start_col = std::min(rect1.position.column, rect2.position.column);
	// TODO(vtl): Some theoretical overflows here.
	int end_row =
	std::max(rect1.position.row + static_cast<int>(rect1.size.rows),
	rect2.position.row + static_cast<int>(rect2.size.rows));
	int end_col =
	std::max(rect1.position.column + static_cast<int>(rect1.size.columns),
	rect2.position.column + static_cast<int>(rect2.size.columns));
	FXL_DCHECK(start_row <= end_row);
	FXL_DCHECK(start_col <= end_col);
	return TermModel::Rectangle(start_row, start_col,
	static_cast<unsigned>(end_row - start_row),
	static_cast<unsigned>(end_col - start_col));
	}

	} // namespace

	const TermModel::Attributes TermModel::kAttributesBold;
	const TermModel::Attributes TermModel::kAttributesUnderline;
	const TermModel::Attributes TermModel::kAttributesBlink;

	TermModel::Delegate::~Delegate() = default;

	TermModel::TermModel(const Size& size, Delegate* delegate)
	: size_(size),
	delegate_(delegate),
	cursor_visible_(true),
	terminal_(),
	current_state_changes_() {
	FXL_DCHECK(size_.rows > 0u);
	FXL_DCHECK(size_.columns > 0u);

	num_chars_ = size_.rows * size_.columns;
	characters_.reset(new teken_char_t[num_chars_]);
	memset(characters_.get(), 0, num_chars_ * sizeof(teken_char_t));
	attributes_.reset(new teken_attr_t[num_chars_]);
	memset(attributes_.get(), 0, num_chars_ * sizeof(teken_attr_t));

	static const teken_funcs_t callbacks = {
	&TermModel::OnBellThunk, &TermModel::OnCursorThunk,
	&TermModel::OnPutcharThunk, &TermModel::OnFillThunk,
	&TermModel::OnCopyThunk, &TermModel::OnParamThunk,
	&TermModel::OnRespondThunk};
	teken_init(&terminal_, &callbacks, this);

	teken_pos_t s = MotermToTekenSize(size_);
	teken_set_winsize(&terminal_, &s);
	}

	TermModel::~TermModel() {}

	void TermModel::ProcessInput(const void* input_bytes,
	size_t num_input_bytes,
	StateChanges* state_changes) {
	FXL_DCHECK(state_changes);
	FXL_DCHECK(!current_state_changes_);
	current_state_changes_ = state_changes;

	// Get the initial cursor position, so we'll be able to tell if it moved.
	teken_pos_t initial_cursor_pos = *teken_get_cursor(&terminal_);

	// Note: This may call some of our callbacks.
	char cr = '\r';
	const char* buffer = static_cast<const char*>(input_bytes);
	for (size_t i = 0; i < num_input_bytes; i++) {
	if (*buffer == '\n') {
	teken_input(&terminal_, &cr, 1);
	}
	teken_input(&terminal_, buffer++, 1);
	}

	teken_pos_t final_cursor_pos = *teken_get_cursor(&terminal_);
	if (initial_cursor_pos.tp_row != final_cursor_pos.tp_row \|\|
	initial_cursor_pos.tp_col != final_cursor_pos.tp_col) {
	state_changes->cursor_changed = true;
	// Update dirty rect to include old and new cursor positions.
	current_state_changes_->dirty_rect = EnclosingRectangle(
	current_state_changes_->dirty_rect,
	Rectangle(initial_cursor_pos.tp_row, initial_cursor_pos.tp_col, 1, 1));
	current_state_changes_->dirty_rect = EnclosingRectangle(
	current_state_changes_->dirty_rect,
	Rectangle(final_cursor_pos.tp_row, final_cursor_pos.tp_col, 1, 1));
	}

	current_state_changes_ = nullptr;
	}

	TermModel::Size TermModel::GetSize() const {
	// Teken isn't const-correct, sadly.
	return TekenToMotermSize(
	teken_get_winsize(const_cast<teken_t>(&terminal_)));
	}

	TermModel::Position TermModel::GetCursorPosition() const {
	// Teken isn't const-correct, sadly.
	return TekenToMotermPosition(
	teken_get_cursor(const_cast<teken_t>(&terminal_)));
	}

	bool TermModel::GetCursorVisibility() const {
	return cursor_visible_;
	}

	TermModel::CharacterInfo TermModel::GetCharacterInfoAt(
	const Position& position) const {
	FXL_DCHECK(position.row >= 0);
	FXL_DCHECK(position.row < static_cast<int>(GetSize().rows));
	FXL_DCHECK(position.column >= 0);
	FXL_DCHECK(position.column < static_cast<int>(GetSize().columns));

	uint32_t ch = characters_[position.row * size_.columns + position.column];
	const teken_attr_t& teken_attr =
	attributes_[position.row * size_.columns + position.column];
	Color fg = TekenToMotermColor(teken_attr.ta_fgcolor,
	(teken_attr.ta_format & TF_BOLD));
	Color bg = TekenToMotermColor(teken_attr.ta_bgcolor, false);
	Attributes attr = 0;
	if ((teken_attr.ta_format & TF_BOLD))
	attr \|= kAttributesBold;
	if ((teken_attr.ta_format & TF_UNDERLINE))
	attr \|= kAttributesUnderline;
	if ((teken_attr.ta_format & TF_BLINK))
	attr \|= kAttributesBlink;
	if ((teken_attr.ta_format & TF_REVERSE))
	std::swap(fg, bg);
	return CharacterInfo(ch, attr, fg, bg);
	}

	void TermModel::SetSize(const Size& size, bool reset) {
	FXL_DCHECK(size.rows > 0u);
	FXL_DCHECK(size.columns > 0u);
	Size old_size = size_;
	size_ = size;
	size_t new_num_chars = size_.rows * size_.columns;
	if (num_chars_ != new_num_chars) {
	teken_char_t* new_characters = new teken_char_t[new_num_chars];
	memset(new_characters, 0, new_num_chars * sizeof(teken_char_t));

	teken_attr_t* new_attributes = new teken_attr_t[new_num_chars];
	memset(new_attributes, 0, new_num_chars * sizeof(teken_attr_t));

	// FIXME(jpoichet) copy from bottom to top instead
	for (size_t r = 0; r < old_size.rows; ++r) {
	size_t bytes = old_size.columns * sizeof(teken_char_t);
	if (r * size_.columns + bytes > new_num_chars) {
	// Until we copy bottom to top, ignore the last line.
	break;
	}
	memcpy(new_characters + r * size_.columns,
	characters_.get() + r * old_size.columns,
	old_size.columns * sizeof(teken_char_t));
	memcpy(new_attributes + r * size_.columns,
	attributes_.get() + r * old_size.columns,
	old_size.columns * sizeof(teken_attr_t));
	}
	characters_.reset(new_characters);
	attributes_.reset(new_attributes);
	num_chars_ = new_num_chars;
	}

	teken_pos_t teken_size = {static_cast<teken_unit_t>(size.rows),
	static_cast<teken_unit_t>(size.columns)};
	if (reset) {
	teken_set_winsize_noreset(&terminal_, &teken_size);
	} else {
	// We'll try a bit harder to keep a sensible cursor position.
	teken_pos_t cursor_pos =
	teken_get_cursor(const_cast<teken_t>(&terminal_));
	teken_set_winsize(&terminal_, &teken_size);
	if (cursor_pos.tp_row >= teken_size.tp_row)
	cursor_pos.tp_row = teken_size.tp_row - 1;
	if (cursor_pos.tp_col >= teken_size.tp_col)
	cursor_pos.tp_col = teken_size.tp_col - 1;
	teken_set_cursor(&terminal_, &cursor_pos);
	}
	}

	void TermModel::OnBell() {
	FXL_DCHECK(current_state_changes_);
	current_state_changes_->bell_count++;
	}

	void TermModel::OnCursor(const teken_pos_t* pos) {
	FXL_DCHECK(current_state_changes_);
	// Don't do anything. We'll just compare initial and final cursor positions.
	}

	void TermModel::OnPutchar(const teken_pos_t* pos,
	teken_char_t ch,
	const teken_attr_t* attr) {
	character_at(pos->tp_row, pos->tp_col) = ch;
	attribute_at(pos->tp_row, pos->tp_col) = *attr;

	// Update dirty rect.
	FXL_DCHECK(current_state_changes_);
	current_state_changes_->dirty_rect =
	EnclosingRectangle(current_state_changes_->dirty_rect,
	Rectangle(pos->tp_row, pos->tp_col, 1, 1));
	}

	void TermModel::OnFill(const teken_rect_t* rect,
	teken_char_t ch,
	const teken_attr_t* attr) {
	for (size_t row = rect->tr_begin.tp_row; row < rect->tr_end.tp_row; row++) {
	for (size_t col = rect->tr_begin.tp_col; col < rect->tr_end.tp_col; col++) {
	character_at(row, col) = ch;
	attribute_at(row, col) = *attr;
	}
	}

	// Update dirty rect.
	FXL_DCHECK(current_state_changes_);
	current_state_changes_->dirty_rect = EnclosingRectangle(
	current_state_changes_->dirty_rect, TekenToMotermRectangle(*rect));
	}

	void TermModel::OnCopy(const teken_rect_t* rect, const teken_pos_t* pos) {
	unsigned height = rect->tr_end.tp_row - rect->tr_begin.tp_row;
	unsigned width = rect->tr_end.tp_col - rect->tr_begin.tp_col;

	// This is really a "move" (like \|memmove()\|) -- overlaps are likely. Process
	// the rows depending on which way (vertically) we're moving.
	if (pos->tp_row <= rect->tr_begin.tp_row) {
	// Start from the top row.
	for (unsigned row = 0; row < height; row++) {
	// Use \|memmove()\| here, to in case we're not moving vertically.
	memmove(&character_at(pos->tp_row + row, pos->tp_col),
	&character_at(rect->tr_begin.tp_row + row, pos->tp_col),
	width * sizeof(characters_[0]));
	memmove(&attribute_at(pos->tp_row + row, pos->tp_col),
	&attribute_at(rect->tr_begin.tp_row + row, pos->tp_col),
	width * sizeof(attributes_[0]));
	}
	} else {
	// Start from the bottom row.
	for (unsigned row = height; row > 0;) {
	row--;
	// We can use \|memcpy()\| here.
	memcpy(&character_at(pos->tp_row + row, pos->tp_col),
	&character_at(rect->tr_begin.tp_row + row, pos->tp_col),
	width * sizeof(characters_[0]));
	memcpy(&attribute_at(pos->tp_row + row, pos->tp_col),
	&attribute_at(rect->tr_begin.tp_row + row, pos->tp_col),
	width * sizeof(attributes_[0]));
	}
	}

	// Update dirty rect.
	FXL_DCHECK(current_state_changes_);
	current_state_changes_->dirty_rect = EnclosingRectangle(
	current_state_changes_->dirty_rect,
	Rectangle(static_cast<int>(pos->tp_row), static_cast<int>(pos->tp_col),
	width, height));
	}

	void TermModel::OnParam(int cmd, unsigned val) {
	FXL_DCHECK(current_state_changes_);

	// Note: \|val\| is usually a "boolean", except for \|TP_SETBELLPD\| (for which
	// \|val\| can be decomposed using \|TP_SETBELLPD_{PITCH, DURATION}()\|).
	switch (cmd) {
	case TP_SHOWCURSOR:
	cursor_visible_ = !!val;
	current_state_changes_->cursor_changed = true;
	break;
	case TP_KEYPADAPP:
	if (delegate_)
	delegate_->OnSetKeypadMode(!!val);
	break;
	case TP_AUTOREPEAT:
	case TP_SWITCHVT:
	case TP_132COLS:
	case TP_SETBELLPD:
	case TP_MOUSE:
	// TODO(vtl): TP_KEYPADAPP seems especially common.
	FXL_NOTIMPLEMENTED() << "OnParam(" << cmd << ", " << val << ")";
	break;
	default:
	FXL_NOTREACHED() << "OnParam(): unknown command: " << cmd;
	break;
	}
	}

	void TermModel::OnRespond(const void* buf, size_t size) {
	if (delegate_)
	delegate_->OnResponse(buf, size);
	else
	FXL_LOG(WARNING) << "Ignoring response: no delegate";
	}

	// static
	void TermModel::OnBellThunk(void* ctx) {
	FXL_DCHECK(ctx);
	return static_cast<TermModel*>(ctx)->OnBell();
	}

	// static
	void TermModel::OnCursorThunk(void* ctx, const teken_pos_t* pos) {
	FXL_DCHECK(ctx);
	return static_cast<TermModel*>(ctx)->OnCursor(pos);
	}

	// static
	void TermModel::OnPutcharThunk(void* ctx,
	const teken_pos_t* pos,
	teken_char_t ch,
	const teken_attr_t* attr) {
	FXL_DCHECK(ctx);
	return static_cast<TermModel*>(ctx)->OnPutchar(pos, ch, attr);
	}

	// static
	void TermModel::OnFillThunk(void* ctx,
	const teken_rect_t* rect,
	teken_char_t ch,
	const teken_attr_t* attr) {
	FXL_DCHECK(ctx);
	return static_cast<TermModel*>(ctx)->OnFill(rect, ch, attr);
	}

	// static
	void TermModel::OnCopyThunk(void* ctx,
	const teken_rect_t* rect,
	const teken_pos_t* pos) {
	FXL_DCHECK(ctx);
	return static_cast<TermModel*>(ctx)->OnCopy(rect, pos);
	}

	// static
	void TermModel::OnParamThunk(void* ctx, int cmd, unsigned val) {
	FXL_DCHECK(ctx);
	return static_cast<TermModel*>(ctx)->OnParam(cmd, val);
	}

	// static
	void TermModel::OnRespondThunk(void* ctx, const void* buf, size_t size) {
	FXL_DCHECK(ctx);
	return static_cast<TermModel*>(ctx)->OnRespond(buf, size);
	}

	} // namespace term