1590 lines
50 KiB
C++
1590 lines
50 KiB
C++
/*
|
|
* document.cpp
|
|
* Document model, wrap layout, font loading, and file I/O
|
|
* Copyright (c) 2026 Daniel Hammer
|
|
*/
|
|
|
|
#include "wordprocessor.hpp"
|
|
#include <gui/dialogs.hpp>
|
|
|
|
static inline int wp_min_int(int a, int b) {
|
|
return a < b ? a : b;
|
|
}
|
|
|
|
static void wp_init_run(StyledRun* r, uint8_t font_id, uint8_t size, uint8_t flags) {
|
|
r->cap = 64;
|
|
r->text = (char*)montauk::malloc(r->cap);
|
|
r->text[0] = '\0';
|
|
r->len = 0;
|
|
r->font_id = font_id;
|
|
r->size = size;
|
|
r->flags = flags;
|
|
}
|
|
|
|
static void wp_free_run(StyledRun* r) {
|
|
if (r->text) montauk::mfree(r->text);
|
|
r->text = nullptr;
|
|
r->len = 0;
|
|
r->cap = 0;
|
|
}
|
|
|
|
static void wp_ensure_run_cap(StyledRun* r, int needed) {
|
|
if (r->len + needed <= r->cap) return;
|
|
int new_cap = r->cap * 2;
|
|
if (new_cap < r->len + needed) new_cap = r->len + needed;
|
|
r->text = (char*)montauk::realloc(r->text, new_cap);
|
|
r->cap = new_cap;
|
|
}
|
|
|
|
static bool wp_same_style(const StyledRun* a, uint8_t font_id, uint8_t size, uint8_t flags) {
|
|
return a->font_id == font_id && a->size == size && a->flags == flags;
|
|
}
|
|
|
|
void wp_init_paragraph_style(ParagraphStyle* para) {
|
|
para->align = PARA_ALIGN_LEFT;
|
|
para->list_type = PARA_LIST_NONE;
|
|
para->line_spacing = 100;
|
|
para->_pad = 0;
|
|
para->left_indent = 0;
|
|
para->first_line_indent = 0;
|
|
para->space_before = 0;
|
|
para->space_after = 0;
|
|
}
|
|
|
|
static void wp_font_at(WordProcessorState* wp, int abs_pos,
|
|
TrueTypeFont** out_font, GlyphCache** out_gc) {
|
|
if (wp->run_count <= 0) {
|
|
*out_font = wp_get_font(wp->cur_font_id, wp->cur_flags);
|
|
*out_gc = (*out_font && (*out_font)->valid) ? (*out_font)->get_cache(wp->cur_size) : nullptr;
|
|
return;
|
|
}
|
|
|
|
int r, o;
|
|
wp_pos_to_run(wp, abs_pos, &r, &o);
|
|
if (r >= wp->run_count) r = wp->run_count - 1;
|
|
if (r < 0) r = 0;
|
|
StyledRun* run = &wp->runs[r];
|
|
*out_font = wp_get_font(run->font_id, run->flags);
|
|
*out_gc = (*out_font && (*out_font)->valid) ? (*out_font)->get_cache(run->size) : nullptr;
|
|
}
|
|
|
|
static void wp_free_runs(WordProcessorState* wp) {
|
|
for (int i = 0; i < wp->run_count; i++)
|
|
wp_free_run(&wp->runs[i]);
|
|
wp->run_count = 0;
|
|
wp->total_text_len = 0;
|
|
}
|
|
|
|
static void wp_free_snapshot(UndoSnapshot* snap) {
|
|
if (snap->data) montauk::mfree(snap->data);
|
|
montauk::memset(snap, 0, sizeof(*snap));
|
|
}
|
|
|
|
static void wp_clear_history(WordProcessorState* wp) {
|
|
for (int i = 0; i < wp->undo_count; i++)
|
|
wp_free_snapshot(&wp->undo[i]);
|
|
wp->undo_count = 0;
|
|
wp->undo_pos = 0;
|
|
}
|
|
|
|
static void wp_insert_paragraph_style(WordProcessorState* wp, int at, const ParagraphStyle* style) {
|
|
if (wp->paragraph_count >= WP_MAX_PARAGRAPHS) return;
|
|
if (at < 0) at = 0;
|
|
if (at > wp->paragraph_count) at = wp->paragraph_count;
|
|
for (int i = wp->paragraph_count; i > at; i--)
|
|
wp->paragraphs[i] = wp->paragraphs[i - 1];
|
|
wp->paragraphs[at] = *style;
|
|
wp->paragraph_count++;
|
|
}
|
|
|
|
static void wp_remove_paragraph_style(WordProcessorState* wp, int at) {
|
|
if (wp->paragraph_count <= 1) {
|
|
wp->paragraph_count = 1;
|
|
wp_init_paragraph_style(&wp->paragraphs[0]);
|
|
return;
|
|
}
|
|
if (at < 0 || at >= wp->paragraph_count) return;
|
|
for (int i = at; i < wp->paragraph_count - 1; i++)
|
|
wp->paragraphs[i] = wp->paragraphs[i + 1];
|
|
wp->paragraph_count--;
|
|
}
|
|
|
|
static int wp_count_paragraphs_in_text(WordProcessorState* wp) {
|
|
int count = 1;
|
|
for (int i = 0; i < wp->total_text_len; i++) {
|
|
if (wp_char_at(wp, i) == '\n') {
|
|
count++;
|
|
if (count > WP_MAX_PARAGRAPHS) return WP_MAX_PARAGRAPHS + 1;
|
|
}
|
|
}
|
|
return count;
|
|
}
|
|
|
|
static void wp_sync_paragraph_count(WordProcessorState* wp) {
|
|
int needed = wp_count_paragraphs_in_text(wp);
|
|
if (needed <= 0) needed = 1;
|
|
if (needed > WP_MAX_PARAGRAPHS) needed = WP_MAX_PARAGRAPHS;
|
|
|
|
if (wp->paragraph_count <= 0) {
|
|
wp->paragraph_count = 1;
|
|
wp_init_paragraph_style(&wp->paragraphs[0]);
|
|
}
|
|
|
|
if (wp->paragraph_count < needed) {
|
|
ParagraphStyle style = wp->paragraphs[wp->paragraph_count - 1];
|
|
while (wp->paragraph_count < needed)
|
|
wp_insert_paragraph_style(wp, wp->paragraph_count, &style);
|
|
} else if (wp->paragraph_count > needed) {
|
|
wp->paragraph_count = needed;
|
|
}
|
|
}
|
|
|
|
static void wp_on_insert_newline(WordProcessorState* wp, int abs_pos) {
|
|
if (wp->paragraph_count >= WP_MAX_PARAGRAPHS) return;
|
|
int para = wp_find_paragraph_at(wp, abs_pos);
|
|
if (para < 0) para = 0;
|
|
if (para >= wp->paragraph_count) para = wp->paragraph_count - 1;
|
|
ParagraphStyle style = wp->paragraphs[para];
|
|
wp_insert_paragraph_style(wp, para + 1, &style);
|
|
}
|
|
|
|
static void wp_on_delete_newline(WordProcessorState* wp, int abs_pos) {
|
|
int para = wp_find_paragraph_at(wp, abs_pos);
|
|
if (para + 1 < wp->paragraph_count)
|
|
wp_remove_paragraph_style(wp, para + 1);
|
|
}
|
|
|
|
static void wp_default_line_metrics(WordProcessorState* wp, int abs_pos, int* out_height, int* out_ascent) {
|
|
TrueTypeFont* font = nullptr;
|
|
GlyphCache* gc = nullptr;
|
|
if (wp->total_text_len > 0) {
|
|
int pos = abs_pos;
|
|
if (pos >= wp->total_text_len) pos = wp->total_text_len - 1;
|
|
if (pos < 0) pos = 0;
|
|
wp_font_at(wp, pos, &font, &gc);
|
|
} else {
|
|
font = wp_get_font(wp->cur_font_id, wp->cur_flags);
|
|
gc = (font && font->valid) ? font->get_cache(wp->cur_size) : nullptr;
|
|
}
|
|
|
|
if (gc) {
|
|
*out_height = gc->line_height;
|
|
*out_ascent = gc->ascent;
|
|
} else {
|
|
*out_height = WP_DEFAULT_SIZE;
|
|
*out_ascent = WP_DEFAULT_SIZE;
|
|
}
|
|
}
|
|
|
|
static int wp_char_advance_at(WordProcessorState* wp, int abs_pos, char ch) {
|
|
if (ch == '\n') return 0;
|
|
if (!(ch >= 32 || ch < 0)) return 0;
|
|
|
|
TrueTypeFont* font = nullptr;
|
|
GlyphCache* gc = nullptr;
|
|
wp_font_at(wp, abs_pos, &font, &gc);
|
|
if (!font || !gc) return 8;
|
|
|
|
CachedGlyph* g = font->get_glyph(gc, (unsigned char)ch);
|
|
return g ? g->advance : 8;
|
|
}
|
|
|
|
static void wp_measure_line_range(WordProcessorState* wp, int start, int count,
|
|
int* out_width, int* out_height, int* out_ascent) {
|
|
int width = 0;
|
|
int height = 0;
|
|
int ascent = 0;
|
|
|
|
for (int i = 0; i < count; i++) {
|
|
char ch = wp_char_at(wp, start + i);
|
|
if (ch != '\n')
|
|
width += wp_char_advance_at(wp, start + i, ch);
|
|
|
|
TrueTypeFont* font = nullptr;
|
|
GlyphCache* gc = nullptr;
|
|
wp_font_at(wp, start + i, &font, &gc);
|
|
if (gc) {
|
|
if (gc->line_height > height) height = gc->line_height;
|
|
if (gc->ascent > ascent) ascent = gc->ascent;
|
|
}
|
|
}
|
|
|
|
if (height == 0)
|
|
wp_default_line_metrics(wp, start, &height, &ascent);
|
|
|
|
*out_width = width;
|
|
*out_height = height;
|
|
*out_ascent = ascent;
|
|
}
|
|
|
|
static int wp_line_spacing_advance(int height, int spacing_percent) {
|
|
int advance = (height * spacing_percent + 99) / 100;
|
|
return advance < height ? height : advance;
|
|
}
|
|
|
|
static int wp_effective_text_indent(const ParagraphStyle* para, bool first_line) {
|
|
int indent = para->left_indent;
|
|
if (indent < 0) indent = 0;
|
|
if (first_line && para->list_type == PARA_LIST_NONE)
|
|
indent += para->first_line_indent;
|
|
if (indent < 0) indent = 0;
|
|
return indent;
|
|
}
|
|
|
|
static bool wp_ensure_wrap_capacity(WordProcessorState* wp, int needed) {
|
|
if (needed <= wp->wrap_line_cap && wp->wrap_lines)
|
|
return true;
|
|
|
|
int new_cap = wp->wrap_line_cap > 0 ? wp->wrap_line_cap : 128;
|
|
while (new_cap < needed && new_cap < WP_MAX_WRAP_LINES)
|
|
new_cap *= 2;
|
|
if (new_cap > WP_MAX_WRAP_LINES) new_cap = WP_MAX_WRAP_LINES;
|
|
if (new_cap < needed) return false;
|
|
|
|
void* mem = nullptr;
|
|
if (wp->wrap_lines)
|
|
mem = montauk::realloc(wp->wrap_lines, new_cap * (int)sizeof(WrapLine));
|
|
else
|
|
mem = montauk::malloc(new_cap * (int)sizeof(WrapLine));
|
|
if (!mem) return false;
|
|
|
|
wp->wrap_lines = (WrapLine*)mem;
|
|
wp->wrap_line_cap = new_cap;
|
|
return true;
|
|
}
|
|
|
|
static void wp_merge_adjacent(WordProcessorState* wp) {
|
|
int i = 0;
|
|
while (i < wp->run_count - 1) {
|
|
StyledRun* a = &wp->runs[i];
|
|
StyledRun* b = &wp->runs[i + 1];
|
|
if (a->font_id == b->font_id && a->size == b->size && a->flags == b->flags) {
|
|
int old_a_len = a->len;
|
|
wp_ensure_run_cap(a, b->len);
|
|
montauk::memcpy(a->text + a->len, b->text, b->len);
|
|
a->len += b->len;
|
|
|
|
if (wp->cursor_run == i + 1) {
|
|
wp->cursor_run = i;
|
|
wp->cursor_offset = old_a_len + wp->cursor_offset;
|
|
} else if (wp->cursor_run > i + 1) {
|
|
wp->cursor_run--;
|
|
}
|
|
|
|
wp_free_run(b);
|
|
for (int j = i + 1; j < wp->run_count - 1; j++)
|
|
wp->runs[j] = wp->runs[j + 1];
|
|
wp->run_count--;
|
|
} else {
|
|
i++;
|
|
}
|
|
}
|
|
|
|
i = 0;
|
|
while (i < wp->run_count && wp->run_count > 1) {
|
|
if (wp->runs[i].len == 0) {
|
|
if (wp->cursor_run == i) {
|
|
if (i < wp->run_count - 1) {
|
|
wp->cursor_run = i;
|
|
wp->cursor_offset = 0;
|
|
} else {
|
|
wp->cursor_run = i - 1;
|
|
wp->cursor_offset = wp->runs[i - 1].len;
|
|
}
|
|
} else if (wp->cursor_run > i) {
|
|
wp->cursor_run--;
|
|
}
|
|
wp_free_run(&wp->runs[i]);
|
|
for (int j = i; j < wp->run_count - 1; j++)
|
|
wp->runs[j] = wp->runs[j + 1];
|
|
wp->run_count--;
|
|
} else {
|
|
i++;
|
|
}
|
|
}
|
|
}
|
|
|
|
static int wp_split_at(WordProcessorState* wp, int abs_pos) {
|
|
int r, o;
|
|
wp_pos_to_run(wp, abs_pos, &r, &o);
|
|
if (o == 0) return r;
|
|
if (o >= wp->runs[r].len) return r + 1;
|
|
if (wp->run_count >= WP_MAX_RUNS) return r;
|
|
|
|
StyledRun* src = &wp->runs[r];
|
|
int after_len = src->len - o;
|
|
|
|
StyledRun after;
|
|
wp_init_run(&after, src->font_id, src->size, src->flags);
|
|
wp_ensure_run_cap(&after, after_len);
|
|
montauk::memcpy(after.text, src->text + o, after_len);
|
|
after.len = after_len;
|
|
|
|
src->len = o;
|
|
|
|
for (int i = wp->run_count - 1; i > r; i--)
|
|
wp->runs[i + 1] = wp->runs[i];
|
|
wp->runs[r + 1] = after;
|
|
wp->run_count++;
|
|
|
|
if (wp->cursor_run == r && wp->cursor_offset > o) {
|
|
wp->cursor_run = r + 1;
|
|
wp->cursor_offset -= o;
|
|
} else if (wp->cursor_run > r) {
|
|
wp->cursor_run++;
|
|
}
|
|
|
|
return r + 1;
|
|
}
|
|
|
|
void wp_load_fonts() {
|
|
if (g_wp_fonts.loaded) return;
|
|
|
|
auto load = [](const char* path) -> TrueTypeFont* {
|
|
TrueTypeFont* f = (TrueTypeFont*)montauk::malloc(sizeof(TrueTypeFont));
|
|
montauk::memset(f, 0, sizeof(TrueTypeFont));
|
|
if (!f->init(path)) {
|
|
montauk::mfree(f);
|
|
return nullptr;
|
|
}
|
|
return f;
|
|
};
|
|
|
|
g_wp_fonts.fonts[FONT_ROBOTO][0] = fonts::system_font ? fonts::system_font : load("0:/fonts/Roboto-Medium.ttf");
|
|
g_wp_fonts.fonts[FONT_ROBOTO][1] = fonts::system_bold ? fonts::system_bold : load("0:/fonts/Roboto-Bold.ttf");
|
|
g_wp_fonts.fonts[FONT_ROBOTO][2] = load("0:/fonts/Roboto-Italic.ttf");
|
|
g_wp_fonts.fonts[FONT_ROBOTO][3] = load("0:/fonts/Roboto-BoldItalic.ttf");
|
|
|
|
g_wp_fonts.fonts[FONT_NOTOSERIF][0] = load("0:/fonts/NotoSerif-Regular.ttf");
|
|
g_wp_fonts.fonts[FONT_NOTOSERIF][1] = load("0:/fonts/NotoSerif-SemiBold.ttf");
|
|
g_wp_fonts.fonts[FONT_NOTOSERIF][2] = load("0:/fonts/NotoSerif-Italic.ttf");
|
|
g_wp_fonts.fonts[FONT_NOTOSERIF][3] = load("0:/fonts/NotoSerif-BoldItalic.ttf");
|
|
|
|
g_wp_fonts.fonts[FONT_C059][0] = load("0:/fonts/C059-Roman.ttf");
|
|
g_wp_fonts.fonts[FONT_C059][1] = load("0:/fonts/C059-Bold.ttf");
|
|
g_wp_fonts.fonts[FONT_C059][2] = load("0:/fonts/C059-Italic.ttf");
|
|
g_wp_fonts.fonts[FONT_C059][3] = load("0:/fonts/C059-Bold.ttf");
|
|
|
|
g_ui_font = g_wp_fonts.fonts[FONT_ROBOTO][0];
|
|
g_ui_bold = g_wp_fonts.fonts[FONT_ROBOTO][1] ? g_wp_fonts.fonts[FONT_ROBOTO][1] : g_ui_font;
|
|
g_wp_fonts.loaded = true;
|
|
}
|
|
|
|
TrueTypeFont* wp_get_font(int font_id, uint8_t flags) {
|
|
if (font_id < 0 || font_id >= FONT_COUNT) font_id = 0;
|
|
|
|
int variant = 0;
|
|
if ((flags & STYLE_BOLD) && (flags & STYLE_ITALIC)) variant = 3;
|
|
else if (flags & STYLE_BOLD) variant = 1;
|
|
else if (flags & STYLE_ITALIC) variant = 2;
|
|
|
|
TrueTypeFont* f = g_wp_fonts.fonts[font_id][variant];
|
|
if (f && f->valid) return f;
|
|
|
|
f = g_wp_fonts.fonts[font_id][0];
|
|
if (f && f->valid) return f;
|
|
|
|
return g_ui_font ? g_ui_font : fonts::system_font;
|
|
}
|
|
|
|
void wp_init_empty_document(WordProcessorState* wp) {
|
|
wp_init_run(&wp->runs[0], FONT_ROBOTO, WP_DEFAULT_SIZE, 0);
|
|
wp->run_count = 1;
|
|
wp->total_text_len = 0;
|
|
|
|
wp->cursor_run = 0;
|
|
wp->cursor_offset = 0;
|
|
|
|
wp->sel_anchor = 0;
|
|
wp->sel_end = 0;
|
|
wp->has_selection = false;
|
|
wp->mouse_selecting = false;
|
|
|
|
wp->cur_font_id = FONT_ROBOTO;
|
|
wp->cur_size = WP_DEFAULT_SIZE;
|
|
wp->cur_flags = 0;
|
|
|
|
wp->scrollbar.init(0, 0, WP_SCROLLBAR_W, 100);
|
|
wp->content_height = 0;
|
|
|
|
wp->wrap_lines = nullptr;
|
|
wp->wrap_line_count = 0;
|
|
wp->wrap_line_cap = 0;
|
|
wp->wrap_dirty = true;
|
|
wp->last_wrap_width = 0;
|
|
|
|
wp->paragraph_count = 1;
|
|
wp_init_paragraph_style(&wp->paragraphs[0]);
|
|
|
|
wp->modified = false;
|
|
wp->filepath[0] = '\0';
|
|
wp->filename[0] = '\0';
|
|
|
|
wp->show_pathbar = false;
|
|
wp->pathbar_save_mode = false;
|
|
wp->pathbar_text[0] = '\0';
|
|
wp->pathbar_cursor = 0;
|
|
wp->pathbar_len = 0;
|
|
|
|
wp->font_dropdown_open = false;
|
|
wp->size_dropdown_open = false;
|
|
wp->line_spacing_dropdown_open = false;
|
|
|
|
wp->undo_count = 0;
|
|
wp->undo_pos = 0;
|
|
montauk::memset(wp->undo, 0, sizeof(wp->undo));
|
|
|
|
wp_history_reset(wp);
|
|
}
|
|
|
|
void wp_free_document(WordProcessorState* wp) {
|
|
wp_free_runs(wp);
|
|
if (wp->wrap_lines) {
|
|
montauk::mfree(wp->wrap_lines);
|
|
wp->wrap_lines = nullptr;
|
|
}
|
|
wp->wrap_line_count = 0;
|
|
wp->wrap_line_cap = 0;
|
|
wp_clear_history(wp);
|
|
}
|
|
|
|
int wp_abs_pos(WordProcessorState* wp, int run, int offset) {
|
|
int pos = 0;
|
|
for (int i = 0; i < run && i < wp->run_count; i++)
|
|
pos += wp->runs[i].len;
|
|
pos += offset;
|
|
return pos;
|
|
}
|
|
|
|
void wp_pos_to_run(WordProcessorState* wp, int abs_pos, int* out_run, int* out_offset) {
|
|
if (abs_pos <= 0) {
|
|
*out_run = 0;
|
|
*out_offset = 0;
|
|
return;
|
|
}
|
|
|
|
int pos = 0;
|
|
for (int i = 0; i < wp->run_count; i++) {
|
|
if (pos + wp->runs[i].len >= abs_pos || i == wp->run_count - 1) {
|
|
*out_run = i;
|
|
*out_offset = abs_pos - pos;
|
|
if (*out_offset > wp->runs[i].len) *out_offset = wp->runs[i].len;
|
|
return;
|
|
}
|
|
pos += wp->runs[i].len;
|
|
}
|
|
|
|
*out_run = 0;
|
|
*out_offset = 0;
|
|
}
|
|
|
|
char wp_char_at(WordProcessorState* wp, int abs_pos) {
|
|
int r, o;
|
|
wp_pos_to_run(wp, abs_pos, &r, &o);
|
|
if (r < wp->run_count && o < wp->runs[r].len)
|
|
return wp->runs[r].text[o];
|
|
return '\0';
|
|
}
|
|
|
|
int wp_find_paragraph_at(WordProcessorState* wp, int abs_pos) {
|
|
if (wp->paragraph_count <= 1 || abs_pos <= 0) return 0;
|
|
if (abs_pos > wp->total_text_len) abs_pos = wp->total_text_len;
|
|
|
|
int para = 0;
|
|
for (int i = 0; i < abs_pos && i < wp->total_text_len; i++) {
|
|
if (wp_char_at(wp, i) == '\n') {
|
|
para++;
|
|
if (para >= wp->paragraph_count - 1)
|
|
return wp->paragraph_count - 1;
|
|
}
|
|
}
|
|
return para;
|
|
}
|
|
|
|
void wp_selected_paragraph_range(WordProcessorState* wp, int* out_start_para, int* out_end_para) {
|
|
if (!out_start_para || !out_end_para) return;
|
|
|
|
if (wp->has_selection) {
|
|
int sel_s, sel_e;
|
|
wp_sel_range(wp, &sel_s, &sel_e);
|
|
if (sel_s != sel_e) {
|
|
*out_start_para = wp_find_paragraph_at(wp, sel_s);
|
|
int end_abs = sel_e > 0 ? sel_e - 1 : 0;
|
|
if (end_abs < sel_s) end_abs = sel_s;
|
|
*out_end_para = wp_find_paragraph_at(wp, end_abs);
|
|
return;
|
|
}
|
|
}
|
|
|
|
int abs = wp_abs_pos(wp, wp->cursor_run, wp->cursor_offset);
|
|
*out_start_para = wp_find_paragraph_at(wp, abs);
|
|
*out_end_para = *out_start_para;
|
|
}
|
|
|
|
void wp_insert_char(WordProcessorState* wp, char c) {
|
|
if (wp->total_text_len >= WP_MAX_TEXT - 1) return;
|
|
if (c == '\n' && wp->paragraph_count >= WP_MAX_PARAGRAPHS) return;
|
|
|
|
int insert_abs = wp_abs_pos(wp, wp->cursor_run, wp->cursor_offset);
|
|
|
|
StyledRun* cur = &wp->runs[wp->cursor_run];
|
|
if (wp_same_style(cur, wp->cur_font_id, wp->cur_size, wp->cur_flags)) {
|
|
wp_ensure_run_cap(cur, 1);
|
|
for (int i = cur->len; i > wp->cursor_offset; i--)
|
|
cur->text[i] = cur->text[i - 1];
|
|
cur->text[wp->cursor_offset] = c;
|
|
cur->len++;
|
|
wp->cursor_offset++;
|
|
wp->total_text_len++;
|
|
wp->modified = true;
|
|
wp->wrap_dirty = true;
|
|
if (c == '\n') wp_on_insert_newline(wp, insert_abs);
|
|
return;
|
|
}
|
|
|
|
if (wp->cursor_offset == 0) {
|
|
if (wp->run_count >= WP_MAX_RUNS) return;
|
|
for (int i = wp->run_count; i > wp->cursor_run; i--)
|
|
wp->runs[i] = wp->runs[i - 1];
|
|
wp->run_count++;
|
|
StyledRun* nr = &wp->runs[wp->cursor_run];
|
|
wp_init_run(nr, wp->cur_font_id, wp->cur_size, wp->cur_flags);
|
|
wp_ensure_run_cap(nr, 1);
|
|
nr->text[0] = c;
|
|
nr->len = 1;
|
|
wp->cursor_offset = 1;
|
|
wp->total_text_len++;
|
|
} else if (wp->cursor_offset == cur->len) {
|
|
if (wp->run_count >= WP_MAX_RUNS) return;
|
|
int insert_idx = wp->cursor_run + 1;
|
|
for (int i = wp->run_count; i > insert_idx; i--)
|
|
wp->runs[i] = wp->runs[i - 1];
|
|
wp->run_count++;
|
|
StyledRun* nr = &wp->runs[insert_idx];
|
|
wp_init_run(nr, wp->cur_font_id, wp->cur_size, wp->cur_flags);
|
|
wp_ensure_run_cap(nr, 1);
|
|
nr->text[0] = c;
|
|
nr->len = 1;
|
|
wp->cursor_run = insert_idx;
|
|
wp->cursor_offset = 1;
|
|
wp->total_text_len++;
|
|
} else {
|
|
if (wp->run_count + 2 > WP_MAX_RUNS) return;
|
|
int split_at = wp->cursor_offset;
|
|
int after_len = cur->len - split_at;
|
|
|
|
StyledRun after;
|
|
wp_init_run(&after, cur->font_id, cur->size, cur->flags);
|
|
wp_ensure_run_cap(&after, after_len);
|
|
montauk::memcpy(after.text, cur->text + split_at, after_len);
|
|
after.len = after_len;
|
|
|
|
cur->len = split_at;
|
|
|
|
int new_idx = wp->cursor_run + 1;
|
|
for (int i = wp->run_count - 1; i >= new_idx; i--)
|
|
wp->runs[i + 2] = wp->runs[i];
|
|
|
|
StyledRun* nr = &wp->runs[new_idx];
|
|
wp_init_run(nr, wp->cur_font_id, wp->cur_size, wp->cur_flags);
|
|
wp_ensure_run_cap(nr, 1);
|
|
nr->text[0] = c;
|
|
nr->len = 1;
|
|
|
|
wp->runs[new_idx + 1] = after;
|
|
wp->run_count += 2;
|
|
wp->cursor_run = new_idx;
|
|
wp->cursor_offset = 1;
|
|
wp->total_text_len++;
|
|
}
|
|
|
|
wp->modified = true;
|
|
wp->wrap_dirty = true;
|
|
if (c == '\n') wp_on_insert_newline(wp, insert_abs);
|
|
}
|
|
|
|
void wp_backspace(WordProcessorState* wp) {
|
|
if (wp->cursor_run == 0 && wp->cursor_offset == 0) return;
|
|
|
|
int removed_abs = wp_abs_pos(wp, wp->cursor_run, wp->cursor_offset) - 1;
|
|
char removed = '\0';
|
|
if (removed_abs >= 0)
|
|
removed = wp_char_at(wp, removed_abs);
|
|
|
|
if (wp->cursor_offset > 0) {
|
|
StyledRun* r = &wp->runs[wp->cursor_run];
|
|
for (int i = wp->cursor_offset - 1; i < r->len - 1; i++)
|
|
r->text[i] = r->text[i + 1];
|
|
r->len--;
|
|
wp->cursor_offset--;
|
|
} else {
|
|
wp->cursor_run--;
|
|
StyledRun* r = &wp->runs[wp->cursor_run];
|
|
if (r->len > 0) r->len--;
|
|
wp->cursor_offset = r->len;
|
|
}
|
|
|
|
wp->total_text_len--;
|
|
wp->modified = true;
|
|
wp->wrap_dirty = true;
|
|
if (removed == '\n') wp_on_delete_newline(wp, removed_abs);
|
|
wp_merge_adjacent(wp);
|
|
wp_sync_paragraph_count(wp);
|
|
}
|
|
|
|
void wp_delete_char(WordProcessorState* wp) {
|
|
int abs = wp_abs_pos(wp, wp->cursor_run, wp->cursor_offset);
|
|
if (abs >= wp->total_text_len) return;
|
|
|
|
char removed = wp_char_at(wp, abs);
|
|
|
|
StyledRun* r = &wp->runs[wp->cursor_run];
|
|
if (wp->cursor_offset < r->len) {
|
|
for (int i = wp->cursor_offset; i < r->len - 1; i++)
|
|
r->text[i] = r->text[i + 1];
|
|
r->len--;
|
|
} else if (wp->cursor_run + 1 < wp->run_count) {
|
|
StyledRun* next = &wp->runs[wp->cursor_run + 1];
|
|
if (next->len > 0) {
|
|
for (int i = 0; i < next->len - 1; i++)
|
|
next->text[i] = next->text[i + 1];
|
|
next->len--;
|
|
}
|
|
}
|
|
|
|
wp->total_text_len--;
|
|
wp->modified = true;
|
|
wp->wrap_dirty = true;
|
|
if (removed == '\n') wp_on_delete_newline(wp, abs);
|
|
wp_merge_adjacent(wp);
|
|
wp_sync_paragraph_count(wp);
|
|
}
|
|
|
|
void wp_cursor_left(WordProcessorState* wp) {
|
|
if (wp->cursor_offset > 0) {
|
|
wp->cursor_offset--;
|
|
} else if (wp->cursor_run > 0) {
|
|
wp->cursor_run--;
|
|
wp->cursor_offset = wp->runs[wp->cursor_run].len;
|
|
}
|
|
}
|
|
|
|
void wp_cursor_right(WordProcessorState* wp) {
|
|
if (wp->cursor_offset < wp->runs[wp->cursor_run].len) {
|
|
wp->cursor_offset++;
|
|
} else if (wp->cursor_run + 1 < wp->run_count) {
|
|
wp->cursor_run++;
|
|
wp->cursor_offset = 0;
|
|
}
|
|
}
|
|
|
|
void wp_clear_selection(WordProcessorState* wp) {
|
|
wp->has_selection = false;
|
|
wp->sel_anchor = 0;
|
|
wp->sel_end = 0;
|
|
}
|
|
|
|
void wp_sel_range(WordProcessorState* wp, int* out_start, int* out_end) {
|
|
if (wp->sel_anchor < wp->sel_end) {
|
|
*out_start = wp->sel_anchor;
|
|
*out_end = wp->sel_end;
|
|
} else {
|
|
*out_start = wp->sel_end;
|
|
*out_end = wp->sel_anchor;
|
|
}
|
|
}
|
|
|
|
void wp_start_selection(WordProcessorState* wp) {
|
|
if (!wp->has_selection) {
|
|
wp->sel_anchor = wp_abs_pos(wp, wp->cursor_run, wp->cursor_offset);
|
|
wp->sel_end = wp->sel_anchor;
|
|
wp->has_selection = true;
|
|
}
|
|
}
|
|
|
|
void wp_update_selection_to_cursor(WordProcessorState* wp) {
|
|
wp->sel_end = wp_abs_pos(wp, wp->cursor_run, wp->cursor_offset);
|
|
if (wp->sel_anchor == wp->sel_end) wp->has_selection = false;
|
|
}
|
|
|
|
void wp_apply_style_to_selection(WordProcessorState* wp, int mode, int value) {
|
|
if (!wp->has_selection) return;
|
|
|
|
int sel_s, sel_e;
|
|
wp_sel_range(wp, &sel_s, &sel_e);
|
|
if (sel_s >= sel_e) return;
|
|
|
|
int end_ri = wp_split_at(wp, sel_e);
|
|
int start_ri = wp_split_at(wp, sel_s);
|
|
|
|
{
|
|
int pos = 0;
|
|
end_ri = wp->run_count;
|
|
for (int i = 0; i < wp->run_count; i++) {
|
|
if (pos >= sel_e) {
|
|
end_ri = i;
|
|
break;
|
|
}
|
|
pos += wp->runs[i].len;
|
|
}
|
|
}
|
|
|
|
for (int i = start_ri; i < end_ri && i < wp->run_count; i++) {
|
|
StyledRun* r = &wp->runs[i];
|
|
switch (mode) {
|
|
case 0: r->font_id = (uint8_t)value; break;
|
|
case 1: r->size = (uint8_t)value; break;
|
|
case 2: r->flags ^= STYLE_BOLD; break;
|
|
case 3: r->flags ^= STYLE_ITALIC; break;
|
|
}
|
|
}
|
|
|
|
wp->wrap_dirty = true;
|
|
wp->modified = true;
|
|
wp_merge_adjacent(wp);
|
|
}
|
|
|
|
void wp_apply_alignment(WordProcessorState* wp, uint8_t align) {
|
|
if (align > PARA_ALIGN_RIGHT) align = PARA_ALIGN_LEFT;
|
|
|
|
int para_s, para_e;
|
|
wp_selected_paragraph_range(wp, ¶_s, ¶_e);
|
|
bool changed = false;
|
|
for (int i = para_s; i <= para_e && i < wp->paragraph_count; i++) {
|
|
if (wp->paragraphs[i].align != align) {
|
|
wp->paragraphs[i].align = align;
|
|
changed = true;
|
|
}
|
|
}
|
|
|
|
if (changed) {
|
|
wp->modified = true;
|
|
wp->wrap_dirty = true;
|
|
}
|
|
}
|
|
|
|
void wp_adjust_paragraph_indent(WordProcessorState* wp, int delta) {
|
|
int para_s, para_e;
|
|
wp_selected_paragraph_range(wp, ¶_s, ¶_e);
|
|
bool changed = false;
|
|
for (int i = para_s; i <= para_e && i < wp->paragraph_count; i++) {
|
|
int v = wp->paragraphs[i].left_indent + delta;
|
|
int16_t nv = (int16_t)gui_clamp(v, 0, 240);
|
|
if (wp->paragraphs[i].left_indent != nv) {
|
|
wp->paragraphs[i].left_indent = nv;
|
|
changed = true;
|
|
}
|
|
}
|
|
|
|
if (changed) {
|
|
wp->modified = true;
|
|
wp->wrap_dirty = true;
|
|
}
|
|
}
|
|
|
|
void wp_adjust_paragraph_first_line_indent(WordProcessorState* wp, int delta) {
|
|
int para_s, para_e;
|
|
wp_selected_paragraph_range(wp, ¶_s, ¶_e);
|
|
bool changed = false;
|
|
for (int i = para_s; i <= para_e && i < wp->paragraph_count; i++) {
|
|
int v = wp->paragraphs[i].first_line_indent + delta;
|
|
int16_t nv = (int16_t)gui_clamp(v, -120, 120);
|
|
if (wp->paragraphs[i].first_line_indent != nv) {
|
|
wp->paragraphs[i].first_line_indent = nv;
|
|
changed = true;
|
|
}
|
|
}
|
|
|
|
if (changed) {
|
|
wp->modified = true;
|
|
wp->wrap_dirty = true;
|
|
}
|
|
}
|
|
|
|
void wp_adjust_paragraph_spacing_before(WordProcessorState* wp, int delta) {
|
|
int para_s, para_e;
|
|
wp_selected_paragraph_range(wp, ¶_s, ¶_e);
|
|
bool changed = false;
|
|
for (int i = para_s; i <= para_e && i < wp->paragraph_count; i++) {
|
|
int v = wp->paragraphs[i].space_before + delta;
|
|
int16_t nv = (int16_t)gui_clamp(v, 0, 120);
|
|
if (wp->paragraphs[i].space_before != nv) {
|
|
wp->paragraphs[i].space_before = nv;
|
|
changed = true;
|
|
}
|
|
}
|
|
|
|
if (changed) {
|
|
wp->modified = true;
|
|
wp->wrap_dirty = true;
|
|
}
|
|
}
|
|
|
|
void wp_adjust_paragraph_spacing_after(WordProcessorState* wp, int delta) {
|
|
int para_s, para_e;
|
|
wp_selected_paragraph_range(wp, ¶_s, ¶_e);
|
|
bool changed = false;
|
|
for (int i = para_s; i <= para_e && i < wp->paragraph_count; i++) {
|
|
int v = wp->paragraphs[i].space_after + delta;
|
|
int16_t nv = (int16_t)gui_clamp(v, 0, 120);
|
|
if (wp->paragraphs[i].space_after != nv) {
|
|
wp->paragraphs[i].space_after = nv;
|
|
changed = true;
|
|
}
|
|
}
|
|
|
|
if (changed) {
|
|
wp->modified = true;
|
|
wp->wrap_dirty = true;
|
|
}
|
|
}
|
|
|
|
void wp_set_line_spacing(WordProcessorState* wp, int value) {
|
|
int selected = WP_LINE_SPACING_OPTIONS[0];
|
|
for (int i = 0; i < WP_LINE_SPACING_OPTION_COUNT; i++) {
|
|
if (WP_LINE_SPACING_OPTIONS[i] == value) {
|
|
selected = value;
|
|
break;
|
|
}
|
|
}
|
|
|
|
int para_s, para_e;
|
|
wp_selected_paragraph_range(wp, ¶_s, ¶_e);
|
|
bool changed = false;
|
|
for (int i = para_s; i <= para_e && i < wp->paragraph_count; i++) {
|
|
if (wp->paragraphs[i].line_spacing != selected) {
|
|
wp->paragraphs[i].line_spacing = (uint8_t)selected;
|
|
changed = true;
|
|
}
|
|
}
|
|
|
|
if (changed) {
|
|
wp->modified = true;
|
|
wp->wrap_dirty = true;
|
|
}
|
|
}
|
|
|
|
void wp_cycle_line_spacing(WordProcessorState* wp) {
|
|
int para_s, para_e;
|
|
wp_selected_paragraph_range(wp, ¶_s, ¶_e);
|
|
int current = wp->paragraphs[para_s].line_spacing;
|
|
int next = WP_LINE_SPACING_OPTIONS[0];
|
|
|
|
for (int i = 0; i < WP_LINE_SPACING_OPTION_COUNT; i++) {
|
|
if (WP_LINE_SPACING_OPTIONS[i] == current) {
|
|
next = WP_LINE_SPACING_OPTIONS[(i + 1) % WP_LINE_SPACING_OPTION_COUNT];
|
|
break;
|
|
}
|
|
}
|
|
|
|
wp_set_line_spacing(wp, next);
|
|
}
|
|
|
|
void wp_toggle_list(WordProcessorState* wp, uint8_t list_type) {
|
|
if (list_type != PARA_LIST_BULLET && list_type != PARA_LIST_NUMBER)
|
|
return;
|
|
|
|
int para_s, para_e;
|
|
wp_selected_paragraph_range(wp, ¶_s, ¶_e);
|
|
|
|
bool turn_off = true;
|
|
for (int i = para_s; i <= para_e && i < wp->paragraph_count; i++) {
|
|
if (wp->paragraphs[i].list_type != list_type) {
|
|
turn_off = false;
|
|
break;
|
|
}
|
|
}
|
|
|
|
bool changed = false;
|
|
for (int i = para_s; i <= para_e && i < wp->paragraph_count; i++) {
|
|
ParagraphStyle* para = &wp->paragraphs[i];
|
|
if (turn_off) {
|
|
if (para->list_type != PARA_LIST_NONE) {
|
|
para->list_type = PARA_LIST_NONE;
|
|
changed = true;
|
|
}
|
|
if (para->left_indent == WP_LIST_LEFT && para->first_line_indent == WP_LIST_HANGING) {
|
|
para->left_indent = 0;
|
|
para->first_line_indent = 0;
|
|
changed = true;
|
|
}
|
|
continue;
|
|
}
|
|
|
|
if (para->list_type == PARA_LIST_NONE &&
|
|
para->left_indent == 0 && para->first_line_indent == 0) {
|
|
para->left_indent = WP_LIST_LEFT;
|
|
para->first_line_indent = WP_LIST_HANGING;
|
|
changed = true;
|
|
}
|
|
if (para->list_type != list_type) {
|
|
para->list_type = list_type;
|
|
changed = true;
|
|
}
|
|
}
|
|
|
|
if (changed) {
|
|
wp->modified = true;
|
|
wp->wrap_dirty = true;
|
|
}
|
|
}
|
|
|
|
void wp_delete_selection(WordProcessorState* wp) {
|
|
if (!wp->has_selection) return;
|
|
|
|
int sel_s, sel_e;
|
|
wp_sel_range(wp, &sel_s, &sel_e);
|
|
int count = sel_e - sel_s;
|
|
if (count <= 0) {
|
|
wp_clear_selection(wp);
|
|
return;
|
|
}
|
|
|
|
wp_pos_to_run(wp, sel_s, &wp->cursor_run, &wp->cursor_offset);
|
|
for (int i = 0; i < count; i++)
|
|
wp_delete_char(wp);
|
|
|
|
wp_clear_selection(wp);
|
|
}
|
|
|
|
void wp_recompute_wrap(WordProcessorState* wp, int content_w) {
|
|
int wrap_width = content_w - WP_MARGIN * 2 - WP_SCROLLBAR_W;
|
|
if (wrap_width < 50) wrap_width = 50;
|
|
|
|
if (wrap_width != wp->last_wrap_width) {
|
|
wp->wrap_dirty = true;
|
|
wp->last_wrap_width = wrap_width;
|
|
}
|
|
|
|
if (!wp->wrap_dirty && wp->wrap_lines) return;
|
|
|
|
wp->wrap_line_count = 0;
|
|
if (!wp_ensure_wrap_capacity(wp, 1)) {
|
|
wp->content_height = WP_MARGIN * 2;
|
|
return;
|
|
}
|
|
int y = WP_MARGIN;
|
|
int total = wp->total_text_len;
|
|
int pos = 0;
|
|
int para_idx = 0;
|
|
int list_number = 1;
|
|
|
|
wp_sync_paragraph_count(wp);
|
|
|
|
while (para_idx < wp->paragraph_count && wp->wrap_line_count < WP_MAX_WRAP_LINES) {
|
|
ParagraphStyle* para = &wp->paragraphs[para_idx];
|
|
int para_start = pos;
|
|
int para_content_end = pos;
|
|
bool has_newline = false;
|
|
|
|
while (para_content_end < total) {
|
|
char ch = wp_char_at(wp, para_content_end);
|
|
if (ch == '\n') {
|
|
has_newline = true;
|
|
break;
|
|
}
|
|
para_content_end++;
|
|
}
|
|
|
|
y += para->space_before;
|
|
|
|
bool first_line = true;
|
|
int line_start = para_start;
|
|
while (line_start < para_content_end) {
|
|
if (wp->wrap_line_count >= WP_MAX_WRAP_LINES) break;
|
|
if (!wp_ensure_wrap_capacity(wp, wp->wrap_line_count + 1)) break;
|
|
|
|
int text_indent = wp_effective_text_indent(para, first_line);
|
|
int avail_width = wrap_width - text_indent;
|
|
if (avail_width < 40) avail_width = 40;
|
|
|
|
int scan = line_start;
|
|
int width = 0;
|
|
int last_space = -1;
|
|
int width_at_last_space = 0;
|
|
|
|
while (scan < para_content_end) {
|
|
char ch = wp_char_at(wp, scan);
|
|
int cw = wp_char_advance_at(wp, scan, ch);
|
|
if (width + cw > avail_width && scan > line_start) {
|
|
if (last_space >= line_start) {
|
|
scan = last_space + 1;
|
|
width = width_at_last_space;
|
|
}
|
|
break;
|
|
}
|
|
|
|
width += cw;
|
|
if (ch == ' ') {
|
|
last_space = scan;
|
|
width_at_last_space = width;
|
|
}
|
|
scan++;
|
|
}
|
|
|
|
if (scan == line_start && scan < para_content_end) {
|
|
width += wp_char_advance_at(wp, scan, wp_char_at(wp, scan));
|
|
scan++;
|
|
}
|
|
|
|
int char_count = scan - line_start;
|
|
bool last_visual_line = (scan >= para_content_end);
|
|
if (last_visual_line && has_newline) char_count++;
|
|
|
|
int line_width = 0;
|
|
int line_height = 0;
|
|
int line_ascent = 0;
|
|
wp_measure_line_range(wp, line_start, char_count, &line_width, &line_height, &line_ascent);
|
|
|
|
WrapLine* line = &wp->wrap_lines[wp->wrap_line_count];
|
|
wp_pos_to_run(wp, line_start, &line->run_idx, &line->run_offset);
|
|
line->char_count = char_count;
|
|
line->y = y;
|
|
line->height = line_height;
|
|
line->baseline = line_ascent;
|
|
line->width = line_width;
|
|
line->paragraph_idx = para_idx;
|
|
line->list_number = (first_line && para->list_type == PARA_LIST_NUMBER) ? list_number : 0;
|
|
line->first_in_paragraph = first_line;
|
|
|
|
int extra = wrap_width - text_indent - line_width;
|
|
if (extra < 0) extra = 0;
|
|
int x = WP_MARGIN + text_indent;
|
|
if (para->align == PARA_ALIGN_CENTER) x += extra / 2;
|
|
else if (para->align == PARA_ALIGN_RIGHT) x += extra;
|
|
line->x = x;
|
|
|
|
wp->wrap_line_count++;
|
|
|
|
line_start = scan;
|
|
first_line = false;
|
|
if (!last_visual_line)
|
|
y += wp_line_spacing_advance(line_height, para->line_spacing);
|
|
else
|
|
y += line_height;
|
|
}
|
|
|
|
if (para_start == para_content_end && wp->wrap_line_count < WP_MAX_WRAP_LINES) {
|
|
if (!wp_ensure_wrap_capacity(wp, wp->wrap_line_count + 1)) break;
|
|
WrapLine* line = &wp->wrap_lines[wp->wrap_line_count];
|
|
wp_pos_to_run(wp, para_start, &line->run_idx, &line->run_offset);
|
|
line->char_count = has_newline ? 1 : 0;
|
|
line->y = y;
|
|
wp_default_line_metrics(wp, para_start, &line->height, &line->baseline);
|
|
line->width = 0;
|
|
line->paragraph_idx = para_idx;
|
|
line->list_number = (para->list_type == PARA_LIST_NUMBER) ? list_number : 0;
|
|
line->first_in_paragraph = true;
|
|
|
|
int text_indent = wp_effective_text_indent(para, true);
|
|
int extra = wrap_width - text_indent;
|
|
if (extra < 0) extra = 0;
|
|
int x = WP_MARGIN + text_indent;
|
|
if (para->align == PARA_ALIGN_CENTER) x += extra / 2;
|
|
else if (para->align == PARA_ALIGN_RIGHT) x += extra;
|
|
line->x = x;
|
|
|
|
wp->wrap_line_count++;
|
|
y = line->y + line->height;
|
|
}
|
|
|
|
y += para->space_after;
|
|
|
|
pos = para_content_end;
|
|
if (has_newline) pos++;
|
|
if (para->list_type == PARA_LIST_NUMBER) list_number++;
|
|
else list_number = 1;
|
|
para_idx++;
|
|
}
|
|
|
|
if (wp->wrap_line_count == 0) {
|
|
if (!wp_ensure_wrap_capacity(wp, 1)) {
|
|
wp->content_height = WP_MARGIN * 2;
|
|
return;
|
|
}
|
|
WrapLine* line = &wp->wrap_lines[0];
|
|
line->run_idx = 0;
|
|
line->run_offset = 0;
|
|
line->char_count = 0;
|
|
line->y = WP_MARGIN;
|
|
wp_default_line_metrics(wp, 0, &line->height, &line->baseline);
|
|
line->x = WP_MARGIN;
|
|
line->width = 0;
|
|
line->paragraph_idx = 0;
|
|
line->list_number = 0;
|
|
line->first_in_paragraph = true;
|
|
|
|
wp->wrap_line_count = 1;
|
|
y = WP_MARGIN + line->height;
|
|
}
|
|
|
|
wp->content_height = y + WP_MARGIN;
|
|
wp->wrap_dirty = false;
|
|
}
|
|
|
|
int wp_find_wrap_line(WordProcessorState* wp, int abs_pos) {
|
|
int pos = 0;
|
|
for (int i = 0; i < wp->wrap_line_count; i++) {
|
|
int next_pos = pos + wp->wrap_lines[i].char_count;
|
|
if (abs_pos < next_pos || i == wp->wrap_line_count - 1)
|
|
return i;
|
|
pos = next_pos;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int wp_wrap_line_start(WordProcessorState* wp, int line_idx) {
|
|
int pos = 0;
|
|
for (int i = 0; i < line_idx && i < wp->wrap_line_count; i++)
|
|
pos += wp->wrap_lines[i].char_count;
|
|
return pos;
|
|
}
|
|
|
|
void wp_cursor_up(WordProcessorState* wp) {
|
|
int abs = wp_abs_pos(wp, wp->cursor_run, wp->cursor_offset);
|
|
int line = wp_find_wrap_line(wp, abs);
|
|
if (line <= 0) return;
|
|
|
|
int col = abs - wp_wrap_line_start(wp, line);
|
|
int prev_start = wp_wrap_line_start(wp, line - 1);
|
|
int prev_len = wp->wrap_lines[line - 1].char_count;
|
|
int new_col = col < prev_len ? col : prev_len;
|
|
if (new_col > 0 && new_col == prev_len) {
|
|
char ch = wp_char_at(wp, prev_start + prev_len - 1);
|
|
if (ch == '\n') new_col = prev_len - 1;
|
|
}
|
|
wp_pos_to_run(wp, prev_start + new_col, &wp->cursor_run, &wp->cursor_offset);
|
|
}
|
|
|
|
void wp_cursor_down(WordProcessorState* wp) {
|
|
int abs = wp_abs_pos(wp, wp->cursor_run, wp->cursor_offset);
|
|
int line = wp_find_wrap_line(wp, abs);
|
|
if (line >= wp->wrap_line_count - 1) return;
|
|
|
|
int col = abs - wp_wrap_line_start(wp, line);
|
|
int next_start = wp_wrap_line_start(wp, line + 1);
|
|
int next_len = wp->wrap_lines[line + 1].char_count;
|
|
int new_col = col < next_len ? col : next_len;
|
|
if (new_col > 0 && new_col == next_len && line + 1 < wp->wrap_line_count - 1) {
|
|
char ch = wp_char_at(wp, next_start + next_len - 1);
|
|
if (ch == '\n') new_col = next_len - 1;
|
|
}
|
|
wp_pos_to_run(wp, next_start + new_col, &wp->cursor_run, &wp->cursor_offset);
|
|
}
|
|
|
|
void wp_ensure_cursor_visible(WordProcessorState* wp, int view_h) {
|
|
int abs = wp_abs_pos(wp, wp->cursor_run, wp->cursor_offset);
|
|
int line = wp_find_wrap_line(wp, abs);
|
|
if (line < 0 || line >= wp->wrap_line_count) return;
|
|
|
|
int cy = wp->wrap_lines[line].y;
|
|
int ch = wp->wrap_lines[line].height;
|
|
|
|
if (cy < wp->scrollbar.scroll_offset) {
|
|
wp->scrollbar.scroll_offset = cy - WP_MARGIN;
|
|
if (wp->scrollbar.scroll_offset < 0) wp->scrollbar.scroll_offset = 0;
|
|
}
|
|
if (cy + ch > wp->scrollbar.scroll_offset + view_h) {
|
|
wp->scrollbar.scroll_offset = cy + ch - view_h + WP_MARGIN;
|
|
}
|
|
|
|
int ms = wp->scrollbar.max_scroll();
|
|
if (wp->scrollbar.scroll_offset > ms) wp->scrollbar.scroll_offset = ms;
|
|
if (wp->scrollbar.scroll_offset < 0) wp->scrollbar.scroll_offset = 0;
|
|
}
|
|
|
|
void wp_set_filepath(WordProcessorState* wp, const char* path) {
|
|
montauk::strncpy(wp->filepath, path, 255);
|
|
int last_slash = -1;
|
|
for (int i = 0; path[i]; i++)
|
|
if (path[i] == '/') last_slash = i;
|
|
if (last_slash >= 0)
|
|
montauk::strncpy(wp->filename, path + last_slash + 1, 63);
|
|
else
|
|
montauk::strncpy(wp->filename, path, 63);
|
|
}
|
|
|
|
void wp_start_pathbar(WordProcessorState* wp, bool save_mode, const char* initial_text) {
|
|
if (!initial_text) initial_text = "";
|
|
wp->show_pathbar = true;
|
|
wp->pathbar_save_mode = save_mode;
|
|
montauk::strncpy(wp->pathbar_text, initial_text, 255);
|
|
wp->pathbar_text[255] = '\0';
|
|
wp->pathbar_len = montauk::slen(wp->pathbar_text);
|
|
wp->pathbar_cursor = wp->pathbar_len;
|
|
}
|
|
|
|
void wp_open_save_pathbar(WordProcessorState* wp) {
|
|
char path[256] = {};
|
|
const char* initial_path = wp->filepath[0] ? wp->filepath : "";
|
|
const char* suggested_name = wp->filename[0] ? wp->filename : "document.mwp";
|
|
char msg[160] = {};
|
|
if (dialogs::save_file("Save Document", initial_path, suggested_name, path, sizeof(path), msg, sizeof(msg))) {
|
|
wp_set_filepath(wp, path);
|
|
wp_save_file(wp);
|
|
} else if (msg[0]) {
|
|
wp_start_pathbar(wp, true, initial_path[0] ? initial_path : suggested_name);
|
|
}
|
|
}
|
|
|
|
static int wp_serialized_size(WordProcessorState* wp) {
|
|
int size = 4 + 2 + 1 + 1 + 1 + 2 + 2;
|
|
for (int i = 0; i < wp->run_count; i++)
|
|
size += 2 + 1 + 1 + 1 + 1 + wp->runs[i].len;
|
|
size += wp->paragraph_count * 12;
|
|
return size;
|
|
}
|
|
|
|
static void wp_write_u16(uint8_t* buf, int* off, int value) {
|
|
buf[(*off)++] = (uint8_t)(value & 0xFF);
|
|
buf[(*off)++] = (uint8_t)((value >> 8) & 0xFF);
|
|
}
|
|
|
|
static int wp_read_u16(const uint8_t* buf, int* off) {
|
|
int value = buf[*off] | (buf[*off + 1] << 8);
|
|
*off += 2;
|
|
return value;
|
|
}
|
|
|
|
static bool wp_serialize_document(WordProcessorState* wp, uint8_t** out_buf, int* out_size) {
|
|
int size = wp_serialized_size(wp);
|
|
uint8_t* buf = (uint8_t*)montauk::malloc(size);
|
|
if (!buf) return false;
|
|
|
|
int off = 0;
|
|
buf[off++] = 'M';
|
|
buf[off++] = 'W';
|
|
buf[off++] = 'P';
|
|
buf[off++] = '1';
|
|
buf[off++] = 2;
|
|
buf[off++] = 0;
|
|
buf[off++] = wp->cur_font_id;
|
|
buf[off++] = wp->cur_size;
|
|
buf[off++] = wp->cur_flags;
|
|
wp_write_u16(buf, &off, wp->run_count);
|
|
wp_write_u16(buf, &off, wp->paragraph_count);
|
|
|
|
for (int i = 0; i < wp->run_count; i++) {
|
|
StyledRun* r = &wp->runs[i];
|
|
wp_write_u16(buf, &off, r->len);
|
|
buf[off++] = r->font_id;
|
|
buf[off++] = r->size;
|
|
buf[off++] = r->flags;
|
|
buf[off++] = 0;
|
|
montauk::memcpy(buf + off, r->text, r->len);
|
|
off += r->len;
|
|
}
|
|
|
|
for (int i = 0; i < wp->paragraph_count; i++) {
|
|
ParagraphStyle* para = &wp->paragraphs[i];
|
|
buf[off++] = para->align;
|
|
buf[off++] = para->list_type;
|
|
buf[off++] = para->line_spacing;
|
|
buf[off++] = 0;
|
|
wp_write_u16(buf, &off, (uint16_t)para->left_indent);
|
|
wp_write_u16(buf, &off, (uint16_t)para->first_line_indent);
|
|
wp_write_u16(buf, &off, (uint16_t)para->space_before);
|
|
wp_write_u16(buf, &off, (uint16_t)para->space_after);
|
|
}
|
|
|
|
*out_buf = buf;
|
|
*out_size = off;
|
|
return true;
|
|
}
|
|
|
|
static int wp_count_newlines_in_buf(const uint8_t* text, int len) {
|
|
int count = 1;
|
|
for (int i = 0; i < len; i++) {
|
|
if (text[i] == '\n') {
|
|
count++;
|
|
if (count > WP_MAX_PARAGRAPHS) return WP_MAX_PARAGRAPHS + 1;
|
|
}
|
|
}
|
|
return count;
|
|
}
|
|
|
|
static bool wp_deserialize_document(WordProcessorState* wp, const uint8_t* buf, int size) {
|
|
if (size < 10) return false;
|
|
if (buf[0] != 'M' || buf[1] != 'W' || buf[2] != 'P' || buf[3] != '1')
|
|
return false;
|
|
|
|
uint8_t major = buf[4];
|
|
if (major != 1 && major != 2) return false;
|
|
|
|
if (major == 1) {
|
|
if (size < 10) return false;
|
|
} else {
|
|
if (size < 13) return false;
|
|
}
|
|
|
|
int header_off = 6;
|
|
uint8_t cur_font = buf[header_off++];
|
|
uint8_t cur_size = buf[header_off++];
|
|
uint8_t cur_flags = 0;
|
|
if (major >= 2) cur_flags = buf[header_off++];
|
|
|
|
if (header_off + 2 > size) return false;
|
|
int run_count = buf[header_off] | (buf[header_off + 1] << 8);
|
|
header_off += 2;
|
|
int stored_para_count = 0;
|
|
if (major >= 2) {
|
|
if (header_off + 2 > size) return false;
|
|
stored_para_count = buf[header_off] | (buf[header_off + 1] << 8);
|
|
header_off += 2;
|
|
}
|
|
|
|
if (run_count < 0 || run_count > WP_MAX_RUNS) return false;
|
|
|
|
int off = header_off;
|
|
int actual_para_count = 1;
|
|
for (int i = 0; i < run_count; i++) {
|
|
if (off + 6 > size) return false;
|
|
int text_len = wp_read_u16(buf, &off);
|
|
off += 4;
|
|
if (text_len < 0 || off + text_len > size) return false;
|
|
int para_count = wp_count_newlines_in_buf(buf + off, text_len);
|
|
if (para_count > WP_MAX_PARAGRAPHS) return false;
|
|
actual_para_count += para_count - 1;
|
|
if (actual_para_count > WP_MAX_PARAGRAPHS) return false;
|
|
off += text_len;
|
|
}
|
|
|
|
if (major >= 2) {
|
|
if (stored_para_count <= 0) stored_para_count = actual_para_count;
|
|
if (stored_para_count > WP_MAX_PARAGRAPHS) return false;
|
|
if (off + stored_para_count * 12 > size) return false;
|
|
}
|
|
|
|
wp_free_runs(wp);
|
|
wp->paragraph_count = 1;
|
|
wp_init_paragraph_style(&wp->paragraphs[0]);
|
|
wp->total_text_len = 0;
|
|
|
|
off = header_off;
|
|
for (int i = 0; i < run_count; i++) {
|
|
int text_len = wp_read_u16(buf, &off);
|
|
uint8_t font_id = buf[off++];
|
|
uint8_t run_size = buf[off++];
|
|
uint8_t flags = buf[off++];
|
|
off++;
|
|
|
|
StyledRun* r = &wp->runs[wp->run_count];
|
|
wp_init_run(r, font_id, run_size, flags);
|
|
wp_ensure_run_cap(r, text_len);
|
|
montauk::memcpy(r->text, buf + off, text_len);
|
|
r->len = text_len;
|
|
wp->run_count++;
|
|
wp->total_text_len += text_len;
|
|
off += text_len;
|
|
}
|
|
|
|
if (wp->run_count == 0) {
|
|
wp_init_run(&wp->runs[0], cur_font, cur_size, cur_flags);
|
|
wp->run_count = 1;
|
|
}
|
|
|
|
wp->cur_font_id = cur_font;
|
|
wp->cur_size = cur_size;
|
|
wp->cur_flags = cur_flags;
|
|
|
|
wp->paragraph_count = actual_para_count > 0 ? actual_para_count : 1;
|
|
for (int i = 0; i < wp->paragraph_count; i++)
|
|
wp_init_paragraph_style(&wp->paragraphs[i]);
|
|
|
|
if (major >= 2) {
|
|
int limit = wp_min_int(stored_para_count, wp->paragraph_count);
|
|
for (int i = 0; i < limit; i++) {
|
|
ParagraphStyle* para = &wp->paragraphs[i];
|
|
para->align = buf[off++];
|
|
para->list_type = buf[off++];
|
|
para->line_spacing = buf[off++];
|
|
off++;
|
|
para->left_indent = (int16_t)wp_read_u16(buf, &off);
|
|
para->first_line_indent = (int16_t)wp_read_u16(buf, &off);
|
|
para->space_before = (int16_t)wp_read_u16(buf, &off);
|
|
para->space_after = (int16_t)wp_read_u16(buf, &off);
|
|
|
|
if (para->align > PARA_ALIGN_RIGHT) para->align = PARA_ALIGN_LEFT;
|
|
if (para->list_type > PARA_LIST_NUMBER) para->list_type = PARA_LIST_NONE;
|
|
|
|
bool known_spacing = false;
|
|
for (int j = 0; j < WP_LINE_SPACING_OPTION_COUNT; j++) {
|
|
if (para->line_spacing == WP_LINE_SPACING_OPTIONS[j]) {
|
|
known_spacing = true;
|
|
break;
|
|
}
|
|
}
|
|
if (!known_spacing) para->line_spacing = 100;
|
|
}
|
|
|
|
for (int i = limit; i < stored_para_count; i++)
|
|
off += 12;
|
|
}
|
|
|
|
wp_sync_paragraph_count(wp);
|
|
wp_merge_adjacent(wp);
|
|
wp->cursor_run = 0;
|
|
wp->cursor_offset = 0;
|
|
wp->scrollbar.scroll_offset = 0;
|
|
wp->modified = false;
|
|
wp->wrap_dirty = true;
|
|
wp->sel_anchor = 0;
|
|
wp->sel_end = 0;
|
|
wp->has_selection = false;
|
|
wp->mouse_selecting = false;
|
|
wp->font_dropdown_open = false;
|
|
wp->size_dropdown_open = false;
|
|
wp->line_spacing_dropdown_open = false;
|
|
wp->show_pathbar = false;
|
|
return true;
|
|
}
|
|
|
|
static bool wp_capture_snapshot(WordProcessorState* wp, UndoSnapshot* snap) {
|
|
montauk::memset(snap, 0, sizeof(*snap));
|
|
if (!wp_serialize_document(wp, &snap->data, &snap->size))
|
|
return false;
|
|
|
|
snap->cursor_abs = wp_abs_pos(wp, wp->cursor_run, wp->cursor_offset);
|
|
snap->sel_anchor = wp->sel_anchor;
|
|
snap->sel_end = wp->sel_end;
|
|
snap->has_selection = wp->has_selection;
|
|
snap->modified = wp->modified;
|
|
return true;
|
|
}
|
|
|
|
static bool wp_snapshots_match(const UndoSnapshot* a, const UndoSnapshot* b) {
|
|
if (a->size != b->size) return false;
|
|
if (a->cursor_abs != b->cursor_abs) return false;
|
|
if (a->sel_anchor != b->sel_anchor || a->sel_end != b->sel_end) return false;
|
|
if (a->has_selection != b->has_selection) return false;
|
|
if (a->modified != b->modified) return false;
|
|
if (a->size == 0) return true;
|
|
return memcmp(a->data, b->data, a->size) == 0;
|
|
}
|
|
|
|
static bool wp_restore_snapshot(WordProcessorState* wp, const UndoSnapshot* snap) {
|
|
if (!wp_deserialize_document(wp, snap->data, snap->size))
|
|
return false;
|
|
|
|
int cursor_abs = gui_clamp(snap->cursor_abs, 0, wp->total_text_len);
|
|
wp_pos_to_run(wp, cursor_abs, &wp->cursor_run, &wp->cursor_offset);
|
|
wp->sel_anchor = gui_clamp(snap->sel_anchor, 0, wp->total_text_len);
|
|
wp->sel_end = gui_clamp(snap->sel_end, 0, wp->total_text_len);
|
|
wp->has_selection = snap->has_selection && (wp->sel_anchor != wp->sel_end);
|
|
wp->modified = snap->modified;
|
|
wp->scrollbar.scroll_offset = 0;
|
|
return true;
|
|
}
|
|
|
|
void wp_save_file(WordProcessorState* wp) {
|
|
if (wp->filepath[0] == '\0') {
|
|
wp_open_save_pathbar(wp);
|
|
return;
|
|
}
|
|
|
|
uint8_t* buf = nullptr;
|
|
int off = 0;
|
|
if (!wp_serialize_document(wp, &buf, &off))
|
|
return;
|
|
|
|
int fd = montauk::fcreate(wp->filepath);
|
|
if (fd >= 0) {
|
|
montauk::fwrite(fd, buf, 0, off);
|
|
montauk::close(fd);
|
|
wp_history_mark_saved(wp);
|
|
}
|
|
|
|
montauk::mfree(buf);
|
|
}
|
|
|
|
void wp_load_file(WordProcessorState* wp, const char* path) {
|
|
int fd = montauk::open(path);
|
|
if (fd < 0) return;
|
|
|
|
uint64_t fsize = montauk::getsize(fd);
|
|
if (fsize < 10 || fsize > WP_MAX_TEXT * 2) {
|
|
montauk::close(fd);
|
|
return;
|
|
}
|
|
|
|
uint8_t* buf = (uint8_t*)montauk::malloc((int)fsize);
|
|
montauk::read(fd, buf, 0, fsize);
|
|
montauk::close(fd);
|
|
|
|
if (buf[0] != 'M' || buf[1] != 'W' || buf[2] != 'P' || buf[3] != '1') {
|
|
montauk::mfree(buf);
|
|
return;
|
|
}
|
|
|
|
bool ok = wp_deserialize_document(wp, buf, (int)fsize);
|
|
montauk::mfree(buf);
|
|
if (!ok) return;
|
|
|
|
wp_set_filepath(wp, path);
|
|
wp_history_reset(wp);
|
|
}
|
|
|
|
void wp_history_reset(WordProcessorState* wp) {
|
|
wp_clear_history(wp);
|
|
|
|
UndoSnapshot snap = {};
|
|
if (!wp_capture_snapshot(wp, &snap))
|
|
return;
|
|
|
|
wp->undo[0] = snap;
|
|
wp->undo_count = 1;
|
|
wp->undo_pos = 0;
|
|
}
|
|
|
|
void wp_history_checkpoint(WordProcessorState* wp) {
|
|
UndoSnapshot snap = {};
|
|
if (!wp_capture_snapshot(wp, &snap))
|
|
return;
|
|
|
|
if (wp->undo_count > 0 && wp_snapshots_match(&snap, &wp->undo[wp->undo_pos])) {
|
|
wp_free_snapshot(&snap);
|
|
return;
|
|
}
|
|
|
|
for (int i = wp->undo_pos + 1; i < wp->undo_count; i++)
|
|
wp_free_snapshot(&wp->undo[i]);
|
|
wp->undo_count = wp->undo_pos + 1;
|
|
|
|
if (wp->undo_count >= WP_UNDO_MAX) {
|
|
wp_free_snapshot(&wp->undo[0]);
|
|
for (int i = 1; i < wp->undo_count; i++)
|
|
wp->undo[i - 1] = wp->undo[i];
|
|
montauk::memset(&wp->undo[wp->undo_count - 1], 0, sizeof(UndoSnapshot));
|
|
wp->undo_count--;
|
|
if (wp->undo_pos > 0) wp->undo_pos--;
|
|
}
|
|
|
|
wp->undo[wp->undo_count++] = snap;
|
|
wp->undo_pos = wp->undo_count - 1;
|
|
}
|
|
|
|
void wp_history_mark_saved(WordProcessorState* wp) {
|
|
wp->modified = false;
|
|
if (wp->undo_count <= 0) {
|
|
wp_history_reset(wp);
|
|
return;
|
|
}
|
|
wp->undo[wp->undo_pos].modified = false;
|
|
}
|
|
|
|
bool wp_undo(WordProcessorState* wp) {
|
|
if (wp->undo_count <= 0 || wp->undo_pos <= 0)
|
|
return false;
|
|
|
|
wp->undo_pos--;
|
|
return wp_restore_snapshot(wp, &wp->undo[wp->undo_pos]);
|
|
}
|
|
|
|
bool wp_redo(WordProcessorState* wp) {
|
|
if (wp->undo_count <= 0 || wp->undo_pos >= wp->undo_count - 1)
|
|
return false;
|
|
|
|
wp->undo_pos++;
|
|
return wp_restore_snapshot(wp, &wp->undo[wp->undo_pos]);
|
|
}
|