2011-09-02 20:51:20 +04:00
|
|
|
#include "buffer.hh"
|
2011-09-08 04:11:48 +04:00
|
|
|
|
|
|
|
#include "buffer_manager.hh"
|
2011-09-08 04:13:19 +04:00
|
|
|
#include "window.hh"
|
2011-09-09 23:24:18 +04:00
|
|
|
#include "assert.hh"
|
2011-09-17 18:13:33 +04:00
|
|
|
#include "utils.hh"
|
2011-09-08 04:11:48 +04:00
|
|
|
|
2011-09-02 20:51:20 +04:00
|
|
|
namespace Kakoune
|
|
|
|
{
|
|
|
|
|
|
|
|
template<typename T>
|
|
|
|
T clamp(T min, T max, T val)
|
|
|
|
{
|
|
|
|
if (val < min)
|
|
|
|
return min;
|
|
|
|
if (val > max)
|
|
|
|
return max;
|
|
|
|
return val;
|
|
|
|
}
|
|
|
|
|
2011-10-07 18:15:55 +04:00
|
|
|
Buffer::Buffer(const std::string& name, Type type,
|
|
|
|
const BufferString& initial_content)
|
|
|
|
: m_name(name), m_type(type),
|
|
|
|
m_history(1), m_history_cursor(m_history.begin()),
|
2011-10-05 18:21:24 +04:00
|
|
|
m_content(initial_content), m_last_save_undo_group(m_history.begin())
|
2011-09-02 20:51:20 +04:00
|
|
|
{
|
2011-09-08 04:11:48 +04:00
|
|
|
BufferManager::instance().register_buffer(this);
|
|
|
|
|
2011-09-06 22:33:18 +04:00
|
|
|
compute_lines();
|
2011-09-02 20:51:20 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
void Buffer::erase(const BufferIterator& begin, const BufferIterator& end)
|
2011-09-06 22:49:32 +04:00
|
|
|
{
|
2011-10-17 18:12:15 +04:00
|
|
|
append_modification(BufferModification(BufferModification::Erase,
|
|
|
|
begin, string(begin, end)));
|
2011-09-06 22:49:32 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
void Buffer::insert(const BufferIterator& position, const BufferString& string)
|
|
|
|
{
|
2011-10-17 18:12:15 +04:00
|
|
|
append_modification(BufferModification(BufferModification::Insert, position, string));
|
2011-09-06 22:49:32 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
void Buffer::do_erase(const BufferIterator& begin, const BufferIterator& end)
|
2011-09-02 20:51:20 +04:00
|
|
|
{
|
|
|
|
m_content.erase(begin.m_position, end - begin);
|
|
|
|
compute_lines();
|
|
|
|
}
|
|
|
|
|
2011-09-06 22:49:32 +04:00
|
|
|
void Buffer::do_insert(const BufferIterator& position, const BufferString& string)
|
2011-09-02 20:51:20 +04:00
|
|
|
{
|
|
|
|
m_content.insert(position.m_position, string);
|
|
|
|
compute_lines();
|
|
|
|
}
|
|
|
|
|
2011-09-05 23:06:31 +04:00
|
|
|
BufferIterator Buffer::iterator_at(const BufferCoord& line_and_column) const
|
2011-09-02 20:51:20 +04:00
|
|
|
{
|
|
|
|
if (m_lines.empty())
|
|
|
|
return begin();
|
|
|
|
|
2011-10-19 18:25:13 +04:00
|
|
|
BufferPos line = Kakoune::clamp<int>(0, m_lines.size() - 1, line_and_column.line);
|
|
|
|
int col_max = std::max(0, line_length(line) - 1);
|
|
|
|
BufferPos column = Kakoune::clamp<int>(0, col_max, line_and_column.column);
|
2011-09-02 20:51:20 +04:00
|
|
|
return BufferIterator(*this, m_lines[line] + column);
|
|
|
|
}
|
|
|
|
|
2011-09-05 23:06:31 +04:00
|
|
|
BufferCoord Buffer::line_and_column_at(const BufferIterator& iterator) const
|
2011-09-02 20:51:20 +04:00
|
|
|
{
|
2011-09-05 23:06:31 +04:00
|
|
|
BufferCoord result;
|
2011-09-02 20:51:20 +04:00
|
|
|
if (not m_lines.empty())
|
|
|
|
{
|
|
|
|
result.line = line_at(iterator);
|
|
|
|
result.column = iterator.m_position - m_lines[result.line];
|
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
BufferPos Buffer::line_at(const BufferIterator& iterator) const
|
|
|
|
{
|
|
|
|
for (unsigned i = 0; i < m_lines.size(); ++i)
|
|
|
|
{
|
|
|
|
if (m_lines[i] > iterator.m_position)
|
|
|
|
return i - 1;
|
|
|
|
}
|
|
|
|
return m_lines.size() - 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
BufferSize Buffer::line_length(BufferPos line) const
|
|
|
|
{
|
|
|
|
assert(not m_lines.empty());
|
|
|
|
BufferPos end = (line >= m_lines.size() - 1) ?
|
|
|
|
m_content.size() : m_lines[line + 1] - 1;
|
|
|
|
return end - m_lines[line];
|
|
|
|
}
|
|
|
|
|
2011-09-05 23:06:31 +04:00
|
|
|
BufferCoord Buffer::clamp(const BufferCoord& line_and_column) const
|
2011-09-02 20:51:20 +04:00
|
|
|
{
|
|
|
|
if (m_lines.empty())
|
2011-09-05 23:06:31 +04:00
|
|
|
return BufferCoord();
|
2011-09-02 20:51:20 +04:00
|
|
|
|
2011-09-05 23:06:31 +04:00
|
|
|
BufferCoord result(line_and_column.line, line_and_column.column);
|
2011-09-02 20:51:20 +04:00
|
|
|
result.line = Kakoune::clamp<int>(0, m_lines.size() - 1, result.line);
|
|
|
|
result.column = Kakoune::clamp<int>(0, line_length(result.line), result.column);
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
void Buffer::compute_lines()
|
|
|
|
{
|
|
|
|
m_lines.clear();
|
|
|
|
m_lines.push_back(0);
|
|
|
|
for (BufferPos i = 0; i < m_content.size(); ++i)
|
|
|
|
{
|
|
|
|
if (m_content[i] == '\n')
|
|
|
|
m_lines.push_back(i + 1);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
BufferIterator Buffer::begin() const
|
|
|
|
{
|
|
|
|
return BufferIterator(*this, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
BufferIterator Buffer::end() const
|
|
|
|
{
|
|
|
|
return BufferIterator(*this, length());
|
|
|
|
}
|
|
|
|
|
|
|
|
BufferSize Buffer::length() const
|
|
|
|
{
|
|
|
|
return m_content.size();
|
|
|
|
}
|
|
|
|
|
2011-09-22 17:58:35 +04:00
|
|
|
BufferSize Buffer::line_count() const
|
|
|
|
{
|
|
|
|
return m_lines.size();
|
|
|
|
}
|
|
|
|
|
2011-09-02 20:51:20 +04:00
|
|
|
BufferString Buffer::string(const BufferIterator& begin, const BufferIterator& end) const
|
|
|
|
{
|
|
|
|
return m_content.substr(begin.m_position, end - begin);
|
|
|
|
}
|
|
|
|
|
|
|
|
BufferChar Buffer::at(BufferPos position) const
|
|
|
|
{
|
|
|
|
return m_content[position];
|
|
|
|
}
|
|
|
|
|
2011-09-06 22:49:32 +04:00
|
|
|
void Buffer::begin_undo_group()
|
|
|
|
{
|
|
|
|
assert(m_current_undo_group.empty());
|
|
|
|
m_history.erase(m_history_cursor, m_history.end());
|
|
|
|
m_history_cursor = m_history.end();
|
|
|
|
}
|
|
|
|
|
|
|
|
void Buffer::end_undo_group()
|
|
|
|
{
|
|
|
|
m_history.push_back(m_current_undo_group);
|
|
|
|
m_history_cursor = m_history.end();
|
|
|
|
|
|
|
|
m_current_undo_group.clear();
|
|
|
|
}
|
|
|
|
|
2011-10-17 18:12:15 +04:00
|
|
|
BufferModification BufferModification::inverse() const
|
2011-09-06 22:49:32 +04:00
|
|
|
{
|
2011-10-17 18:12:15 +04:00
|
|
|
Type inverse_type;
|
2011-09-06 22:49:32 +04:00
|
|
|
switch (type)
|
|
|
|
{
|
2011-10-17 18:12:15 +04:00
|
|
|
case Insert: inverse_type = Erase; break;
|
|
|
|
case Erase: inverse_type = Insert; break;
|
2011-09-06 22:49:32 +04:00
|
|
|
default: assert(false);
|
|
|
|
}
|
2011-10-17 18:12:15 +04:00
|
|
|
return BufferModification(inverse_type, position, content);
|
2011-09-06 22:49:32 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
bool Buffer::undo()
|
|
|
|
{
|
|
|
|
if (m_history_cursor == m_history.begin())
|
|
|
|
return false;
|
|
|
|
|
|
|
|
--m_history_cursor;
|
|
|
|
|
2011-10-17 18:12:15 +04:00
|
|
|
for (const BufferModification& modification : reversed(*m_history_cursor))
|
2011-10-18 04:55:45 +04:00
|
|
|
apply_modification(modification.inverse());
|
2011-09-06 22:49:32 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
bool Buffer::redo()
|
|
|
|
{
|
|
|
|
if (m_history_cursor == m_history.end())
|
|
|
|
return false;
|
|
|
|
|
2011-10-17 18:12:15 +04:00
|
|
|
for (const BufferModification& modification : *m_history_cursor)
|
2011-10-18 04:55:45 +04:00
|
|
|
apply_modification(modification);
|
2011-09-06 22:49:32 +04:00
|
|
|
|
|
|
|
++m_history_cursor;
|
|
|
|
}
|
|
|
|
|
2011-10-18 04:55:45 +04:00
|
|
|
void Buffer::apply_modification(const BufferModification& modification)
|
2011-09-06 22:49:32 +04:00
|
|
|
{
|
|
|
|
switch (modification.type)
|
|
|
|
{
|
2011-10-17 18:12:15 +04:00
|
|
|
case BufferModification::Insert:
|
2011-09-06 22:49:32 +04:00
|
|
|
do_insert(modification.position, modification.content);
|
|
|
|
break;
|
2011-10-17 18:12:15 +04:00
|
|
|
case BufferModification::Erase:
|
2011-09-06 22:49:32 +04:00
|
|
|
{
|
|
|
|
BufferIterator begin = modification.position;
|
|
|
|
BufferIterator end = begin + modification.content.size();
|
|
|
|
assert(string(begin, end) == modification.content);
|
|
|
|
do_erase(begin, end);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
default:
|
|
|
|
assert(false);
|
|
|
|
}
|
2011-10-18 04:55:45 +04:00
|
|
|
for (auto listener : m_modification_listeners)
|
|
|
|
listener->on_modification(modification);
|
2011-09-06 22:49:32 +04:00
|
|
|
}
|
|
|
|
|
2011-10-17 18:12:15 +04:00
|
|
|
void Buffer::append_modification(BufferModification&& modification)
|
2011-09-06 22:49:32 +04:00
|
|
|
{
|
2011-10-18 04:55:45 +04:00
|
|
|
apply_modification(modification);
|
2011-10-17 18:12:15 +04:00
|
|
|
m_current_undo_group.push_back(std::move(modification));
|
2011-09-06 22:49:32 +04:00
|
|
|
}
|
|
|
|
|
2011-09-08 18:30:36 +04:00
|
|
|
Window* Buffer::get_or_create_window()
|
2011-09-08 04:13:19 +04:00
|
|
|
{
|
2011-09-08 18:30:36 +04:00
|
|
|
if (m_windows.empty())
|
|
|
|
m_windows.push_front(std::unique_ptr<Window>(new Window(*this)));
|
2011-09-08 04:13:19 +04:00
|
|
|
|
2011-09-08 18:30:36 +04:00
|
|
|
return m_windows.front().get();
|
2011-09-08 04:13:19 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
void Buffer::delete_window(Window* window)
|
|
|
|
{
|
|
|
|
assert(&window->buffer() == this);
|
|
|
|
auto window_it = std::find(m_windows.begin(), m_windows.end(), window);
|
|
|
|
assert(window_it != m_windows.end());
|
|
|
|
m_windows.erase(window_it);
|
|
|
|
}
|
|
|
|
|
2011-10-05 18:21:24 +04:00
|
|
|
bool Buffer::is_modified() const
|
|
|
|
{
|
|
|
|
return m_last_save_undo_group != m_history_cursor
|
|
|
|
or not m_current_undo_group.empty();
|
|
|
|
}
|
|
|
|
|
|
|
|
void Buffer::notify_saved()
|
|
|
|
{
|
|
|
|
m_last_save_undo_group = m_history_cursor;
|
|
|
|
}
|
|
|
|
|
2011-10-18 04:55:45 +04:00
|
|
|
void Buffer::register_modification_listener(BufferModificationListener* listener)
|
|
|
|
{
|
|
|
|
assert(listener);
|
|
|
|
assert(not contains(m_modification_listeners, listener));
|
|
|
|
m_modification_listeners.push_back(listener);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Buffer::unregister_modification_listener(BufferModificationListener* listener)
|
|
|
|
{
|
|
|
|
assert(listener);
|
|
|
|
auto it = std::find(m_modification_listeners.begin(),
|
|
|
|
m_modification_listeners.end(),
|
|
|
|
listener);
|
|
|
|
assert(it != m_modification_listeners.end());
|
|
|
|
m_modification_listeners.erase(it);
|
|
|
|
}
|
|
|
|
|
2011-09-02 20:51:20 +04:00
|
|
|
}
|