413 lines
12 KiB
C++
413 lines
12 KiB
C++
#include <cstdint>
|
|
extern "C" {
|
|
#include "../libs/libgrapheme/grapheme.h"
|
|
}
|
|
#include "../include/editor.h"
|
|
#include "../include/utils.h"
|
|
#include <cmath>
|
|
|
|
void scroll_up(Editor *editor, uint32_t number) {
|
|
number++;
|
|
uint32_t numlen =
|
|
2 + static_cast<int>(std::log10(editor->root->line_count + 1));
|
|
uint32_t render_width = editor->size.col - numlen;
|
|
Coord *scroll_queue = (Coord *)malloc(sizeof(Coord) * number);
|
|
uint32_t q_head = 0;
|
|
uint32_t q_size = 0;
|
|
int line_index = editor->scroll.row - number;
|
|
line_index = line_index < 0 ? 0 : line_index;
|
|
LineIterator *it = begin_l_iter(editor->root, line_index);
|
|
if (!it) {
|
|
free(scroll_queue);
|
|
return;
|
|
}
|
|
for (uint32_t i = line_index; i <= editor->scroll.row; i++) {
|
|
uint32_t line_len;
|
|
char *line = next_line(it, &line_len);
|
|
if (!line)
|
|
break;
|
|
if (line[line_len - 1] == '\n')
|
|
--line_len;
|
|
uint32_t offset = 0;
|
|
uint32_t col = 0;
|
|
if (q_size < number) {
|
|
scroll_queue[(q_head + q_size) % number] = {i, 0};
|
|
q_size++;
|
|
} else {
|
|
scroll_queue[q_head] = {i, 0};
|
|
q_head = (q_head + 1) % number;
|
|
}
|
|
if (i == editor->scroll.row && 0 == editor->scroll.col) {
|
|
editor->scroll = scroll_queue[q_head];
|
|
free(line);
|
|
free(it);
|
|
free(scroll_queue);
|
|
return;
|
|
}
|
|
while (offset < line_len) {
|
|
uint32_t inc =
|
|
grapheme_next_character_break_utf8(line + offset, line_len - offset);
|
|
int width = display_width(line + offset, inc);
|
|
if (col + width > render_width) {
|
|
if (q_size < number) {
|
|
scroll_queue[(q_head + q_size) % number] = {i, offset};
|
|
q_size++;
|
|
} else {
|
|
scroll_queue[q_head] = {i, offset};
|
|
q_head = (q_head + 1) % number;
|
|
}
|
|
if (i == editor->scroll.row && offset >= editor->scroll.col) {
|
|
editor->scroll = scroll_queue[q_head];
|
|
free(line);
|
|
free(it);
|
|
free(scroll_queue);
|
|
return;
|
|
}
|
|
col = 0;
|
|
}
|
|
col += width;
|
|
offset += inc;
|
|
}
|
|
free(line);
|
|
}
|
|
editor->scroll = {0, 0};
|
|
free(scroll_queue);
|
|
free(it);
|
|
}
|
|
|
|
void scroll_down(Editor *editor, uint32_t number) {
|
|
if (!editor || number == 0)
|
|
return;
|
|
uint32_t numlen =
|
|
2 + static_cast<int>(std::log10(editor->root->line_count + 1));
|
|
uint32_t render_width = editor->size.col - numlen;
|
|
uint32_t line_index = editor->scroll.row;
|
|
LineIterator *it = begin_l_iter(editor->root, line_index);
|
|
if (!it)
|
|
return;
|
|
const uint32_t max_visual_lines = editor->size.row;
|
|
Coord *scroll_queue = (Coord *)malloc(sizeof(Coord) * max_visual_lines);
|
|
uint32_t q_head = 0;
|
|
uint32_t q_size = 0;
|
|
uint32_t visual_seen = 0;
|
|
bool first_visual_line = true;
|
|
while (true) {
|
|
if (editor->folded[line_index]) {
|
|
if (editor->folded[line_index] == 2) {
|
|
Coord fold_coord = {line_index, 0};
|
|
if (q_size < max_visual_lines) {
|
|
scroll_queue[(q_head + q_size) % max_visual_lines] = fold_coord;
|
|
q_size++;
|
|
} else {
|
|
scroll_queue[q_head] = fold_coord;
|
|
q_head = (q_head + 1) % max_visual_lines;
|
|
}
|
|
visual_seen++;
|
|
if (visual_seen >= number + max_visual_lines) {
|
|
editor->scroll = scroll_queue[q_head];
|
|
break;
|
|
}
|
|
}
|
|
do {
|
|
char *line = next_line(it, nullptr);
|
|
if (!line) {
|
|
free(scroll_queue);
|
|
free(it);
|
|
return;
|
|
}
|
|
free(line);
|
|
line_index++;
|
|
} while (editor->folded[line_index] == 1);
|
|
continue;
|
|
}
|
|
uint32_t line_len;
|
|
char *line = next_line(it, &line_len);
|
|
if (!line)
|
|
break;
|
|
if (line_len && line[line_len - 1] == '\n')
|
|
line_len--;
|
|
uint32_t current_byte_offset = 0;
|
|
if (first_visual_line) {
|
|
current_byte_offset += editor->scroll.col;
|
|
first_visual_line = false;
|
|
}
|
|
while (current_byte_offset < line_len ||
|
|
(line_len == 0 && current_byte_offset == 0)) {
|
|
Coord coord = {line_index, current_byte_offset};
|
|
if (q_size < max_visual_lines) {
|
|
scroll_queue[(q_head + q_size) % max_visual_lines] = coord;
|
|
q_size++;
|
|
} else {
|
|
scroll_queue[q_head] = coord;
|
|
q_head = (q_head + 1) % max_visual_lines;
|
|
}
|
|
visual_seen++;
|
|
if (visual_seen >= number + max_visual_lines) {
|
|
editor->scroll = scroll_queue[q_head];
|
|
free(line);
|
|
free(scroll_queue);
|
|
free(it);
|
|
return;
|
|
}
|
|
uint32_t col = 0;
|
|
uint32_t local_render_offset = 0;
|
|
uint32_t left = line_len - current_byte_offset;
|
|
while (left > 0 && col < render_width) {
|
|
uint32_t cluster_len = grapheme_next_character_break_utf8(
|
|
line + current_byte_offset + local_render_offset, left);
|
|
int width = display_width(
|
|
line + current_byte_offset + local_render_offset, cluster_len);
|
|
if (col + width > render_width)
|
|
break;
|
|
local_render_offset += cluster_len;
|
|
left -= cluster_len;
|
|
col += width;
|
|
}
|
|
current_byte_offset += local_render_offset;
|
|
if (line_len == 0)
|
|
break;
|
|
}
|
|
free(line);
|
|
line_index++;
|
|
}
|
|
if (q_size > 0) {
|
|
uint32_t idx;
|
|
if (q_size < max_visual_lines)
|
|
idx = (q_head + q_size - 1) % max_visual_lines;
|
|
else
|
|
idx = q_head;
|
|
editor->scroll = scroll_queue[idx];
|
|
}
|
|
free(it);
|
|
free(scroll_queue);
|
|
}
|
|
|
|
void ensure_cursor(Editor *editor) {
|
|
std::shared_lock knot_lock(editor->knot_mtx);
|
|
if (editor->cursor < editor->scroll) {
|
|
editor->cursor = editor->scroll;
|
|
return;
|
|
}
|
|
uint32_t numlen =
|
|
2 + static_cast<int>(std::log10(editor->root->line_count + 1));
|
|
uint32_t render_width = editor->size.col - numlen;
|
|
uint32_t visual_rows = 0;
|
|
uint32_t line_index = editor->scroll.row;
|
|
bool first_visual_line = true;
|
|
LineIterator *it = begin_l_iter(editor->root, line_index);
|
|
if (!it)
|
|
return;
|
|
Coord last_visible = editor->scroll;
|
|
while (true) {
|
|
if (visual_rows >= editor->size.row)
|
|
break;
|
|
if (editor->folded[line_index]) {
|
|
if (editor->folded[line_index] == 2) {
|
|
Coord c = {line_index, 0};
|
|
last_visible = c;
|
|
visual_rows++;
|
|
if (line_index == editor->cursor.row) {
|
|
free(it);
|
|
return;
|
|
}
|
|
}
|
|
do {
|
|
char *line = next_line(it, nullptr);
|
|
if (!line)
|
|
break;
|
|
free(line);
|
|
line_index++;
|
|
} while (editor->folded[line_index] == 1);
|
|
continue;
|
|
}
|
|
uint32_t line_len;
|
|
char *line = next_line(it, &line_len);
|
|
if (!line)
|
|
break;
|
|
if (line_len > 0 && line[line_len - 1] == '\n')
|
|
line_len--;
|
|
uint32_t offset = first_visual_line ? editor->scroll.col : 0;
|
|
first_visual_line = false;
|
|
while (offset < line_len || (line_len == 0 && offset == 0)) {
|
|
Coord current = {line_index, offset};
|
|
last_visible = current;
|
|
visual_rows++;
|
|
if (visual_rows >= editor->size.row)
|
|
break;
|
|
uint32_t col = 0;
|
|
uint32_t advance = 0;
|
|
uint32_t left = line_len - offset;
|
|
while (left > 0 && col < render_width) {
|
|
uint32_t g =
|
|
grapheme_next_character_break_utf8(line + offset + advance, left);
|
|
int w = display_width(line + offset + advance, g);
|
|
if (col + w > render_width)
|
|
break;
|
|
advance += g;
|
|
left -= g;
|
|
col += w;
|
|
}
|
|
if (line_index == editor->cursor.row) {
|
|
if (editor->cursor.col >= offset &&
|
|
editor->cursor.col < offset + advance) {
|
|
free(line);
|
|
free(it);
|
|
return;
|
|
}
|
|
}
|
|
if (advance == 0)
|
|
break;
|
|
offset += advance;
|
|
if (line_len == 0)
|
|
break;
|
|
}
|
|
free(line);
|
|
line_index++;
|
|
}
|
|
editor->cursor = last_visible;
|
|
free(it);
|
|
}
|
|
|
|
void ensure_scroll(Editor *editor) {
|
|
std::shared_lock knot_lock(editor->knot_mtx);
|
|
uint32_t numlen =
|
|
2 + static_cast<int>(std::log10(editor->root->line_count + 1));
|
|
uint32_t render_width = editor->size.col - numlen;
|
|
if (editor->cursor < editor->scroll) {
|
|
LineIterator *it = begin_l_iter(editor->root, editor->cursor.row);
|
|
if (!it)
|
|
return;
|
|
uint32_t len;
|
|
char *line = next_line(it, &len);
|
|
if (!line) {
|
|
free(it);
|
|
return;
|
|
}
|
|
if (len > 0 && line[len - 1] == '\n')
|
|
--len;
|
|
uint32_t rows = 1;
|
|
uint32_t cols = 0;
|
|
uint32_t offset = 0;
|
|
uint32_t old_offset = 0;
|
|
while (offset < len) {
|
|
uint32_t inc =
|
|
grapheme_next_character_break_utf8(line + offset, len - offset);
|
|
int width = display_width(line + offset, inc);
|
|
if (cols + width > render_width) {
|
|
rows++;
|
|
cols = 0;
|
|
if (editor->cursor.col > old_offset && editor->cursor.col <= offset) {
|
|
editor->scroll.row = editor->cursor.row;
|
|
editor->scroll.col = old_offset;
|
|
free(line);
|
|
free(it);
|
|
return;
|
|
}
|
|
old_offset = offset;
|
|
}
|
|
cols += width;
|
|
offset += inc;
|
|
}
|
|
free(line);
|
|
free(it);
|
|
editor->scroll.row = editor->cursor.row;
|
|
editor->scroll.col = (editor->cursor.col == 0) ? 0 : old_offset;
|
|
} else {
|
|
uint32_t line_index = editor->scroll.row;
|
|
LineIterator *it = begin_l_iter(editor->root, line_index);
|
|
if (!it)
|
|
return;
|
|
uint32_t max_visual_lines = editor->size.row;
|
|
Coord *scroll_queue = (Coord *)malloc(sizeof(Coord) * max_visual_lines);
|
|
uint32_t q_head = 0;
|
|
uint32_t q_size = 0;
|
|
bool first_visual_line = true;
|
|
while (true) {
|
|
if (editor->folded[line_index]) {
|
|
if (editor->folded[line_index] == 2) {
|
|
Coord fold_coord = {line_index, 0};
|
|
if (q_size < max_visual_lines) {
|
|
scroll_queue[(q_head + q_size) % max_visual_lines] = fold_coord;
|
|
q_size++;
|
|
} else {
|
|
scroll_queue[q_head] = fold_coord;
|
|
q_head = (q_head + 1) % max_visual_lines;
|
|
}
|
|
if (line_index == editor->cursor.row) {
|
|
editor->scroll = scroll_queue[q_head];
|
|
break;
|
|
}
|
|
}
|
|
do {
|
|
char *line = next_line(it, nullptr);
|
|
if (!line)
|
|
break;
|
|
free(line);
|
|
line_index++;
|
|
} while (line_index < editor->size.row &&
|
|
editor->folded[line_index] == 1);
|
|
continue;
|
|
}
|
|
uint32_t line_len;
|
|
char *line = next_line(it, &line_len);
|
|
if (!line)
|
|
break;
|
|
if (line_len > 0 && line[line_len - 1] == '\n')
|
|
line_len--;
|
|
uint32_t current_byte_offset = 0;
|
|
if (first_visual_line) {
|
|
current_byte_offset += editor->scroll.col;
|
|
first_visual_line = false;
|
|
}
|
|
while (current_byte_offset < line_len ||
|
|
(line_len == 0 && current_byte_offset == 0)) {
|
|
Coord current_coord = {line_index, current_byte_offset};
|
|
if (q_size < max_visual_lines) {
|
|
scroll_queue[(q_head + q_size) % max_visual_lines] = current_coord;
|
|
q_size++;
|
|
} else {
|
|
scroll_queue[q_head] = current_coord;
|
|
q_head = (q_head + 1) % max_visual_lines;
|
|
}
|
|
uint32_t col = 0;
|
|
uint32_t local_render_offset = 0;
|
|
uint32_t line_left = line_len - current_byte_offset;
|
|
while (line_left > 0 && col < render_width) {
|
|
uint32_t cluster_len = grapheme_next_character_break_utf8(
|
|
line + current_byte_offset + local_render_offset, line_left);
|
|
int width = display_width(
|
|
line + current_byte_offset + local_render_offset, cluster_len);
|
|
if (col + width > render_width)
|
|
break;
|
|
local_render_offset += cluster_len;
|
|
line_left -= cluster_len;
|
|
col += width;
|
|
}
|
|
if (line_index == editor->cursor.row) {
|
|
bool cursor_found = false;
|
|
if (editor->cursor.col >= current_byte_offset &&
|
|
editor->cursor.col < current_byte_offset + local_render_offset)
|
|
cursor_found = true;
|
|
else if (editor->cursor.col == line_len &&
|
|
current_byte_offset + local_render_offset == line_len)
|
|
cursor_found = true;
|
|
if (cursor_found) {
|
|
editor->scroll = scroll_queue[q_head];
|
|
free(line);
|
|
free(scroll_queue);
|
|
free(it);
|
|
return;
|
|
}
|
|
}
|
|
current_byte_offset += local_render_offset;
|
|
if (line_len == 0)
|
|
break;
|
|
}
|
|
line_index++;
|
|
free(line);
|
|
}
|
|
free(scroll_queue);
|
|
free(it);
|
|
}
|
|
}
|