kakoune/src/window.cc

299 lines
7.0 KiB
C++
Raw Normal View History

2011-09-02 18:51:20 +02:00
#include "window.hh"
#include "assert.hh"
2011-09-02 18:51:20 +02:00
#include <algorithm>
namespace Kakoune
{
BufferIterator Selection::begin() const
{
return std::min(m_first, m_last);
}
BufferIterator Selection::end() const
{
return std::max(m_first, m_last) + 1;
}
void Selection::offset(int offset)
{
m_first += offset;
m_last += offset;
}
Window::Window(Buffer& buffer)
2011-09-02 18:51:20 +02:00
: m_buffer(buffer),
m_position(0, 0),
m_cursor(0, 0),
m_dimensions(0, 0),
m_current_inserter(nullptr)
2011-09-02 18:51:20 +02:00
{
}
void Window::erase()
{
m_buffer.begin_undo_group();
2011-09-02 18:51:20 +02:00
if (m_selections.empty())
{
BufferIterator cursor = iterator_at(m_cursor);
m_buffer.erase(cursor, cursor+1);
2011-09-02 18:51:20 +02:00
}
for (auto& sel : m_selections)
2011-09-02 18:51:20 +02:00
{
m_buffer.erase(sel.begin(), sel.end());
sel = Selection(sel.begin(), sel.begin());
2011-09-02 18:51:20 +02:00
}
2011-09-18 22:09:25 +02:00
if (not m_selections.empty())
m_cursor = line_and_column_at(m_selections.back().last());
m_buffer.end_undo_group();
2011-09-02 18:51:20 +02:00
}
static WindowCoord measure_string(const Window::String& string)
2011-09-02 18:51:20 +02:00
{
WindowCoord result(0, 0);
2011-09-02 18:51:20 +02:00
for (size_t i = 0; i < string.length(); ++i)
{
if (string[i] == '\n')
{
++result.line;
result.column = 0;
}
else
++result.column;
}
return result;
}
void Window::insert(const String& string)
{
m_buffer.begin_undo_group();
2011-09-02 18:51:20 +02:00
if (m_selections.empty())
{
m_buffer.insert(iterator_at(m_cursor), string);
2011-09-02 18:51:20 +02:00
move_cursor(measure_string(string));
}
for (auto& sel : m_selections)
2011-09-02 18:51:20 +02:00
{
m_buffer.insert(sel.begin(), string);
sel.offset(string.length());
2011-09-02 18:51:20 +02:00
}
m_buffer.end_undo_group();
2011-09-02 18:51:20 +02:00
}
void Window::append(const String& string)
{
m_buffer.begin_undo_group();
2011-09-02 18:51:20 +02:00
if (m_selections.empty())
{
move_cursor(WindowCoord(0 , 1));
2011-09-02 18:51:20 +02:00
insert(string);
}
for (auto& sel : m_selections)
2011-09-02 18:51:20 +02:00
{
m_buffer.insert(sel.end(), string);
2011-09-02 18:51:20 +02:00
}
m_buffer.end_undo_group();
}
bool Window::undo()
{
return m_buffer.undo();
}
bool Window::redo()
{
return m_buffer.redo();
2011-09-02 18:51:20 +02:00
}
BufferCoord Window::window_to_buffer(const WindowCoord& window_pos) const
{
return BufferCoord(m_position.line + window_pos.line,
m_position.column + window_pos.column);
}
WindowCoord Window::buffer_to_window(const BufferCoord& buffer_pos) const
{
return WindowCoord(buffer_pos.line - m_position.line,
buffer_pos.column - m_position.column);
}
BufferIterator Window::iterator_at(const WindowCoord& window_pos) const
{
return m_buffer.iterator_at(window_to_buffer(window_pos));
}
WindowCoord Window::line_and_column_at(const BufferIterator& iterator) const
{
return buffer_to_window(m_buffer.line_and_column_at(iterator));
}
2011-09-02 18:51:20 +02:00
void Window::empty_selections()
{
m_selections.clear();
}
void Window::select(bool append, const Selector& selector)
{
if (not append or m_selections.empty())
{
empty_selections();
m_selections.push_back(selector(iterator_at(m_cursor)));
2011-09-02 18:51:20 +02:00
}
else
{
for (auto& sel : m_selections)
2011-09-02 18:51:20 +02:00
{
sel = Selection(sel.first(), selector(sel.last()).last());
2011-09-02 18:51:20 +02:00
}
}
m_cursor = line_and_column_at(m_selections.back().last());
scroll_to_keep_cursor_visible_ifn();
2011-09-02 18:51:20 +02:00
}
void Window::move_cursor(const WindowCoord& offset)
2011-09-02 18:51:20 +02:00
{
2011-09-22 16:00:04 +02:00
move_cursor_to(m_cursor + offset);
}
void Window::move_cursor_to(const WindowCoord& new_pos)
{
BufferCoord target_position = window_to_buffer(new_pos);
m_cursor = buffer_to_window(m_buffer.clamp(target_position));
scroll_to_keep_cursor_visible_ifn();
2011-09-02 18:51:20 +02:00
}
void Window::update_display_buffer()
{
m_display_buffer.clear();
SelectionList sorted_selections = m_selections;
2011-09-02 18:51:20 +02:00
std::sort(sorted_selections.begin(), sorted_selections.end(),
[](const Selection& lhs, const Selection& rhs) { return lhs.begin() < rhs.begin(); });
2011-09-02 18:51:20 +02:00
BufferIterator current_position = m_buffer.iterator_at(m_position);
2011-09-02 18:51:20 +02:00
for (Selection& sel : sorted_selections)
{
if (current_position != sel.begin())
2011-09-02 18:51:20 +02:00
{
DisplayAtom atom;
atom.content = m_buffer.string(current_position, sel.begin());
2011-09-02 18:51:20 +02:00
m_display_buffer.append(atom);
}
if (sel.begin() != sel.end())
2011-09-02 18:51:20 +02:00
{
DisplayAtom atom;
atom.content = m_buffer.string(sel.begin(), sel.end());
2011-09-02 18:51:20 +02:00
atom.attribute = UNDERLINE;
m_display_buffer.append(atom);
}
current_position = sel.end();
2011-09-02 18:51:20 +02:00
}
if (current_position != m_buffer.end())
2011-09-02 18:51:20 +02:00
{
DisplayAtom atom;
atom.content = m_buffer.string(current_position, m_buffer.end());
2011-09-02 18:51:20 +02:00
m_display_buffer.append(atom);
}
}
void Window::set_dimensions(const WindowCoord& dimensions)
{
m_dimensions = dimensions;
}
2011-09-05 20:55:31 +02:00
void Window::scroll_to_keep_cursor_visible_ifn()
{
if (m_cursor.line < 0)
{
m_position.line = std::max(m_position.line + m_cursor.line, 0);
m_cursor.line = 0;
}
else if (m_cursor.line >= m_dimensions.line)
{
m_position.line += m_cursor.line - (m_dimensions.line - 1);
m_cursor.line = m_dimensions.line - 1;
}
if (m_cursor.column < 0)
{
m_position.column = std::max(m_position.column + m_cursor.column, 0);
m_cursor.column = 0;
}
else if (m_cursor.column >= m_dimensions.column)
{
m_position.column += m_cursor.column - (m_dimensions.column - 1);
m_cursor.column = m_dimensions.column - 1;
}
}
IncrementalInserter::IncrementalInserter(Window& window, bool append)
: m_window(window)
{
assert(not m_window.m_current_inserter);
m_window.m_current_inserter = this;
if (m_window.m_selections.empty())
{
WindowCoord pos = m_window.m_cursor;
if (append)
pos += WindowCoord(0, 1);
m_cursors.push_back(pos);
}
else
{
for (auto& sel : m_window.m_selections)
{
const BufferIterator& pos = append ? sel.end() : sel.begin();
m_cursors.push_back(m_window.line_and_column_at(pos));
}
}
m_window.m_buffer.begin_undo_group();
}
IncrementalInserter::~IncrementalInserter()
{
assert(m_window.m_current_inserter == this);
m_window.m_current_inserter = nullptr;
m_window.m_buffer.end_undo_group();
}
void IncrementalInserter::insert(const Window::String& string)
{
for (auto& cursor : m_cursors)
{
m_window.m_buffer.insert(m_window.iterator_at(cursor), string);
move_cursor(measure_string(string));
}
}
void IncrementalInserter::erase()
{
for (auto& cursor : m_cursors)
{
BufferIterator pos = m_window.iterator_at(cursor);
m_window.m_buffer.erase(pos - 1, pos);
move_cursor(WindowCoord(0, -1));
}
}
void IncrementalInserter::move_cursor(const WindowCoord& offset)
{
for (auto& cursor : m_cursors)
{
BufferCoord target = m_window.window_to_buffer(cursor + offset);
cursor = m_window.buffer_to_window(m_window.m_buffer.clamp(target));
}
}
2011-09-02 18:51:20 +02:00
}