1
1
mirror of https://github.com/mawww/kakoune.git synced 2024-12-23 11:32:20 +03:00
kakoune/src/selection.hh

125 lines
3.7 KiB
C++
Raw Normal View History

#ifndef selection_hh_INCLUDED
#define selection_hh_INCLUDED
#include "buffer.hh"
namespace Kakoune
{
using CaptureList = std::vector<String>;
// A selection is a Selection, associated with a CaptureList
struct Selection
{
2014-04-03 01:33:52 +04:00
Selection() = default;
explicit Selection(BufferCoord pos) : Selection(pos,pos) {}
Selection(BufferCoord anchor, BufferCoord cursor,
CaptureList captures = {})
: m_anchor{anchor}, m_cursor{cursor},
m_captures(std::move(captures)) {}
void merge_with(const Selection& range);
BufferCoord& anchor() { return m_anchor; }
BufferCoord& cursor() { return m_cursor; }
const BufferCoord& anchor() const { return m_anchor; }
const BufferCoord& cursor() const { return m_cursor; }
CaptureList& captures() { return m_captures; }
const CaptureList& captures() const { return m_captures; }
bool operator== (const Selection& other) const
{
return m_anchor == other.m_anchor and m_cursor == other.m_cursor;
}
const BufferCoord& min() const { return std::min(m_anchor, m_cursor); }
const BufferCoord& max() const { return std::max(m_anchor, m_cursor); }
private:
BufferCoord m_anchor;
BufferCoord m_cursor;
CaptureList m_captures;
};
inline bool overlaps(const Selection& lhs, const Selection& rhs)
{
return lhs.min() <= rhs.min() ? lhs.max() >= rhs.min()
: lhs.min() <= rhs.max();
}
static bool compare_selections(const Selection& lhs, const Selection& rhs)
{
return lhs.min() < rhs.min();
}
struct SelectionList : std::vector<Selection>
{
2013-06-18 23:43:44 +04:00
SelectionList() = default;
SelectionList(BufferCoord c) : std::vector<Selection>{Selection{c,c}} {}
2013-06-18 23:43:44 +04:00
SelectionList(Selection s) : std::vector<Selection>{s} {}
2013-07-26 02:44:00 +04:00
void update_insert(const Buffer& buffer, BufferCoord begin, BufferCoord end);
void update_erase(const Buffer& buffer, BufferCoord begin, BufferCoord end);
2013-05-03 15:38:48 +04:00
void check_invariant() const;
const Selection& main() const { return (*this)[m_main]; }
Selection& main() { return (*this)[m_main]; }
size_t main_index() const { return m_main; }
void set_main_index(size_t main) { kak_assert(main < size()); m_main = main; }
void rotate_main(int count) { m_main = (m_main + count) % size(); }
template<typename OverlapsFunc>
void merge_overlapping(OverlapsFunc overlaps)
{
kak_assert(std::is_sorted(begin(), end(), compare_selections));
size_t i = 0;
for (size_t j = 1; j < size(); ++j)
{
if (overlaps((*this)[i], (*this)[j]))
{
(*this)[i].merge_with((*this)[j]);
if (i < m_main)
--m_main;
}
else
{
++i;
if (i != j)
(*this)[i] = std::move((*this)[j]);
}
}
erase(begin() + i + 1, end());
kak_assert(std::is_sorted(begin(), end(), compare_selections));
}
void sort_and_merge_overlapping()
{
if (size() == 1)
return;
const auto& main = this->main();
const auto main_begin = main.min();
m_main = std::count_if(begin(), end(), [&](const Selection& sel) {
auto begin = sel.min();
if (begin == main_begin)
return &sel < &main;
else
return begin < main_begin;
});
std::stable_sort(begin(), end(), compare_selections);
merge_overlapping(overlaps);
}
private:
size_t m_main = 0;
};
}
#endif // selection_hh_INCLUDED