text: #include <AK/StringBuilder.h>
  #include <Kernel/KeyCode.h>
  #include <LibGUI/GAction.h>
  #include <LibGUI/GClipboard.h>
  #include <LibGUI/GFontDatabase.h>
  #include <LibGUI/GMenu.h>
  #include <LibGUI/GPainter.h>
  #include <LibGUI/GScrollBar.h>
  #include <LibGUI/GTextEditor.h>
  #include <LibGUI/GWindow.h>
  #include <ctype.h>
  #include <fcntl.h>
  #include <stdio.h>
  #include <unistd.h>
  
  GTextEditor::GTextEditor(Type type, GWidget* parent)
      : GScrollableWidget(parent)
      , m_type(type)
  {
      set_frame_shape(FrameShape::Container);
      set_frame_shadow(FrameShadow::Sunken);
      set_frame_thickness(2);
      set_scrollbars_enabled(is_multi_line());
      set_font(GFontDatabase::the().get_by_name("Csilla Thin"));
      // FIXME: Recompute vertical scrollbar step size on font change.
      vertical_scrollbar().set_step(line_height());
      m_lines.append(make<Line>(*this));
      m_cursor = { 0, 0 };
      create_actions();
  }
  
  GTextEditor::~GTextEditor()
  {
  }
  
  void GTextEditor::create_actions()
  {
      m_undo_action = GAction::create(
      "Undo", { Mod_Ctrl, Key_Z }, GraphicsBitmap::load_from_file("/res/icons/16x16/undo.png"), [&](const GAction&) {
          // FIXME: Undo
      },
      this);
  
      m_redo_action = GAction::create(
      "Redo", { Mod_Ctrl, Key_Y }, GraphicsBitmap::load_from_file("/res/icons/16x16/redo.png"), [&](const GAction&) {
          // FIXME: Redo
      },
      this);
  
      m_cut_action = GAction::create(
      "Cut", { Mod_Ctrl, Key_X }, GraphicsBitmap::load_from_file("/res/icons/cut16.png"), [&](const GAction&) {
          cut();
      },
      this);
  
      m_copy_action = GAction::create(
      "Copy", { Mod_Ctrl, Key_C }, GraphicsBitmap::load_from_file("/res/icons/16x16/edit-copy.png"), [&](const GAction&) {
          copy();
      },
      this);
  
  
      m_paste_action = GAction::create(
      "Paste", { Mod_Ctrl, Key_V }, GraphicsBitmap::load_from_file("/res/icons/paste16.png"), [&](const GAction&) {
          paste();
      },
      this);
  
      m_delete_action = GAction::create(
      "Delete", { 0, Key_Delete }, GraphicsBitmap::load_from_file("/res/icons/16x16/delete.png"), [&](const GAction&) {
          do_delete();
      },
      this);
  }
  
  void GTextEditor::set_text(const StringView& text)
  {
      if (is_single_line() && text.length() == m_lines[0].length() && !memcmp(text.characters_without_null_termination(), m_lines[0].characters(), text.length()))
          return;
  
      m_selection.clear();
      m_lines.clear();
      int start_of_current_line = 0;
  
      auto add_line = [&](int current_position) {
          int line_length = current_position - start_of_current_line;
          auto line = make<Line>(*this);
          if (line_length)
              line->set_text(text.substring_view(start_of_current_line, current_position - start_of_current_line));
          m_lines.append(move(line));
          start_of_current_line = current_position + 1;
      };
      int i = 0;
      for (i = 0; i < text.length(); ++i) {
          if (text[i] == '\n')
              add_line(i);
      }
      add_line(i);
      update_content_size();
      recompute_all_visual_lines();
      if (is_single_line())
          set_cursor(0, m_lines[0].length());
      else
          set_cursor(0, 0);
      did_update_selection();
      update();
  }
  
  void GTextEditor::update_content_size()
  {
      int content_width = 0;
      int content_height = 0;
      for (auto& line : m_lines) {
          content_width = max(line.m_visual_rect.width(), content_width);
          content_height += line.m_visual_rect.height();
      }
      content_width += m_horizontal_content_padding * 2;
      if (is_right_text_alignment(m_text_alignment))
          content_width = max(frame_inner_rect().width(), content_width);
  
      set_content_size({ content_width, content_height });
      set_size_occupied_by_fixed_elements({ ruler_width(), 0 });
  }
  
  GTextPosition GTextEditor::text_position_at(const Point& a_position) const
  {
      auto position = a_position;
      position.move_by(horizontal_scrollbar().value(), vertical_scrollbar().value());
      position.move_by(-(m_horizontal_content_padding + ruler_width()), 0);
      position.move_by(-frame_thickness(), -frame_thickness());
  
      int line_index = -1;
  
      if (is_line_wrapping_enabled()) {
          for (int i = 0; i < m_lines.size(); ++i) {
              auto& rect = m_lines[i].m_visual_rect;
              if (position.y() >= rect.top() && position.y() <= rect.bottom()) {
                  line_index = i;
                  break;
              } else if (position.y() > rect.bottom())
                  line_index = m_lines.size() - 1;
          }
      } else {
          line_index = position.y() / line_height();
      }
  
      line_index = max(0, min(line_index, line_count() - 1));
  
      auto& line = m_lines[line_index];
  
      int column_index;
      switch (m_text_alignment) {
      case TextAlignment::CenterLeft:
          column_index = (position.x() + glyph_width() / 2) / glyph_width();
          if (is_line_wrapping_enabled()) {
              line.for_each_visual_line([&](const Rect& rect, const StringView&, int start_of_line) {
                  if (rect.contains_vertically(position.y())) {
                      column_index += start_of_line;
                      return IterationDecision::Break;
                  }
                  return IterationDecision::Continue;
              });
          }
          break;
      case TextAlignment::CenterRight:
          // FIXME: Support right-aligned line wrapping, I guess.
          ASSERT(!is_line_wrapping_enabled());
          column_index = (position.x() - content_x_for_position({ line_index, 0 }) + glyph_width() / 2) / glyph_width();
          break;
      default:
          ASSERT_NOT_REACHED();
      }
  
      column_index = max(0, min(column_index, m_lines[line_index].length()));
      return { line_index, column_index };
  }
  
  void GTextEditor::doubleclick_event(GMouseEvent& event)
  {
      if (event.button() != GMouseButton::Left)
          return;
  
      m_triple_click_timer.start();
      m_in_drag_select = false;
  
      auto start = text_position_at(event.position());
      auto end = start;
      auto& line = m_lines[start.line()];
      while (start.column() > 0) {
          if (isspace(line.characters()[start.column() - 1]))
              break;
          start.set_column(start.column() - 1);
      }
  
      while (end.column() < line.length()) {
          if (isspace(line.characters()[end.column()]))
              break;
          end.set_column(end.column() + 1);
      }
  
      m_selection.set(start, end);
      set_cursor(end);
      update();
      did_update_selection();
  }
  
  void GTextEditor::mousedown_event(GMouseEvent& event)
  {
      if (event.button() != GMouseButton::Left) {
          return;
      }
  
      if (m_triple_click_timer.is_valid() && m_triple_click_timer.elapsed() < 250) {
          m_triple_click_timer = CElapsedTimer();
  
          GTextPosition start;
          GTextPosition end;
  
          if (is_multi_line()) {
              // select *current* line
              start = GTextPosition(m_cursor.line(), 0);
              end = GTextPosition(m_cursor.line(), m_lines[m_cursor.line()].length());
          } else {
              // select *whole* line
              start = GTextPosition(0, 0);
              end = GTextPosition(line_count() - 1, m_lines[line_count() - 1].length());
          }
  
          m_selection.set(start, end);
          set_cursor(end);
          return;
      }
  
      if (event.modifiers() & Mod_Shift) {
          if (!has_selection())
              m_selection.set(m_cursor, {});
      } else {
          m_selection.clear();
      }
  
      m_in_drag_select = true;
  
      set_cursor(text_position_at(event.position()));
  
      if (!(event.modifiers() & Mod_Shift)) {
          if (!has_selection())
              m_selection.set(m_cursor, {});
      }
  
      if (m_selection.start().is_valid() && m_selection.start() != m_cursor)
          m_selection.set_end(m_cursor);
  
      // FIXME: Only update the relevant rects.
      update();
      did_update_selection();
  }
  
  void GTextEditor::mouseup_event(GMouseEvent& event)
  {
      if (event.button() == GMouseButton::Left) {
          if (m_in_drag_select) {
              m_in_drag_select = false;
          }
          return;
      }
  }
  
  void GTextEditor::mousemove_event(GMouseEvent& event)
  {
      if (m_in_drag_select) {
          set_cursor(text_position_at(event.position()));
          m_selection.set_end(m_cursor);
          did_update_selection();
          update();
          return;
      }
  }
  
  int GTextEditor::ruler_width() const
  {
      if (!m_ruler_visible)
          return 0;
      // FIXME: Resize based on needed space.
      return 5 * font().glyph_width('x') + 4;
  }
  
  Rect GTextEditor::ruler_content_rect(int line_index) const
  {
      if (!m_ruler_visible)
          return {};
      return {
          0 - ruler_width() + horizontal_scrollbar().value(),
          line_content_rect(line_index).y(),
          ruler_width(),
          line_content_rect(line_index).height()
      };
  }
  
  Rect GTextEditor::ruler_rect_in_inner_coordinates() const
  {
      return { 0, 0, ruler_width(), height() - height_occupied_by_horizontal_scrollbar() };
  }
  
  Rect GTextEditor::visible_text_rect_in_inner_coordinates() const
  {
      return {
          m_horizontal_content_padding + (m_ruler_visible ? (ruler_rect_in_inner_coordinates().right() + 1) : 0),
          0,
          frame_inner_rect().width() - (m_horizontal_content_padding * 2) - width_occupied_by_vertical_scrollbar() - ruler_width(),
          frame_inner_rect().height() - height_occupied_by_horizontal_scrollbar()
      };
  }
  
  void GTextEditor::paint_event(GPaintEvent& event)
  {
      GFrame::paint_event(event);
  
      GPainter painter(*this);
      painter.add_clip_rect(widget_inner_rect());
      painter.add_clip_rect(event.rect());
      painter.fill_rect(event.rect(), Color::White);
  
      painter.translate(frame_thickness(), frame_thickness());
  
      auto ruler_rect = ruler_rect_in_inner_coordinates();
  
      if (m_ruler_visible) {
          painter.fill_rect(ruler_rect, Color::WarmGray);
          painter.draw_line(ruler_rect.top_right(), ruler_rect.bottom_right(), Color::DarkGray);
      }
  
      painter.translate(-horizontal_scrollbar().value(), -vertical_scrollbar().value());
      if (m_ruler_visible)
          painter.translate(ruler_width(), 0);
  
      int first_visible_line = text_position_at(event.rect().top_left()).line();
      int last_visible_line = text_position_at(event.rect().bottom_right()).line();
  
      auto selection = normalized_selection();
      bool has_selection = selection.is_valid();
  
      if (m_ruler_visible) {
          for (int i = first_visible_line; i <= last_visible_line; ++i) {
              bool is_current_line = i == m_cursor.line();
              auto ruler_line_rect = ruler_content_rect(i);
              painter.draw_text(
                  ruler_line_rect.shrunken(2, 0).translated(0, m_line_spacing / 2),
                  String::number(i + 1),
                  is_current_line ? Font::default_bold_font() : font(),
                  TextAlignment::TopRight,
                  is_current_line ? Color::DarkGray : Color::MidGray);
          }
      }
  
      Rect text_clip_rect {
          (m_ruler_visible ? (ruler_rect_in_inner_coordinates().right() + frame_thickness() + 1) : frame_thickness()),
          frame_thickness(),
          width() - width_occupied_by_vertical_scrollbar() - ruler_width(),
          height() - height_occupied_by_horizontal_scrollbar()
      };
      painter.add_clip_rect(text_clip_rect);
  
      for (int line_index = first_visible_line; line_index <= last_visible_line; ++line_index) {
          auto& line = m_lines[line_index];
  
          bool physical_line_has_selection = has_selection && line_index >= selection.start().line() && line_index <= selection.end().line();
          int first_visual_line_with_selection = -1;
          int last_visual_line_with_selection = -1;
          if (physical_line_has_selection) {
              if (selection.start().line() < line_index)
                  first_visual_line_with_selection = 0;
              else
                  first_visual_line_with_selection = line.visual_line_containing(selection.start().column());
  
              if (selection.end().line() > line_index)
                  last_visual_line_with_selection = line.m_visual_line_breaks.size();
              else
                  last_visual_line_with_selection = line.visual_line_containing(selection.end().column());
          }
  
          int selection_start_column_within_line = selection.start().line() == line_index ? selection.start().column() : 0;
          int selection_end_column_within_line = selection.end().line() == line_index ? selection.end().column() : line.length();
  
          int visual_line_index = 0;
          line.for_each_visual_line([&](const Rect& visual_line_rect, const StringView& visual_line_text, int start_of_visual_line) {
              // FIXME: Make sure we always fill the entire line.
              //line_rect.set_width(exposed_width);
              if (is_multi_line() && line_index == m_cursor.line())
                  painter.fill_rect(visual_line_rect, Color(230, 230, 230));
              painter.draw_text(visual_line_rect, visual_line_text, m_text_alignment, Color::Black);
              bool physical_line_has_selection = has_selection && line_index >= selection.start().line() && line_index <= selection.end().line();
              if (physical_line_has_selection) {
  
                  bool current_visual_line_has_selection = (line_index != selection.start().line() && line_index != selection.end().line())
                          || (visual_line_index >= first_visual_line_with_selection && visual_line_index <= last_visual_line_with_selection);
                  if (current_visual_line_has_selection) {
                      bool selection_begins_on_current_visual_line = visual_line_index == first_visual_line_with_selection;
                      bool selection_ends_on_current_visual_line = visual_line_index == last_visual_line_with_selection;
  
                      int selection_left = selection_begins_on_current_visual_line
                                           ? content_x_for_position({ line_index, selection_start_column_within_line })
                                           : m_horizontal_content_padding;
  
                      int selection_right = selection_ends_on_current_visual_line
                                            ? content_x_for_position({ line_index, selection_end_column_within_line })
                                            : visual_line_rect.right();
                      Rect selection_rect {
                          selection_left,
                          visual_line_rect.y(),
                          selection_right - selection_left,
                          visual_line_rect.height()
                      };
  
                      painter.fill_rect(selection_rect, Color::from_rgb(0x955233));
  
                      int start_of_selection_within_visual_line = max(0, selection_start_column_within_line - start_of_visual_line);
                      int end_of_selection_within_visual_line = selection_end_column_within_line - start_of_visual_line;
  
                      StringView visual_selected_text {
                          visual_line_text.characters_without_null_termination() + start_of_selection_within_visual_line,
                          end_of_selection_within_visual_line - start_of_selection_within_visual_line
                      };
  
                      painter.draw_text(selection_rect, visual_selected_text, TextAlignment::CenterLeft, Color::White);
                  }
              }
              ++visual_line_index;
              return IterationDecision::Continue;
          });
      }
  
      if (is_focused() && m_cursor_state)
          painter.fill_rect(cursor_content_rect(), Color::Red);
  }
  
  void GTextEditor::toggle_selection_if_needed_for_event(const GKeyEvent& event)
  {
      if (event.shift() && !m_selection.is_valid()) {
          m_selection.set(m_cursor, {});
          did_update_selection();
          update();
          return;
      }
      if (!event.shift() && m_selection.is_valid()) {
          m_selection.clear();
          did_update_selection();
          update();
          return;
      }
  }
  
  void GTextEditor::select_all()
  {
      GTextPosition start_of_document { 0, 0 };
      GTextPosition end_of_document { line_count() - 1, m_lines[line_count() - 1].length() };
      m_selection.set(start_of_document, end_of_document);
      did_update_selection();
      set_cursor(end_of_document);
      update();
  }
  
  void GTextEditor::keydown_event(GKeyEvent& event)
  {
      if (is_single_line() && event.key() == KeyCode::Key_Tab)
          return GWidget::keydown_event(event);
  
      if (is_single_line() && event.key() == KeyCode::Key_Return) {
          if (on_return_pressed)
              on_return_pressed();
          return;
      }
  
      if (event.key() == KeyCode::Key_Escape) {
          if (on_escape_pressed)
              on_escape_pressed();
          return;
      }
      if (event.key() == KeyCode::Key_Up) {
          if (m_cursor.line() > 0) {
              int new_line = m_cursor.line() - 1;
              int new_column = min(m_cursor.column(), m_lines[new_line].length());
              toggle_selection_if_needed_for_event(event);
              set_cursor(new_line, new_column);
              if (m_selection.start().is_valid()) {
                  m_selection.set_end(m_cursor);
                  did_update_selection();
              }
          }
          return;
      }
      if (event.key() == KeyCode::Key_Down) {
          if (m_cursor.line() < (m_lines.size() - 1)) {
              int new_line = m_cursor.line() + 1;
              int new_column = min(m_cursor.column(), m_lines[new_line].length());
              toggle_selection_if_needed_for_event(event);
              set_cursor(new_line, new_column);
              if (m_selection.start().is_valid()) {
                  m_selection.set_end(m_cursor);
                  did_update_selection();
              }
          }
          return;
      }
      if (event.key() == KeyCode::Key_PageUp) {
          if (m_cursor.line() > 0) {
              int new_line = max(0, m_cursor.line() - visible_content_rect().height() / line_height());
              int new_column = min(m_cursor.column(), m_lines[new_line].length());
              toggle_selection_if_needed_for_event(event);
              set_cursor(new_line, new_column);
              if (m_selection.start().is_valid()) {
                  m_selection.set_end(m_cursor);
                  did_update_selection();
              }
          }
          return;
      }
      if (event.key() == KeyCode::Key_PageDown) {
          if (m_cursor.line() < (m_lines.size() - 1)) {
              int new_line = min(line_count() - 1, m_cursor.line() + visible_content_rect().height() / line_height());
              int new_column = min(m_cursor.column(), m_lines[new_line].length());
              toggle_selection_if_needed_for_event(event);
              set_cursor(new_line, new_column);
              if (m_selection.start().is_valid()) {
                  m_selection.set_end(m_cursor);
                  did_update_selection();
              }
          }
          return;
      }
      if (event.key() == KeyCode::Key_Left) {
          if (m_cursor.column() > 0) {
              int new_column = m_cursor.column() - 1;
              toggle_selection_if_needed_for_event(event);
              set_cursor(m_cursor.line(), new_column);
              if (m_selection.start().is_valid()) {
                  m_selection.set_end(m_cursor);
                  did_update_selection();
              }
          } else if (m_cursor.line() > 0) {
              int new_line = m_cursor.line() - 1;
              int new_column = m_lines[new_line].length();
              toggle_selection_if_needed_for_event(event);
              set_cursor(new_line, new_column);
              if (m_selection.start().is_valid()) {
                  m_selection.set_end(m_cursor);
                  did_update_selection();
              }
          }
          return;
      }
      if (event.key() == KeyCode::Key_Right) {
          int new_line = m_cursor.line();
          int new_column = m_cursor.column();
          if (m_cursor.column() < current_line().length()) {
              new_line = m_cursor.line();
              new_column = m_cursor.column() + 1;
          } else if (m_cursor.line() != line_count() - 1) {
              new_line = m_cursor.line() + 1;
              new_column = 0;
          }
          toggle_selection_if_needed_for_event(event);
          set_cursor(new_line, new_column);
          if (m_selection.start().is_valid()) {
              m_selection.set_end(m_cursor);
              did_update_selection();
          }
          return;
      }
      if (!event.ctrl() && event.key() == KeyCode::Key_Home) {
          toggle_selection_if_needed_for_event(event);
          set_cursor(m_cursor.line(), 0);
          if (m_selection.start().is_valid()) {
              m_selection.set_end(m_cursor);
              did_update_selection();
          }
          return;
      }
      if (!event.ctrl() && event.key() == KeyCode::Key_End) {
          toggle_selection_if_needed_for_event(event);
          set_cursor(m_cursor.line(), current_line().length());
          if (m_selection.start().is_valid()) {
              m_selection.set_end(m_cursor);
              did_update_selection();
          }
          return;
      }
      if (event.ctrl() && event.key() == KeyCode::Key_Home) {
          toggle_selection_if_needed_for_event(event);
          set_cursor(0, 0);
          if (m_selection.start().is_valid()) {
              m_selection.set_end(m_cursor);
              did_update_selection();
          }
          return;
      }
      if (event.ctrl() && event.key() == KeyCode::Key_End) {
          toggle_selection_if_needed_for_event(event);
          set_cursor(line_count() - 1, m_lines[line_count() - 1].length());
          if (m_selection.start().is_valid()) {
              m_selection.set_end(m_cursor);
              did_update_selection();
          }
          return;
      }
      if (event.modifiers() == Mod_Ctrl && event.key() == KeyCode::Key_A) {
          select_all();
          return;
      }
  
      if (event.key() == KeyCode::Key_Backspace) {
          if (is_readonly())
              return;
          if (has_selection()) {
              delete_selection();
              did_update_selection();
              return;
          }
          if (m_cursor.column() > 0) {
              // Backspace within line
              current_line().remove(m_cursor.column() - 1);
              update_content_size();
              set_cursor(m_cursor.line(), m_cursor.column() - 1);
              did_change();
              return;
          }
          if (m_cursor.column() == 0 && m_cursor.line() != 0) {
              // Backspace at column 0; merge with previous line
              auto& previous_line = m_lines[m_cursor.line() - 1];
              int previous_length = previous_line.length();
              previous_line.append(current_line().characters(), current_line().length());
              m_lines.remove(m_cursor.line());
              update_content_size();
              update();
              set_cursor(m_cursor.line() - 1, previous_length);
              did_change();
              return;
          }
          return;
      }
  
      if (event.modifiers() == Mod_Shift && event.key() == KeyCode::Key_Delete) {
          if (is_readonly())
              return;
          delete_current_line();
          return;
      }
  
      if (event.key() == KeyCode::Key_Delete) {
          if (is_readonly())
              return;
          do_delete();
          return;
      }
  
      if (!is_readonly() && !event.ctrl() && !event.alt() && !event.text().is_empty())
          insert_at_cursor_or_replace_selection(event.text());
  }
  
  void GTextEditor::delete_current_line()
  {
      if (has_selection())
          return delete_selection();
  
      m_lines.remove(m_cursor.line());
      if (m_lines.is_empty())
          m_lines.append(make<Line>(*this));
  
      update_content_size();
      update();
  }
  
  void GTextEditor::do_delete()
  {
      if (is_readonly())
          return;
  
      if (has_selection())
          return delete_selection();
  
      if (m_cursor.column() < current_line().length()) {
          // Delete within line
          current_line().remove(m_cursor.column());
          did_change();
          update_cursor();
          return;
      }
      if (m_cursor.column() == current_line().length() && m_cursor.line() != line_count() - 1) {
          // Delete at end of line; merge with next line
          auto& next_line = m_lines[m_cursor.line() + 1];
          int previous_length = current_line().length();
          current_line().append(next_line.characters(), next_line.length());
          m_lines.remove(m_cursor.line() + 1);
          update();
          did_change();
          set_cursor(m_cursor.line(), previous_length);
          return;
      }
  }
  
  void GTextEditor::insert_at_cursor(const StringView& text)
  {
      // FIXME: This should obviously not be implemented this way.
      for (int i = 0; i < text.length(); ++i) {
          insert_at_cursor(text[i]);
      }
  }
  
  void GTextEditor::insert_at_cursor(char ch)
  {
      bool at_head = m_cursor.column() == 0;
      bool at_tail = m_cursor.column() == current_line().length();
      if (ch == '\n') {
          if (at_tail || at_head) {
              String new_line_contents;
              if (m_automatic_indentation_enabled && at_tail) {
                  int leading_spaces = 0;
                  auto& old_line = m_lines[m_cursor.line()];
                  for (int i = 0; i < old_line.length(); ++i) {
                      if (old_line.characters()[i] == ' ')
                          ++leading_spaces;
                      else
                          break;
                  }
                  if (leading_spaces)
                      new_line_contents = String::repeated(' ', leading_spaces);
              }
              m_lines.insert(m_cursor.line() + (at_tail ? 1 : 0), make<Line>(*this, new_line_contents));
              update();
              did_change();
              set_cursor(m_cursor.line() + 1, m_lines[m_cursor.line() + 1].length());
              return;
          }
          auto new_line = make<Line>(*this);
          new_line->append(current_line().characters() + m_cursor.column(), current_line().length() - m_cursor.column());
          current_line().truncate(m_cursor.column());
          m_lines.insert(m_cursor.line() + 1, move(new_line));
          update();
          did_change();
          set_cursor(m_cursor.line() + 1, 0);
          return;
      }
      if (ch == '\t') {
          int next_soft_tab_stop = ((m_cursor.column() + m_soft_tab_width) / m_soft_tab_width) * m_soft_tab_width;
          int spaces_to_insert = next_soft_tab_stop - m_cursor.column();
          for (int i = 0; i < spaces_to_insert; ++i) {
              current_line().insert(m_cursor.column(), ' ');
          }
          did_change();
          set_cursor(m_cursor.line(), next_soft_tab_stop);
          return;
      }
      current_line().insert(m_cursor.column(), ch);
      did_change();
      set_cursor(m_cursor.line(), m_cursor.column() + 1);
  }
  
  int GTextEditor::content_x_for_position(const GTextPosition& position) const
  {
      auto& line = m_lines[position.line()];
      int x_offset = -1;
      switch (m_text_alignment) {
      case TextAlignment::CenterLeft:
          line.for_each_visual_line([&](const Rect&, const StringView& view, int start_of_visual_line) {
              if (position.column() >= start_of_visual_line && ((position.column() - start_of_visual_line) <= view.length())) {
                  x_offset = (position.column() - start_of_visual_line) * glyph_width();
                  return IterationDecision::Break;
              }
              return IterationDecision::Continue;
          });
          return m_horizontal_content_padding + x_offset;
      case TextAlignment::CenterRight:
          // FIXME
          ASSERT(!is_line_wrapping_enabled());
          return content_width() - m_horizontal_content_padding - (line.length() * glyph_width()) + (position.column() * glyph_width());
      default:
          ASSERT_NOT_REACHED();
      }
  }
  
  Rect GTextEditor::content_rect_for_position(const GTextPosition& position) const
  {
      if (!position.is_valid())
          return {};
      ASSERT(!m_lines.is_empty());
      ASSERT(position.column() <= (current_line().length() + 1));
  
      int x = content_x_for_position(position);
  
      if (is_single_line()) {
          Rect rect { x, 0, 1, font().glyph_height() + 2 };
          rect.center_vertically_within({ {}, frame_inner_rect().size() });
          return rect;
      }
  
      auto& line = m_lines[position.line()];
      Rect rect;
      line.for_each_visual_line([&](const Rect& visual_line_rect, const StringView& view, int start_of_visual_line) {
          if (position.column() >= start_of_visual_line && ((position.column() - start_of_visual_line) <= view.length())) {
              // NOTE: We have to subtract the horizontal padding here since it's part of the visual line rect
              //       *and* included in what we get from content_x_for_position().
              rect = {
                  visual_line_rect.x() + x - (m_horizontal_content_padding),
                  visual_line_rect.y(),
                  1,
                  line_height()
              };
              return IterationDecision::Break;
          }
          return IterationDecision::Continue;
      });
      return rect;
  }
  
  Rect GTextEditor::cursor_content_rect() const
  {
      return content_rect_for_position(m_cursor);
  }
  
  Rect GTextEditor::line_widget_rect(int line_index) const
  {
      auto rect = line_content_rect(line_index);
      rect.set_x(frame_thickness());
      rect.set_width(frame_inner_rect().width());
      rect.move_by(0, -(vertical_scrollbar().value()));
      rect.move_by(0, frame_thickness());
      rect.intersect(frame_inner_rect());
      return rect;
  }
  
  void GTextEditor::scroll_position_into_view(const GTextPosition& position)
  {
      auto rect = content_rect_for_position(position);
      if (position.column() == 0)
          rect.set_x(content_x_for_position({ position.line(), 0 }) - 2);
      else if (position.column() == m_lines[position.line()].length())
          rect.set_x(content_x_for_position({ position.line(), m_lines[position.line()].length() }) + 2);
      scroll_into_view(rect, true, true);
  }
  
  void GTextEditor::scroll_cursor_into_view()
  {
      scroll_position_into_view(m_cursor);
  }
  
  Rect GTextEditor::line_content_rect(int line_index) const
  {
      auto& line = m_lines[line_index];
      if (is_single_line()) {
          Rect line_rect = { content_x_for_position({ line_index, 0 }), 0, line.length() * glyph_width(), font().glyph_height() + 2 };
          line_rect.center_vertically_within({ {}, frame_inner_rect().size() });
          return line_rect;
      }
      if (is_line_wrapping_enabled())
          return line.m_visual_rect;
      return {
          content_x_for_position({ line_index, 0 }),
          line_index * line_height(),
          line.length() * glyph_width(),
          line_height()
      };
  }
  
  void GTextEditor::update_cursor()
  {
      update(line_widget_rect(m_cursor.line()));
  }
  
  void GTextEditor::set_cursor(int line, int column)
  {
      set_cursor({ line, column });
  }
  
  void GTextEditor::set_cursor(const GTextPosition& position)
  {
      ASSERT(!m_lines.is_empty());
      ASSERT(position.line() < m_lines.size());
      ASSERT(position.column() <= m_lines[position.line()].length());
      if (m_cursor != position) {
          // NOTE: If the old cursor is no longer valid, repaint everything just in case.
          auto old_cursor_line_rect = m_cursor.line() < m_lines.size()
                                      ? line_widget_rect(m_cursor.line())
                                      : rect();
          m_cursor = position;
          m_cursor_state = true;
          scroll_cursor_into_view();
          update(old_cursor_line_rect);
          update_cursor();
      }
      if (on_cursor_change)
          on_cursor_change();
  }
  
  void GTextEditor::focusin_event(CEvent&)
  {
      update_cursor();
      start_timer(500);
  }
  
  void GTextEditor::focusout_event(CEvent&)
  {
      stop_timer();
  }
  
  void GTextEditor::timer_event(CTimerEvent&)
  {
      m_cursor_state = !m_cursor_state;
      if (is_focused())
          update_cursor();
  }
  
  GTextEditor::Line::Line(GTextEditor& editor)
      : m_editor(editor)
  {
      clear();
  }
  
  GTextEditor::Line::Line(GTextEditor& editor, const StringView& text)
      : m_editor(editor)
  {
      set_text(text);
  }
  
  void GTextEditor::Line::clear()
  {
      m_text.clear();
      m_text.append(0);
  }
  
  void GTextEditor::Line::set_text(const StringView& text)
  {
      if (text.length() == length() && !memcmp(text.characters_without_null_termination(), characters(), length()))
          return;
      if (text.is_empty()) {
          clear();
          return;
      }
      m_text.resize(text.length() + 1);
      memcpy(m_text.data(), text.characters_without_null_termination(), text.length() + 1);
  }
  
  void GTextEditor::Line::append(const char* characters, int length)
  {
      int old_length = m_text.size() - 1;
      m_text.resize(m_text.size() + length);
      memcpy(m_text.data() + old_length, characters, length);
      m_text.last() = 0;
  }
  
  void GTextEditor::Line::append(char ch)
  {
      insert(length(), ch);
  }
  
  void GTextEditor::Line::prepend(char ch)
  {
      insert(0, ch);
  }
  
  void GTextEditor::Line::insert(int index, char ch)
  {
      if (index == length()) {
          m_text.last() = ch;
          m_text.append(0);
      } else {
          m_text.insert(index, move(ch));
      }
  }
  
  void GTextEditor::Line::remove(int index)
  {
      if (index == length()) {
          m_text.take_last();
          m_text.last() = 0;
      } else {
          m_text.remove(index);
      }
  }
  
  void GTextEditor::Line::truncate(int length)
  {
      m_text.resize(length + 1);
      m_text.last() = 0;
  }
  
  bool GTextEditor::write_to_file(const StringView& path)
  {
      int fd = open_with_path_length(path.characters_without_null_termination(), path.length(), O_WRONLY | O_CREAT | O_TRUNC, 0666);
      if (fd < 0) {
          perror("open");
          return false;
      }
  
      // Compute the final file size and ftruncate() to make writing fast.
      // FIXME: Remove this once the kernel is smart enough to do this instead.
      off_t file_size = 0;
      for (int i = 0; i < m_lines.size(); ++i)
          file_size += m_lines[i].length();
      file_size += m_lines.size() - 1;
  
      int rc = ftruncate(fd, file_size);
      if (rc < 0) {
          perror("ftruncate");
          return false;
      }
  
      for (int i = 0; i < m_lines.size(); ++i) {
          auto& line = m_lines[i];
          if (line.length()) {
              ssize_t nwritten = write(fd, line.characters(), line.length());
              if (nwritten < 0) {
                  perror("write");
                  close(fd);
                  return false;
              }
          }
          if (i != m_lines.size() - 1) {
              char ch = '\n';
              ssize_t nwritten = write(fd, &ch, 1);
              if (nwritten != 1) {
                  perror("write");
                  close(fd);
                  return false;
              }
          }
      }
  
      close(fd);
      return true;
  }
  
  String GTextEditor::text() const
  {
      StringBuilder builder;
      for (int i = 0; i < line_count(); ++i) {
          auto& line = m_lines[i];
          builder.append(line.characters(), line.length());
          if (i != line_count() - 1)
              builder.append('\n');
      }
      return builder.to_string();
  }
  
  void GTextEditor::clear()
  {
      m_lines.clear();
      m_lines.append(make<Line>(*this));
      m_selection.clear();
      did_update_selection();
      set_cursor(0, 0);
      update();
  }
  
  String GTextEditor::selected_text() const
  {
      if (!has_selection())
          return {};
  
      auto selection = normalized_selection();
      StringBuilder builder;
      for (int i = selection.start().line(); i <= selection.end().line(); ++i) {
          auto& line = m_lines[i];
          int selection_start_column_on_line = selection.start().line() == i ? selection.start().column() : 0;
          int selection_end_column_on_line = selection.end().line() == i ? selection.end().column() : line.length();
          builder.append(line.characters() + selection_start_column_on_line, selection_end_column_on_line - selection_start_column_on_line);
          if (i != selection.end().line())
              builder.append('\n');
      }
  
      return builder.to_string();
  }
  
  void GTextEditor::delete_selection()
  {
      if (!has_selection())
          return;
  
      auto selection = normalized_selection();
  
      // First delete all the lines in between the first and last one.
      for (int i = selection.start().line() + 1; i < selection.end().line();) {
          m_lines.remove(i);
          selection.end().set_line(selection.end().line() - 1);
      }
  
      if (selection.start().line() == selection.end().line()) {
          // Delete within same line.
          auto& line = m_lines[selection.start().line()];
          bool whole_line_is_selected = selection.start().column() == 0 && selection.end().column() == line.length();
          if (whole_line_is_selected) {
              line.clear();
          } else {
              auto before_selection = String(line.characters(), line.length()).substring(0, selection.start().column());
              auto after_selection = String(line.characters(), line.length()).substring(selection.end().column(), line.length() - selection.end().column());
              StringBuilder builder(before_selection.length() + after_selection.length());
              builder.append(before_selection);
              builder.append(after_selection);
              line.set_text(builder.to_string());
          }
      } else {
          // Delete across a newline, merging lines.
          ASSERT(selection.start().line() == selection.end().line() - 1);
          auto& first_line = m_lines[selection.start().line()];
          auto& second_line = m_lines[selection.end().line()];
          auto before_selection = String(first_line.characters(), first_line.length()).substring(0, selection.start().column());
          auto after_selection = String(second_line.characters(), second_line.length()).substring(selection.end().column(), second_line.length() - selection.end().column());
          StringBuilder builder(before_selection.length() + after_selection.length());
          builder.append(before_selection);
          builder.append(after_selection);
          first_line.set_text(builder.to_string());
          m_lines.remove(selection.end().line());
      }
  
      if (m_lines.is_empty())
          m_lines.append(make<Line>(*this));
  
      m_selection.clear();
      did_update_selection();
      did_change();
      set_cursor(selection.start());
      update();
  }
  
  void GTextEditor::insert_at_cursor_or_replace_selection(const StringView& text)
  {
      ASSERT(!is_readonly());
      if (has_selection())
          delete_selection();
      insert_at_cursor(text);
  }
  
  void GTextEditor::cut()
  {
      if (is_readonly())
          return;
      auto selected_text = this->selected_text();
      printf("Cut: \"%s\"\n", selected_text.characters());
      GClipboard::the().set_data(selected_text);
      delete_selection();
  }
  
  void GTextEditor::copy()
  {
      auto selected_text = this->selected_text();
      printf("Copy: \"%s\"\n", selected_text.characters());
      GClipboard::the().set_data(selected_text);
  }
  
  void GTextEditor::paste()
  {
      if (is_readonly())
          return;
      auto paste_text = GClipboard::the().data();
      printf("Paste: \"%s\"\n", paste_text.characters());
      insert_at_cursor_or_replace_selection(paste_text);
  }
  
  void GTextEditor::enter_event(CEvent&)
  {
      ASSERT(window());
      window()->set_override_cursor(GStandardCursor::IBeam);
  }
  
  void GTextEditor::leave_event(CEvent&)
  {
      ASSERT(window());
      window()->set_override_cursor(GStandardCursor::None);
  }
  
  void GTextEditor::did_change()
  {
      ASSERT(!is_readonly());
      update_content_size();
      recompute_all_visual_lines();
      if (!m_have_pending_change_notification) {
          m_have_pending_change_notification = true;
          deferred_invoke([this](auto&) {
              if (on_change)
                  on_change();
              m_have_pending_change_notification = false;
          });
      }
  }
  
  void GTextEditor::set_readonly(bool readonly)
  {
      if (m_readonly == readonly)
          return;
      m_readonly = readonly;
      m_cut_action->set_enabled(!is_readonly() && has_selection());
      m_delete_action->set_enabled(!is_readonly());
      m_paste_action->set_enabled(!is_readonly());
  }
  
  void GTextEditor::did_update_selection()
  {
      m_cut_action->set_enabled(!is_readonly() && has_selection());
      m_copy_action->set_enabled(has_selection());
      if (on_selection_change)
          on_selection_change();
      if (is_line_wrapping_enabled()) {
          // FIXME: Try to repaint less.
          update();
      }
  }
  
  void GTextEditor::context_menu_event(GContextMenuEvent& event)
  {
      if (!m_context_menu) {
          m_context_menu = make<GMenu>("GTextEditor context menu");
          m_context_menu->add_action(undo_action());
          m_context_menu->add_action(redo_action());
          m_context_menu->add_separator();
          m_context_menu->add_action(cut_action());
          m_context_menu->add_action(copy_action());
          m_context_menu->add_action(paste_action());
          m_context_menu->add_action(delete_action());
          if (!m_custom_context_menu_actions.is_empty()) {
              m_context_menu->add_separator();
              for (auto& action : m_custom_context_menu_actions) {
                  m_context_menu->add_action(action);
              }
          }
      }
      m_context_menu->popup(event.screen_position());
  }
  
  void GTextEditor::set_text_alignment(TextAlignment alignment)
  {
      if (m_text_alignment == alignment)
          return;
      m_text_alignment = alignment;
      update();
  }
  
  void GTextEditor::resize_event(GResizeEvent& event)
  {
      GScrollableWidget::resize_event(event);
      update_content_size();
      recompute_all_visual_lines();
  }
  
  GTextPosition GTextEditor::next_position_after(const GTextPosition& position, ShouldWrapAtEndOfDocument should_wrap)
  {
      auto& line = m_lines[position.line()];
      if (position.column() == line.length()) {
          if (position.line() == line_count() - 1) {
              if (should_wrap == ShouldWrapAtEndOfDocument::Yes)
                  return { 0, 0 };
              return {};
          }
          return { position.line() + 1, 0 };
      }
      return { position.line(), position.column() + 1 };
  }
  
  GTextPosition GTextEditor::prev_position_before(const GTextPosition& position, ShouldWrapAtStartOfDocument should_wrap)
  {
      if (position.column() == 0) {
          if (position.line() == 0) {
              if (should_wrap == ShouldWrapAtStartOfDocument::Yes) {
                  auto& last_line = m_lines[line_count() - 1];
                  return { line_count() - 1, last_line.length() };
              }
              return {};
          }
          auto& prev_line = m_lines[position.line() - 1];
          return { position.line() - 1, prev_line.length() };
      }
      return { position.line(), position.column() - 1 };
  }
  
  GTextRange GTextEditor::find_next(const StringView& needle, const GTextPosition& start)
  {
      if (needle.is_empty())
          return {};
  
      GTextPosition position = start.is_valid() ? start : GTextPosition(0, 0);
      GTextPosition original_position = position;
  
      GTextPosition start_of_potential_match;
      int needle_index = 0;
  
      do {
          auto ch = character_at(position);
          if (ch == needle[needle_index]) {
              if (needle_index == 0)
                  start_of_potential_match = position;
              ++needle_index;
              if (needle_index >= needle.length())
                  return { start_of_potential_match, next_position_after(position) };
          } else {
              if (needle_index > 0)
                  position = start_of_potential_match;
              needle_index = 0;
          }
          position = next_position_after(position);
      } while (position.is_valid() && position != original_position);
  
      return {};
  }
  
  GTextRange GTextEditor::find_prev(const StringView& needle, const GTextPosition& start)
  {
      if (needle.is_empty())
          return {};
  
      GTextPosition position = start.is_valid() ? start : GTextPosition(0, 0);
      position = prev_position_before(position);
      GTextPosition original_position = position;
  
      GTextPosition end_of_potential_match;
      int needle_index = needle.length() - 1;
  
      do {
          auto ch = character_at(position);
          if (ch == needle[needle_index]) {
              if (needle_index == needle.length() - 1)
                  end_of_potential_match = position;
              --needle_index;
              if (needle_index < 0)
                  return { position, next_position_after(end_of_potential_match) };
          } else {
              if (needle_index < needle.length() - 1)
                  position = end_of_potential_match;
              needle_index = needle.length() - 1;
          }
          position = prev_position_before(position);
      } while (position.is_valid() && position != original_position);
  
      return {};
  }
  
  void GTextEditor::set_selection(const GTextRange& selection)
  {
      if (m_selection == selection)
          return;
      m_selection = selection;
      set_cursor(m_selection.end());
      scroll_position_into_view(normalized_selection().start());
      update();
  }
  
  char GTextEditor::character_at(const GTextPosition& position) const
  {
      ASSERT(position.line() < line_count());
      auto& line = m_lines[position.line()];
      if (position.column() == line.length())
          return '\n';
      return line.characters()[position.column()];
  }
  
  void GTextEditor::recompute_all_visual_lines()
  {
      int y_offset = 0;
      for (auto& line : m_lines) {
          line.recompute_visual_lines();
          line.m_visual_rect.set_y(y_offset);
          y_offset += line.m_visual_rect.height();
      }
  
      update_content_size();
  }
  
  void GTextEditor::Line::recompute_visual_lines()
  {
      m_visual_line_breaks.clear_with_capacity();
  
      int available_width = m_editor.visible_text_rect_in_inner_coordinates().width();
  
      if (m_editor.is_line_wrapping_enabled()) {
          int line_width_so_far = 0;
  
          for (int i = 0; i < length(); ++i) {
              auto ch = characters()[i];
              auto glyph_width = m_editor.font().glyph_width(ch);
              if ((line_width_so_far + glyph_width) > available_width) {
                  m_visual_line_breaks.append(i);
                  line_width_so_far = glyph_width;
                  continue;
              }
              line_width_so_far += glyph_width;
          }
      }
  
      m_visual_line_breaks.append(length());
  
      if (m_editor.is_line_wrapping_enabled())
          m_visual_rect = { m_editor.m_horizontal_content_padding, 0, available_width, m_visual_line_breaks.size() * m_editor.line_height() };
      else
          m_visual_rect = { m_editor.m_horizontal_content_padding, 0, m_editor.font().width(view()), m_editor.line_height() };
  }
  
  template<typename Callback>
  void GTextEditor::Line::for_each_visual_line(Callback callback) const
  {
      int start_of_line = 0;
      int line_index = 0;
      for (auto visual_line_break : m_visual_line_breaks) {
          auto visual_line_view = StringView(characters() + start_of_line, visual_line_break - start_of_line);
          Rect visual_line_rect {
              m_visual_rect.x(),
              m_visual_rect.y() + (line_index * m_editor.line_height()),
              m_editor.font().width(visual_line_view),
              m_editor.line_height()
          };
          if (callback(visual_line_rect, visual_line_view, start_of_line) == IterationDecision::Break)
              break;
          start_of_line = visual_line_break;
          ++line_index;
      }
  }
  
  void GTextEditor::set_line_wrapping_enabled(bool enabled)
  {
      if (m_line_wrapping_enabled == enabled)
          return;
  
      m_line_wrapping_enabled = enabled;
      horizontal_scrollbar().set_visible(!m_line_wrapping_enabled);
      update_content_size();
      recompute_all_visual_lines();
      update();
  }
  
  int GTextEditor::Line::visual_line_containing(int column) const
  {
      int visual_line_index = 0;
      for_each_visual_line([&](const Rect&, const StringView& view, int start_of_visual_line) {
          if (column >= start_of_visual_line && ((column - start_of_visual_line) < view.length()))
              return IterationDecision::Break;
          ++visual_line_index;
          return IterationDecision::Continue;
      });
      return visual_line_index;
  }
  
  void GTextEditor::add_custom_context_menu_action(GAction& action)
  {
      m_custom_context_menu_actions.append(action);
  }
  
  void GTextEditor::did_change_font()
  {
      vertical_scrollbar().set_step(line_height());
      GWidget::did_change_font();
  }
  