1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
|
#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
{
Selection() = default;
Selection(ByteCoord pos) : Selection(pos,pos) {}
Selection(ByteCoord anchor, ByteCoord cursor,
CaptureList captures = {})
: m_anchor{anchor}, m_cursor{cursor},
m_captures(std::move(captures)) {}
void merge_with(const Selection& range);
ByteCoord& anchor() { return m_anchor; }
ByteCoordAndTarget& cursor() { return m_cursor; }
const ByteCoord& anchor() const { return m_anchor; }
const ByteCoordAndTarget& 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 ByteCoord& min() const { return m_anchor < m_cursor ? m_anchor : m_cursor; }
const ByteCoord& max() const { return m_anchor < m_cursor ? m_cursor : m_anchor; }
ByteCoord& min() { return m_anchor < m_cursor ? m_anchor : m_cursor; }
ByteCoord& max() { return m_anchor < m_cursor ? m_cursor : m_anchor; }
private:
ByteCoord m_anchor;
ByteCoordAndTarget 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();
}
enum class InsertMode : unsigned
{
Insert,
InsertCursor,
Append,
Replace,
InsertAtLineBegin,
InsertAtNextLineBegin,
AppendAtLineEnd,
OpenLineBelow,
OpenLineAbove
};
struct SelectionList
{
SelectionList(Buffer& buffer, Selection s);
SelectionList(Buffer& buffer, Selection s, size_t timestamp);
SelectionList(Buffer& buffer, std::vector<Selection> s);
SelectionList(Buffer& buffer, std::vector<Selection> s, size_t timestamp);
void update();
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(); }
void avoid_eol();
void push_back(const Selection& sel) { m_selections.push_back(sel); }
void push_back(Selection&& sel) { m_selections.push_back(std::move(sel)); }
Selection& operator[](size_t i) { return m_selections[i]; }
const Selection& operator[](size_t i) const { return m_selections[i]; }
SelectionList& operator=(std::vector<Selection> list)
{
m_selections = std::move(list);
m_main = size()-1;
sort_and_merge_overlapping();
update_timestamp();
check_invariant();
return *this;
}
using iterator = std::vector<Selection>::iterator;
iterator begin() { return m_selections.begin(); }
iterator end() { return m_selections.end(); }
using const_iterator = std::vector<Selection>::const_iterator;
const_iterator begin() const { return m_selections.begin(); }
const_iterator end() const { return m_selections.end(); }
void remove(size_t index) { m_selections.erase(begin() + index); }
size_t size() const { return m_selections.size(); }
bool operator==(const SelectionList& other) const { return m_buffer == other.m_buffer and m_selections == other.m_selections; }
bool operator!=(const SelectionList& other) const { return !((*this) == other); }
void sort_and_merge_overlapping();
Buffer& buffer() const { return *m_buffer; }
size_t timestamp() const { return m_timestamp; }
void update_timestamp() { m_timestamp = m_buffer->timestamp(); }
void insert(memoryview<String> strings, InsertMode mode,
bool select_inserted = false);
void erase();
private:
size_t m_main = 0;
std::vector<Selection> m_selections;
safe_ptr<Buffer> m_buffer;
size_t m_timestamp;
};
std::vector<Selection> compute_modified_ranges(Buffer& buffer, size_t timestamp);
}
#endif // selection_hh_INCLUDED
|
