GopherProxy

	tRename some functions - ledit - Text editor (WIP)
	git clone git://lumidify.org/ledit.git (fast, but not encrypted)
	git clone https://lumidify.org/git/ledit.git (encrypted, but very slow)
	Log
	Files
	Refs
	README
	LICENSE
	---
	commit f0abd591c8ef4c52c3649aba5b68d460a1c78f47
	parent 9bdc877acf81ae270c68cacad2e70b9860f0832e
	Author: lumidify <[email protected]>
	Date: Mon, 29 Nov 2021 09:19:33 +0100

	Rename some functions

	But it's still very inconsistent.

	Diffstat:
	M buffer.c \| 180 ++++++++++++++++-------------…
	M buffer.h \| 88 ++++++++++++++++-------------…
	M keys_basic.c \| 134 ++++++++++++++++-------------…
	M keys_command.c \| 44 ++++++++++++++++-------------…
	M keys_command.h \| 2 +-
	M ledit.c \| 31 +++++++++++++++++------------…
	M search.c \| 40 ++++++++++++++++-------------…
	M search.h \| 8 ++++----
	M theme.c \| 4 ++--
	M theme.h \| 4 ++--
	M undo.c \| 34 ++++++++++++++++-------------…
	M undo.h \| 26 +++++++++++++-------------
	M util.c \| 6 +++---
	M util.h \| 6 +++---
	M view.c \| 235 ++++++++++++++++-------------…
	M window.c \| 102 ++++++++++++++++-------------…
	M window.h \| 74 ++++++++++++++++-------------…

	17 files changed, 511 insertions(+), 507 deletions(-)
	---
	diff --git a/buffer.c b/buffer.c
	t@@ -86,7 +86,7 @@ marklist_destroy(ledit_buffer_marklist *marklist) {
	}

	void
	-ledit_buffer_insert_mark(ledit_buffer buffer, char mark, size_t len, size_t …
	+buffer_insert_mark(ledit_buffer buffer, char mark, size_t len, size_t line, …
	ledit_buffer_marklist *marklist = buffer->marklist;
	for (size_t i = 0; i < marklist->len; i++) {
	if (!strncmp(mark, marklist->marks[i].text, len)) {
	t@@ -118,10 +118,10 @@ marklist_create(void) {
	}

	ledit_buffer *
	-ledit_buffer_create(ledit_common *common) {
	+buffer_create(ledit_common *common) {
	ledit_buffer *buffer = ledit_malloc(sizeof(ledit_buffer));
	buffer->common = common;
	- buffer->undo = ledit_undo_stack_create();
	+ buffer->undo = undo_stack_create();
	buffer->marklist = marklist_create();

	buffer->filename = NULL;
	t@@ -137,7 +137,7 @@ ledit_buffer_create(ledit_common *common) {
	resize_and_move_line_gap(buffer, 1, 0);
	buffer->lines_num++;
	buffer->lines_gap++;
	- ledit_line *ll = ledit_buffer_get_line(buffer, 0);
	+ ledit_line *ll = buffer_get_line(buffer, 0);
	init_line(buffer, ll);

	return buffer;
	t@@ -146,11 +146,11 @@ ledit_buffer_create(ledit_common *common) {
	static void
	set_view_hard_line_text(ledit_buffer buffer, ledit_view view) {
	char *text = buffer->hard_line_based ? "\|HL" : "\|SL";
	- ledit_window_set_mode_extra_text(view->window, text);
	+ window_set_mode_extra_text(view->window, text);
	}

	void
	-ledit_buffer_set_hard_line_based(ledit_buffer *buffer, int hl) {
	+buffer_set_hard_line_based(ledit_buffer *buffer, int hl) {
	buffer->hard_line_based = hl;
	for (size_t i = 0; i < buffer->views_num; i++) {
	set_view_hard_line_text(buffer, buffer->views[i]);
	t@@ -158,7 +158,7 @@ ledit_buffer_set_hard_line_based(ledit_buffer *buffer, int…
	}

	void
	-ledit_buffer_add_view(ledit_buffer buffer, ledit_theme theme, enum ledit_mod…
	+buffer_add_view(ledit_buffer buffer, ledit_theme theme, enum ledit_mode mode…
	size_t new_num = buffer->views_num + 1;
	if (new_num <= buffer->views_num)
	err_overflow();
	t@@ -170,7 +170,7 @@ ledit_buffer_add_view(ledit_buffer buffer, ledit_theme t…

	/* FIXME: error checking */
	void
	-ledit_buffer_remove_view(ledit_buffer buffer, ledit_view view) {
	+buffer_remove_view(ledit_buffer buffer, ledit_view view) {
	size_t i = 0;
	int found = 0;
	for (; i < buffer->views_num; i++) {
	t@@ -191,7 +191,7 @@ ledit_buffer_remove_view(ledit_buffer *buffer, ledit_view …
	}

	void
	-ledit_buffer_recalc_all_views_from_line(ledit_buffer *buffer, size_t line) {
	+buffer_recalc_all_views_from_line(ledit_buffer *buffer, size_t line) {
	for (size_t i = 0; i < buffer->views_num; i++) {
	view_recalc_from_line(buffer->views[i], line);
	}
	t@@ -200,7 +200,7 @@ ledit_buffer_recalc_all_views_from_line(ledit_buffer *buff…
	/* FIXME: don't generate extra blank line at end! */
	/* WARNING: errstr must be copied as soon as possible! */
	int
	-ledit_buffer_load_file(ledit_buffer buffer, char filename, size_t line, char…
	+buffer_load_file(ledit_buffer buffer, char filename, size_t line, char **err…
	long len;
	int off = 0;
	ledit_line *ll;
	t@@ -214,7 +214,7 @@ ledit_buffer_load_file(ledit_buffer buffer, char filenam…
	if (len < 0) goto errorclose;
	if (fseek(file, 0, SEEK_SET)) goto errorclose;

	- ll = ledit_buffer_get_line(buffer, line);
	+ ll = buffer_get_line(buffer, line);
	file_contents = ledit_malloc(len + 2);
	/* mimic nvi (or at least the openbsd version) - if the line
	is empty, insert directly, otherwise insert after the line */
	t@@ -233,7 +233,7 @@ ledit_buffer_load_file(ledit_buffer buffer, char filenam…
	}
	if (fclose(file)) goto error;

	- ledit_buffer_insert_text_with_newlines(
	+ buffer_insert_text_with_newlines(
	buffer, line, ll->len, file_contents, len + off, NULL, NULL
	);
	free(file_contents);
	t@@ -251,15 +251,15 @@ errorclose:

	/* FIXME: allow to write only certain lines */
	int
	-ledit_buffer_write_to_file(ledit_buffer buffer, char filename, char **errstr…
	+buffer_write_to_file(ledit_buffer buffer, char filename, char **errstr) {
	FILE *file;
	ledit_line *ll;
	file = fopen(filename, "w");
	if (!file) goto error;
	clearerr(file);
	for (size_t i = 0; i < buffer->lines_num; i++) {
	- ll = ledit_buffer_get_line(buffer, i);
	- ledit_buffer_normalize_line(ll);
	+ ll = buffer_get_line(buffer, i);
	+ buffer_normalize_line(ll);
	if (fprintf(file, "%s\n", ll->text) < 0) goto errorclose;
	}
	if (fclose(file)) goto error;
	t@@ -276,13 +276,13 @@ errorclose:
	}

	void
	-ledit_buffer_destroy(ledit_buffer *buffer) {
	+buffer_destroy(ledit_buffer *buffer) {
	ledit_line *l;
	for (size_t i = 0; i < buffer->lines_num; i++) {
	- l = ledit_buffer_get_line(buffer, i);
	+ l = buffer_get_line(buffer, i);
	free(l->text);
	}
	- ledit_undo_stack_destroy(buffer->undo);
	+ undo_stack_destroy(buffer->undo);
	free(buffer->lines);
	if (buffer->filename)
	free(buffer->filename);
	t@@ -291,7 +291,7 @@ ledit_buffer_destroy(ledit_buffer *buffer) {
	}

	void
	-ledit_buffer_normalize_line(ledit_line *line) {
	+buffer_normalize_line(ledit_line *line) {
	if (line->gap < line->len) {
	memmove(
	line->text + line->gap,
	t@@ -308,35 +308,35 @@ ledit_buffer_normalize_line(ledit_line *line) {
	/* FIXME: To simplify this a bit, maybe just copy text to txtbuf first and
	then insert it in one go instead of having this complex logic */
	void
	-ledit_buffer_insert_text_from_line(
	+buffer_insert_text_from_line(
	ledit_buffer *buffer,
	size_t dst_line, size_t dst_index,
	size_t src_line, size_t src_index, size_t src_len,
	txtbuf *text_ret) {
	- ledit_buffer_insert_text_from_line_base(
	+ buffer_insert_text_from_line_base(
	buffer, dst_line, dst_index, src_line, src_index, src_len, text_ret
	);
	- ledit_buffer_recalc_line(buffer, dst_line);
	+ buffer_recalc_line(buffer, dst_line);
	}

	/* FIXME: check if there can be bugs when a newline is inserted in some way
	other than pasting or pressing enter */

	void
	-ledit_buffer_insert_text_from_line_base(
	+buffer_insert_text_from_line_base(
	ledit_buffer *buffer,
	size_t dst_line, size_t dst_index,
	size_t src_line, size_t src_index, size_t src_len,
	txtbuf *text_ret) {
	assert(dst_line != src_line);
	- ledit_line *ll = ledit_buffer_get_line(buffer, src_line);
	+ ledit_line *ll = buffer_get_line(buffer, src_line);
	if (text_ret != NULL) {
	txtbuf_grow(text_ret, src_len);
	text_ret->len = src_len;
	}
	if (src_index >= ll->gap) {
	/* all text to insert is after gap */
	- ledit_buffer_insert_text_base(
	+ buffer_insert_text_base(
	buffer, dst_line, dst_index,
	ll->text + src_index + ll->cap - ll->len, src_len
	);
	t@@ -349,7 +349,7 @@ ledit_buffer_insert_text_from_line_base(
	}
	} else if (ll->gap - src_index >= src_len) {
	/* all text to insert is before gap */
	- ledit_buffer_insert_text_base(
	+ buffer_insert_text_base(
	buffer, dst_line, dst_index,
	ll->text + src_index, src_len
	);
	t@@ -362,12 +362,12 @@ ledit_buffer_insert_text_from_line_base(
	}
	} else {
	/* insert part of text before gap */
	- ledit_buffer_insert_text_base(
	+ buffer_insert_text_base(
	buffer, dst_line, dst_index,
	ll->text + src_index, ll->gap - src_index
	);
	/* insert part of text after gap */
	- ledit_buffer_insert_text_base(
	+ buffer_insert_text_base(
	buffer, dst_line, dst_index + ll->gap - src_index,
	ll->text + ll->gap + ll->cap - ll->len,
	src_len - ll->gap + src_index
	t@@ -436,14 +436,14 @@ resize_and_move_line_gap(ledit_buffer *buffer, size_t mi…
	}

	void
	-ledit_buffer_insert_text(ledit_buffer *buffer, size_t line_index, size_t index…
	- ledit_buffer_insert_text_base(buffer, line_index, index, text, len);
	- ledit_buffer_recalc_line(buffer, line_index);
	+buffer_insert_text(ledit_buffer *buffer, size_t line_index, size_t index, char…
	+ buffer_insert_text_base(buffer, line_index, index, text, len);
	+ buffer_recalc_line(buffer, line_index);
	}

	void
	-ledit_buffer_insert_text_base(ledit_buffer *buffer, size_t line_index, size_t …
	- ledit_line *line = ledit_buffer_get_line(buffer, line_index);
	+buffer_insert_text_base(ledit_buffer *buffer, size_t line_index, size_t index,…
	+ ledit_line *line = buffer_get_line(buffer, line_index);
	/* \0 is not included in line->len */
	/* FIXME: this if should be redundant now because resize_and_move... i…
	if (line->len + len + 1 > line->cap \|\| line->text == NULL)
	t@@ -471,27 +471,27 @@ strchr_len(char *text, char c, size_t len) {

	/* FIXME: make these functions that call recalc* also be final as described ab…
	void
	-ledit_buffer_insert_text_with_newlines(
	+buffer_insert_text_with_newlines(
	ledit_buffer *buffer,
	size_t line_index, size_t index,
	char *text, size_t len,
	size_t end_line_ret, size_t end_byte_ret) {
	size_t end;
	- ledit_buffer_insert_text_with_newlines_base(
	+ buffer_insert_text_with_newlines_base(
	buffer, line_index, index, text, len,
	&end, end_byte_ret
	);
	if (end_line_ret)
	*end_line_ret = end;
	if (line_index == end)
	- ledit_buffer_recalc_line(buffer, line_index);
	+ buffer_recalc_line(buffer, line_index);
	else
	- ledit_buffer_recalc_from_line(buffer, line_index);
	+ buffer_recalc_from_line(buffer, line_index);
	}

	/* FIXME: also look for \r */
	void
	-ledit_buffer_insert_text_with_newlines_base(
	+buffer_insert_text_with_newlines_base(
	ledit_buffer *buffer,
	size_t line_index, size_t index,
	char *text, size_t len,
	t@@ -504,15 +504,15 @@ ledit_buffer_insert_text_with_newlines_base(
	while ((cur = strchr_len(last, '\n', rem_len)) != NULL) {
	/* FIXME: this is probably inefficient, but I don't have time …
	think about it right now */
	- ledit_buffer_append_line_base(buffer, cur_line, cur_index, 1);
	- ledit_buffer_insert_text_base(buffer, cur_line, cur_index, las…
	+ buffer_append_line_base(buffer, cur_line, cur_index, 1);
	+ buffer_insert_text_base(buffer, cur_line, cur_index, last, cur…
	cur_index = 0;
	cur_line++;
	rem_len -= cur - last + 1;
	last = cur + 1;
	}
	/* FIXME: check how legal this casting between pointers and ints is */
	- ledit_buffer_insert_text_base(buffer, cur_line, cur_index, last, text …
	+ buffer_insert_text_base(buffer, cur_line, cur_index, last, text + len …
	if (end_line_ret)
	*end_line_ret = cur_line;
	if (end_byte_ret)
	t@@ -530,14 +530,14 @@ init_line(ledit_buffer buffer, ledit_line line) {
	}

	void
	-ledit_buffer_append_line(ledit_buffer *buffer, size_t line_index, size_t text_…
	- ledit_buffer_append_line_base(buffer, line_index, text_index, break_te…
	- ledit_buffer_recalc_from_line(buffer, line_index);
	+buffer_append_line(ledit_buffer *buffer, size_t line_index, size_t text_index,…
	+ buffer_append_line_base(buffer, line_index, text_index, break_text);
	+ buffer_recalc_from_line(buffer, line_index);
	}

	/* FIXME: error checking (index out of bounds, etc.) */
	void
	-ledit_buffer_append_line_base(ledit_buffer *buffer, size_t line_index, size_t …
	+buffer_append_line_base(ledit_buffer *buffer, size_t line_index, size_t text_i…
	size_t new_len = buffer->lines_num + 1;
	if (new_len <= buffer->lines_num)
	err_overflow();
	t@@ -547,18 +547,18 @@ ledit_buffer_append_line_base(ledit_buffer *buffer, size…
	resize_and_move_line_gap(buffer, new_len, insert_index);
	buffer->lines_num++;
	buffer->lines_gap++;
	- ledit_line *new_l = ledit_buffer_get_line(buffer, line_index + 1);
	+ ledit_line *new_l = buffer_get_line(buffer, line_index + 1);
	init_line(buffer, new_l);
	for (size_t i = 0; i < buffer->views_num; i++) {
	view_notify_append_line(buffer->views[i], line_index);
	}
	if (break_text) {
	- ledit_line *l = ledit_buffer_get_line(buffer, line_index);
	- ledit_buffer_insert_text_from_line_base(
	+ ledit_line *l = buffer_get_line(buffer, line_index);
	+ buffer_insert_text_from_line_base(
	buffer, line_index + 1, 0,
	line_index, text_index, l->len - text_index, NULL
	);
	- ledit_buffer_delete_line_section_base(
	+ buffer_delete_line_section_base(
	buffer, line_index,
	text_index, l->len - text_index
	);
	t@@ -567,20 +567,20 @@ ledit_buffer_append_line_base(ledit_buffer *buffer, size…

	/* FIXME: set offset to 0 when recalculating first line? */
	void
	-ledit_buffer_delete_line_entries(ledit_buffer *buffer, size_t index1, size_t i…
	- ledit_buffer_delete_line_entries_base(buffer, index1, index2);
	- ledit_buffer_recalc_from_line(buffer, index1 > 0 ? index1 - 1 : 0);
	+buffer_delete_line_entries(ledit_buffer *buffer, size_t index1, size_t index2)…
	+ buffer_delete_line_entries_base(buffer, index1, index2);
	+ buffer_recalc_from_line(buffer, index1 > 0 ? index1 - 1 : 0);
	}

	-/* IMPORTANT: ledit_buffer_recalc_from_line needs to be called sometime after …
	+/* IMPORTANT: buffer_recalc_from_line needs to be called sometime after this! …
	void
	-ledit_buffer_delete_line_entries_base(ledit_buffer *buffer, size_t index1, siz…
	+buffer_delete_line_entries_base(ledit_buffer *buffer, size_t index1, size_t in…
	ledit_line *l;
	assert (index2 >= index1);
	/* it isn't allowed to delete all lines */
	assert(index2 - index1 != buffer->lines_num);
	for (size_t i = index1; i <= index2; i++) {
	- l = ledit_buffer_get_line(buffer, i);
	+ l = buffer_get_line(buffer, i);
	free(l->text);
	}
	move_line_gap(buffer, index1);
	t@@ -591,17 +591,17 @@ ledit_buffer_delete_line_entries_base(ledit_buffer *buff…
	}

	void
	-ledit_buffer_delete_line_entry(ledit_buffer *buffer, size_t index) {
	- ledit_buffer_delete_line_entries(buffer, index, index);
	+buffer_delete_line_entry(ledit_buffer *buffer, size_t index) {
	+ buffer_delete_line_entries(buffer, index, index);
	}

	void
	-ledit_buffer_delete_line_entry_base(ledit_buffer *buffer, size_t index) {
	- ledit_buffer_delete_line_entries_base(buffer, index, index);
	+buffer_delete_line_entry_base(ledit_buffer *buffer, size_t index) {
	+ buffer_delete_line_entries_base(buffer, index, index);
	}

	ledit_line *
	-ledit_buffer_get_line(ledit_buffer *buffer, size_t index) {
	+buffer_get_line(ledit_buffer *buffer, size_t index) {
	assert(index < buffer->lines_num);
	return index < buffer->lines_gap ?
	&buffer->lines[index] :
	t@@ -609,38 +609,38 @@ ledit_buffer_get_line(ledit_buffer *buffer, size_t index…
	}

	void
	-ledit_buffer_recalc_line(ledit_buffer *buffer, size_t line) {
	+buffer_recalc_line(ledit_buffer *buffer, size_t line) {
	for (size_t i = 0; i < buffer->views_num; i++) {
	view_recalc_line(buffer->views[i], line);
	}
	}

	void
	-ledit_buffer_recalc_from_line(ledit_buffer *buffer, size_t line) {
	+buffer_recalc_from_line(ledit_buffer *buffer, size_t line) {
	for (size_t i = 0; i < buffer->views_num; i++) {
	view_recalc_from_line(buffer->views[i], line);
	}
	}

	void
	-ledit_buffer_recalc_all_lines(ledit_buffer *buffer) {
	+buffer_recalc_all_lines(ledit_buffer *buffer) {
	for (size_t i = 0; i < buffer->views_num; i++) {
	view_recalc_all_lines(buffer->views[i]);
	}
	}

	size_t
	-ledit_buffer_textlen(ledit_buffer *buffer, size_t line1, size_t byte1, size_t …
	+buffer_textlen(ledit_buffer *buffer, size_t line1, size_t byte1, size_t line2,…
	assert(line1 < line2 \|\| (line1 == line2 && byte1 <= byte2));
	size_t len = 0;
	- ledit_line *ll = ledit_buffer_get_line(buffer, line1);
	+ ledit_line *ll = buffer_get_line(buffer, line1);
	if (line1 == line2) {
	len = byte2 - byte1;
	} else {
	/* + 1 for newline */
	len = ll->len - byte1 + byte2 + 1;
	for (size_t i = line1 + 1; i < line2; i++) {
	- ll = ledit_buffer_get_line(buffer, i);
	+ ll = buffer_get_line(buffer, i);
	len += ll->len + 1;
	}
	}
	t@@ -654,11 +654,11 @@ ledit_buffer_textlen(ledit_buffer *buffer, size_t line1,…
	of pango's requirements). If a more efficient rendering
	backend is added, it would be good to optimize this, though. */
	void
	-ledit_buffer_copy_text(ledit_buffer buffer, char dst, int line1, int byte1, …
	+buffer_copy_text(ledit_buffer buffer, char dst, int line1, int byte1, int li…
	assert(line1 < line2 \|\| (line1 == line2 && byte1 <= byte2));
	- ledit_line *ll1 = ledit_buffer_get_line(buffer, line1);
	- ledit_line *ll2 = ledit_buffer_get_line(buffer, line2);
	- ledit_buffer_normalize_line(ll1);
	+ ledit_line *ll1 = buffer_get_line(buffer, line1);
	+ ledit_line *ll2 = buffer_get_line(buffer, line2);
	+ buffer_normalize_line(ll1);
	if (line1 == line2) {
	memcpy(dst, ll1->text + byte1, byte2 - byte1);
	dst[byte2 - byte1] = '\0';
	t@@ -669,14 +669,14 @@ ledit_buffer_copy_text(ledit_buffer buffer, char dst, …
	dst[cur_pos] = '\n';
	cur_pos++;
	for (int i = line1 + 1; i < line2; i++) {
	- ledit_line *ll = ledit_buffer_get_line(buffer, i);
	- ledit_buffer_normalize_line(ll);
	+ ledit_line *ll = buffer_get_line(buffer, i);
	+ buffer_normalize_line(ll);
	memcpy(dst + cur_pos, ll->text, ll->len);
	cur_pos += ll->len;
	dst[cur_pos] = '\n';
	cur_pos++;
	}
	- ledit_buffer_normalize_line(ll2);
	+ buffer_normalize_line(ll2);
	memcpy(dst + cur_pos, ll2->text, byte2);
	cur_pos += byte2;
	dst[cur_pos] = '\0';
	t@@ -684,15 +684,15 @@ ledit_buffer_copy_text(ledit_buffer buffer, char dst, …
	}

	void
	-ledit_buffer_copy_text_to_txtbuf(
	+buffer_copy_text_to_txtbuf(
	ledit_buffer *buffer,
	txtbuf *buf,
	size_t line1, size_t byte1,
	size_t line2, size_t byte2) {
	assert(line1 < line2 \|\| (line1 == line2 && byte1 <= byte2));
	- size_t len = ledit_buffer_textlen(buffer, line1, byte1, line2, byte2);
	+ size_t len = buffer_textlen(buffer, line1, byte1, line2, byte2);
	txtbuf_grow(buf, len + 1);
	- ledit_buffer_copy_text(buffer, buf->text, line1, byte1, line2, byte2);
	+ buffer_copy_text(buffer, buf->text, line1, byte1, line2, byte2);
	buf->len = len;
	}

	t@@ -700,7 +700,7 @@ ledit_buffer_copy_text_to_txtbuf(
	#define LINE_CHAR(line, i) ((i) < (line)->gap ? (line)->text[i] : (line)->text…

	size_t
	-ledit_line_prev_utf8(ledit_line *line, size_t index) {
	+line_prev_utf8(ledit_line *line, size_t index) {
	if (index <= 0)
	return 0;
	size_t i = index - 1;
	t@@ -712,7 +712,7 @@ ledit_line_prev_utf8(ledit_line *line, size_t index) {
	}

	size_t
	-ledit_line_next_utf8(ledit_line *line, size_t index) {
	+line_next_utf8(ledit_line *line, size_t index) {
	if (index >= line->len)
	return line->len;
	size_t i = index + 1;
	t@@ -731,14 +731,14 @@ line_byte_to_char(ledit_line *line, size_t byte) {
	size_t b = byte > line->len ? line->len : byte; /* maybe not necessary…
	while (i < b) {
	c++;
	- i = ledit_line_next_utf8(line, i);
	+ i = line_next_utf8(line, i);
	}
	return c;
	}

	void
	-ledit_buffer_delete_line_section_base(ledit_buffer *buffer, size_t line, size_…
	- ledit_line *l = ledit_buffer_get_line(buffer, line);
	+buffer_delete_line_section_base(ledit_buffer *buffer, size_t line, size_t star…
	+ ledit_line *l = buffer_get_line(buffer, line);
	if (start <= l->gap && start + length >= l->gap) {
	l->gap = start;
	} else if (start < l->gap && start + length < l->gap) {
	t@@ -762,23 +762,23 @@ ledit_buffer_delete_line_section_base(ledit_buffer *buff…
	}

	size_t
	-ledit_buffer_delete_unicode_char(ledit_buffer *buffer, size_t line_index, size…
	- size_t new_index = ledit_buffer_delete_unicode_char_base(buffer, line_…
	- ledit_buffer_recalc_line(buffer, line_index);
	+buffer_delete_unicode_char(ledit_buffer *buffer, size_t line_index, size_t byt…
	+ size_t new_index = buffer_delete_unicode_char_base(buffer, line_index,…
	+ buffer_recalc_line(buffer, line_index);
	return new_index;
	}

	size_t
	-ledit_buffer_delete_unicode_char_base(ledit_buffer *buffer, size_t line_index,…
	- ledit_line *l = ledit_buffer_get_line(buffer, line_index);
	+buffer_delete_unicode_char_base(ledit_buffer *buffer, size_t line_index, size_…
	+ ledit_line *l = buffer_get_line(buffer, line_index);
	size_t new_index = byte_index;
	if (dir < 0) {
	- size_t i = ledit_line_prev_utf8(l, byte_index);
	- ledit_buffer_delete_line_section_base(buffer, line_index, i, b…
	+ size_t i = line_prev_utf8(l, byte_index);
	+ buffer_delete_line_section_base(buffer, line_index, i, byte_in…
	new_index = i;
	} else {
	- size_t i = ledit_line_next_utf8(l, byte_index);
	- ledit_buffer_delete_line_section_base(buffer, line_index, byte…
	+ size_t i = line_next_utf8(l, byte_index);
	+ buffer_delete_line_section_base(buffer, line_index, byte_index…
	}
	return new_index;
	}
	diff --git a/buffer.h b/buffer.h
	t@@ -29,7 +29,7 @@ typedef struct {
	struct ledit_buffer {
	ledit_common common; / common stuff, e.g. display, etc. */
	char filename; / last opened filename */
	- ledit_undo_stack undo; / undo manager */
	+ undo_stack undo; / undo manager */
	ledit_buffer_marklist marklist; / list of mark positions set */
	ledit_line lines; / array of lines */
	ledit_view *views; / array of registered views */
	t@@ -46,29 +46,29 @@ struct ledit_buffer {
	/*
	* Create a new buffer with one empty line
	*/
	-ledit_buffer ledit_buffer_create(ledit_common common);
	+ledit_buffer buffer_create(ledit_common common);

	/*
	* Set the hard line mode of the buffer and update the
	* displayed mode in all views.
	*/
	-void ledit_buffer_set_hard_line_based(ledit_buffer *buffer, int hl);
	+void buffer_set_hard_line_based(ledit_buffer *buffer, int hl);

	/*
	* Add a new view to the buffer.
	*/
	-void ledit_buffer_add_view(ledit_buffer buffer, ledit_theme theme, enum ledi…
	+void buffer_add_view(ledit_buffer buffer, ledit_theme theme, enum ledit_mode…

	/*
	* Remove the given view from the buffer.
	* Nothing is done if the view does not belong to the buffer.
	*/
	-void ledit_buffer_remove_view(ledit_buffer buffer, ledit_view view);
	+void buffer_remove_view(ledit_buffer buffer, ledit_view view);

	/*
	* Call 'view_recalc_from_line' for all views.
	*/
	-void ledit_buffer_recalc_all_views_from_line(ledit_buffer *buffer, size_t line…
	+void buffer_recalc_all_views_from_line(ledit_buffer *buffer, size_t line);

	/*
	* Load a file into the buffer at line 'line'.
	t@@ -78,7 +78,7 @@ void ledit_buffer_recalc_all_views_from_line(ledit_buffer *b…
	* with an error message which must be copied as soon as possible because it m…
	* be overwritten by subsequent function calls.
	*/
	-int ledit_buffer_load_file(ledit_buffer buffer, char filename, size_t line, …
	+int buffer_load_file(ledit_buffer buffer, char filename, size_t line, char *…

	/*
	* Write the buffer to a file.
	t@@ -86,18 +86,18 @@ int ledit_buffer_load_file(ledit_buffer buffer, char fil…
	* with an error message which must be copied as soon as possible because it m…
	* be overwritten by subsequent function calls.
	*/
	-int ledit_buffer_write_to_file(ledit_buffer buffer, char filename, char **er…
	+int buffer_write_to_file(ledit_buffer buffer, char filename, char **errstr);

	/*
	* Destroy a buffer.
	*/
	-void ledit_buffer_destroy(ledit_buffer *buffer);
	+void buffer_destroy(ledit_buffer *buffer);

	/*
	* Normalize a line, i.e. move the gap to the end and add '\0'
	* so the text can be used as a normal string
	*/
	-void ledit_buffer_normalize_line(ledit_line *line);
	+void buffer_normalize_line(ledit_line *line);

	/*
	* Insert 'src_len' bytes from 'src_line' starting at byte position 'src_index'
	t@@ -107,7 +107,7 @@ void ledit_buffer_normalize_line(ledit_line *line);
	* This function does not update the views or normalize the lines, so it should
	* only be used for efficiency purposes when performing multiple operations.
	*/
	-void ledit_buffer_insert_text_from_line_base(
	+void buffer_insert_text_from_line_base(
	ledit_buffer *buffer,
	size_t dst_line, size_t dst_index,
	size_t src_line, size_t src_index, size_t src_len,
	t@@ -115,9 +115,9 @@ void ledit_buffer_insert_text_from_line_base(
	);

	/*
	- * Same as ledit_buffer_insert_text_from_line_base, but the views are updated …
	+ * Same as buffer_insert_text_from_line_base, but the views are updated afterw…
	*/
	-void ledit_buffer_insert_text_from_line(
	+void buffer_insert_text_from_line(
	ledit_buffer *buffer,
	size_t dst_line, size_t dst_index,
	size_t src_line, size_t src_index, size_t src_len,
	t@@ -130,16 +130,16 @@ void ledit_buffer_insert_text_from_line(
	* This function does not update the views or normalize the lines, so it should
	* only be used for efficiency purposes when performing multiple operations.
	*/
	-void ledit_buffer_insert_text_base(
	+void buffer_insert_text_base(
	ledit_buffer *buffer,
	size_t line_index, size_t index,
	char *text, size_t len
	);

	/*
	- * Same as ledit_buffer_insert_text_base, but the views are updated afterwards.
	+ * Same as buffer_insert_text_base, but the views are updated afterwards.
	*/
	-void ledit_buffer_insert_text(
	+void buffer_insert_text(
	ledit_buffer *buffer,
	size_t line_index, size_t index,
	char *text, size_t len
	t@@ -154,7 +154,7 @@ void ledit_buffer_insert_text(
	* This function does not update the views or normalize the lines, so it should
	* only be used for efficiency purposes when performing multiple operations.
	*/
	-void ledit_buffer_insert_text_with_newlines_base(
	+void buffer_insert_text_with_newlines_base(
	ledit_buffer *buffer,
	size_t line_index, size_t index,
	char *text, size_t len,
	t@@ -162,9 +162,9 @@ void ledit_buffer_insert_text_with_newlines_base(
	);

	/*
	- * Same as ledit_buffer_insert_text_with_newlines_base, but the views are upda…
	+ * Same as buffer_insert_text_with_newlines_base, but the views are updated af…
	*/
	-void ledit_buffer_insert_text_with_newlines(
	+void buffer_insert_text_with_newlines(
	ledit_buffer *buffer,
	size_t line_index, size_t index,
	char *text, size_t len,
	t@@ -178,51 +178,51 @@ void ledit_buffer_insert_text_with_newlines(
	* The views are notified that a line has been appended, but not told to update
	* their line heights and offsets.
	*/
	-void ledit_buffer_append_line_base(ledit_buffer *buffer, size_t line_index, si…
	+void buffer_append_line_base(ledit_buffer *buffer, size_t line_index, size_t t…

	/*
	- * Same as ledit_buffer_append_line_base, but the views are told to update
	+ * Same as buffer_append_line_base, but the views are told to update
	* their line heights and offsets afterwards.
	*/
	-void ledit_buffer_append_line(ledit_buffer *buffer, size_t line_index, size_t …
	+void buffer_append_line(ledit_buffer *buffer, size_t line_index, size_t text_i…

	/*
	* Delete lines between 'index1' and 'index2' (inclusive).
	* The views are notified of the deletion but not told to
	* update their line heights and offsets.
	*/
	-void ledit_buffer_delete_line_entries_base(ledit_buffer *buffer, size_t index1…
	+void buffer_delete_line_entries_base(ledit_buffer *buffer, size_t index1, size…

	/*
	- * Same as ledit_buffer_delete_line_entries_base, but the views are told to
	+ * Same as buffer_delete_line_entries_base, but the views are told to
	* update their line heights and offsets.
	*/
	-void ledit_buffer_delete_line_entries(ledit_buffer *buffer, size_t index1, siz…
	+void buffer_delete_line_entries(ledit_buffer *buffer, size_t index1, size_t in…

	/*
	- * Convenience function to call ledit_buffer_delete_line_entries_base
	+ * Convenience function to call buffer_delete_line_entries_base
	* with two times the same line index.
	*/
	-void ledit_buffer_delete_line_entry_base(ledit_buffer *buffer, size_t index);
	+void buffer_delete_line_entry_base(ledit_buffer *buffer, size_t index);

	/*
	- * Convenience function to call ledit_buffer_delete_line_entries
	+ * Convenience function to call buffer_delete_line_entries
	* with two times the same line index.
	*/
	-void ledit_buffer_delete_line_entry(ledit_buffer *buffer, size_t index);
	+void buffer_delete_line_entry(ledit_buffer *buffer, size_t index);

	/*
	* Get the line at logical index 'index'.
	* The returned line is only valid until the next
	* action that appends or deletes line entries.
	*/
	-ledit_line ledit_buffer_get_line(ledit_buffer buffer, size_t index);
	+ledit_line buffer_get_line(ledit_buffer buffer, size_t index);

	/*
	* Tell views to recalculate the height of line 'line' and
	* update the pixel offsets of the following lines.
	*/
	-void ledit_buffer_recalc_line(ledit_buffer *buffer, size_t line);
	+void buffer_recalc_line(ledit_buffer *buffer, size_t line);

	/*
	* Tell views to recalculate the height for all lines starting at 'line'
	t@@ -230,13 +230,13 @@ void ledit_buffer_recalc_line(ledit_buffer *buffer, size…
	* all lines after 'line'.
	* Also clear the text_dirty attribute for all lines starting at 'line'.
	*/
	-void ledit_buffer_recalc_from_line(ledit_buffer *buffer, size_t line);
	+void buffer_recalc_from_line(ledit_buffer *buffer, size_t line);

	/*
	* Tell views to recalculate all lines.
	* Also clear the text_dirty attribute for all lines.
	*/
	-void ledit_buffer_recalc_all_lines(ledit_buffer *buffer);
	+void buffer_recalc_all_lines(ledit_buffer *buffer);

	/*
	* Get needed length of text range, including newlines.
	t@@ -244,21 +244,21 @@ void ledit_buffer_recalc_all_lines(ledit_buffer *buffer);
	* - if the last range ends at the end of a line, the newline is not included
	* - the range must be sorted already
	*/
	-size_t ledit_buffer_textlen(ledit_buffer *buffer, size_t line1, size_t byte1, …
	+size_t buffer_textlen(ledit_buffer *buffer, size_t line1, size_t byte1, size_t…

	/*
	* Copy text range into given buffer.
	* - dst is null-terminated
	- * - dst must be large enough to contain the text and NUL (only use this toget…
	+ * - dst must be large enough to contain the text and NUL (only use this toget…
	* - the range must be sorted already
	*/
	-void ledit_buffer_copy_text(ledit_buffer buffer, char dst, int line1, int by…
	+void buffer_copy_text(ledit_buffer buffer, char dst, int line1, int byte1, i…

	/*
	* Copy text range into given buffer and resize it if necessary.
	* - the range must be sorted already
	*/
	-void ledit_buffer_copy_text_to_txtbuf(
	+void buffer_copy_text_to_txtbuf(
	ledit_buffer *buffer,
	txtbuf buf, / oh, isn't that a very non-confusing name? */
	size_t line1, size_t byte1,
	t@@ -268,12 +268,12 @@ void ledit_buffer_copy_text_to_txtbuf(
	/*
	* Get the byte index of the previous utf8 character starting at byte index 'i…
	*/
	-size_t ledit_line_next_utf8(ledit_line *line, size_t index);
	+size_t line_next_utf8(ledit_line *line, size_t index);

	/*
	* Get the byte index of the previous utf8 character starting at byte index 'i…
	*/
	-size_t ledit_line_prev_utf8(ledit_line *line, size_t index);
	+size_t line_prev_utf8(ledit_line *line, size_t index);

	/*
	* Get the unicode character index of a byte position.
	t@@ -285,7 +285,7 @@ size_t line_byte_to_char(ledit_line *line, size_t byte);
	* and notify the views.
	* Note that this does not tell the views to recalculate their line heights an…
	*/
	-void ledit_buffer_delete_line_section_base(ledit_buffer *buffer, size_t line, …
	+void buffer_delete_line_section_base(ledit_buffer *buffer, size_t line, size_t…

	/*
	* Delete the unicode char at 'line_index' and 'byte_index' if 'dir' is >= 0,
	t@@ -294,16 +294,16 @@ void ledit_buffer_delete_line_section_base(ledit_buffer …
	* This function only notifies the views of the deletion, but does not tell
	* them to recalculate their line heights and offsets.
	*/
	-size_t ledit_buffer_delete_unicode_char_base(ledit_buffer *buffer, size_t line…
	+size_t buffer_delete_unicode_char_base(ledit_buffer *buffer, size_t line_index…

	/*
	- * Same as ledit_buffer_delete_unicode_char_base, but the views are updated.
	+ * Same as buffer_delete_unicode_char_base, but the views are updated.
	*/
	-size_t ledit_buffer_delete_unicode_char(ledit_buffer *buffer, size_t line_inde…
	+size_t buffer_delete_unicode_char(ledit_buffer *buffer, size_t line_index, siz…

	/*
	* Insert a mark with key 'mark' at line 'line' and byte 'byte'.
	*/
	-void ledit_buffer_insert_mark(ledit_buffer buffer, char mark, size_t len, si…
	+void buffer_insert_mark(ledit_buffer buffer, char mark, size_t len, size_t l…

	#endif
	diff --git a/keys_basic.c b/keys_basic.c
	t@@ -180,7 +180,7 @@ clear_key_stack(void) {

	static struct action
	err_invalid_key(ledit_view *view) {
	- ledit_window_show_message(view->window, "Invalid key", -1);
	+ window_show_message(view->window, "Invalid key", -1);
	clear_key_stack();
	discard_repetition_stack();
	return (struct action){ACTION_NONE, NULL};
	t@@ -423,7 +423,7 @@ delete_range(
	);
	cur_range.line2 = view->cur_line;
	cur_range.byte2 = view->cur_index;
	- ledit_push_undo_delete(
	+ undo_push_delete(
	view->buffer->undo, buf, del_range, cur_range, 1, view->mode
	);
	if (!copy_to_buffer)
	t@@ -450,7 +450,7 @@ insert_text(
	del_range.line1 = line;
	del_range.byte1 = index;
	size_t cur_line, cur_index;
	- ledit_buffer_insert_text_with_newlines(
	+ buffer_insert_text_with_newlines(
	view->buffer, line, index, text, len,
	&cur_line, &cur_index
	);
	t@@ -465,7 +465,7 @@ insert_text(
	}
	del_range.line2 = cur_line;
	del_range.byte2 = cur_index;
	- ledit_push_undo_insert(
	+ undo_push_insert(
	view->buffer->undo, &ins_buf, del_range, cur_range, start_group, v…
	);
	}
	t@@ -494,7 +494,7 @@ delete_chars_forwards(ledit_view view, char text, size_t…
	(void)len;
	int num = get_key_repeat();
	if (num == -1) {
	- ledit_window_show_message(view->window, "Invalid key", -1);
	+ window_show_message(view->window, "Invalid key", -1);
	return (struct action){ACTION_NONE, NULL};
	} else if (num == 0) {
	num = 1;
	t@@ -521,7 +521,7 @@ delete_chars_backwards(ledit_view view, char text, size_…
	(void)len;
	int num = get_key_repeat();
	if (num == -1) {
	- ledit_window_show_message(view->window, "Invalid key", -1);
	+ window_show_message(view->window, "Invalid key", -1);
	return (struct action){ACTION_NONE, NULL};
	} else if (num == 0) {
	num = 1;
	t@@ -550,7 +550,7 @@ push_undo_empty_insert(ledit_view *view, size_t line, size…
	txtbuf ins_buf = {.text = "", .len = 0, .cap = 0};
	ledit_range ins_range = {.line1 = line, .byte1 = index, .line2 = line,…
	ledit_range cur_range = {.line1 = line, .byte1 = index, .line2 = line,…
	- ledit_push_undo_insert(
	+ undo_push_insert(
	view->buffer->undo, &ins_buf, ins_range, cur_range, start_group, v…
	);
	}
	t@@ -575,7 +575,7 @@ append_line_below(ledit_view view, char text, size_t len…
	size_t start, end;
	enter_insert(view, text, len);
	view_get_pos_softline_bounds(view, view->cur_line, view->cur_index, &s…
	- ledit_line *ll = ledit_buffer_get_line(view->buffer, view->cur_line);
	+ ledit_line *ll = buffer_get_line(view->buffer, view->cur_line);
	if (hard_line_based \|\| end == ll->len) {
	insert_text(view, view->cur_line, ll->len, "\n", 1, 0, 0, view…
	} else {
	t@@ -602,7 +602,7 @@ append_after_eol(ledit_view view, char text, size_t len)…
	view_get_pos_softline_bounds(view, view->cur_line, view->cur_index, &s…
	/* make cursor jump back to original position on undo */
	push_undo_empty_insert(view, view->cur_line, view->cur_index, 1);
	- ledit_line *ll = ledit_buffer_get_line(view->buffer, view->cur_line);
	+ ledit_line *ll = buffer_get_line(view->buffer, view->cur_line);
	if (hard_line_based)
	view->cur_index = ll->len;
	else
	t@@ -630,7 +630,7 @@ move_to_line(ledit_view view, char text, size_t len) {
	view->cur_line = line - 1;
	view->cur_index = 0;
	int text_w, text_h;
	- ledit_window_get_textview_size(view->window, &text_w, &text_h);
	+ window_get_textview_size(view->window, &text_w, &text_h);
	ledit_view_line *vl = view_get_line(view, view->cur_line);
	int x, y, h;
	view_get_cursor_pixel_pos(view, view->cur_line, 0, &x, &y, &h);
	t@@ -659,7 +659,7 @@ scroll_lines(ledit_view *view, int lines, int dir) {
	/* get the middle position of char */
	ledit_pos_to_x_softline(view, view->cur_line, view->cur_index,…
	long abs_pos = vl->y_offset + y;
	- ledit_window_get_textview_size(view->window, &text_w, &text_h);
	+ window_get_textview_size(view->window, &text_w, &text_h);
	if (lines > 0)
	final_lines = last_lines_scrolled = lines;
	else
	t@@ -689,7 +689,7 @@ scroll_lines_up(ledit_view view, char text, size_t len) {
	if (repeat >= 0)
	scroll_lines(view, repeat, -1);
	else
	- ledit_window_show_message(view->window, "Invalid key", -1);
	+ window_show_message(view->window, "Invalid key", -1);
	discard_repetition_stack();
	return (struct action){ACTION_NONE, NULL};
	}
	t@@ -702,7 +702,7 @@ scroll_lines_down(ledit_view view, char text, size_t len…
	if (repeat >= 0)
	scroll_lines(view, repeat, 1);
	else
	- ledit_window_show_message(view->window, "Invalid key", -1);
	+ window_show_message(view->window, "Invalid key", -1);
	discard_repetition_stack();
	return (struct action){ACTION_NONE, NULL};
	}
	t@@ -744,7 +744,7 @@ scroll_with_cursor_up(ledit_view view, char text, size_t…
	if (repeat >= 0)
	scroll_with_cursor(view, -(repeat == 0 ? 1 : repeat));
	else
	- ledit_window_show_message(view->window, "Invalid key", -1);
	+ window_show_message(view->window, "Invalid key", -1);
	discard_repetition_stack();
	return (struct action){ACTION_NONE, NULL};
	}
	t@@ -757,7 +757,7 @@ scroll_with_cursor_down(ledit_view view, char text, size…
	if (repeat >= 0)
	scroll_with_cursor(view, repeat == 0 ? 1 : repeat);
	else
	- ledit_window_show_message(view->window, "Invalid key", -1);
	+ window_show_message(view->window, "Invalid key", -1);
	discard_repetition_stack();
	return (struct action){ACTION_NONE, NULL};
	}
	t@@ -770,7 +770,7 @@ scroll_with_cursor_down(ledit_view view, char text, size…
	static void
	move_half_screen(ledit_view *view, int movement) {
	int w, h;
	- ledit_window_get_textview_size(view->window, &w, &h);
	+ window_get_textview_size(view->window, &w, &h);
	/* FIXME: overflow */
	int total = movement * h/2;
	ledit_view_line *vl = view_get_line(view, view->cur_line);
	t@@ -825,7 +825,7 @@ screen_up(ledit_view view, char text, size_t len) {
	if (repeat >= 0)
	move_half_screen(view, -(repeat == 0 ? 2 : repeat*2));
	else
	- ledit_window_show_message(view->window, "Invalid key", -1);
	+ window_show_message(view->window, "Invalid key", -1);
	discard_repetition_stack();
	return (struct action){ACTION_NONE, NULL};
	}
	t@@ -838,7 +838,7 @@ screen_down(ledit_view view, char text, size_t len) {
	if (repeat >= 0)
	move_half_screen(view, repeat == 0 ? 2 : repeat*2);
	else
	- ledit_window_show_message(view->window, "Invalid key", -1);
	+ window_show_message(view->window, "Invalid key", -1);
	discard_repetition_stack();
	return (struct action){ACTION_NONE, NULL};
	}
	t@@ -850,7 +850,7 @@ delete_to_eol(ledit_view view, char text, size_t len) {
	if (!key_stack_empty())
	return err_invalid_key(view);
	size_t start, end;
	- ledit_line *ll = ledit_buffer_get_line(view->buffer, view->cur_line);
	+ ledit_line *ll = buffer_get_line(view->buffer, view->cur_line);
	if (hard_line_based) {
	end = ll->len;
	} else {
	t@@ -877,7 +877,7 @@ change_to_eol(ledit_view view, char text, size_t len) {
	return err_invalid_key(view);
	view_set_mode(view, INSERT);
	size_t start, end;
	- ledit_line *ll = ledit_buffer_get_line(view->buffer, view->cur_line);
	+ ledit_line *ll = buffer_get_line(view->buffer, view->cur_line);
	if (hard_line_based) {
	end = ll->len;
	} else {
	t@@ -947,7 +947,7 @@ change_cb(ledit_view *view, size_t line, size_t char_pos, …
	view_get_pos_softline_bounds(view, line, char_pos, &tmp, &pos2…
	} else if (line_based && hard_line_based) {
	pos1 = 0;
	- ledit_line *ll = ledit_buffer_get_line(view->buffer, line);
	+ ledit_line *ll = buffer_get_line(view->buffer, line);
	pos2 = ll->len;
	}
	/* force line_based to 0 (see comment about hackery above) */
	t@@ -970,7 +970,7 @@ yank(ledit_view view, char text, size_t len) {
	view_sort_selection(
	&view->sel.line1, &view->sel.byte1, &view->sel.line2, &vie…
	);
	- ledit_buffer_copy_text_to_txtbuf(
	+ buffer_copy_text_to_txtbuf(
	view->buffer, paste_buffer,
	view->sel.line1, view->sel.byte1, view->sel.line2, view->s…
	);
	t@@ -1049,26 +1049,26 @@ yank_cb(ledit_view *view, size_t line, size_t char_pos…
	size_t start1, end2, tmp;
	view_get_pos_softline_bounds(view, l1, b1, &start1, &tmp);
	view_get_pos_softline_bounds(view, l2, b2, &tmp, &end2);
	- ledit_line *ll = ledit_buffer_get_line(view->buffer, l2);
	+ ledit_line *ll = buffer_get_line(view->buffer, l2);
	if (end2 == ll->len && l2 < view->lines_num - 1) {
	l2++;
	end2 = 0;
	}
	- ledit_buffer_copy_text_to_txtbuf(
	+ buffer_copy_text_to_txtbuf(
	view->buffer, paste_buffer, l1, start1, l2, end2
	);
	} else if (line_based && hard_line_based) {
	- ledit_line *ll = ledit_buffer_get_line(view->buffer, l2);
	+ ledit_line *ll = buffer_get_line(view->buffer, l2);
	size_t end = ll->len;
	if (l2 < view->lines_num - 1) {
	l2++;
	end = 0;
	}
	- ledit_buffer_copy_text_to_txtbuf(
	+ buffer_copy_text_to_txtbuf(
	view->buffer, paste_buffer, l1, 0, l2, end
	);
	} else {
	- ledit_buffer_copy_text_to_txtbuf(
	+ buffer_copy_text_to_txtbuf(
	view->buffer, paste_buffer, l1, b1, l2, b2
	);
	}
	t@@ -1138,13 +1138,13 @@ paste_normal(ledit_view view, char text, size_t len)…
	(void)text;
	(void)len;
	if (!paste_buffer) {
	- ledit_window_show_message(view->window, "Nothing to paste", -1…
	+ window_show_message(view->window, "Nothing to paste", -1);
	discard_repetition_stack();
	return (struct action){ACTION_NONE, NULL};
	}
	if (paste_buffer_line_based) {
	view_wipe_line_cursor_attrs(view, view->cur_line);
	- ledit_line *ll = ledit_buffer_get_line(view->buffer, view->cur…
	+ ledit_line *ll = buffer_get_line(view->buffer, view->cur_line);
	size_t brk = 0;
	if (hard_line_based) {
	brk = ll->len;
	t@@ -1157,7 +1157,7 @@ paste_normal(ledit_view view, char text, size_t len) {
	"\n", 1, 0, 0, view->cur_line, view->cur_index, 0, 1, 1
	);
	size_t text_len = paste_buffer->len;
	- ll = ledit_buffer_get_line(view->buffer, view->cur_line + 1);
	+ ll = buffer_get_line(view->buffer, view->cur_line + 1);
	if (ll->len == 0 && paste_buffer->text[text_len-1] == '\n') {
	/* remove trailing newline if it exists and text is al…
	text_len--;
	t@@ -1194,13 +1194,13 @@ paste_normal_backwards(ledit_view view, char text, s…
	(void)text;
	(void)len;
	if (!paste_buffer) {
	- ledit_window_show_message(view->window, "Nothing to paste", -1…
	+ window_show_message(view->window, "Nothing to paste", -1);
	discard_repetition_stack();
	return (struct action){ACTION_NONE, NULL};
	}
	if (paste_buffer_line_based) {
	view_wipe_line_cursor_attrs(view, view->cur_line);
	- ledit_line *ll = ledit_buffer_get_line(view->buffer, view->cur…
	+ ledit_line *ll = buffer_get_line(view->buffer, view->cur_line);
	size_t brk = 0;
	if (!hard_line_based) {
	size_t tmp;
	t@@ -1212,7 +1212,7 @@ paste_normal_backwards(ledit_view view, char text, siz…
	"\n", 1, 0, 0, view->cur_line, view->cur_index, 0, 1, 1
	);
	size_t text_len = paste_buffer->len;
	- ll = ledit_buffer_get_line(view->buffer, view->cur_line);
	+ ll = buffer_get_line(view->buffer, view->cur_line);
	if (paste_buffer->text[text_len-1] == '\n') {
	/* remove trailing newline if it exists */
	text_len--;
	t@@ -1363,12 +1363,12 @@ backspace(ledit_view view, char text, size_t len) {
	/* NOP */
	} else if (view->cur_index == 0) {
	if (view->cur_line != 0) {
	- ledit_line *l1 = ledit_buffer_get_line(view->buffer, v…
	+ ledit_line *l1 = buffer_get_line(view->buffer, view->c…
	delete_range(view, 0, 0, view->cur_line - 1, l1->len, …
	}
	} else {
	- ledit_line *l = ledit_buffer_get_line(view->buffer, view->cur_…
	- int i = ledit_line_prev_utf8(l, view->cur_index);
	+ ledit_line *l = buffer_get_line(view->buffer, view->cur_line);
	+ int i = line_prev_utf8(l, view->cur_index);
	delete_range(view, 0, 0, view->cur_line, view->cur_index, view…
	}
	return (struct action){ACTION_NONE, NULL};
	t@@ -1378,7 +1378,7 @@ static struct action
	delete_key(ledit_view view, char text, size_t len) {
	(void)text;
	(void)len;
	- ledit_line *cur_line = ledit_buffer_get_line(view->buffer, view->cur_l…
	+ ledit_line *cur_line = buffer_get_line(view->buffer, view->cur_line);
	if (delete_selection(view)) {
	/* NOP */
	} else if (view->cur_index == cur_line->len) {
	t@@ -1386,7 +1386,7 @@ delete_key(ledit_view view, char text, size_t len) {
	delete_range(view, 0, 0, view->cur_line, cur_line->len…
	}
	} else {
	- int i = ledit_line_next_utf8(cur_line, view->cur_index);
	+ int i = line_next_utf8(cur_line, view->cur_index);
	delete_range(view, 0, 0, view->cur_line, view->cur_index, view…
	}
	/* FIXME: This was probably a mistake earlier, right?
	t@@ -1411,7 +1411,7 @@ move_to_eol(ledit_view view, char text, size_t len) {
	view, view->cur_line, view->cur_index, num - 1,
	&new_line, &new_softline
	);
	- ledit_line *ll = ledit_buffer_get_line(view->buffer, new_line);
	+ ledit_line *ll = buffer_get_line(view->buffer, new_line);
	size_t end_index = ll->len;
	if (!hard_line_based) {
	size_t tmp;
	t@@ -1461,7 +1461,7 @@ name(ledit_view view, char text, size_t len) { …
	if (cb != NULL) { …
	cb(view, new_line, new_real_index, KEY_MOTION_CHAR); …
	} else { …
	- if (view->mode == VISUAL) { \
	+ if (view->mode == VISUAL) { …
	view_set_selection( …
	view, …
	view->sel.line1, view->sel.byte1, …
	t@@ -1502,7 +1502,7 @@ move_cursor_left_right(ledit_view *view, int dir, int al…
	if (num == 0)
	num = 1;

	- ledit_line *cur_line = ledit_buffer_get_line(view->buffer, view->cur_l…
	+ ledit_line *cur_line = buffer_get_line(view->buffer, view->cur_line);
	/* FIXME: standardize interface - num * dir or separately? */
	size_t last_index;
	size_t new_index = view_move_cursor_visually(
	t@@ -1693,7 +1693,7 @@ join_lines(ledit_view view, char text, size_t len) {
	/* getting cur line again should be unnecessary, but
	I'll just leave it in case I change the way lines
	are stored later */
	- ll1 = ledit_buffer_get_line(view->buffer, cur_line);
	+ ll1 = buffer_get_line(view->buffer, cur_line);
	oldlen = ll1->len;
	/* FIXME: truncate whitespace to one space */
	view_delete_range(
	t@@ -1704,7 +1704,7 @@ join_lines(ledit_view view, char text, size_t len) {
	cur_range.byte1 = view->cur_index;
	cur_range.byte2 = view->cur_index =
	view_get_legal_normal_pos(view, view->cur_line, oldlen);
	- ledit_push_undo_delete(
	+ undo_push_delete(
	view->buffer->undo, buf, del_range, cur_range,
	start_group, view->mode
	);
	t@@ -1833,46 +1833,46 @@ static struct action
	enter_commandedit(ledit_view view, char text, size_t len) {
	(void)text;
	(void)len;
	- ledit_window_set_bottom_bar_text(view->window, ":", -1);
	- ledit_window_set_bottom_bar_min_pos(view->window, 1);
	- ledit_window_set_bottom_bar_cursor(view->window, 1);
	+ window_set_bottom_bar_text(view->window, ":", -1);
	+ window_set_bottom_bar_min_pos(view->window, 1);
	+ window_set_bottom_bar_cursor(view->window, 1);
	view->cur_command_type = CMD_EDIT;
	- ledit_window_set_bottom_bar_text_shown(view->window, 1);
	+ window_set_bottom_bar_text_shown(view->window, 1);
	discard_repetition_stack();
	- return (struct action){ACTION_GRABKEY, &ledit_command_key_handler};
	+ return (struct action){ACTION_GRABKEY, &command_key_handler};
	}

	static struct action
	enter_searchedit_forward(ledit_view view, char text, size_t len) {
	(void)text;
	(void)len;
	- ledit_window_set_bottom_bar_text(view->window, "/", -1);
	- ledit_window_set_bottom_bar_min_pos(view->window, 1);
	- ledit_window_set_bottom_bar_cursor(view->window, 1);
	+ window_set_bottom_bar_text(view->window, "/", -1);
	+ window_set_bottom_bar_min_pos(view->window, 1);
	+ window_set_bottom_bar_cursor(view->window, 1);
	view->cur_command_type = CMD_EDITSEARCH;
	- ledit_window_set_bottom_bar_text_shown(view->window, 1);
	+ window_set_bottom_bar_text_shown(view->window, 1);
	discard_repetition_stack();
	- return (struct action){ACTION_GRABKEY, &ledit_command_key_handler};
	+ return (struct action){ACTION_GRABKEY, &command_key_handler};
	}

	static struct action
	enter_searchedit_backward(ledit_view view, char text, size_t len) {
	(void)text;
	(void)len;
	- ledit_window_set_bottom_bar_text(view->window, "?", -1);
	- ledit_window_set_bottom_bar_min_pos(view->window, 1);
	- ledit_window_set_bottom_bar_cursor(view->window, 1);
	+ window_set_bottom_bar_text(view->window, "?", -1);
	+ window_set_bottom_bar_min_pos(view->window, 1);
	+ window_set_bottom_bar_cursor(view->window, 1);
	view->cur_command_type = CMD_EDITSEARCHB;
	- ledit_window_set_bottom_bar_text_shown(view->window, 1);
	+ window_set_bottom_bar_text_shown(view->window, 1);
	discard_repetition_stack();
	- return (struct action){ACTION_GRABKEY, &ledit_command_key_handler};
	+ return (struct action){ACTION_GRABKEY, &command_key_handler};
	}

	/* FIXME: differentiate between jumping to line and index like nvi */
	static struct action
	mark_line_cb(ledit_view view, char text, size_t len) {
	grab_char_cb = NULL;
	- ledit_buffer_insert_mark(
	+ buffer_insert_mark(
	view->buffer, text, len, view->cur_line, view->cur_index
	);
	return (struct action){ACTION_NONE, NULL};
	t@@ -1896,11 +1896,11 @@ jump_to_mark_cb(ledit_view view, char text, size_t l…
	ledit_buffer_mark *m = &marklist->marks[i];
	if (m->line >= view->lines_num) {
	line = view->lines_num - 1;
	- ll = ledit_buffer_get_line(view->buffer, line);
	+ ll = buffer_get_line(view->buffer, line);
	index = ll->len;
	} else {
	line = m->line;
	- ll = ledit_buffer_get_line(view->buffer, m->li…
	+ ll = buffer_get_line(view->buffer, m->line);
	if (m->byte >= ll->len)
	index = ll->len;
	else
	t@@ -1983,7 +1983,7 @@ show_line(ledit_view view, char text, size_t len) {
	int textlen = snprintf(NULL, 0, "Line %zu of %zu", view->cur_line + 1,…
	char *str = ledit_malloc(textlen + 1);
	snprintf(str, textlen + 1, "Line %zu of %zu", view->cur_line + 1, view…
	- ledit_window_show_message(view->window, str, textlen);
	+ window_show_message(view->window, str, textlen);
	discard_repetition_stack();
	return (struct action){ACTION_NONE, NULL};
	}
	t@@ -2101,7 +2101,7 @@ name##_cb(ledit_view view, char text, size_t len) { …
	return err_invalid_key(view); …
	if (num == 0) …
	num = 1; …
	- ledit_line *ll = ledit_buffer_get_line(view->buffer, view->cur_line); …
	+ ledit_line *ll = buffer_get_line(view->buffer, view->cur_line); …
	size_t new_index = view->cur_index; …
	int ret = -1; …
	for (int i = 0; i < num; i++) { …
	t@@ -2118,7 +2118,7 @@ name##_cb(ledit_view view, char text, size_t len) { …
	); …
	cb(view, view->cur_line, new_index, KEY_MOTION_CHAR); …
	} else { …
	- if (view->mode == VISUAL) { \
	+ if (view->mode == VISUAL) { …
	view->cur_index = cur_funcv( …
	view, view->cur_line, new_index, 1 …
	); …
	t@@ -2145,7 +2145,7 @@ name##_cb(ledit_view view, char text, size_t len) { …
	…
	static struct action …
	name(ledit_view view, char text, size_t len) { …
	- (void)view; …
	+ (void)view; …
	(void)text; …
	(void)len; …
	grab_char_cb = &name##_cb; …
	t@@ -2215,7 +2215,7 @@ toggle_hard_line_based(ledit_view view, char text, siz…
	int num = get_key_repeat();
	if (num != 0)
	return err_invalid_key(view);
	- ledit_buffer_set_hard_line_based(view->buffer, !view->buffer->hard_lin…
	+ buffer_set_hard_line_based(view->buffer, !view->buffer->hard_line_base…
	return (struct action){ACTION_NONE, NULL};
	}

	t@@ -2295,7 +2295,7 @@ basic_key_handler(ledit_view view, XEvent event, int l…
	re->lang_index = lang_index;

	/* FIXME: only hide when actually necessary */
	- ledit_window_hide_message(view->window);
	+ window_hide_message(view->window);
	int found = 0;
	struct action act = handle_key(view, buf, (size_t)n, sym, key_state, l…

	diff --git a/keys_command.c b/keys_command.c
	t@@ -47,7 +47,7 @@ handle_write(ledit_view view, char cmd, size_t l1, size_t …
	/* FIXME: Implement properly; handle error */
	char *errstr;
	if (view->buffer->filename)
	- ledit_buffer_write_to_file(view->buffer, view->buffer->filenam…
	+ buffer_write_to_file(view->buffer, view->buffer->filename, &er…
	return 0;
	}

	t@@ -68,7 +68,7 @@ create_view(ledit_view view, char cmd, size_t l1, size_t l…
	(void)cmd;
	(void)l1;
	(void)l2;
	- ledit_buffer_add_view(view->buffer, view->theme, view->mode, view->cur…
	+ buffer_add_view(view->buffer, view->theme, view->mode, view->cur_line,…
	return 0;
	}

	t@@ -79,7 +79,7 @@ close_view(ledit_view view, char cmd, size_t l1, size_t l2…
	(void)l2;
	/* FIXME: This will lead to problems if I add something that
	requires access to the view after the command is handled. */
	- ledit_buffer_remove_view(view->buffer, view);
	+ buffer_remove_view(view->buffer, view);
	if (view->buffer->views_num == 0) {
	ledit_cleanup();
	exit(0);
	t@@ -264,8 +264,8 @@ substitute_no_all(ledit_view view, char key_text, size_t…
	static int
	edit_insert_text(ledit_view view, char key_text, size_t len) {
	/* FIXME: overflow */
	- ledit_window_insert_bottom_bar_text(view->window, key_text, len);
	- ledit_window_set_bottom_bar_cursor(
	+ window_insert_bottom_bar_text(view->window, key_text, len);
	+ window_set_bottom_bar_cursor(
	view->window, ledit_window_get_bottom_bar_cursor(view->window) + l…
	);
	return 1;
	t@@ -275,7 +275,7 @@ static int
	edit_cursor_to_end(ledit_view view, char key_text, size_t len) {
	(void)key_text;
	(void)len;
	- ledit_window_bottom_bar_cursor_to_end(view->window);
	+ window_bottom_bar_cursor_to_end(view->window);
	return 1;
	}

	t@@ -283,7 +283,7 @@ static int
	edit_cursor_to_beginning(ledit_view view, char key_text, size_t len) {
	(void)key_text;
	(void)len;
	- ledit_window_bottom_bar_cursor_to_beginning(view->window);
	+ window_bottom_bar_cursor_to_beginning(view->window);
	return 1;
	}

	t@@ -291,7 +291,7 @@ static int
	edit_cursor_left(ledit_view view, char key_text, size_t len) {
	(void)key_text;
	(void)len;
	- ledit_window_move_bottom_bar_cursor(view->window, -1);
	+ window_move_bottom_bar_cursor(view->window, -1);
	return 1;
	}

	t@@ -299,7 +299,7 @@ static int
	edit_cursor_right(ledit_view view, char key_text, size_t len) {
	(void)key_text;
	(void)len;
	- ledit_window_move_bottom_bar_cursor(view->window, 1);
	+ window_move_bottom_bar_cursor(view->window, 1);
	return 1;
	}

	t@@ -307,7 +307,7 @@ static int
	edit_backspace(ledit_view view, char key_text, size_t len) {
	(void)key_text;
	(void)len;
	- ledit_window_delete_bottom_bar_char(view->window, -1);
	+ window_delete_bottom_bar_char(view->window, -1);
	return 1;
	}

	t@@ -315,7 +315,7 @@ static int
	edit_delete(ledit_view view, char key_text, size_t len) {
	(void)key_text;
	(void)len;
	- ledit_window_delete_bottom_bar_char(view->window, 1);
	+ window_delete_bottom_bar_char(view->window, 1);
	return 1;
	}

	t@@ -323,9 +323,9 @@ static int
	edit_submit(ledit_view view, char key_text, size_t len) {
	(void)key_text;
	(void)len;
	- ledit_window_set_bottom_bar_text_shown(view->window, 0);
	+ window_set_bottom_bar_text_shown(view->window, 0);
	/* FIXME: this is hacky */
	- return handle_cmd(view, ledit_window_get_bottom_bar_text(view->window)…
	+ return handle_cmd(view, window_get_bottom_bar_text(view->window) + 1, …
	}

	/* FIXME: support visual mode, i.e. change selection to new place? */
	t@@ -335,7 +335,7 @@ search_next(ledit_view *view) {
	enum ledit_search_state ret = ledit_search_next(view, &view->cur_line,…
	view_set_line_cursor_attrs(view, view->cur_line, view->cur_index);
	if (ret != SEARCH_NORMAL)
	- ledit_window_show_message(view->window, ledit_search_state_to_…
	+ window_show_message(view->window, search_state_to_str(ret), -1…
	}

	void
	t@@ -344,15 +344,15 @@ search_prev(ledit_view *view) {
	enum ledit_search_state ret = ledit_search_prev(view, &view->cur_line,…
	view_set_line_cursor_attrs(view, view->cur_line, view->cur_index);
	if (ret != SEARCH_NORMAL)
	- ledit_window_show_message(view->window, ledit_search_state_to_…
	+ window_show_message(view->window, search_state_to_str(ret), -1…
	}

	static int
	editsearch_submit(ledit_view view, char key_text, size_t len) {
	(void)key_text;
	(void)len;
	- ledit_window_set_bottom_bar_text_shown(view->window, 0);
	- ledit_set_search_forward(ledit_window_get_bottom_bar_text(view->window…
	+ window_set_bottom_bar_text_shown(view->window, 0);
	+ set_search_forward(window_get_bottom_bar_text(view->window) + 1);
	search_next(view);
	return 0;
	}
	t@@ -361,8 +361,8 @@ static int
	editsearchb_submit(ledit_view view, char key_text, size_t len) {
	(void)key_text;
	(void)len;
	- ledit_window_set_bottom_bar_text_shown(view->window, 0);
	- ledit_set_search_backward(ledit_window_get_bottom_bar_text(view->windo…
	+ window_set_bottom_bar_text_shown(view->window, 0);
	+ set_search_backward(window_get_bottom_bar_text(view->window) + 1);
	search_next(view);
	return 0;
	}
	t@@ -372,12 +372,12 @@ edit_discard(ledit_view view, char key_text, size_t le…
	(void)view;
	(void)key_text;
	(void)len;
	- ledit_window_set_bottom_bar_text_shown(view->window, 0);
	+ window_set_bottom_bar_text_shown(view->window, 0);
	return 0;
	}

	struct action
	-ledit_command_key_handler(ledit_view view, XEvent event, int lang_index) {
	+command_key_handler(ledit_view view, XEvent event, int lang_index) {
	char buf[64];
	KeySym sym;
	int n;
	t@@ -404,7 +404,7 @@ ledit_command_key_handler(ledit_view view, XEvent event,…
	}
	}
	if (grabkey)
	- return (struct action){ACTION_GRABKEY, &ledit_command_key_hand…
	+ return (struct action){ACTION_GRABKEY, &command_key_handler};
	else
	return (struct action){ACTION_NONE, NULL};
	}
	diff --git a/keys_command.h b/keys_command.h
	t@@ -2,4 +2,4 @@
	void search_next(ledit_view *view);
	void search_prev(ledit_view *view);

	-struct action ledit_command_key_handler(ledit_view view, XEvent event, int l…
	+struct action command_key_handler(ledit_view view, XEvent event, int lang_in…
	diff --git a/ledit.c b/ledit.c
	t@@ -1,3 +1,6 @@
	+/* FIXME: On large files, expose event takes a long time for some reason
	+ -> but somehow only sometimes... */
	+/* FIXME: generally optimize redrawing */
	/* FIXME: Just use int for everything? size_t just doesn't seem to be worth it…
	/* FIXME: Make scrolling more smooth */
	/* FIXME: Document that everything is assumed to be utf8 */
	t@@ -119,23 +122,23 @@ mainloop(void) {
	view->redraw = 1;
	break;
	case ConfigureNotify:
	- ledit_window_register_resize(view->window, &ev…
	+ window_register_resize(view->window, &event);
	break;
	case ButtonPress:
	- ledit_window_register_button_press(view->windo…
	+ window_register_button_press(view->window, &ev…
	break;
	case ButtonRelease:
	- ledit_window_button_release(view->window, &eve…
	+ window_button_release(view->window, &event);
	break;
	case MotionNotify:
	- ledit_window_register_motion(window, &event);
	+ window_register_motion(window, &event);
	break;
	case KeyPress:
	key_press(view, &event);
	break;
	case ClientMessage:
	if ((Atom)event.xclient.data.l[0] == view->win…
	- ledit_buffer_remove_view(buffer, view);
	+ buffer_remove_view(buffer, view);
	if (buffer->views_num == 0)
	running = 0;
	}
	t@@ -143,7 +146,7 @@ mainloop(void) {
	case SelectionNotify:
	case PropertyNotify:
	case SelectionRequest:
	- ledit_window_clipboard_event(view->window, &ev…
	+ window_clipboard_event(view->window, &event);
	break;
	default:
	break;
	t@@ -151,7 +154,7 @@ mainloop(void) {
	};

	for (size_t i = 0; i < buffer->views_num; i++) {
	- ledit_window_handle_filtered_events(buffer->views[i]->…
	+ window_handle_filtered_events(buffer->views[i]->window…
	}

	if (change_kbd) {
	t@@ -229,12 +232,12 @@ setup(int argc, char *argv[]) {
	common.depth = DefaultDepth(common.dpy, common.screen);
	common.cm = DefaultColormap(common.dpy, common.screen);

	- theme = ledit_theme_create(&common);
	- buffer = ledit_buffer_create(&common);
	+ theme = theme_create(&common);
	+ buffer = buffer_create(&common);
	/* FIXME: Support multiple buffers/files */
	if (argc > 1) {
	char *load_err;
	- if (ledit_buffer_load_file(buffer, argv[1], 0, &load_err)) {
	+ if (buffer_load_file(buffer, argv[1], 0, &load_err)) {
	fprintf(stderr, "Error opening file '%s': %s\n", argv[…
	ledit_cleanup();
	exit(1);
	t@@ -242,7 +245,7 @@ setup(int argc, char *argv[]) {
	/* FIXME: encapsulate */
	buffer->filename = ledit_strdup(argv[1]);
	}
	- ledit_buffer_add_view(buffer, theme, NORMAL, 0, 0);
	+ buffer_add_view(buffer, theme, NORMAL, 0, 0);
	/* FIXME: don't access view directly here */
	ledit_view *view = buffer->views[0];
	view_set_line_cursor_attrs(view, view->cur_line, view->cur_index);
	t@@ -253,12 +256,12 @@ setup(int argc, char *argv[]) {
	void
	ledit_cleanup(void) {
	/* FIXME: check for other things to clean up */
	- ledit_search_cleanup();
	+ search_cleanup();
	basic_key_cleanup();
	if (buffer)
	- ledit_buffer_destroy(buffer);
	+ buffer_destroy(buffer);
	if (theme)
	- ledit_theme_destroy(&common, theme);
	+ theme_destroy(&common, theme);
	XCloseDisplay(common.dpy);
	}

	diff --git a/search.c b/search.c
	t@@ -26,19 +26,19 @@ enum {
	} last_dir = FORWARD;

	void
	-ledit_search_cleanup(void) {
	+search_cleanup(void) {
	free(last_search);
	}

	void
	-ledit_set_search_forward(char *pattern) {
	+set_search_forward(char *pattern) {
	last_dir = FORWARD;
	free(last_search);
	last_search = ledit_strdup(pattern);
	}

	void
	-ledit_set_search_backward(char *pattern) {
	+set_search_backward(char *pattern) {
	last_dir = BACKWARD;
	free(last_search);
	last_search = ledit_strdup(pattern);
	t@@ -55,16 +55,16 @@ search_forward(ledit_view view, size_t line_ret, size_t …
	note: since the string ends with '\0', this is always valid */
	size_t byte = view->cur_index + 1;
	char *res;
	- ledit_line *lline = ledit_buffer_get_line(view->buffer, line);
	- ledit_buffer_normalize_line(lline);
	+ ledit_line *lline = buffer_get_line(view->buffer, line);
	+ buffer_normalize_line(lline);
	if ((res = strstr(lline->text + byte, last_search)) != NULL) {
	*line_ret = line;
	*byte_ret = (size_t)(res - lline->text);
	return SEARCH_NORMAL;
	}
	for (size_t i = line + 1; i < view->lines_num; i++) {
	- lline = ledit_buffer_get_line(view->buffer, i);
	- ledit_buffer_normalize_line(lline);
	+ lline = buffer_get_line(view->buffer, i);
	+ buffer_normalize_line(lline);
	if ((res = strstr(lline->text, last_search)) != NULL) {
	*line_ret = i;
	*byte_ret = (size_t)(res - lline->text);
	t@@ -72,16 +72,16 @@ search_forward(ledit_view view, size_t line_ret, size_t …
	}
	}
	for (size_t i = 0; i < line; i++) {
	- lline = ledit_buffer_get_line(view->buffer, i);
	- ledit_buffer_normalize_line(lline);
	+ lline = buffer_get_line(view->buffer, i);
	+ buffer_normalize_line(lline);
	if ((res = strstr(lline->text, last_search)) != NULL) {
	*line_ret = i;
	*byte_ret = (size_t)(res - lline->text);
	return SEARCH_WRAPPED;
	}
	}
	- lline = ledit_buffer_get_line(view->buffer, line);
	- ledit_buffer_normalize_line(lline);
	+ lline = buffer_get_line(view->buffer, line);
	+ buffer_normalize_line(lline);
	if ((res = strstr(lline->text, last_search)) != NULL) {
	*line_ret = line;
	*byte_ret = (size_t)(res - lline->text);
	t@@ -100,8 +100,8 @@ search_backward(ledit_view view, size_t line_ret, size_t…
	return SEARCH_NO_PATTERN;
	size_t line = view->cur_line;
	size_t byte = view->cur_index;
	- ledit_line *lline = ledit_buffer_get_line(view->buffer, line);
	- ledit_buffer_normalize_line(lline);
	+ ledit_line *lline = buffer_get_line(view->buffer, line);
	+ buffer_normalize_line(lline);
	char last = NULL, res = lline->text;
	while ((res = strstr(res, last_search)) != NULL && res < lline->text +…
	last = res;
	t@@ -114,8 +114,8 @@ search_backward(ledit_view view, size_t line_ret, size_t…
	return SEARCH_NORMAL;
	}
	for (size_t i = line; i > 0; i--) {
	- lline = ledit_buffer_get_line(view->buffer, i-1);
	- ledit_buffer_normalize_line(lline);
	+ lline = buffer_get_line(view->buffer, i-1);
	+ buffer_normalize_line(lline);
	res = lline->text;
	while ((res = strstr(res, last_search)) != NULL) {
	last = res;
	t@@ -128,8 +128,8 @@ search_backward(ledit_view view, size_t line_ret, size_t…
	}
	}
	for (size_t i = view->lines_num - 1; i > line; i--) {
	- lline = ledit_buffer_get_line(view->buffer, i);
	- ledit_buffer_normalize_line(lline);
	+ lline = buffer_get_line(view->buffer, i);
	+ buffer_normalize_line(lline);
	res = lline->text;
	while ((res = strstr(res, last_search)) != NULL) {
	last = res;
	t@@ -141,8 +141,8 @@ search_backward(ledit_view view, size_t line_ret, size_t…
	return SEARCH_WRAPPED;
	}
	}
	- lline = ledit_buffer_get_line(view->buffer, line);
	- ledit_buffer_normalize_line(lline);
	+ lline = buffer_get_line(view->buffer, line);
	+ buffer_normalize_line(lline);
	res = lline->text + byte;
	while ((res = strstr(res, last_search)) != NULL) {
	last = res;
	t@@ -173,7 +173,7 @@ ledit_search_prev(ledit_view view, size_t line_ret, size…
	}

	char *
	-ledit_search_state_to_str(enum ledit_search_state state) {
	+search_state_to_str(enum ledit_search_state state) {
	switch (state) {
	case SEARCH_WRAPPED:
	return "Search wrapped";
	diff --git a/search.h b/search.h
	t@@ -5,9 +5,9 @@ enum ledit_search_state {
	SEARCH_NO_PATTERN
	};

	-void ledit_search_cleanup(void);
	-void ledit_set_search_forward(char *pattern);
	-void ledit_set_search_backward(char *pattern);
	+void search_cleanup(void);
	+void set_search_forward(char *pattern);
	+void set_search_backward(char *pattern);
	enum ledit_search_state ledit_search_next(ledit_view view, size_t line_ret, …
	enum ledit_search_state ledit_search_prev(ledit_view view, size_t line_ret, …
	-char *ledit_search_state_to_str(enum ledit_search_state state);
	+char *search_state_to_str(enum ledit_search_state state);
	diff --git a/theme.c b/theme.c
	t@@ -9,7 +9,7 @@
	#include "theme_config.h"

	ledit_theme *
	-ledit_theme_create(ledit_common *common) {
	+theme_create(ledit_common *common) {
	ledit_theme *theme = ledit_malloc(sizeof(ledit_theme));
	theme->scrollbar_width = SCROLLBAR_WIDTH;
	theme->scrollbar_step = SCROLLBAR_STEP;
	t@@ -26,7 +26,7 @@ ledit_theme_create(ledit_common *common) {
	}

	void
	-ledit_theme_destroy(ledit_common common, ledit_theme theme) {
	+theme_destroy(ledit_common common, ledit_theme theme) {
	XftColorFree(common->dpy, common->vis, common->cm, &theme->text_fg);
	XftColorFree(common->dpy, common->vis, common->cm, &theme->text_bg);
	XftColorFree(common->dpy, common->vis, common->cm, &theme->scrollbar_f…
	diff --git a/theme.h b/theme.h
	t@@ -12,5 +12,5 @@ typedef struct {
	const char *scrollbar_bg_hex;
	} ledit_theme;

	-ledit_theme ledit_theme_create(ledit_common common);
	-void ledit_theme_destroy(ledit_common common, ledit_theme theme);
	+ledit_theme theme_create(ledit_common common);
	+void theme_destroy(ledit_common common, ledit_theme theme);
	diff --git a/undo.c b/undo.c
	t@@ -40,16 +40,16 @@ typedef struct {
	int mode_group;
	} undo_elem;

	-struct ledit_undo_stack {
	+struct undo_stack {
	/* FIXME: size_t? */
	int len, cur, cap;
	undo_elem *stack;
	int change_mode_group;
	};

	-ledit_undo_stack *
	-ledit_undo_stack_create(void) {
	- ledit_undo_stack *undo = ledit_malloc(sizeof(ledit_undo_stack));
	+undo_stack *
	+undo_stack_create(void) {
	+ undo_stack *undo = ledit_malloc(sizeof(undo_stack));
	undo->len = undo->cap = 0;
	undo->cur = -1;
	undo->stack = NULL;
	t@@ -58,14 +58,14 @@ ledit_undo_stack_create(void) {
	}

	void
	-ledit_undo_stack_destroy(ledit_undo_stack *undo) {
	+undo_stack_destroy(undo_stack *undo) {
	free(undo->stack);
	free(undo);
	}

	/* FIXME: resize text buffers when they aren't needed anymore */
	static undo_elem *
	-push_undo_elem(ledit_undo_stack *undo) {
	+push_undo_elem(undo_stack *undo) {
	assert(undo->cur >= -1);
	undo->cur++;
	undo->len = undo->cur + 1;
	t@@ -82,20 +82,20 @@ push_undo_elem(ledit_undo_stack *undo) {
	}

	static undo_elem *
	-peek_undo_elem(ledit_undo_stack *undo) {
	+peek_undo_elem(undo_stack *undo) {
	if (undo->cur < 0)
	return NULL;
	return &undo->stack[undo->cur];
	}

	void
	-ledit_change_mode_group(ledit_undo_stack *undo) {
	+undo_change_mode_group(undo_stack *undo) {
	undo->change_mode_group = 1;
	}

	static void
	push_undo(
	- ledit_undo_stack undo, txtbuf text,
	+ undo_stack undo, txtbuf text,
	ledit_range insert_range,
	ledit_range cursor_range,
	int start_group,
	t@@ -118,8 +118,8 @@ push_undo(
	}

	void
	-ledit_push_undo_insert(
	- ledit_undo_stack undo, txtbuf text,
	+undo_push_insert(
	+ undo_stack undo, txtbuf text,
	ledit_range insert_range, ledit_range cursor_range,
	int start_group, enum ledit_mode mode) {
	push_undo(
	t@@ -129,8 +129,8 @@ ledit_push_undo_insert(
	}

	void
	-ledit_push_undo_delete(
	- ledit_undo_stack undo, txtbuf text,
	+undo_push_delete(
	+ undo_stack undo, txtbuf text,
	ledit_range insert_range, ledit_range cursor_range,
	int start_group, enum ledit_mode mode) {
	push_undo(
	t@@ -139,8 +139,8 @@ ledit_push_undo_delete(
	);
	}

	-ledit_undo_status
	-ledit_undo(ledit_undo_stack undo, enum ledit_mode mode, void callback_data,
	+undo_status
	+ledit_undo(undo_stack undo, enum ledit_mode mode, void callback_data,
	undo_insert_callback insert_cb, undo_delete_callback delete_cb,
	size_t cur_line_ret, size_t cur_index_ret, size_t *min_line_ret) {
	undo_elem *e;
	t@@ -209,8 +209,8 @@ ledit_undo(ledit_undo_stack *undo, enum ledit_mode mode, v…
	return UNDO_NORMAL;
	}

	-ledit_undo_status
	-ledit_redo(ledit_undo_stack undo, enum ledit_mode mode, void callback_data,
	+undo_status
	+ledit_redo(undo_stack undo, enum ledit_mode mode, void callback_data,
	undo_insert_callback insert_cb, undo_delete_callback delete_cb,
	size_t cur_line_ret, size_t cur_index_ret, size_t *min_line_ret) {
	undo_elem *e;
	diff --git a/undo.h b/undo.h
	t@@ -2,32 +2,32 @@ typedef enum {
	UNDO_NORMAL,
	UNDO_OLDEST_CHANGE,
	UNDO_NEWEST_CHANGE
	-} ledit_undo_status;
	+} undo_status;

	-typedef struct ledit_undo_stack ledit_undo_stack;
	+typedef struct undo_stack undo_stack;
	typedef void (undo_insert_callback)(void , size_t, size_t, char *, size_t);
	typedef void (undo_delete_callback)(void , size_t, size_t, size_t, size_t);

	-ledit_undo_stack *ledit_undo_stack_create(void);
	-void ledit_undo_stack_destroy(ledit_undo_stack *undo);
	-void ledit_change_mode_group(ledit_undo_stack *undo);
	-void ledit_push_undo_insert(
	- ledit_undo_stack undo, txtbuf text,
	+undo_stack *undo_stack_create(void);
	+void undo_stack_destroy(undo_stack *undo);
	+void undo_change_mode_group(undo_stack *undo);
	+void undo_push_insert(
	+ undo_stack undo, txtbuf text,
	ledit_range insert_range, ledit_range cursor_range,
	int start_group, enum ledit_mode mode
	);
	-void ledit_push_undo_delete(
	- ledit_undo_stack undo, txtbuf text,
	+void undo_push_delete(
	+ undo_stack undo, txtbuf text,
	ledit_range insert_range, ledit_range cursor_range,
	int start_group, enum ledit_mode mode
	);
	-ledit_undo_status ledit_undo(
	- ledit_undo_stack *undo, enum ledit_mode mode,
	+undo_status ledit_undo(
	+ undo_stack *undo, enum ledit_mode mode,
	void *callback_data, undo_insert_callback insert_cb, undo_delete_callback …
	size_t cur_line_ret, size_t cur_index_ret, size_t *min_line_ret
	);
	-ledit_undo_status ledit_redo(
	- ledit_undo_stack *undo, enum ledit_mode mode,
	+undo_status ledit_redo(
	+ undo_stack *undo, enum ledit_mode mode,
	void *callback_data, undo_insert_callback insert_cb, undo_delete_callback …
	size_t cur_line_ret, size_t cur_index_ret, size_t *min_line_ret
	);
	diff --git a/util.c b/util.c
	t@@ -13,7 +13,7 @@
	#include "util.h"

	ledit_draw *
	-ledit_draw_create(ledit_window *window, int w, int h) {
	+draw_create(ledit_window *window, int w, int h) {
	ledit_draw *draw = ledit_malloc(sizeof(ledit_draw));
	draw->w = w;
	draw->h = h;
	t@@ -27,7 +27,7 @@ ledit_draw_create(ledit_window *window, int w, int h) {
	}

	void
	-ledit_draw_grow(ledit_window window, ledit_draw draw, int w, int h) {
	+draw_grow(ledit_window window, ledit_draw draw, int w, int h) {
	/* FIXME: sensible default pixmap sizes here */
	/* FIXME: maybe shrink the pixmaps at some point */
	if (draw->w < w \|\| draw->h < h) {
	t@@ -43,7 +43,7 @@ ledit_draw_grow(ledit_window window, ledit_draw draw, int …
	}

	void
	-ledit_draw_destroy(ledit_window window, ledit_draw draw) {
	+draw_destroy(ledit_window window, ledit_draw draw) {
	XFreePixmap(window->common->dpy, draw->pixmap);
	XftDrawDestroy(draw->xftdraw);
	free(draw);
	diff --git a/util.h b/util.h
	t@@ -6,6 +6,6 @@ typedef struct {
	int w, h;
	} ledit_draw;

	-ledit_draw ledit_draw_create(ledit_window window, int w, int h);
	-void ledit_draw_grow(ledit_window window, ledit_draw draw, int w, int h);
	-void ledit_draw_destroy(ledit_window window, ledit_draw draw);
	+ledit_draw draw_create(ledit_window window, int w, int h);
	+void draw_grow(ledit_window window, ledit_draw draw, int w, int h);
	+void draw_destroy(ledit_window window, ledit_draw draw);
	diff --git a/view.c b/view.c
	t@@ -71,8 +71,8 @@ static void invalidate_layout_line_helper(void *data, size_t…
	void
	view_set_mode(ledit_view *view, enum ledit_mode mode) {
	view->mode = mode;
	- ledit_change_mode_group(view->buffer->undo);
	- ledit_window_set_mode(view->window, mode);
	+ undo_change_mode_group(view->buffer->undo);
	+ window_set_mode(view->window, mode);
	}

	ledit_view *
	t@@ -88,13 +88,13 @@ view_create(ledit_buffer buffer, ledit_theme theme, enum…
	ledit_view *view = ledit_malloc(sizeof(ledit_view));
	view->mode = mode;
	view->buffer = buffer;
	- view->window = ledit_window_create(buffer->common, theme, mode);
	+ view->window = window_create(buffer->common, theme, mode);
	view->theme = theme;
	view->cache = cache_create(buffer->common->dpy);
	view->cur_action = (struct action){ACTION_NONE, NULL};
	- ledit_window_set_scroll_callback(view->window, &view_scroll_handler, v…
	- ledit_window_set_button_callback(view->window, &view_button_handler, v…
	- ledit_window_set_resize_callback(view->window, &view_resize_textview, …
	+ window_set_scroll_callback(view->window, &view_scroll_handler, view);
	+ window_set_button_callback(view->window, &view_button_handler, view);
	+ window_set_resize_callback(view->window, &view_resize_textview, view);

	view->lines = ledit_reallocarray(NULL, buffer->lines_cap, sizeof(ledit…
	view->lines_cap = buffer->lines_cap;
	t@@ -235,7 +235,7 @@ view_notify_delete_lines(ledit_view *view, size_t index1, …
	void
	view_destroy(ledit_view *view) {
	cache_destroy(view->cache);
	- ledit_window_destroy(view->window);
	+ window_destroy(view->window);
	free(view->lines);
	free(view);
	}
	t@@ -269,7 +269,7 @@ get_pango_attributes(ledit_view *view, size_t start_byte, …
	/* this takes layout directly to possibly avoid infinite recursion */
	static void
	set_line_layout_attrs(ledit_view view, size_t line, PangoLayout layout) {
	- ledit_line *ll = ledit_buffer_get_line(view->buffer, line);
	+ ledit_line *ll = buffer_get_line(view->buffer, line);
	ledit_view_line *vl = view_get_line(view, line);
	PangoAttrList *list = NULL;
	if (view->sel_valid) {
	t@@ -375,7 +375,7 @@ view_render_line(ledit_view *view, size_t line_index) {
	static void
	init_line(ledit_view view, ledit_view_line line) {
	int text_w, text_h;
	- ledit_window_get_textview_size(view->window, &text_w, &text_h);
	+ window_get_textview_size(view->window, &text_w, &text_h);
	line->view = view;
	line->w = text_w;
	line->h = 0;
	t@@ -429,7 +429,7 @@ view_recalc_line(ledit_view *view, size_t line) {
	set_pango_text_and_highlight(view, line);

	int text_w, text_h;
	- ledit_window_get_textview_size(view->window, &text_w, &text_h);
	+ window_get_textview_size(view->window, &text_w, &text_h);
	/* if height changed, set height of current line
	* and adjust offsets of all lines following it */
	if (l->h_dirty) {
	t@@ -449,7 +449,7 @@ view_recalc_line(ledit_view *view, size_t line) {
	l->y_offset + l->h >= view->display_offset) {
	view->redraw = 1;
	}
	- ledit_window_set_scroll_max(view->window, view->total_height);
	+ window_set_scroll_max(view->window, view->total_height);
	view_scroll(view, view->display_offset);
	}

	t@@ -459,7 +459,7 @@ void
	view_recalc_from_line(ledit_view *view, size_t line) {
	ledit_view_line *l = view_get_line(view, line);
	int text_w, text_h;
	- ledit_window_get_textview_size(view->window, &text_w, &text_h);
	+ window_get_textview_size(view->window, &text_w, &text_h);
	long off = l->y_offset;
	if (off < view->display_offset + text_h)
	view->redraw = 1;
	t@@ -472,7 +472,7 @@ view_recalc_from_line(ledit_view *view, size_t line) {
	off += l->h;
	}
	view->total_height = off;
	- ledit_window_set_scroll_max(view->window, view->total_height);
	+ window_set_scroll_max(view->window, view->total_height);
	view_scroll(view, view->display_offset);
	}

	t@@ -487,7 +487,7 @@ view_recalc_all_lines(ledit_view *view) {
	int
	view_line_visible(ledit_view *view, size_t index) {
	int text_w, text_h;
	- ledit_window_get_textview_size(view->window, &text_w, &text_h);
	+ window_get_textview_size(view->window, &text_w, &text_h);
	ledit_view_line *l = view_get_line(view, index);
	return l->y_offset < view->display_offset + text_h &&
	l->y_offset + l->h > view->display_offset;
	t@@ -498,7 +498,7 @@ view_line_visible(ledit_view *view, size_t index) {
	size_t
	view_next_cursor_pos(ledit_view *view, size_t line, size_t byte, int num) {
	int nattrs;
	- ledit_line *ll = ledit_buffer_get_line(view->buffer, line);
	+ ledit_line *ll = buffer_get_line(view->buffer, line);
	size_t c = line_byte_to_char(ll, byte);
	size_t cur_byte = byte;
	PangoLayout *layout = get_pango_layout(view, line);
	t@@ -507,11 +507,11 @@ view_next_cursor_pos(ledit_view *view, size_t line, size…
	if (num < 0)
	return 0; /* FIXME: error */
	for (size_t i = 0; i < (size_t)num; i++) {
	- cur_byte = ledit_line_next_utf8(ll, byte);
	+ cur_byte = line_next_utf8(ll, byte);
	for (c++; c < (size_t)nattrs; c++) {
	if (attrs[c].is_cursor_position)
	break;
	- cur_byte = ledit_line_next_utf8(ll, cur_byte);
	+ cur_byte = line_next_utf8(ll, cur_byte);
	}
	if (cur_byte >= ll->len)
	break;
	t@@ -522,7 +522,7 @@ view_next_cursor_pos(ledit_view *view, size_t line, size_t…
	size_t
	view_prev_cursor_pos(ledit_view *view, size_t line, size_t byte, int num) {
	int nattrs;
	- ledit_line *ll = ledit_buffer_get_line(view->buffer, line);
	+ ledit_line *ll = buffer_get_line(view->buffer, line);
	size_t c = line_byte_to_char(ll, byte);
	size_t cur_byte = byte;
	PangoLayout *layout = get_pango_layout(view, line);
	t@@ -531,11 +531,11 @@ view_prev_cursor_pos(ledit_view *view, size_t line, size…
	if (num < 0)
	return 0; /* FIXME: error */
	for (int i = 0; i < num; i++) {
	- cur_byte = ledit_line_prev_utf8(ll, cur_byte);
	+ cur_byte = line_prev_utf8(ll, cur_byte);
	for (; c > 0; c--) {
	if (attrs[c-1].is_cursor_position)
	break;
	- cur_byte = ledit_line_prev_utf8(ll, cur_byte);
	+ cur_byte = line_prev_utf8(ll, cur_byte);
	}
	if (cur_byte <= 0)
	break;
	t@@ -549,8 +549,8 @@ line_next_word(
	size_t line, size_t byte, size_t char_index, int wrapped_line,
	size_t char_ret, size_t byte_ret, size_t *real_byte_ret) {
	int nattrs;
	- ledit_line *ll = ledit_buffer_get_line(view->buffer, line);
	- int cur_byte = wrapped_line ? byte : ledit_line_next_utf8(ll, byte);
	+ ledit_line *ll = buffer_get_line(view->buffer, line);
	+ int cur_byte = wrapped_line ? byte : line_next_utf8(ll, byte);
	PangoLayout *layout = get_pango_layout(view, line);
	const PangoLogAttr *attrs =
	pango_layout_get_log_attrs_readonly(layout, &nattrs);
	t@@ -561,7 +561,7 @@ line_next_word(
	*byte_ret = cur_byte;
	return 0;
	}
	- cur_byte = ledit_line_next_utf8(ll, cur_byte);
	+ cur_byte = line_next_utf8(ll, cur_byte);
	}
	return -1;
	}
	t@@ -572,8 +572,8 @@ line_prev_word(
	size_t line, size_t byte, size_t char_index,
	size_t char_ret, size_t byte_ret) {
	int nattrs;
	- ledit_line *ll = ledit_buffer_get_line(view->buffer, line);
	- size_t cur_byte = ledit_line_prev_utf8(ll, byte);
	+ ledit_line *ll = buffer_get_line(view->buffer, line);
	+ size_t cur_byte = line_prev_utf8(ll, byte);
	PangoLayout *layout = get_pango_layout(view, line);
	const PangoLogAttr *attrs =
	pango_layout_get_log_attrs_readonly(layout, &nattrs);
	t@@ -586,7 +586,7 @@ line_prev_word(
	*byte_ret = cur_byte;
	return 0;
	}
	- cur_byte = ledit_line_prev_utf8(ll, cur_byte);
	+ cur_byte = line_prev_utf8(ll, cur_byte);
	}
	return -1;
	}
	t@@ -597,8 +597,8 @@ line_prev_bigword(
	size_t line, size_t byte, size_t char_index,
	size_t char_ret, size_t byte_ret) {
	int nattrs;
	- ledit_line *ll = ledit_buffer_get_line(view->buffer, line);
	- size_t cur_byte = ledit_line_prev_utf8(ll, byte);
	+ ledit_line *ll = buffer_get_line(view->buffer, line);
	+ size_t cur_byte = line_prev_utf8(ll, byte);
	PangoLayout *layout = get_pango_layout(view, line);
	const PangoLogAttr *attrs =
	pango_layout_get_log_attrs_readonly(layout, &nattrs);
	t@@ -623,7 +623,7 @@ line_prev_bigword(
	next_cursorc = i-1;
	next_cursorb = cur_byte;
	}
	- cur_byte = ledit_line_prev_utf8(ll, cur_byte);
	+ cur_byte = line_prev_utf8(ll, cur_byte);
	}
	return -1;
	}
	t@@ -634,7 +634,7 @@ line_next_bigword_end(
	size_t line, size_t byte, size_t char_index, int wrapped_line,
	size_t char_ret, size_t byte_ret, size_t *real_byte_ret) {
	int nattrs;
	- ledit_line *ll = ledit_buffer_get_line(view->buffer, line);
	+ ledit_line *ll = buffer_get_line(view->buffer, line);
	PangoLayout *layout = get_pango_layout(view, line);
	const PangoLogAttr *attrs =
	pango_layout_get_log_attrs_readonly(layout, &nattrs);
	t@@ -663,7 +663,7 @@ line_next_bigword_end(
	last_cursorb = cur_byte;
	last_cursor_valid = 1;
	}
	- cur_byte = ledit_line_next_utf8(ll, cur_byte);
	+ cur_byte = line_next_utf8(ll, cur_byte);
	}
	return -1;
	}
	t@@ -674,8 +674,8 @@ line_next_word_end(
	size_t line, size_t byte, size_t char_index, int wrapped_line,
	size_t char_ret, size_t byte_ret, size_t *real_byte_ret) {
	int nattrs;
	- ledit_line *ll = ledit_buffer_get_line(view->buffer, line);
	- size_t cur_byte = ledit_line_next_utf8(ll, byte);
	+ ledit_line *ll = buffer_get_line(view->buffer, line);
	+ size_t cur_byte = line_next_utf8(ll, byte);
	PangoLayout *layout = get_pango_layout(view, line);
	const PangoLogAttr *attrs =
	pango_layout_get_log_attrs_readonly(layout, &nattrs);
	t@@ -700,7 +700,7 @@ line_next_word_end(
	last_cursorb = cur_byte;
	last_cursor_valid = 1;
	}
	- cur_byte = ledit_line_next_utf8(ll, cur_byte);
	+ cur_byte = line_next_utf8(ll, cur_byte);
	}
	return -1;
	}
	t@@ -711,7 +711,7 @@ line_next_bigword(
	size_t line, size_t byte, size_t char_index, int wrapped_line,
	size_t char_ret, size_t byte_ret, size_t *real_byte_ret) {
	int nattrs;
	- ledit_line *ll = ledit_buffer_get_line(view->buffer, line);
	+ ledit_line *ll = buffer_get_line(view->buffer, line);
	size_t cur_byte = byte;
	PangoLayout *layout = get_pango_layout(view, line);
	const PangoLogAttr *attrs =
	t@@ -726,7 +726,7 @@ line_next_bigword(
	*byte_ret = cur_byte;
	return 0;
	}
	- cur_byte = ledit_line_next_utf8(ll, cur_byte);
	+ cur_byte = line_next_utf8(ll, cur_byte);
	}
	return -1;
	}
	t@@ -734,7 +734,7 @@ line_next_bigword(
	size_t
	view_line_next_non_whitespace(ledit_view *view, size_t line, size_t byte) {
	int nattrs;
	- ledit_line *ll = ledit_buffer_get_line(view->buffer, line);
	+ ledit_line *ll = buffer_get_line(view->buffer, line);
	size_t c = line_byte_to_char(ll, byte);
	size_t cur_byte = byte;
	PangoLayout *layout = get_pango_layout(view, line);
	t@@ -743,7 +743,7 @@ view_line_next_non_whitespace(ledit_view *view, size_t lin…
	for (; c < (size_t)nattrs; c++) {
	if (!attrs[c].is_white)
	return cur_byte;
	- cur_byte = ledit_line_next_utf8(ll, cur_byte);
	+ cur_byte = line_next_utf8(ll, cur_byte);
	}
	return ll->len;
	}
	t@@ -758,7 +758,7 @@ view_next_##name( …
	size_t line_ret, size_t byte_ret, size_t *real_byte_ret) { …
	size_t cur_line = line; …
	size_t cur_byte = byte; …
	- ledit_line *ll = ledit_buffer_get_line(view->buffer, line); …
	+ ledit_line *ll = buffer_get_line(view->buffer, line); …
	size_t cur_char = line_byte_to_char(ll, byte); …
	size_t real_byte = 0; …
	int last_ret = -1; …
	t@@ -777,7 +777,7 @@ view_next_##name( …
	} …
	if (last_ret == -1) { …
	*line_ret = view->lines_num - 1; …
	- ledit_line *ll = ledit_buffer_get_line(view->buffer, view->lin…
	+ ledit_line *ll = buffer_get_line(view->buffer, view->lines_num…
	*byte_ret = view_get_legal_normal_pos(view, view->lines_num - …
	*real_byte_ret = ll->len; …
	} else { …
	t@@ -795,14 +795,14 @@ view_prev_##name( …
	size_t line_ret, size_t byte_ret, size_t *real_byte_ret) { …
	size_t cur_line = line; …
	size_t cur_byte = byte; …
	- ledit_line *ll = ledit_buffer_get_line(view->buffer, line); …
	+ ledit_line *ll = buffer_get_line(view->buffer, line); …
	size_t cur_char = line_byte_to_char(ll, byte); …
	int last_ret = -1; …
	for (int i = 0; i < num_repeat; i++) { …
	while ((last_ret = func(view, cur_line, cur_byte, cur_char, …
	&cur_char, &cur_byte)) == -1 && cur_line > 0) { …
	cur_line--; …
	- ll = ledit_buffer_get_line(view->buffer, cur_line); …
	+ ll = buffer_get_line(view->buffer, cur_line); …
	cur_byte = ll->len; …
	} …
	if (last_ret == -1 && cur_line == 0) …
	t@@ -831,7 +831,7 @@ view_get_pos_softline_bounds(
	ledit_view *view, size_t line, size_t pos,
	size_t start_byte_ret, size_t end_byte_ret) {
	assert(line < view->lines_num);
	- ledit_line *ll = ledit_buffer_get_line(view->buffer, line);
	+ ledit_line *ll = buffer_get_line(view->buffer, line);
	assert(pos <= ll->len);
	PangoLayout *layout = get_pango_layout(view, line);
	int x, sli;
	t@@ -868,7 +868,7 @@ view_get_softline_count(ledit_view *view, size_t line) {
	int
	view_pos_to_softline(ledit_view *view, size_t line, size_t pos) {
	assert(line < view->lines_num);
	- ledit_line *ll = ledit_buffer_get_line(view->buffer, line);
	+ ledit_line *ll = buffer_get_line(view->buffer, line);
	assert(pos <= ll->len);
	PangoLayout *layout = get_pango_layout(view, line);
	int x, sli;
	t@@ -881,7 +881,7 @@ view_pos_to_softline(ledit_view *view, size_t line, size_t…
	void
	view_get_cursor_pixel_pos(ledit_view view, size_t line, size_t pos, int x_re…
	assert(line < view->lines_num);
	- ledit_line *ll = ledit_buffer_get_line(view->buffer, line);
	+ ledit_line *ll = buffer_get_line(view->buffer, line);
	assert(pos <= ll->len);
	PangoLayout *layout = get_pango_layout(view, line);
	PangoRectangle strong, weak;
	t@@ -904,7 +904,7 @@ view_move_cursor_visually(ledit_view *view, size_t line, s…
	err_overflow();
	/* FIXME: trailing */
	int trailing = 0;
	- ledit_line *cur_line = ledit_buffer_get_line(view->buffer, line);
	+ ledit_line *cur_line = buffer_get_line(view->buffer, line);
	PangoLayout *layout = get_pango_layout(view, line);
	int tmp_index;
	int new_index = (int)pos, last_index = (int)pos;
	t@@ -942,7 +942,7 @@ view_move_cursor_visually(ledit_view *view, size_t line, s…
	/* FIXME: spaces at end of softlines are weird in normal mode */
	while (trailing > 0) {
	trailing--;
	- new_index = ledit_line_next_utf8(cur_line, new_index);
	+ new_index = line_next_utf8(cur_line, new_index);
	}
	if (new_index < 0)
	new_index = 0;
	t@@ -965,7 +965,7 @@ ledit_line_word_boundaries(ledit_line *line, int byte, int…
	static void
	set_pango_text_and_highlight(ledit_view *view, size_t line) {
	cache_layout *cl;
	- ledit_line *ll = ledit_buffer_get_line(view->buffer, line);
	+ ledit_line *ll = buffer_get_line(view->buffer, line);
	ledit_view_line *vl = view_get_line(view, line);
	char old_valid = vl->cache_layout_valid;
	if (!vl->cache_layout_valid) {
	t@@ -983,7 +983,7 @@ set_pango_text_and_highlight(ledit_view *view, size_t line…
	pango_layout_set_wrap(cl->layout, PANGO_WRAP_WORD_CHAR);
	}
	if (vl->text_dirty \|\| !old_valid) {
	- ledit_buffer_normalize_line(ll);
	+ buffer_normalize_line(ll);
	if (ll->len > INT_MAX)
	err_overflow();
	pango_layout_set_text(cl->layout, ll->text, (int)ll->len);
	t@@ -1064,10 +1064,10 @@ ledit_x_softline_to_pos(ledit_view *view, size_t line,…
	/* if in insert mode, snap to the nearest border between graphemes */
	/* FIXME: add parameter for this instead of checking mode */
	if (view->mode == INSERT) {
	- ledit_line *ll = ledit_buffer_get_line(view->buffer, line);
	+ ledit_line *ll = buffer_get_line(view->buffer, line);
	while (trailing > 0) {
	trailing--;
	- pos_ret = ledit_line_next_utf8(ll, pos_ret);
	+ pos_ret = line_next_utf8(ll, pos_ret);
	}
	}
	}
	t@@ -1076,7 +1076,7 @@ size_t
	view_get_legal_normal_pos(ledit_view *view, size_t line, size_t pos) {
	/* move back one grapheme if at end of line */
	size_t ret = pos;
	- ledit_line *ll = ledit_buffer_get_line(view->buffer, line);
	+ ledit_line *ll = buffer_get_line(view->buffer, line);
	if (pos == ll->len && pos > 0) {
	int nattrs;
	PangoLayout *layout = get_pango_layout(view, line);
	t@@ -1085,10 +1085,10 @@ view_get_legal_normal_pos(ledit_view *view, size_t lin…
	if (nattrs < 2)
	return 0;
	size_t cur = nattrs - 2;
	- ret = ledit_line_prev_utf8(ll, ret);
	+ ret = line_prev_utf8(ll, ret);
	while (ret > 0 && cur > 0 && !attrs[cur].is_cursor_position) {
	cur--;
	- ret = ledit_line_prev_utf8(ll, ret);
	+ ret = line_prev_utf8(ll, ret);
	}
	}
	return ret;
	t@@ -1113,7 +1113,7 @@ view_delete_range(
	size_t min = line_index1 < line_index2 ? line_index1 : line_index2;
	/* FIXME: a bit ugly to do this here */
	for (size_t i = 0; i < view->buffer->views_num; i++) {
	- ledit_buffer_recalc_all_views_from_line(
	+ buffer_recalc_all_views_from_line(
	view->buffer, min > 0 ? min - 1 : min
	);
	}
	t@@ -1149,7 +1149,7 @@ view_delete_range_base(
	l2 = line_index1;
	}
	size_t dell1 = l1, dell2 = l2;
	- ledit_line *ll = ledit_buffer_get_line(view->buffer, line_inde…
	+ ledit_line *ll = buffer_get_line(view->buffer, line_index1);
	ledit_pos_to_x_softline(view, line_index1, byte_index1, &x, &s…
	if (l1 > 0 && l2 < view->lines_num - 1) {
	rgl1 = l1;
	t@@ -1158,10 +1158,10 @@ view_delete_range_base(
	rgb2 = 0;
	} else if (l1 > 0) {
	rgl1 = l1 - 1;
	- ll = ledit_buffer_get_line(view->buffer, rgl1);
	+ ll = buffer_get_line(view->buffer, rgl1);
	rgb1 = ll->len;
	rgl2 = l2;
	- ll = ledit_buffer_get_line(view->buffer, rgl2);
	+ ll = buffer_get_line(view->buffer, rgl2);
	rgb2 = ll->len;
	} else if (l2 < view->lines_num - 1) {
	rgl1 = l1;
	t@@ -1172,11 +1172,11 @@ view_delete_range_base(
	rgl1 = l1;
	rgb1 = 0;
	rgl2 = l2;
	- ll = ledit_buffer_get_line(view->buffer, rgl2);
	+ ll = buffer_get_line(view->buffer, rgl2);
	rgb2 = ll->len;
	}
	if (text_ret) {
	- ledit_buffer_copy_text_to_txtbuf(
	+ buffer_copy_text_to_txtbuf(
	view->buffer, text_ret,
	rgl1, rgb1, rgl2, rgb2
	);
	t@@ -1200,17 +1200,17 @@ view_delete_range_base(
	new_line = l1;
	new_byte = 0;
	/* happens when all lines are deleted, so one line has…
	- ll = ledit_buffer_get_line(view->buffer, l1);
	- ledit_buffer_delete_line_section_base(
	+ ll = buffer_get_line(view->buffer, l1);
	+ buffer_delete_line_section_base(
	view->buffer, l1, 0, ll->len
	);
	}
	if (dell1 <= dell2) {
	- ledit_buffer_delete_line_entries_base(view->buffer, de…
	+ buffer_delete_line_entries_base(view->buffer, dell1, d…
	}
	} else if (delmode == DELETE_SOFTLINE) {
	int x, softline1, softline2;
	- ledit_line *line1 = ledit_buffer_get_line(view->buffer, line_i…
	+ ledit_line *line1 = buffer_get_line(view->buffer, line_index1);
	ledit_view_line *vline1 = view_get_line(view, line_index1);
	ledit_pos_to_x_softline(view, line_index1, byte_index1, &x, &s…
	if (line_index1 == line_index2) {
	t@@ -1242,7 +1242,7 @@ view_delete_range_base(
	/* note: logically, line_index1 - 1 mu…
	view->lines_num > 1 && line_index1 …
	new_line = line_index1 - 1;
	- ledit_line *prevline = ledit_buffer_ge…
	+ ledit_line *prevline = buffer_get_line…
	ledit_view_line *vprevline = view_get_…
	if (vprevline->text_dirty)
	set_pango_text_and_highlight(v…
	t@@ -1253,26 +1253,26 @@ view_delete_range_base(
	rgb2 = line1->len;
	}
	if (text_ret) {
	- ledit_buffer_copy_text_to_txtbuf(
	+ buffer_copy_text_to_txtbuf(
	view->buffer, text_ret,
	rgl1, rgb1,
	rgl2, rgb2
	);
	}
	- ledit_buffer_delete_line_entry_base(view->buff…
	+ buffer_delete_line_entry_base(view->buffer, li…
	} else {
	assert(pl2->start_index + pl2->length >= pl1->…
	rgl1 = rgl2 = line_index1;
	rgb1 = (size_t)pl1->start_index;
	rgb2 = (size_t)(pl2->start_index + pl2->length…
	if (text_ret) {
	- ledit_buffer_copy_text_to_txtbuf(
	+ buffer_copy_text_to_txtbuf(
	view->buffer, text_ret,
	rgl1, rgb1,
	rgl2, rgb2
	);
	}
	- ledit_buffer_delete_line_section_base(
	+ buffer_delete_line_section_base(
	view->buffer, line_index1, rgb1, rgb2 - rg…
	);
	if (l2 == vline1->softlines - 1 && line_index1…
	t@@ -1319,8 +1319,8 @@ view_delete_range_base(
	l2 = line_index1;
	b2 = byte_index1;
	}
	- ledit_line *ll1 = ledit_buffer_get_line(view->buffer, …
	- ledit_line *ll2 = ledit_buffer_get_line(view->buffer, …
	+ ledit_line *ll1 = buffer_get_line(view->buffer, l1);
	+ ledit_line *ll2 = buffer_get_line(view->buffer, l2);
	ledit_view_line *vl1 = view_get_line(view, l1);
	ledit_view_line *vl2 = view_get_line(view, l2);
	PangoLayout *layout1 = get_pango_layout(view, l1);
	t@@ -1336,20 +1336,20 @@ view_delete_range_base(
	rgb1 = 0;
	rgb2 = ll2->len;
	if (text_ret) {
	- ledit_buffer_copy_text_to_txtb…
	+ buffer_copy_text_to_txtbuf(
	view->buffer, text_ret,
	rgl1, rgb1,
	rgl2, rgb2
	);
	}
	- ledit_buffer_delete_line_section_base(…
	- ledit_buffer_delete_line_entries_base(…
	+ buffer_delete_line_section_base(view->…
	+ buffer_delete_line_entries_base(view->…
	new_line = 0;
	new_byte = 0;
	} else {
	if (l2 == view->lines_num - 1) {
	new_line = l1 - 1;
	- ledit_line *new_lline = ledit_…
	+ ledit_line *new_lline = buffer…
	ledit_view_line *new_vline = v…
	if (new_vline->text_dirty)
	set_pango_text_and_hig…
	t@@ -1369,13 +1369,13 @@ view_delete_range_base(
	rgb2 = 0;
	}
	if (text_ret) {
	- ledit_buffer_copy_text_to_txtb…
	+ buffer_copy_text_to_txtbuf(
	view->buffer, text_ret,
	rgl1, rgb1,
	rgl2, rgb2
	);
	}
	- ledit_buffer_delete_line_entries_base(…
	+ buffer_delete_line_entries_base(view->…
	}
	} else if (sl1 == 0) {
	rgl1 = l1;
	t@@ -1383,16 +1383,16 @@ view_delete_range_base(
	rgl2 = l2;
	rgb2 = (size_t)(pl2->start_index + pl2->length…
	if (text_ret) {
	- ledit_buffer_copy_text_to_txtbuf(
	+ buffer_copy_text_to_txtbuf(
	view->buffer, text_ret,
	rgl1, rgb1,
	rgl2, rgb2
	);
	}
	- ledit_buffer_delete_line_section_base(view->bu…
	+ buffer_delete_line_section_base(view->buffer, …
	new_line = l1;
	ledit_x_softline_to_pos(view, l2, x, 0, &new_b…
	- ledit_buffer_delete_line_entries_base(view->bu…
	+ buffer_delete_line_entries_base(view->buffer, …
	} else if (sl2 == vl2->softlines - 1) {
	rgl1 = l1;
	rgb1 = (size_t)pl1->start_index;
	t@@ -1409,14 +1409,14 @@ view_delete_range_base(
	);
	}
	if (text_ret) {
	- ledit_buffer_copy_text_to_txtbuf(
	+ buffer_copy_text_to_txtbuf(
	view->buffer, text_ret,
	rgl1, rgb1,
	rgl2, rgb2
	);
	}
	- ledit_buffer_delete_line_section_base(view->bu…
	- ledit_buffer_delete_line_entries_base(view->bu…
	+ buffer_delete_line_section_base(view->buffer, …
	+ buffer_delete_line_entries_base(view->buffer, …
	} else {
	/* FIXME: this could be made nicer by just usi…
	delete all in one go at the end */
	t@@ -1425,19 +1425,19 @@ view_delete_range_base(
	rgl2 = l2;
	rgb2 = (size_t)(pl2->start_index + pl2->length…
	if (text_ret) {
	- ledit_buffer_copy_text_to_txtbuf(
	+ buffer_copy_text_to_txtbuf(
	view->buffer, text_ret,
	rgl1, rgb1,
	rgl2, rgb2
	);
	}
	- ledit_buffer_delete_line_section_base(view->bu…
	- ledit_buffer_insert_text_from_line_base(
	+ buffer_delete_line_section_base(view->buffer, …
	+ buffer_insert_text_from_line_base(
	view->buffer,
	l1, rgb1, l2, rgb2,
	ll2->len - rgb2, NULL
	);
	- ledit_buffer_delete_line_entries_base(view->bu…
	+ buffer_delete_line_entries_base(view->buffer, …
	new_line = l1;
	set_pango_text_and_highlight(view, l1);
	/* it's technically possible that the remainin…
	t@@ -1462,13 +1462,13 @@ view_delete_range_base(
	rgb2 = byte_index1;
	}
	if (text_ret) {
	- ledit_buffer_copy_text_to_txtbuf(
	+ buffer_copy_text_to_txtbuf(
	view->buffer, text_ret,
	rgl1, rgb1,
	rgl2, rgb2
	);
	}
	- ledit_buffer_delete_line_section_base(view->buffer, li…
	+ buffer_delete_line_section_base(view->buffer, line_ind…
	new_line = line_index1;
	new_byte = rgb1;
	} else {
	t@@ -1484,21 +1484,21 @@ view_delete_range_base(
	rgb2 = byte_index1;
	}
	if (text_ret) {
	- ledit_buffer_copy_text_to_txtbuf(
	+ buffer_copy_text_to_txtbuf(
	view->buffer, text_ret,
	rgl1, rgb1,
	rgl2, rgb2
	);
	}
	- ledit_line *line1 = ledit_buffer_get_line(view->buffer…
	- ledit_line *line2 = ledit_buffer_get_line(view->buffer…
	- ledit_buffer_delete_line_section_base(view->buffer, rg…
	- ledit_buffer_insert_text_from_line_base(
	+ ledit_line *line1 = buffer_get_line(view->buffer, rgl1…
	+ ledit_line *line2 = buffer_get_line(view->buffer, rgl2…
	+ buffer_delete_line_section_base(view->buffer, rgl1, rg…
	+ buffer_insert_text_from_line_base(
	view->buffer, rgl1, rgb1, rgl2, rgb2, line2->len -…
	);
	new_line = rgl1;
	new_byte = rgb1;
	- ledit_buffer_delete_line_entries_base(view->buffer, rg…
	+ buffer_delete_line_entries_base(view->buffer, rgl1 + 1…
	}
	/* FIXME: too much magic - maybe don't include this here */
	if (view->mode == NORMAL)
	t@@ -1522,7 +1522,7 @@ view_resize_textview(void *data) {
	ledit_view view = (ledit_view )data;
	view->total_height = 0;
	int text_w, text_h;
	- ledit_window_get_textview_size(view->window, &text_w, &text_h);
	+ window_get_textview_size(view->window, &text_w, &text_h);
	for (size_t i = 0; i < view->lines_num; i++) {
	ledit_view_line *line = view_get_line(view, i);
	line->w = text_w;
	t@@ -1533,7 +1533,7 @@ view_resize_textview(void *data) {
	line->h_dirty = 0;
	view->total_height += line->h;
	}
	- ledit_window_set_scroll_max(view->window, view->total_height);
	+ window_set_scroll_max(view->window, view->total_height);
	if (view->display_offset > 0 &&
	view->display_offset + text_h > view->total_height) {
	view_scroll(view, view->total_height - text_h);
	t@@ -1543,13 +1543,13 @@ view_resize_textview(void *data) {
	void
	view_scroll(ledit_view *view, long new_offset) {
	int text_w, text_h;
	- ledit_window_get_textview_size(view->window, &text_w, &text_h);
	+ window_get_textview_size(view->window, &text_w, &text_h);
	if (new_offset + text_h > view->total_height)
	new_offset = view->total_height - text_h;
	if (new_offset < 0)
	new_offset = 0;
	view->display_offset = new_offset;
	- ledit_window_set_scroll_pos(view->window, view->display_offset);
	+ window_set_scroll_pos(view->window, view->display_offset);
	}

	/* FIXME: there's gotta be a better/more efficient way to do this... */
	t@@ -1563,7 +1563,7 @@ view_get_nearest_legal_pos(
	PangoRectangle strong, weak;
	int text_w, text_h;
	int x, sl_useless;
	- ledit_window_get_textview_size(view->window, &text_w, &text_h);
	+ window_get_textview_size(view->window, &text_w, &text_h);
	ledit_view_line *vline = view_get_line(view, line);
	PangoLayout *layout = get_pango_layout(view, line);
	if (byte > INT_MAX)
	t@@ -1669,10 +1669,10 @@ ledit_xy_to_line_byte(ledit_view *view, int x, int y, …
	);
	*byte_ret = (size_t)index;
	if (snap_to_nearest) {
	- ledit_line *ll = ledit_buffer_get_line(view->b…
	+ ledit_line *ll = buffer_get_line(view->buffer,…
	while (trailing > 0) {
	trailing--;
	- byte_ret = ledit_line_next_utf8(ll, …
	+ byte_ret = line_next_utf8(ll, byte_r…
	}
	}
	*line_ret = i;
	t@@ -1686,7 +1686,7 @@ static void
	scroll_to_pos(ledit_view *view, size_t line, size_t byte, int top) {
	PangoRectangle strong, weak;
	int text_w, text_h;
	- ledit_window_get_textview_size(view->window, &text_w, &text_h);
	+ window_get_textview_size(view->window, &text_w, &text_h);
	ledit_view_line *vl = view_get_line(view, line);
	PangoLayout *layout = get_pango_layout(view, line);
	if (byte > INT_MAX)
	t@@ -1714,7 +1714,7 @@ void
	view_ensure_cursor_shown(ledit_view *view) {
	PangoRectangle strong, weak;
	int text_w, text_h;
	- ledit_window_get_textview_size(view->window, &text_w, &text_h);
	+ window_get_textview_size(view->window, &text_w, &text_h);
	ledit_view_line *vline = view_get_line(view, view->cur_line);
	PangoLayout *layout = get_pango_layout(view, view->cur_line);
	if (view->cur_index > INT_MAX)
	t@@ -1755,8 +1755,8 @@ view_sort_selection(size_t line1, size_t byte1, size_t…
	static void
	copy_selection_to_x_primary(ledit_view *view, size_t line1, size_t byte1, size…
	/* FIXME: let window handle this */
	- txtbuf *primary = ledit_window_get_primary_clipboard_buffer();
	- ledit_buffer_copy_text_to_txtbuf(view->buffer, primary, line1, byte1, …
	+ txtbuf *primary = window_get_primary_clipboard_buffer();
	+ buffer_copy_text_to_txtbuf(view->buffer, primary, line1, byte1, line2,…
	XSetSelectionOwner(view->buffer->common->dpy, XA_PRIMARY, view->window…
	/*
	FIXME
	t@@ -1889,7 +1889,8 @@ view_redraw_text(ledit_view *view) {
	int cur_line_y = 0;
	int cursor_displayed = 0;
	int text_w, text_h;
	- ledit_window_get_textview_size(view->window, &text_w, &text_h);
	+ window_get_textview_size(view->window, &text_w, &text_h);
	+ /* FIXME: use binary search here */
	for (size_t i = 0; i < view->lines_num; i++) {
	ledit_view_line *vline = view_get_line(view, i);
	if (h + vline->h > view->display_offset) {
	t@@ -1931,7 +1932,7 @@ view_redraw_text(ledit_view *view) {

	XSetForeground(view->buffer->common->dpy, view->window->gc, view->them…
	PangoRectangle strong, weak;
	- ledit_line *cur_line = ledit_buffer_get_line(view->buffer, view->cur_l…
	+ ledit_line *cur_line = buffer_get_line(view->buffer, view->cur_line);
	PangoLayout *layout = get_pango_layout(view, view->cur_line);
	pango_layout_get_cursor_pos(
	layout, (int)view->cur_index, &strong, &weak
	t@@ -1999,16 +2000,16 @@ view_redraw_text(ledit_view *view) {
	void
	view_redraw(ledit_view *view) {
	if (view->redraw \|\| view->window->redraw) {
	- ledit_window_clear(view->window);
	+ window_clear(view->window);
	view_redraw_text(view);
	- ledit_window_redraw(view->window);
	+ window_redraw(view->window);
	}
	}

	static void
	undo_insert_helper(void data, size_t line, size_t byte, char text, size_t te…
	ledit_view view = (ledit_view )data;
	- ledit_buffer_insert_text_with_newlines_base(view->buffer, line, byte, …
	+ buffer_insert_text_with_newlines_base(view->buffer, line, byte, text, …
	}

	static void
	t@@ -2033,7 +2034,7 @@ view_undo(ledit_view *view) {
	view_wipe_line_cursor_attrs(view, old_line);
	view_set_line_cursor_attrs(view, view->cur_line, view->cur_index);
	if (min_line < view->lines_num) {
	- ledit_buffer_recalc_all_views_from_line(
	+ buffer_recalc_all_views_from_line(
	view->buffer, min_line > 0 ? min_line - 1 : min_line
	);
	}
	t@@ -2056,7 +2057,7 @@ view_redo(ledit_view *view) {
	view_wipe_line_cursor_attrs(view, old_line);
	view_set_line_cursor_attrs(view, view->cur_line, view->cur_index);
	if (min_line < view->lines_num) {
	- ledit_buffer_recalc_all_views_from_line(
	+ buffer_recalc_all_views_from_line(
	view->buffer, min_line > 0 ? min_line - 1 : min_line
	);
	}
	t@@ -2070,13 +2071,13 @@ paste_callback(void data, char text, size_t len) {
	ledit_range cur_range, ins_range;
	cur_range.line1 = ins_range.line1 = view->cur_line;
	cur_range.byte1 = ins_range.byte1 = view->cur_index;
	- ledit_buffer_insert_text_with_newlines(
	+ buffer_insert_text_with_newlines(
	view->buffer, view->cur_line, view->cur_index,
	text, len, &view->cur_line, &view->cur_index
	);
	cur_range.line2 = ins_range.line2 = view->cur_line;
	cur_range.byte2 = ins_range.byte2 = view->cur_index;
	- ledit_push_undo_insert(
	+ undo_push_insert(
	view->buffer->undo, &ins_buf, ins_range, cur_range, 1, view->mode
	);
	}
	t@@ -2085,12 +2086,12 @@ paste_callback(void data, char text, size_t len) {

	void
	view_paste_clipboard(ledit_view *view) {
	- ledit_window_set_paste_callback(view->window, &paste_callback, view);
	+ window_set_paste_callback(view->window, &paste_callback, view);
	clipboard_paste_clipboard(view->window);
	}

	void
	view_paste_primary(ledit_view *view) {
	- ledit_window_set_paste_callback(view->window, &paste_callback, view);
	+ window_set_paste_callback(view->window, &paste_callback, view);
	clipboard_paste_primary(view->window);
	}
	diff --git a/window.c b/window.c
	t@@ -57,7 +57,7 @@ static void clipboard_selnotify(ledit_window *window, XEvent…
	static void clipboard_selrequest(ledit_window window, XEvent e);

	txtbuf *
	-ledit_window_get_primary_clipboard_buffer(void) {
	+window_get_primary_clipboard_buffer(void) {
	/* FIXME: check if NULL */
	return xsel.primary;
	}
	t@@ -76,7 +76,7 @@ recalc_text_size(ledit_window *window) {

	/* FIXME: allow lines longer than window width to be displayed properly */
	void
	-ledit_window_insert_bottom_bar_text(ledit_window window, char text, int len)…
	+window_insert_bottom_bar_text(ledit_window window, char text, int len) {
	assert(len >= -1);
	assert(window->bb->line_cur_pos <= window->bb->line_len);

	t@@ -101,7 +101,7 @@ ledit_window_insert_bottom_bar_text(ledit_window *window, …
	window->bb->line_text[window->bb->line_len] = '\0';
	pango_layout_set_text(window->bb->line, window->bb->line_text, window-…
	pango_layout_get_pixel_size(window->bb->line, &window->bb->line_w, &wi…
	- ledit_draw_grow(window, window->bb->line_draw, window->bb->line_w, win…
	+ draw_grow(window, window->bb->line_draw, window->bb->line_w, window->b…
	XftDrawRect(window->bb->line_draw->xftdraw, &window->theme->text_bg, 0…
	pango_xft_render_layout(window->bb->line_draw->xftdraw, &window->theme…
	recalc_text_size(window);
	t@@ -109,7 +109,7 @@ ledit_window_insert_bottom_bar_text(ledit_window *window, …
	}

	void
	-ledit_window_move_bottom_bar_cursor(ledit_window *window, int movement) {
	+window_move_bottom_bar_cursor(ledit_window *window, int movement) {
	assert(window->bb->line_cur_pos <= window->bb->line_len);
	int trailing = 0;
	int new_index = window->bb->line_cur_pos;
	t@@ -135,25 +135,25 @@ ledit_window_move_bottom_bar_cursor(ledit_window *window…
	}

	void
	-ledit_window_set_bottom_bar_min_pos(ledit_window *window, int pos) {
	+window_set_bottom_bar_min_pos(ledit_window *window, int pos) {
	window->bb->min_pos = pos;
	}

	void
	-ledit_window_bottom_bar_cursor_to_beginning(ledit_window *window) {
	+window_bottom_bar_cursor_to_beginning(ledit_window *window) {
	window->bb->line_cur_pos = window->bb->min_pos;
	window->redraw = 1;
	}

	void
	-ledit_window_bottom_bar_cursor_to_end(ledit_window *window) {
	+window_bottom_bar_cursor_to_end(ledit_window *window) {
	window->bb->line_cur_pos = window->bb->line_len;
	window->redraw = 1;
	}

	/* FIXME: respect PangoLogAttr.backspace_deletes_character */
	void
	-ledit_window_delete_bottom_bar_char(ledit_window *window, int dir) {
	+window_delete_bottom_bar_char(ledit_window *window, int dir) {
	int byte = window->bb->line_cur_pos;
	if (dir < 0) {
	byte--;
	t@@ -189,7 +189,7 @@ ledit_window_delete_bottom_bar_char(ledit_window *window, …
	window->bb->line_text[window->bb->line_len] = '\0';
	pango_layout_set_text(window->bb->line, window->bb->line_text, window-…
	pango_layout_get_pixel_size(window->bb->line, &window->bb->line_w, &wi…
	- ledit_draw_grow(window, window->bb->line_draw, window->bb->line_w, win…
	+ draw_grow(window, window->bb->line_draw, window->bb->line_w, window->b…
	XftDrawRect(window->bb->line_draw->xftdraw, &window->theme->text_bg, 0…
	pango_xft_render_layout(window->bb->line_draw->xftdraw, &window->theme…
	recalc_text_size(window);
	t@@ -197,7 +197,7 @@ ledit_window_delete_bottom_bar_char(ledit_window *window, …
	}

	void
	-ledit_window_set_bottom_bar_cursor(ledit_window *window, int byte_pos) {
	+window_set_bottom_bar_cursor(ledit_window *window, int byte_pos) {
	/* FIXME: check if valid? */
	window->bb->line_cur_pos = byte_pos;
	window->redraw = 1;
	t@@ -209,7 +209,7 @@ ledit_window_get_bottom_bar_cursor(ledit_window *window) {
	}

	void
	-ledit_window_set_bottom_bar_text_shown(ledit_window *window, int shown) {
	+window_set_bottom_bar_text_shown(ledit_window *window, int shown) {
	window->bottom_text_shown = shown;
	window->redraw = 1;
	}
	t@@ -221,21 +221,21 @@ ledit_window_bottom_bar_text_shown(ledit_window *window)…
	}

	void
	-ledit_window_set_bottom_bar_text(ledit_window window, char text, int len) {
	+window_set_bottom_bar_text(ledit_window window, char text, int len) {
	window->bb->line_len = 0;
	window->bb->line_cur_pos = 0;
	- ledit_window_insert_bottom_bar_text(window, text, len);
	+ window_insert_bottom_bar_text(window, text, len);
	window->redraw = 1;
	}

	char *
	-ledit_window_get_bottom_bar_text(ledit_window *window) {
	+window_get_bottom_bar_text(ledit_window *window) {
	return window->bb->line_text;
	}

	void
	-ledit_window_show_message(ledit_window window, char text, int len) {
	- ledit_window_set_bottom_bar_text(window, text, len);
	+window_show_message(ledit_window window, char text, int len) {
	+ window_set_bottom_bar_text(window, text, len);
	/* FIXME: rename these */
	window->bottom_text_shown = 0;
	window->message_shown = 1;
	t@@ -243,18 +243,18 @@ ledit_window_show_message(ledit_window window, char te…
	}

	int
	-ledit_window_message_shown(ledit_window *window) {
	+window_message_shown(ledit_window *window) {
	return window->message_shown;
	}

	void
	-ledit_window_hide_message(ledit_window *window) {
	+window_hide_message(ledit_window *window) {
	window->message_shown = 0;
	window->redraw = 1;
	}

	void
	-ledit_window_set_mode(ledit_window *window, enum ledit_mode mode) {
	+window_set_mode(ledit_window *window, enum ledit_mode mode) {
	window->mode = mode;
	char *text;
	switch (mode) {
	t@@ -275,7 +275,7 @@ ledit_window_set_mode(ledit_window *window, enum ledit_mod…
	pango_layout_set_text(window->bb->mode, final_text, -1);
	free(final_text);
	pango_layout_get_pixel_size(window->bb->mode, &window->bb->mode_w, &wi…
	- ledit_draw_grow(window, window->bb->mode_draw, window->bb->mode_w, win…
	+ draw_grow(window, window->bb->mode_draw, window->bb->mode_w, window->b…
	XftDrawRect(window->bb->mode_draw->xftdraw, &window->theme->text_bg, 0…
	pango_xft_render_layout(window->bb->mode_draw->xftdraw, &window->theme…
	recalc_text_size(window);
	t@@ -283,9 +283,9 @@ ledit_window_set_mode(ledit_window *window, enum ledit_mod…
	}

	void
	-ledit_window_set_mode_extra_text(ledit_window window, char text) {
	+window_set_mode_extra_text(ledit_window window, char text) {
	window->mode_extra_text = ledit_strdup(text);
	- ledit_window_set_mode(window, window->mode);
	+ window_set_mode(window, window->mode);
	window->redraw = 1;
	}

	t@@ -311,37 +311,37 @@ set_scroll_pos(ledit_window *window, double pos) {
	}

	void
	-ledit_window_set_scroll_max(ledit_window *window, long max) {
	+window_set_scroll_max(ledit_window *window, long max) {
	window->scroll_max = max;
	window->redraw = 1;
	}

	void
	-ledit_window_set_scroll_pos(ledit_window *window, long pos) {
	+window_set_scroll_pos(ledit_window *window, long pos) {
	window->scroll_offset = pos;
	window->redraw = 1;
	}

	void
	-ledit_window_set_scroll_callback(ledit_window window, void (cb)(void *, long…
	+window_set_scroll_callback(ledit_window window, void (cb)(void *, long), voi…
	window->scroll_callback = cb;
	window->scroll_cb_data = data;
	}

	void
	-ledit_window_set_paste_callback(ledit_window window, void (cb)(void *, char …
	+window_set_paste_callback(ledit_window window, void (cb)(void , char , siz…
	window->paste_callback = cb;
	window->paste_cb_data = data;
	}

	void
	-ledit_window_set_button_callback(ledit_window window, void (cb)(void *, XEve…
	+window_set_button_callback(ledit_window window, void (cb)(void , XEvent ),…
	window->button_callback = cb;
	window->button_cb_data = data;
	}

	void
	-ledit_window_set_resize_callback(ledit_window window, void (cb)(void *), voi…
	+window_set_resize_callback(ledit_window window, void (cb)(void ), void dat…
	window->resize_callback = cb;
	window->resize_cb_data = data;
	}
	t@@ -433,7 +433,7 @@ xximspot(ledit_window *window, int x, int y) {
	}

	ledit_window *
	-ledit_window_create(ledit_common common, ledit_theme theme, enum ledit_mode …
	+window_create(ledit_common common, ledit_theme theme, enum ledit_mode mode) {
	XSetWindowAttributes attrs;
	XGCValues gcv;

	t@@ -500,10 +500,10 @@ ledit_window_create(ledit_common common, ledit_theme t…
	window->bb->mode = pango_layout_new(window->context);
	pango_layout_set_font_description(window->bb->mode, window->font);
	/* FIXME: only create "dummy draw" at first and create with proper siz…
	- window->bb->mode_draw = ledit_draw_create(window, 10, 10);
	+ window->bb->mode_draw = draw_create(window, 10, 10);
	window->bb->line = pango_layout_new(window->context);
	pango_layout_set_font_description(window->bb->line, window->font);
	- window->bb->line_draw = ledit_draw_create(window, 10, 10);
	+ window->bb->line_draw = draw_create(window, 10, 10);
	window->bb->line_w = window->bb->line_h = 10;
	window->bb->line_text = NULL;
	window->bb->line_alloc = window->bb->line_len = 0;
	t@@ -554,13 +554,13 @@ ledit_window_create(ledit_common common, ledit_theme t…
	}

	void
	-ledit_window_destroy(ledit_window *window) {
	+window_destroy(ledit_window *window) {
	/* FIXME: check what's still missing */
	g_object_unref(window->bb->mode);
	/g_object_unref(window->bb->ruler);/ /* FIXME: implement ruler */
	g_object_unref(window->bb->line);
	- ledit_draw_destroy(window, window->bb->mode_draw);
	- ledit_draw_destroy(window, window->bb->line_draw);
	+ draw_destroy(window, window->bb->mode_draw);
	+ draw_destroy(window, window->bb->line_draw);

	pango_font_description_free(window->font);
	/* FIXME: The pango documentation says that the context must be freed,
	t@@ -581,13 +581,13 @@ ledit_window_destroy(ledit_window *window) {
	}

	void
	-ledit_window_cleanup(void) {
	+window_cleanup(void) {
	txtbuf_destroy(xsel.primary);
	free(xsel.clipboard);
	}

	void
	-ledit_window_clear(ledit_window *window) {
	+window_clear(ledit_window *window) {
	XSetForeground(window->common->dpy, window->gc, window->theme->text_bg…
	XFillRectangle(
	window->common->dpy, window->back_buf, window->gc, 0, 0, window->w…
	t@@ -595,7 +595,7 @@ ledit_window_clear(ledit_window *window) {
	}

	void
	-ledit_window_redraw(ledit_window *window) {
	+window_redraw(ledit_window *window) {
	ledit_theme *t = window->theme;
	if (window->scroll_max > window->text_h) {
	XSetForeground(window->common->dpy, window->gc, t->scrollbar_b…
	t@@ -680,19 +680,19 @@ ledit_window_redraw(ledit_window *window) {
	}

	void
	-ledit_window_get_textview_size(ledit_window window, int w_ret, int *h_ret) {
	+window_get_textview_size(ledit_window window, int w_ret, int *h_ret) {
	*w_ret = window->text_w;
	*h_ret = window->text_h;
	}

	void
	-ledit_window_handle_filtered_events(ledit_window *window) {
	+window_handle_filtered_events(ledit_window *window) {
	struct timespec now, elapsed;
	if (window->last_motion_valid) {
	clock_gettime(CLOCK_MONOTONIC, &now);
	ledit_timespecsub(&now, &window->last_motion, &elapsed);
	if (elapsed.tv_sec > 0 \|\| elapsed.tv_nsec >= MOUSE_TICK) {
	- ledit_window_drag_motion(window, &window->last_motion_…
	+ window_drag_motion(window, &window->last_motion_event);
	window->last_motion = now;
	window->last_motion_valid = 0;
	}
	t@@ -701,7 +701,7 @@ ledit_window_handle_filtered_events(ledit_window *window) {
	clock_gettime(CLOCK_MONOTONIC, &now);
	ledit_timespecsub(&now, &window->last_scroll, &elapsed);
	if (elapsed.tv_sec > 0 \|\| elapsed.tv_nsec >= MOUSE_TICK) {
	- ledit_window_button_press(window, &window->last_scroll…
	+ window_button_press(window, &window->last_scroll_event…
	window->last_scroll = now;
	window->last_scroll_valid = 0;
	}
	t@@ -710,7 +710,7 @@ ledit_window_handle_filtered_events(ledit_window *window) {
	clock_gettime(CLOCK_MONOTONIC, &now);
	ledit_timespecsub(&now, &window->last_resize, &elapsed);
	if (elapsed.tv_sec > 0 \|\| elapsed.tv_nsec >= RESIZE_TICK) {
	- ledit_window_resize(
	+ window_resize(
	window,
	window->last_resize_event.xconfigure.width,
	window->last_resize_event.xconfigure.height
	t@@ -723,7 +723,7 @@ ledit_window_handle_filtered_events(ledit_window *window) {
	}

	void
	-ledit_window_resize(ledit_window *window, int w, int h) {
	+window_resize(ledit_window *window, int w, int h) {
	window->w = w;
	window->h = h;
	recalc_text_size(window);
	t@@ -908,7 +908,7 @@ clipboard_selrequest(ledit_window window, XEvent e)
	}

	void
	-ledit_window_register_button_press(ledit_window window, XEvent event) {
	+window_register_button_press(ledit_window window, XEvent event) {
	int scroll_delta;
	if (event->xbutton.button == Button4 \|\|
	event->xbutton.button == Button5) {
	t@@ -921,25 +921,25 @@ ledit_window_register_button_press(ledit_window *window,…
	window->scroll_num = scroll_delta;
	}
	} else {
	- ledit_window_button_press(window, event, 0);
	+ window_button_press(window, event, 0);
	}
	}

	void
	-ledit_window_register_resize(ledit_window window, XEvent event) {
	+window_register_resize(ledit_window window, XEvent event) {
	window->last_resize_event = *event;
	window->last_resize_valid = 1;
	}

	void
	-ledit_window_register_motion(ledit_window window, XEvent event) {
	+window_register_motion(ledit_window window, XEvent event) {
	window->last_motion_event = *event;
	window->last_motion_valid = 1;
	}

	/* FIXME: improve set_scroll_pos; make it a bit clearer */
	void
	-ledit_window_button_press(ledit_window window, XEvent event, int scroll_num)…
	+window_button_press(ledit_window window, XEvent event, int scroll_num) {
	int x, y;
	double scroll_h, scroll_y;
	switch (event->xbutton.button) {
	t@@ -976,7 +976,7 @@ ledit_window_button_press(ledit_window window, XEvent ev…
	}

	void
	-ledit_window_button_release(ledit_window window, XEvent event) {
	+window_button_release(ledit_window window, XEvent event) {
	if (event->xbutton.button == Button1) {
	window->scroll_dragging = 0;
	if (window->button_callback)
	t@@ -986,7 +986,7 @@ ledit_window_button_release(ledit_window window, XEvent …
	}

	void
	-ledit_window_drag_motion(ledit_window window, XEvent event) {
	+window_drag_motion(ledit_window window, XEvent event) {
	if (window->scroll_dragging) {
	double scroll_h, scroll_y;
	get_scroll_pos_height(window, &scroll_y, &scroll_h);
	t@@ -1002,7 +1002,7 @@ ledit_window_drag_motion(ledit_window window, XEvent e…
	}

	void
	-ledit_window_clipboard_event(ledit_window window, XEvent event) {
	+window_clipboard_event(ledit_window window, XEvent event) {
	/* FIXME: paste in bottom bar */
	switch (event->type) {
	case SelectionNotify:
	diff --git a/window.h b/window.h
	t@@ -59,53 +59,53 @@ typedef struct {
	char *mode_extra_text;
	} ledit_window;

	-ledit_window ledit_window_create(ledit_common common, ledit_theme *theme, en…
	-void ledit_window_destroy(ledit_window *window);
	-void ledit_window_cleanup(void);
	+ledit_window window_create(ledit_common common, ledit_theme *theme, enum led…
	+void window_destroy(ledit_window *window);
	+void window_cleanup(void);

	/* FIXME: this is a bit confusing because there's a difference between editable
	text shown and non-editable message shown */
	-void ledit_window_move_bottom_bar_cursor(ledit_window *window, int movement);
	-void ledit_window_delete_bottom_bar_char(ledit_window *window, int dir);
	-void ledit_window_bottom_bar_cursor_to_beginning(ledit_window *window);
	-void ledit_window_bottom_bar_cursor_to_end(ledit_window *window);
	-void ledit_window_set_bottom_bar_min_pos(ledit_window *window, int pos);
	-void ledit_window_set_bottom_bar_text_shown(ledit_window *window, int shown);
	+void window_move_bottom_bar_cursor(ledit_window *window, int movement);
	+void window_delete_bottom_bar_char(ledit_window *window, int dir);
	+void window_bottom_bar_cursor_to_beginning(ledit_window *window);
	+void window_bottom_bar_cursor_to_end(ledit_window *window);
	+void window_set_bottom_bar_min_pos(ledit_window *window, int pos);
	+void window_set_bottom_bar_text_shown(ledit_window *window, int shown);
	int ledit_window_bottom_bar_text_shown(ledit_window *window);
	-void ledit_window_set_bottom_bar_cursor(ledit_window *window, int byte_pos);
	+void window_set_bottom_bar_cursor(ledit_window *window, int byte_pos);
	int ledit_window_get_bottom_bar_cursor(ledit_window *window);
	-void ledit_window_insert_bottom_bar_text(ledit_window window, char text, int…
	-void ledit_window_set_bottom_bar_text(ledit_window window, char text, int le…
	-char ledit_window_get_bottom_bar_text(ledit_window window);
	-void ledit_window_show_message(ledit_window window, char text, int len);
	-void ledit_window_hide_message(ledit_window *window);
	-int ledit_window_message_shown(ledit_window *window);
	-void ledit_window_set_mode(ledit_window *window, enum ledit_mode mode);
	-void ledit_window_set_mode_extra_text(ledit_window window, char text);
	+void window_insert_bottom_bar_text(ledit_window window, char text, int len);
	+void window_set_bottom_bar_text(ledit_window window, char text, int len);
	+char window_get_bottom_bar_text(ledit_window window);
	+void window_show_message(ledit_window window, char text, int len);
	+void window_hide_message(ledit_window *window);
	+int window_message_shown(ledit_window *window);
	+void window_set_mode(ledit_window *window, enum ledit_mode mode);
	+void window_set_mode_extra_text(ledit_window window, char text);

	-void ledit_window_set_scroll_max(ledit_window *window, long max);
	-void ledit_window_set_scroll_pos(ledit_window *window, long pos);
	-void ledit_window_set_scroll_callback(ledit_window window, void (cb)(void *,…
	-void ledit_window_set_paste_callback(ledit_window window, void (cb)(void *, …
	-void ledit_window_set_button_callback(ledit_window window, void (cb)(void *,…
	-void ledit_window_set_resize_callback(ledit_window window, void (cb)(void *)…
	-void ledit_window_register_resize(ledit_window window, XEvent event);
	-void ledit_window_register_button_press(ledit_window window, XEvent event);
	-void ledit_window_register_motion(ledit_window window, XEvent event);
	-void ledit_window_handle_filtered_events(ledit_window *window);
	+void window_set_scroll_max(ledit_window *window, long max);
	+void window_set_scroll_pos(ledit_window *window, long pos);
	+void window_set_scroll_callback(ledit_window window, void (cb)(void *, long)…
	+void window_set_paste_callback(ledit_window window, void (cb)(void , char …
	+void window_set_button_callback(ledit_window window, void (cb)(void *, XEven…
	+void window_set_resize_callback(ledit_window window, void (cb)(void *), void…
	+void window_register_resize(ledit_window window, XEvent event);
	+void window_register_button_press(ledit_window window, XEvent event);
	+void window_register_motion(ledit_window window, XEvent event);
	+void window_handle_filtered_events(ledit_window *window);

	-void ledit_window_clear(ledit_window *window);
	-void ledit_window_redraw(ledit_window *window);
	-void ledit_window_resize(ledit_window *window, int w, int h);
	-void ledit_window_get_textview_size(ledit_window window, int w_ret, int *h_r…
	+void window_clear(ledit_window *window);
	+void window_redraw(ledit_window *window);
	+void window_resize(ledit_window *window, int w, int h);
	+void window_get_textview_size(ledit_window window, int w_ret, int *h_ret);

	void clipboard_primary_to_clipboard(ledit_window *window);
	void clipboard_paste_clipboard(ledit_window *window);
	void clipboard_paste_primary(ledit_window *window);
	-txtbuf *ledit_window_get_primary_clipboard_buffer(void);
	+txtbuf *window_get_primary_clipboard_buffer(void);

	-void ledit_window_button_press(ledit_window window, XEvent event, int scroll…
	-void ledit_window_button_release(ledit_window window, XEvent event);
	-void ledit_window_drag_motion(ledit_window window, XEvent event);
	-void ledit_window_clipboard_event(ledit_window window, XEvent event);
	+void window_button_press(ledit_window window, XEvent event, int scroll_num);
	+void window_button_release(ledit_window window, XEvent event);
	+void window_drag_motion(ledit_window window, XEvent event);
	+void window_clipboard_event(ledit_window window, XEvent event);
	void xximspot(ledit_window *window, int x, int y);