commit - a8a482c8f4a387119160d9b4027aad4ae806769c
commit + 46f6e97405d8f8693a6b1b1213974f96f3da3bab
blob - 1231e799a729a56a30aee811690097e438642a9b
blob + 83ecc6873598cf817804fd056c39496b2d85e511
--- cmd.h
+++ cmd.h
-struct window;
+struct buffer;
-#define CMD(fnname) void fnname(struct window *)
+#define CMD(fnname) void fnname(struct buffer *)
#define DEFALIAS(s, d) /* nothing */
CMD(cmd_previous_line);
blob - edc75ae140dd3f960138eaa470a3179e8f4f9c93
blob + 7983a140af5472a2628a733ac109e5ffaf3be6a7
--- keymap.c
+++ keymap.c
}
int
-kmap_define_key(struct kmap *map, const char *key, void (*fn)(struct window*))
+kmap_define_key(struct kmap *map, const char *key, void (*fn)(struct buffer*))
{
int ctrl, meta, k;
struct keymap *entry;
blob - 1e30c4206deb1ba2272e5a6db76cccb91374ac8b
blob + d21a21d5993abce864bc3a0fe4fab31a6421164f
--- mime.c
+++ mime.c
for (t = ptable; t->mediatype != NULL; ++t) {
if (!fnmatch(t->mediatype, buf, 0)) {
- t->parserinit(&tab->window.page);
+ t->parserinit(&tab->buffer.page);
return 1;
}
}
blob - 1eee5e55de6e7494f46e248eec4d0c7c1e2e74f9
blob + 5a2ac14a3cd7761db968ecce40265b9be099d831
--- telescope.c
+++ telescope.c
tab->bytes += datalen;
if (tab->fd == -1) {
- if (!tab->window.page.parse(&tab->window.page,
+ if (!tab->buffer.page.parse(&tab->buffer.page,
imsg->data, datalen))
die();
} else {
tab = tab_by_id(imsg->hdr.peerid);
if (tab->fd == -1) {
- if (!tab->window.page.free(&tab->window.page))
+ if (!tab->buffer.page.free(&tab->buffer.page))
die();
} else {
l = asprintf(&page, "Wrote %s (%zu bytes)\n",
static void
load_page_from_str(struct tab *tab, const char *page)
{
- gemtext_initparser(&tab->window.page);
- if (!tab->window.page.parse(&tab->window.page, page, strlen(page)))
+ gemtext_initparser(&tab->buffer.page);
+ if (!tab->buffer.page.parse(&tab->buffer.page, page, strlen(page)))
die();
- if (!tab->window.page.free(&tab->window.page))
+ if (!tab->buffer.page.free(&tab->buffer.page))
die();
ui_on_tab_refresh(tab);
ui_on_tab_loaded(tab);
{
tab->trust = TS_VERIFIED;
- gemtext_initparser(&tab->window.page);
+ gemtext_initparser(&tab->buffer.page);
imsg_compose(fsibuf, IMSG_GET, tab->id, 0, -1,
tab->hist_cur->h, strlen(tab->hist_cur->h)+1);
}
hist_push(&tab->hist, tab->hist_cur);
do_load_url(tab, url);
- empty_vlist(&tab->window);
- empty_linelist(&tab->window);
+ empty_vlist(&tab->buffer);
+ empty_linelist(&tab->buffer);
}
int
blob - 0d150af562162b1190f37e5c5f9b35276daf95be
blob + 7857e4f827d82b502488c5e1ac0ea63708f54271
--- telescope.h
+++ telescope.h
TAILQ_ENTRY(hist) entries;
};
-struct window {
+struct buffer {
struct parser page;
int curs_x;
int curs_y;
char meta[GEMINI_URL_LEN];
int redirect_count;
- struct window window;
+ struct buffer buffer;
short loading_anim;
short loading_anim_step;
int meta;
int key;
struct kmap map;
- void (*fn)(struct window*);
+ void (*fn)(struct buffer*);
TAILQ_ENTRY(keymap) keymaps;
};
/* keymap.c */
int kbd(const char*);
const char *unkbd(int);
-int kmap_define_key(struct kmap*, const char*, void(*)(struct window*));
+int kmap_define_key(struct kmap*, const char*, void(*)(struct buffer*));
/* mime.c */
int setup_parser_for(struct tab*);
void dispatch_imsg(struct imsgbuf*, imsg_handlerfn**, size_t);
/* wrap.c */
-void empty_linelist(struct window*);
-void empty_vlist(struct window*);
-int wrap_text(struct window*, const char*, struct line*, size_t);
-int hardwrap_text(struct window*, struct line*, size_t);
+void empty_linelist(struct buffer*);
+void empty_vlist(struct buffer*);
+int wrap_text(struct buffer*, const char*, struct line*, size_t);
+int hardwrap_text(struct buffer*, struct line*, size_t);
#endif /* TELESCOPE_H */
blob - 8698f2b4e9b56aabfb51e4b1c4299d61587dc284
blob + 593792ba28fe96c658798e00c63a3f61267870d6
--- ui.c
+++ ui.c
static struct event stdioev, winchev;
static void load_default_keys(void);
-static void restore_cursor(struct window*);
+static void restore_cursor(struct buffer*);
static void global_key_unbound(void);
static void minibuffer_hist_save_entry(void);
static void read_abort(void);
static void read_select(void);
-static struct vline *nth_line(struct window*, size_t);
+static struct vline *nth_line(struct buffer*, size_t);
static struct tab *current_tab(void);
-static struct window *current_window(void);
+static struct buffer *current_buffer(void);
static int readkey(void);
static void dispatch_stdio(int, short, void*);
static void handle_clear_minibuf(int, short, void*);
static void handle_resize(int, short, void*);
static void handle_resize_nodelay(int, short, void*);
-static int wrap_page(struct window*, int);
+static int wrap_page(struct buffer*, int);
static void print_vline(WINDOW*, struct vline*);
static void redraw_tabline(void);
-static void redraw_window(WINDOW*, int, struct window*);
+static void redraw_window(WINDOW*, int, struct buffer*);
static void redraw_help(void);
static void redraw_body(struct tab*);
static void redraw_modeline(struct tab*);
static int body_lines, body_cols;
static WINDOW *help;
-static struct window helpwin;
+static struct buffer helpwin;
static int help_lines, help_cols;
static int side_window;
char buf[1025];
struct line line;
struct vline vline;
- struct window window;
+ struct buffer buffer;
struct histhead *history;
struct hist *hist_cur;
};
static inline void
-global_set_key(const char *key, void (*fn)(struct window*))
+global_set_key(const char *key, void (*fn)(struct buffer*))
{
if (!kmap_define_key(&global_map, key, fn))
_exit(1);
}
static inline void
-minibuffer_set_key(const char *key, void (*fn)(struct window*))
+minibuffer_set_key(const char *key, void (*fn)(struct buffer*))
{
if (!kmap_define_key(&minibuffer_map, key, fn))
_exit(1);
}
static void
-restore_cursor(struct window *window)
+restore_cursor(struct buffer *buffer)
{
struct vline *vl;
const char *prfx;
- vl = window->current_line;
+ vl = buffer->current_line;
if (vl == NULL || vl->line == NULL)
- window->curs_x = window->cpoff = 0;
+ buffer->curs_x = buffer->cpoff = 0;
else
- window->curs_x = utf8_snwidth(vl->line, window->cpoff);
+ buffer->curs_x = utf8_snwidth(vl->line, buffer->cpoff);
if (vl != NULL) {
prfx = line_prefixes[vl->parent->type].prfx1;
- window->curs_x += utf8_swidth(prfx);
+ buffer->curs_x += utf8_swidth(prfx);
}
}
void
-cmd_previous_line(struct window *window)
+cmd_previous_line(struct buffer *buffer)
{
struct vline *vl;
- if (window->current_line == NULL
- || (vl = TAILQ_PREV(window->current_line, vhead, vlines)) == NULL)
+ if (buffer->current_line == NULL
+ || (vl = TAILQ_PREV(buffer->current_line, vhead, vlines)) == NULL)
return;
- if (--window->curs_y < 0) {
- window->curs_y = 0;
- cmd_scroll_line_up(window);
+ if (--buffer->curs_y < 0) {
+ buffer->curs_y = 0;
+ cmd_scroll_line_up(buffer);
return;
}
- window->current_line = vl;
- restore_cursor(window);
+ buffer->current_line = vl;
+ restore_cursor(buffer);
}
void
-cmd_next_line(struct window *window)
+cmd_next_line(struct buffer *buffer)
{
struct vline *vl;
- if (window->current_line == NULL
- || (vl = TAILQ_NEXT(window->current_line, vlines)) == NULL)
+ if (buffer->current_line == NULL
+ || (vl = TAILQ_NEXT(buffer->current_line, vlines)) == NULL)
return;
- if (++window->curs_y > body_lines-1) {
- window->curs_y = body_lines-1;
- cmd_scroll_line_down(window);
+ if (++buffer->curs_y > body_lines-1) {
+ buffer->curs_y = body_lines-1;
+ cmd_scroll_line_down(buffer);
return;
}
- window->current_line = vl;
- restore_cursor(window);
+ buffer->current_line = vl;
+ restore_cursor(buffer);
}
void
-cmd_backward_char(struct window *window)
+cmd_backward_char(struct buffer *buffer)
{
- if (window->cpoff != 0)
- window->cpoff--;
- restore_cursor(window);
+ if (buffer->cpoff != 0)
+ buffer->cpoff--;
+ restore_cursor(buffer);
}
void
-cmd_forward_char(struct window *window)
+cmd_forward_char(struct buffer *buffer)
{
size_t len = 0;
- if (window->current_line->line != NULL)
- len = utf8_cplen(window->current_line->line);
- if (++window->cpoff > len)
- window->cpoff = len;
- restore_cursor(window);
+ if (buffer->current_line->line != NULL)
+ len = utf8_cplen(buffer->current_line->line);
+ if (++buffer->cpoff > len)
+ buffer->cpoff = len;
+ restore_cursor(buffer);
}
void
-cmd_backward_paragraph(struct window *window)
+cmd_backward_paragraph(struct buffer *buffer)
{
do {
- if (window->current_line == NULL ||
- window->current_line == TAILQ_FIRST(&window->head)) {
+ if (buffer->current_line == NULL ||
+ buffer->current_line == TAILQ_FIRST(&buffer->head)) {
message("No previous paragraph");
return;
}
- cmd_previous_line(window);
- } while (window->current_line->line != NULL ||
- window->current_line->parent->type != LINE_TEXT);
+ cmd_previous_line(buffer);
+ } while (buffer->current_line->line != NULL ||
+ buffer->current_line->parent->type != LINE_TEXT);
}
void
-cmd_forward_paragraph(struct window *window)
+cmd_forward_paragraph(struct buffer *buffer)
{
do {
- if (window->current_line == NULL ||
- window->current_line == TAILQ_LAST(&window->head, vhead)) {
+ if (buffer->current_line == NULL ||
+ buffer->current_line == TAILQ_LAST(&buffer->head, vhead)) {
message("No next paragraph");
return;
}
- cmd_next_line(window);
- } while (window->current_line->line != NULL ||
- window->current_line->parent->type != LINE_TEXT);
+ cmd_next_line(buffer);
+ } while (buffer->current_line->line != NULL ||
+ buffer->current_line->parent->type != LINE_TEXT);
}
void
-cmd_move_beginning_of_line(struct window *window)
+cmd_move_beginning_of_line(struct buffer *buffer)
{
- window->cpoff = 0;
- restore_cursor(window);
+ buffer->cpoff = 0;
+ restore_cursor(buffer);
}
void
-cmd_move_end_of_line(struct window *window)
+cmd_move_end_of_line(struct buffer *buffer)
{
struct vline *vl;
- vl = window->current_line;
+ vl = buffer->current_line;
if (vl->line == NULL)
return;
- window->cpoff = utf8_cplen(vl->line);
- restore_cursor(window);
+ buffer->cpoff = utf8_cplen(vl->line);
+ restore_cursor(buffer);
}
void
-cmd_redraw(struct window *window)
+cmd_redraw(struct buffer *buffer)
{
handle_resize(0, 0, NULL);
}
void
-cmd_scroll_line_up(struct window *window)
+cmd_scroll_line_up(struct buffer *buffer)
{
struct vline *vl;
- if (window->line_off == 0)
+ if (buffer->line_off == 0)
return;
- vl = nth_line(window, --window->line_off);
+ vl = nth_line(buffer, --buffer->line_off);
wscrl(body, -1);
wmove(body, 0, 0);
print_vline(body, vl);
- window->current_line = TAILQ_PREV(window->current_line, vhead, vlines);
- restore_cursor(window);
+ buffer->current_line = TAILQ_PREV(buffer->current_line, vhead, vlines);
+ restore_cursor(buffer);
}
void
-cmd_scroll_line_down(struct window *window)
+cmd_scroll_line_down(struct buffer *buffer)
{
struct vline *vl;
- vl = window->current_line;
+ vl = buffer->current_line;
if ((vl = TAILQ_NEXT(vl, vlines)) == NULL)
return;
- window->current_line = vl;
+ buffer->current_line = vl;
- window->line_off++;
+ buffer->line_off++;
wscrl(body, 1);
- if (window->line_max - window->line_off < (size_t)body_lines)
+ if (buffer->line_max - buffer->line_off < (size_t)body_lines)
return;
- vl = nth_line(window, window->line_off + body_lines-1);
+ vl = nth_line(buffer, buffer->line_off + body_lines-1);
wmove(body, body_lines-1, 0);
print_vline(body, vl);
- restore_cursor(window);
+ restore_cursor(buffer);
}
void
-cmd_scroll_up(struct window *window)
+cmd_scroll_up(struct buffer *buffer)
{
size_t off;
off = body_lines-1;
for (; off > 0; --off)
- cmd_scroll_line_up(window);
+ cmd_scroll_line_up(buffer);
}
void
-cmd_scroll_down(struct window *window)
+cmd_scroll_down(struct buffer *buffer)
{
size_t off;
off = body_lines-1;
for (; off > 0; --off)
- cmd_scroll_line_down(window);
+ cmd_scroll_line_down(buffer);
}
void
-cmd_beginning_of_buffer(struct window *window)
+cmd_beginning_of_buffer(struct buffer *buffer)
{
- window->current_line = TAILQ_FIRST(&window->head);
- window->line_off = 0;
- window->curs_y = 0;
- window->cpoff = 0;
- restore_cursor(window);
+ buffer->current_line = TAILQ_FIRST(&buffer->head);
+ buffer->line_off = 0;
+ buffer->curs_y = 0;
+ buffer->cpoff = 0;
+ restore_cursor(buffer);
}
void
-cmd_end_of_buffer(struct window *window)
+cmd_end_of_buffer(struct buffer *buffer)
{
ssize_t off;
- off = window->line_max - body_lines;
+ off = buffer->line_max - body_lines;
off = MAX(0, off);
- window->line_off = off;
- window->curs_y = MIN((size_t)body_lines, window->line_max-1);
+ buffer->line_off = off;
+ buffer->curs_y = MIN((size_t)body_lines, buffer->line_max-1);
- window->current_line = TAILQ_LAST(&window->head, vhead);
- window->cpoff = body_cols;
- restore_cursor(window);
+ buffer->current_line = TAILQ_LAST(&buffer->head, vhead);
+ buffer->cpoff = body_cols;
+ restore_cursor(buffer);
}
void
-cmd_kill_telescope(struct window *window)
+cmd_kill_telescope(struct buffer *buffer)
{
save_session();
event_loopbreak();
}
void
-cmd_push_button(struct window *window)
+cmd_push_button(struct buffer *buffer)
{
struct vline *vl;
size_t nth;
- nth = window->line_off + window->curs_y;
- if (nth >= window->line_max)
+ nth = buffer->line_off + buffer->curs_y;
+ if (nth >= buffer->line_max)
return;
- vl = nth_line(window, nth);
+ vl = nth_line(buffer, nth);
if (vl->parent->type != LINE_LINK)
return;
}
void
-cmd_push_button_new_tab(struct window *window)
+cmd_push_button_new_tab(struct buffer *buffer)
{
struct vline *vl;
size_t nth;
- nth = window->line_off + window->curs_y;
- if (nth > window->line_max)
+ nth = buffer->line_off + buffer->curs_y;
+ if (nth > buffer->line_max)
return;
- vl = nth_line(window, nth);
+ vl = nth_line(buffer, nth);
if (vl->parent->type != LINE_LINK)
return;
}
void
-cmd_previous_button(struct window *window)
+cmd_previous_button(struct buffer *buffer)
{
do {
- if (window->current_line == NULL ||
- window->current_line == TAILQ_FIRST(&window->head)) {
+ if (buffer->current_line == NULL ||
+ buffer->current_line == TAILQ_FIRST(&buffer->head)) {
message("No previous link");
return;
}
- cmd_previous_line(window);
- } while (window->current_line->parent->type != LINE_LINK);
+ cmd_previous_line(buffer);
+ } while (buffer->current_line->parent->type != LINE_LINK);
}
void
-cmd_next_button(struct window *window)
+cmd_next_button(struct buffer *buffer)
{
do {
- if (window->current_line == NULL ||
- window->current_line == TAILQ_LAST(&window->head, vhead)) {
+ if (buffer->current_line == NULL ||
+ buffer->current_line == TAILQ_LAST(&buffer->head, vhead)) {
message("No next link");
return;
}
- cmd_next_line(window);
- } while (window->current_line->parent->type != LINE_LINK);
+ cmd_next_line(buffer);
+ } while (buffer->current_line->parent->type != LINE_LINK);
}
void
-cmd_previous_page(struct window *window)
+cmd_previous_page(struct buffer *buffer)
{
struct tab *tab = current_tab();
}
void
-cmd_next_page(struct window *window)
+cmd_next_page(struct buffer *buffer)
{
struct tab *tab = current_tab();
}
void
-cmd_clear_minibuf(struct window *window)
+cmd_clear_minibuf(struct buffer *buffer)
{
handle_clear_minibuf(0, 0, NULL);
}
void
-cmd_execute_extended_command(struct window *window)
+cmd_execute_extended_command(struct buffer *buffer)
{
size_t len;
}
void
-cmd_tab_close(struct window *window)
+cmd_tab_close(struct buffer *buffer)
{
struct tab *tab, *t;
}
void
-cmd_tab_close_other(struct window *window)
+cmd_tab_close_other(struct buffer *buffer)
{
struct tab *t, *i;
}
void
-cmd_tab_new(struct window *window)
+cmd_tab_new(struct buffer *buffer)
{
new_tab(NEW_TAB_URL);
}
void
-cmd_tab_next(struct window *window)
+cmd_tab_next(struct buffer *buffer)
{
struct tab *tab, *t;
}
void
-cmd_tab_previous(struct window *window)
+cmd_tab_previous(struct buffer *buffer)
{
struct tab *tab, *t;
}
void
-cmd_tab_move(struct window *window)
+cmd_tab_move(struct buffer *buffer)
{
struct tab *tab, *t;
}
void
-cmd_tab_move_to(struct window *window)
+cmd_tab_move_to(struct buffer *buffer)
{
struct tab *tab, *t;
}
void
-cmd_load_url(struct window *window)
+cmd_load_url(struct buffer *buffer)
{
if (in_minibuffer) {
message("We don't have enable-recursive-minibuffers");
&lu_history);
strlcpy(ministate.prompt, "Load URL: ", sizeof(ministate.prompt));
strlcpy(ministate.buf, "gemini://", sizeof(ministate.buf));
- cmd_move_end_of_line(&ministate.window);
+ cmd_move_end_of_line(&ministate.buffer);
}
void
-cmd_load_current_url(struct window *window)
+cmd_load_current_url(struct buffer *buffer)
{
struct tab *tab = current_tab();
&lu_history);
strlcpy(ministate.prompt, "Load URL: ", sizeof(ministate.prompt));
strlcpy(ministate.buf, tab->hist_cur->h, sizeof(ministate.buf));
- ministate.window.cpoff = utf8_cplen(ministate.buf);
+ ministate.buffer.cpoff = utf8_cplen(ministate.buf);
}
void
-cmd_bookmark_page(struct window *window)
+cmd_bookmark_page(struct buffer *buffer)
{
struct tab *tab = current_tab();
enter_minibuffer(lu_self_insert, bp_select, exit_minibuffer, NULL);
strlcpy(ministate.prompt, "Bookmark URL: ", sizeof(ministate.prompt));
strlcpy(ministate.buf, tab->hist_cur->h, sizeof(ministate.buf));
- ministate.window.cpoff = utf8_cplen(ministate.buf);
+ ministate.buffer.cpoff = utf8_cplen(ministate.buf);
}
void
-cmd_list_bookmarks(struct window *window)
+cmd_list_bookmarks(struct buffer *buffer)
{
load_url_in_tab(current_tab(), "about:bookmarks");
}
void
-cmd_toggle_help(struct window *window)
+cmd_toggle_help(struct buffer *buffer)
{
side_window = !side_window;
if (side_window)
}
void
-cmd_mini_delete_char(struct window *window)
+cmd_mini_delete_char(struct buffer *buffer)
{
char *c, *n;
minibuffer_taint_hist();
- c = utf8_nth(window->current_line->line, window->cpoff);
+ c = utf8_nth(buffer->current_line->line, buffer->cpoff);
if (*c == '\0')
return;
n = utf8_next_cp(c);
}
void
-cmd_mini_delete_backward_char(struct window *window)
+cmd_mini_delete_backward_char(struct buffer *buffer)
{
char *c, *p, *start;
minibuffer_taint_hist();
- c = utf8_nth(window->current_line->line, window->cpoff);
- start = window->current_line->line;
+ c = utf8_nth(buffer->current_line->line, buffer->cpoff);
+ start = buffer->current_line->line;
if (c == start)
return;
p = utf8_prev_cp(c-1, start);
memmove(p, c, strlen(c)+1);
- window->cpoff--;
+ buffer->cpoff--;
}
void
-cmd_mini_kill_line(struct window *window)
+cmd_mini_kill_line(struct buffer *buffer)
{
char *c;
}
minibuffer_taint_hist();
- c = utf8_nth(window->current_line->line, window->cpoff);
+ c = utf8_nth(buffer->current_line->line, buffer->cpoff);
*c = '\0';
}
void
-cmd_mini_abort(struct window *window)
+cmd_mini_abort(struct buffer *buffer)
{
if (!in_minibuffer)
return;
}
void
-cmd_mini_complete_and_exit(struct window *window)
+cmd_mini_complete_and_exit(struct buffer *buffer)
{
if (!in_minibuffer)
return;
}
void
-cmd_mini_previous_history_element(struct window *window)
+cmd_mini_previous_history_element(struct buffer *buffer)
{
if (ministate.history == NULL) {
message("No history");
}
if (ministate.hist_cur != NULL)
- window->current_line->line = ministate.hist_cur->h;
+ buffer->current_line->line = ministate.hist_cur->h;
}
void
-cmd_mini_next_history_element(struct window *window)
+cmd_mini_next_history_element(struct buffer *buffer)
{
if (ministate.history == NULL) {
message("No history");
}
if (ministate.hist_cur != NULL)
- window->current_line->line = ministate.hist_cur->h;
+ buffer->current_line->line = ministate.hist_cur->h;
}
static void
return;
len = utf8_encode(thiskey.cp, tmp);
- c = utf8_nth(ministate.window.current_line->line, ministate.window.cpoff);
+ c = utf8_nth(ministate.buffer.current_line->line, ministate.buffer.cpoff);
if (c + len > ministate.buf + sizeof(ministate.buf) - 1)
return;
memmove(c + len, c, strlen(c)+1);
memcpy(c, tmp, len);
- ministate.window.cpoff++;
+ ministate.buffer.cpoff++;
}
static void
if (!strcmp(cmd->cmd, ministate.buf)) {
exit_minibuffer();
minibuffer_hist_save_entry();
- cmd->fn(current_window());
+ cmd->fn(current_buffer());
return;
}
}
}
static struct vline *
-nth_line(struct window *window, size_t n)
+nth_line(struct buffer *buffer, size_t n)
{
struct vline *vl;
size_t i;
i = 0;
- TAILQ_FOREACH(vl, &window->head, vlines) {
+ TAILQ_FOREACH(vl, &buffer->head, vlines) {
if (i == n)
return vl;
i++;
abort();
}
-static struct window *
-current_window(void)
+static struct buffer *
+current_buffer(void)
{
if (in_minibuffer)
- return &ministate.window;
- return ¤t_tab()->window;
+ return &ministate.buffer;
+ return ¤t_tab()->buffer;
}
static int
else {
current_map = base_map;
strlcpy(keybuf, "", sizeof(keybuf));
- k->fn(current_window());
+ k->fn(current_buffer());
}
goto done;
}
tab = current_tab();
- wrap_page(&tab->window, body_cols);
+ wrap_page(&tab->buffer, body_cols);
redraw_tab(tab);
}
static int
-wrap_page(struct window *window, int width)
+wrap_page(struct buffer *buffer, int width)
{
struct line *l;
const struct line *orig;
struct vline *vl;
const char *prfx;
- orig = window->current_line == NULL
+ orig = buffer->current_line == NULL
? NULL
- : window->current_line->parent;
- window->current_line = NULL;
+ : buffer->current_line->parent;
+ buffer->current_line = NULL;
- window->curs_y = 0;
- window->line_off = 0;
+ buffer->curs_y = 0;
+ buffer->line_off = 0;
- empty_vlist(window);
+ empty_vlist(buffer);
- TAILQ_FOREACH(l, &window->page.head, lines) {
+ TAILQ_FOREACH(l, &buffer->page.head, lines) {
prfx = line_prefixes[l->type].prfx1;
switch (l->type) {
case LINE_TEXT:
case LINE_QUOTE:
case LINE_PRE_START:
case LINE_PRE_END:
- wrap_text(window, prfx, l, width);
+ wrap_text(buffer, prfx, l, width);
break;
case LINE_PRE_CONTENT:
- hardwrap_text(window, l, width);
+ hardwrap_text(buffer, l, width);
break;
}
- if (orig == l && window->current_line == NULL) {
- window->line_off = window->line_max-1;
- window->current_line = TAILQ_LAST(&window->head, vhead);
+ if (orig == l && buffer->current_line == NULL) {
+ buffer->line_off = buffer->line_max-1;
+ buffer->current_line = TAILQ_LAST(&buffer->head, vhead);
while (1) {
- vl = TAILQ_PREV(window->current_line, vhead, vlines);
+ vl = TAILQ_PREV(buffer->current_line, vhead, vlines);
if (vl == NULL || vl->parent != orig)
break;
- window->current_line = vl;
- window->line_off--;
+ buffer->current_line = vl;
+ buffer->line_off--;
}
}
}
- if (window->current_line == NULL)
- window->current_line = TAILQ_FIRST(&window->head);
+ if (buffer->current_line == NULL)
+ buffer->current_line = TAILQ_FIRST(&buffer->head);
return 1;
}
current = tab->flags & TAB_CURRENT;
- if (*(title = tab->window.page.title) == '\0')
+ if (*(title = tab->buffer.page.title) == '\0')
title = tab->hist_cur->h;
if (tab->flags & TAB_URGENT)
}
static void
-redraw_window(WINDOW *win, int height, struct window *window)
+redraw_window(WINDOW *win, int height, struct buffer *buffer)
{
struct vline *vl;
int l;
werase(win);
- window->line_off = MIN(window->line_max-1, window->line_off);
- if (TAILQ_EMPTY(&window->head))
+ buffer->line_off = MIN(buffer->line_max-1, buffer->line_off);
+ if (TAILQ_EMPTY(&buffer->head))
return;
l = 0;
- vl = nth_line(window, window->line_off);
+ vl = nth_line(buffer, buffer->line_off);
for (; vl != NULL; vl = TAILQ_NEXT(vl, vlines)) {
wmove(win, l, 0);
print_vline(win, vl);
break;
}
- wmove(win, window->curs_y, window->curs_x);
+ wmove(win, buffer->curs_y, buffer->curs_x);
}
static void
static void
redraw_body(struct tab *tab)
{
- redraw_window(body, body_lines, &tab->window);
+ redraw_window(body, body_lines, &tab->buffer);
}
static inline char
{
double pct;
int x, y, max_x, max_y;
- const char *mode = tab->window.page.name;
+ const char *mode = tab->buffer.page.name;
const char *spin = "-\\|/";
werase(modeline);
trust_status_char(tab->trust),
mode == NULL ? "(none)" : mode);
- pct = (tab->window.line_off + tab->window.curs_y) * 100.0 / tab->window.line_max;
+ pct = (tab->buffer.line_off + tab->buffer.curs_y) * 100.0 / tab->buffer.line_max;
- if (tab->window.line_max <= (size_t)body_lines)
+ if (tab->buffer.line_max <= (size_t)body_lines)
wprintw(modeline, "All ");
- else if (tab->window.line_off == 0)
+ else if (tab->buffer.line_off == 0)
wprintw(modeline, "Top ");
- else if (tab->window.line_off + body_lines >= tab->window.line_max)
+ else if (tab->buffer.line_off + body_lines >= tab->buffer.line_max)
wprintw(modeline, "Bottom ");
else
wprintw(modeline, "%.0f%% ", pct);
wprintw(modeline, "%d/%d %s ",
- tab->window.line_off + tab->window.curs_y,
- tab->window.line_max,
+ tab->buffer.line_off + tab->buffer.curs_y,
+ tab->buffer.line_max,
tab->hist_cur->h);
getyx(modeline, y, x);
start = ministate.hist_cur != NULL
? ministate.hist_cur->h
: ministate.buf;
- c = utf8_nth(ministate.window.current_line->line,
- ministate.window.cpoff);
+ c = utf8_nth(ministate.buffer.current_line->line,
+ ministate.buffer.cpoff);
while (utf8_swidth_between(start, c) > (size_t)COLS/2) {
start = utf8_next_cp(start);
}
/* If nothing else, show the URL at point */
if (!in_minibuffer && ministate.curmesg == NULL && *keybuf == '\0') {
tab = current_tab();
- if (tab->window.current_line != NULL &&
- tab->window.current_line->parent->type == LINE_LINK)
- waddstr(minibuf, tab->window.current_line->parent->alt);
+ if (tab->buffer.current_line != NULL &&
+ tab->buffer.current_line->parent->type == LINE_LINK)
+ waddstr(minibuf, tab->buffer.current_line->parent->alt);
}
if (in_minibuffer)
start_loading_anim(tab);
load_url(tab, url);
- tab->window.curs_x = 0;
- tab->window.curs_y = 0;
+ tab->buffer.curs_x = 0;
+ tab->buffer.curs_y = 0;
redraw_tab(tab);
}
ministate.donefn = donefn;
ministate.abortfn = abortfn;
memset(ministate.buf, 0, sizeof(ministate.buf));
- ministate.window.current_line = &ministate.vline;
- ministate.window.current_line->line = ministate.buf;
- ministate.window.cpoff = 0;
+ ministate.buffer.current_line = &ministate.vline;
+ ministate.buffer.current_line->line = ministate.buf;
+ ministate.buffer.cpoff = 0;
strlcpy(ministate.buf, "", sizeof(ministate.prompt));
ministate.history = hist;
TAILQ_INIT(&tab->hist.head);
- TAILQ_INIT(&tab->window.head);
+ TAILQ_INIT(&tab->buffer.head);
tab->id = tab_new_id();
switch_to_tab(tab);
ministate.line.type = LINE_TEXT;
ministate.vline.parent = &ministate.line;
- ministate.window.current_line = &ministate.vline;
+ ministate.buffer.current_line = &ministate.vline;
/* initialize help window */
TAILQ_INIT(&helpwin.head);
void
ui_on_tab_refresh(struct tab *tab)
{
- wrap_page(&tab->window, body_cols);
+ wrap_page(&tab->buffer, body_cols);
if (tab->flags & TAB_CURRENT) {
- restore_cursor(&tab->window);
+ restore_cursor(&tab->buffer);
redraw_tab(tab);
} else
tab->flags |= TAB_URGENT;
blob - f5c483c9b31de62b76a4b7a20f877fd2db080aa9
blob + ac846f1c32fe2821e46e2d77d8881622fedb2732
--- wrap.c
+++ wrap.c
*/
void
-empty_linelist(struct window *window)
+empty_linelist(struct buffer *buffer)
{
struct line *l, *lt;
- TAILQ_FOREACH_SAFE(l, &window->page.head, lines, lt) {
- TAILQ_REMOVE(&window->page.head, l, lines);
+ TAILQ_FOREACH_SAFE(l, &buffer->page.head, lines, lt) {
+ TAILQ_REMOVE(&buffer->page.head, l, lines);
free(l->line);
free(l->alt);
free(l);
}
void
-empty_vlist(struct window *window)
+empty_vlist(struct buffer *buffer)
{
struct vline *vl, *t;
- window->current_line = NULL;
- window->line_max = 0;
+ buffer->current_line = NULL;
+ buffer->line_max = 0;
- TAILQ_FOREACH_SAFE(vl, &window->head, vlines, t) {
- TAILQ_REMOVE(&window->head, vl, vlines);
+ TAILQ_FOREACH_SAFE(vl, &buffer->head, vlines, t) {
+ TAILQ_REMOVE(&buffer->head, vl, vlines);
free(vl->line);
free(vl);
}
}
static int
-push_line(struct window *window, const struct line *l, const char *buf, size_t len, int cont)
+push_line(struct buffer *buffer, const struct line *l, const char *buf, size_t len, int cont)
{
struct vline *vl;
- window->line_max++;
+ buffer->line_max++;
if ((vl = calloc(1, sizeof(*vl))) == NULL)
return 0;
memcpy(vl->line, buf, len);
vl->flags = cont;
- if (TAILQ_EMPTY(&window->head))
- TAILQ_INSERT_HEAD(&window->head, vl, vlines);
+ if (TAILQ_EMPTY(&buffer->head))
+ TAILQ_INSERT_HEAD(&buffer->head, vl, vlines);
else
- TAILQ_INSERT_TAIL(&window->head, vl, vlines);
+ TAILQ_INSERT_TAIL(&buffer->head, vl, vlines);
return 1;
}
* that when printed will have a leading prefix prfx.
*/
int
-wrap_text(struct window *window, const char *prfx, struct line *l, size_t width)
+wrap_text(struct buffer *buffer, const char *prfx, struct line *l, size_t width)
{
const char *separators = " \t-";
const char *start, *end, *line, *lastsep, *lastchar;
int cont;
if ((line = l->line) == NULL)
- return push_line(window, l, NULL, 0, 0);
+ return push_line(buffer, l, NULL, 0, 0);
prfxwidth = utf8_swidth(prfx);
cur = prfxwidth;
end = lastsep == NULL
? utf8_next_cp((char*)lastchar)
: utf8_next_cp((char*)lastsep);
- if (!push_line(window, l, start, end - start, cont))
+ if (!push_line(buffer, l, start, end - start, cont))
return 0;
cont = 1;
start = end;
cur += w;
}
- return push_line(window, l, start, line - start, cont);
+ return push_line(buffer, l, start, line - start, cont);
}
int
-hardwrap_text(struct window *window, struct line *l, size_t width)
+hardwrap_text(struct buffer *buffer, struct line *l, size_t width)
{
const char *line, *start, *lastchar;
int cont;
size_t cur, w;
if ((line = l->line) == NULL)
- return push_line(window, l, NULL, 0, 0);
+ return push_line(buffer, l, NULL, 0, 0);
start = line;
lastchar = line;
continue;
w = utf8_chwidth(cp);
if (cur + w >= width) {
- if (!push_line(window, l, start, lastchar - start, cont))
+ if (!push_line(buffer, l, start, lastchar - start, cont))
return 0;
cont = 1;
cur = 0;
cur += w;
}
- return push_line(window, l, start, line - start, cont);
+ return push_line(buffer, l, start, line - start, cont);
}