374 lines
13 KiB
C++
374 lines
13 KiB
C++
extern "C" {
|
|
#include "../libs/libgrapheme/grapheme.h"
|
|
}
|
|
#include "../include/hover.h"
|
|
#include "../include/ts.h"
|
|
#include "../include/ui.h"
|
|
|
|
void HoverBox::clear() {
|
|
text = "";
|
|
scroll_ = 0;
|
|
is_markup = false;
|
|
box_width = 0;
|
|
box_height = 0;
|
|
cells.clear();
|
|
highlights.clear();
|
|
hover_spans.clear();
|
|
}
|
|
|
|
void HoverBox::scroll(int32_t number) {
|
|
if (text.empty() || number == 0)
|
|
return;
|
|
uint32_t line_count = 0;
|
|
for (uint32_t i = 0; i < text.length(); i++)
|
|
if (text[i] == '\n')
|
|
line_count++;
|
|
scroll_ = MAX((int32_t)scroll_ + number, 0);
|
|
if (scroll_ > line_count)
|
|
scroll_ = line_count;
|
|
render_first(true);
|
|
}
|
|
|
|
void HoverBox::render_first(bool scroll) {
|
|
if (!scroll) {
|
|
std::vector<Span> base_spans;
|
|
std::vector<Span> injected_spans;
|
|
TSSetBase ts = TSSetBase{};
|
|
if (is_markup) {
|
|
highlights.reserve(1024);
|
|
base_spans.reserve(1024);
|
|
injected_spans.reserve(1024);
|
|
hover_spans.reserve(1024);
|
|
std::string query_path = get_exe_dir() + "/../grammar/hover.scm";
|
|
ts.language = LANG(markdown)();
|
|
ts.query = load_query(query_path.c_str(), &ts);
|
|
ts.parser = ts_parser_new();
|
|
ts_parser_set_language(ts.parser, ts.language);
|
|
ts.tree = ts_parser_parse_string(ts.parser, nullptr, text.c_str(),
|
|
text.length());
|
|
TSQueryCursor *cursor = ts_query_cursor_new();
|
|
ts_query_cursor_exec(cursor, ts.query, ts_tree_root_node(ts.tree));
|
|
TSQueryMatch match;
|
|
while (ts_query_cursor_next_match(cursor, &match)) {
|
|
auto subject_fn = [&](const TSNode *node) -> std::string {
|
|
uint32_t start = ts_node_start_byte(*node);
|
|
uint32_t end = ts_node_end_byte(*node);
|
|
return text.substr(start, end - start);
|
|
};
|
|
if (!ts_predicate(ts.query, match, subject_fn))
|
|
continue;
|
|
for (uint32_t i = 0; i < match.capture_count; i++) {
|
|
TSQueryCapture cap = match.captures[i];
|
|
uint32_t start = ts_node_start_byte(cap.node);
|
|
uint32_t end = ts_node_end_byte(cap.node);
|
|
if (Language *inj_lang = safe_get(ts.injection_map, cap.index)) {
|
|
TSSetBase inj_ts = TSSetBase{};
|
|
inj_ts.language = inj_lang->fn();
|
|
inj_ts.query_file =
|
|
get_exe_dir() + "/../grammar/" + inj_lang->name + ".scm";
|
|
inj_ts.query = load_query(inj_ts.query_file.c_str(), &inj_ts);
|
|
inj_ts.parser = ts_parser_new();
|
|
ts_parser_set_language(inj_ts.parser, inj_ts.language);
|
|
TSPoint start_p = ts_node_start_point(cap.node);
|
|
TSPoint end_p = ts_node_end_point(cap.node);
|
|
std::vector<TSRange> ranges = {{start_p, end_p, start, end}};
|
|
ts_parser_set_included_ranges(inj_ts.parser, ranges.data(), 1);
|
|
inj_ts.tree = ts_parser_parse_string(inj_ts.parser, nullptr,
|
|
text.c_str(), text.length());
|
|
TSQueryCursor *inj_cursor = ts_query_cursor_new();
|
|
ts_query_cursor_exec(inj_cursor, inj_ts.query,
|
|
ts_tree_root_node(inj_ts.tree));
|
|
TSQueryMatch inj_match;
|
|
while (ts_query_cursor_next_match(inj_cursor, &inj_match)) {
|
|
auto subject_fn = [&](const TSNode *node) -> std::string {
|
|
uint32_t start = ts_node_start_byte(*node);
|
|
uint32_t end = ts_node_end_byte(*node);
|
|
return text.substr(start, end - start);
|
|
};
|
|
if (!ts_predicate(inj_ts.query, inj_match, subject_fn))
|
|
continue;
|
|
for (uint32_t i = 0; i < inj_match.capture_count; i++) {
|
|
TSQueryCapture inj_cap = inj_match.captures[i];
|
|
uint32_t start = ts_node_start_byte(inj_cap.node);
|
|
uint32_t end = ts_node_end_byte(inj_cap.node);
|
|
if (Highlight *hl = safe_get(inj_ts.query_map, inj_cap.index)) {
|
|
highlights.push_back(*hl);
|
|
Highlight *hl_f = &highlights.back();
|
|
injected_spans.push_back({start, end, hl_f});
|
|
}
|
|
}
|
|
}
|
|
ts_query_cursor_delete(inj_cursor);
|
|
ts_tree_delete(inj_ts.tree);
|
|
ts_parser_delete(inj_ts.parser);
|
|
ts_query_delete(inj_ts.query);
|
|
continue;
|
|
}
|
|
if (Highlight *hl = safe_get(ts.query_map, cap.index)) {
|
|
highlights.push_back(*hl);
|
|
Highlight *hl_f = &highlights.back();
|
|
base_spans.push_back({start, end, hl_f});
|
|
}
|
|
}
|
|
}
|
|
ts_query_cursor_delete(cursor);
|
|
ts_query_delete(ts.query);
|
|
ts_tree_delete(ts.tree);
|
|
ts_parser_delete(ts.parser);
|
|
}
|
|
for (const auto &inj : injected_spans) {
|
|
base_spans.erase(std::remove_if(base_spans.begin(), base_spans.end(),
|
|
[&](const Span &base) {
|
|
return !(base.end <= inj.start ||
|
|
base.start >= inj.end);
|
|
}),
|
|
base_spans.end());
|
|
}
|
|
hover_spans.insert(hover_spans.end(), base_spans.begin(), base_spans.end());
|
|
hover_spans.insert(hover_spans.end(), injected_spans.begin(),
|
|
injected_spans.end());
|
|
std::sort(hover_spans.begin(), hover_spans.end());
|
|
}
|
|
uint32_t longest_line = 0;
|
|
uint32_t current_width = 0;
|
|
for (size_t j = 0; j < text.length(); j++) {
|
|
if (text[j] == '\n') {
|
|
longest_line = std::max(longest_line, current_width);
|
|
current_width = 0;
|
|
} else {
|
|
current_width += 1;
|
|
}
|
|
}
|
|
// HACK: the 1 is added so the longest line doesnt wrap which should be fixed
|
|
// in the loop instead as it was never meant to wrap in the first place
|
|
longest_line = MAX(longest_line, current_width) + 1;
|
|
uint32_t content_width = MIN(longest_line, 130u);
|
|
box_width = content_width + 2;
|
|
size_t i = 0;
|
|
size_t lines_skipped = 0;
|
|
while (i < text.length() && lines_skipped < scroll_) {
|
|
if (text[i] == '\n')
|
|
lines_skipped++;
|
|
i++;
|
|
}
|
|
Spans spans{};
|
|
spans.spans = hover_spans;
|
|
uint32_t border_fg = 0x82AAFF;
|
|
uint32_t base_bg = 0;
|
|
SpanCursor span_cursor(spans);
|
|
span_cursor.sync(i);
|
|
cells.assign(box_width * 26, ScreenCell{" ", 0, 0, 0, 0, 0});
|
|
auto set = [&](uint32_t r, uint32_t c, const char *text, uint32_t fg,
|
|
uint32_t bg, uint8_t flags) {
|
|
cells[r * box_width + c] = {std::string(text), 0, fg, bg, flags, 0};
|
|
};
|
|
uint32_t r = 0;
|
|
while (i < text.length() && r < 24) {
|
|
uint32_t c = 0;
|
|
while (c < content_width && i < text.length()) {
|
|
if (text[i] == '\n') {
|
|
while (i < text.length() && text[i] == '\n')
|
|
i++;
|
|
break;
|
|
}
|
|
uint32_t cluster_len = grapheme_next_character_break_utf8(
|
|
text.c_str() + i, text.length() - i);
|
|
std::string cluster = text.substr(i, cluster_len);
|
|
int width = display_width(cluster.c_str(), cluster_len);
|
|
if (c + width > content_width)
|
|
break;
|
|
Highlight *hl = span_cursor.get_highlight(i);
|
|
uint32_t fg = hl ? hl->fg : 0xFFFFFF;
|
|
uint32_t bg = hl ? hl->bg : 0;
|
|
uint32_t flags = hl ? hl->flags : 0;
|
|
set(r + 1, c + 1, cluster.c_str(), fg, bg | base_bg, flags);
|
|
c += width;
|
|
i += cluster_len;
|
|
for (int w = 1; w < width; w++)
|
|
set(r + 1, c - w + 1, "\x1b", 0xFFFFFF, base_bg, 0);
|
|
}
|
|
r++;
|
|
}
|
|
if (!scroll)
|
|
box_height = r + 2;
|
|
set(0, 0, "┌", border_fg, base_bg, 0);
|
|
for (uint32_t i = 1; i < box_width - 1; i++)
|
|
set(0, i, "─", border_fg, base_bg, 0);
|
|
set(0, box_width - 1, "┐", border_fg, base_bg, 0);
|
|
for (uint32_t r = 1; r < box_height - 1; r++) {
|
|
set(r, 0, "│", border_fg, base_bg, 0);
|
|
set(r, box_width - 1, "│", border_fg, base_bg, 0);
|
|
}
|
|
set(box_height - 1, 0, "└", border_fg, base_bg, 0);
|
|
for (uint32_t i = 1; i < box_width - 1; i++)
|
|
set(box_height - 1, i, "─", border_fg, base_bg, 0);
|
|
set(box_height - 1, box_width - 1, "┘", border_fg, base_bg, 0);
|
|
cells.resize(box_width * box_height);
|
|
}
|
|
|
|
void HoverBox::render(Coord pos) {
|
|
int32_t start_row = (int32_t)pos.row - (int32_t)box_height;
|
|
if (start_row < 0)
|
|
start_row = pos.row + 1;
|
|
int32_t start_col = pos.col;
|
|
if (start_col + box_width > cols) {
|
|
start_col = cols - box_width;
|
|
if (start_col < 0)
|
|
start_col = 0;
|
|
}
|
|
for (uint32_t r = 0; r < box_height; r++)
|
|
for (uint32_t c = 0; c < box_width; c++)
|
|
update(start_row + r, start_col + c, cells[r * box_width + c].utf8,
|
|
cells[r * box_width + c].fg, cells[r * box_width + c].bg,
|
|
cells[r * box_width + c].flags);
|
|
}
|
|
|
|
void DiagnosticBox::clear() {
|
|
warnings.clear();
|
|
cells.clear();
|
|
box_width = 0;
|
|
box_height = 0;
|
|
}
|
|
|
|
void DiagnosticBox::render_first() {
|
|
if (warnings.empty())
|
|
return;
|
|
uint32_t longest_line = 8 + warnings[0].source.length();
|
|
for (auto &warn : warnings) {
|
|
longest_line = MAX(longest_line, (uint32_t)warn.text.length() + 7);
|
|
longest_line = MAX(longest_line, (uint32_t)warn.code.length() + 4);
|
|
for (auto &see_also : warn.see_also)
|
|
longest_line = MAX(longest_line, (uint32_t)see_also.length() + 4);
|
|
}
|
|
uint32_t content_width = MIN(longest_line, 150u);
|
|
box_width = content_width + 2;
|
|
cells.assign(box_width * 25, {" ", 0, 0, 0, 0, 0});
|
|
auto set = [&](uint32_t r, uint32_t c, const char *text, uint32_t fg,
|
|
uint32_t bg, uint8_t flags) {
|
|
cells[r * box_width + c] = {std::string(text), 0, fg, bg, flags, 0};
|
|
};
|
|
uint32_t base_bg = 0;
|
|
uint32_t border_fg = 0x82AAFF;
|
|
uint32_t r = 0;
|
|
if (warnings[0].source != "") {
|
|
std::string src_txt = "Source: ";
|
|
for (uint32_t i = 0; i < src_txt.length() && i < content_width; i++)
|
|
set(1, i + 1, (char[2]){src_txt[i], 0}, 0x3EAAFF, base_bg, 0);
|
|
for (uint32_t i = 0; i < warnings[0].source.length() && i < content_width;
|
|
i++)
|
|
set(1, i + 1 + src_txt.length(), (char[2]){warnings[0].source[i], 0},
|
|
0xffffff, base_bg, 0);
|
|
r++;
|
|
}
|
|
int idx = 1;
|
|
for (auto &warn : warnings) {
|
|
char buf[4];
|
|
std::snprintf(buf, sizeof(buf), "%2d", idx % 100);
|
|
std::string line_txt = std::string(buf) + ". ";
|
|
for (uint32_t i = 0; i < line_txt.length(); i++)
|
|
set(r + 1, i + 1, (char[2]){line_txt[i], 0}, 0xffffff, base_bg, 0);
|
|
if (r >= 23)
|
|
break;
|
|
const char *err_sym = "";
|
|
uint32_t c_sym = 0xAAAAAA;
|
|
switch (warn.type) {
|
|
case 1:
|
|
err_sym = "";
|
|
c_sym = 0xFF0000;
|
|
break;
|
|
case 2:
|
|
err_sym = "";
|
|
c_sym = 0xFFFF00;
|
|
break;
|
|
case 3:
|
|
err_sym = "";
|
|
c_sym = 0xFF00FF;
|
|
break;
|
|
case 4:
|
|
err_sym = "";
|
|
c_sym = 0xAAAAAA;
|
|
break;
|
|
}
|
|
std::string text = warn.text_full + " " + err_sym;
|
|
uint32_t i = 0;
|
|
while (i < text.length() && r < 23) {
|
|
uint32_t c = 4;
|
|
while (c < content_width && i < text.length()) {
|
|
if (text[i] == '\n') {
|
|
while (i < text.length() && text[i] == '\n')
|
|
i++;
|
|
break;
|
|
}
|
|
uint32_t cluster_len = grapheme_next_character_break_utf8(
|
|
text.c_str() + i, text.length() - i);
|
|
std::string cluster = text.substr(i, cluster_len);
|
|
int width = display_width(cluster.c_str(), cluster_len);
|
|
if (c + width > content_width)
|
|
break;
|
|
set(r + 1, c + 1, cluster.c_str(), c_sym, base_bg, 0);
|
|
c += width;
|
|
i += cluster_len;
|
|
for (int w = 1; w < width; w++)
|
|
set(r + 1, c - w + 1, "\x1b", c_sym, base_bg, 0);
|
|
}
|
|
r++;
|
|
}
|
|
if (r >= 23)
|
|
break;
|
|
if (warn.code != "") {
|
|
for (uint32_t i = 0; i < warn.code.length() && i + 5 < content_width; i++)
|
|
set(r + 1, i + 5, (char[2]){warn.code[i], 0}, 0x81cdc6, base_bg, 0);
|
|
r++;
|
|
}
|
|
if (r >= 23)
|
|
break;
|
|
for (std::string &see_also : warn.see_also) {
|
|
uint32_t fg = 0xB55EFF;
|
|
uint8_t colon_count = 0;
|
|
for (uint32_t i = 0; i < see_also.length() && i + 5 < content_width;
|
|
i++) {
|
|
set(r + 1, i + 5, (char[2]){see_also[i], 0}, fg, base_bg, 0);
|
|
if (see_also[i] == ':')
|
|
colon_count++;
|
|
if (colon_count == 2)
|
|
fg = 0xFFFFFF;
|
|
}
|
|
r++;
|
|
if (r >= 23)
|
|
break;
|
|
};
|
|
idx++;
|
|
}
|
|
box_height = 2 + r;
|
|
set(0, 0, "┌", border_fg, base_bg, 0);
|
|
for (uint32_t i = 1; i < box_width - 1; i++)
|
|
set(0, i, "─", border_fg, base_bg, 0);
|
|
set(0, box_width - 1, "┐", border_fg, base_bg, 0);
|
|
for (uint32_t r = 1; r < box_height - 1; r++) {
|
|
set(r, 0, "│", border_fg, base_bg, 0);
|
|
set(r, box_width - 1, "│", border_fg, base_bg, 0);
|
|
}
|
|
set(box_height - 1, 0, "└", border_fg, base_bg, 0);
|
|
for (uint32_t i = 1; i < box_width - 1; i++)
|
|
set(box_height - 1, i, "─", border_fg, base_bg, 0);
|
|
set(box_height - 1, box_width - 1, "┘", border_fg, base_bg, 0);
|
|
cells.resize(box_width * box_height);
|
|
}
|
|
|
|
void DiagnosticBox::render(Coord pos) {
|
|
int32_t start_row = (int32_t)pos.row - (int32_t)box_height;
|
|
if (start_row < 0)
|
|
start_row = pos.row + 1;
|
|
int32_t start_col = pos.col;
|
|
if (start_col + box_width > cols) {
|
|
start_col = cols - box_width;
|
|
if (start_col < 0)
|
|
start_col = 0;
|
|
}
|
|
for (uint32_t r = 0; r < box_height; r++)
|
|
for (uint32_t c = 0; c < box_width; c++)
|
|
update(start_row + r, start_col + c, cells[r * box_width + c].utf8,
|
|
cells[r * box_width + c].fg, cells[r * box_width + c].bg,
|
|
cells[r * box_width + c].flags);
|
|
}
|