diff options
Diffstat (limited to 'cpp')
-rw-r--r-- | cpp/termbox/bytebuffer.inl | 92 | ||||
-rw-r--r-- | cpp/termbox/input.inl | 214 | ||||
-rw-r--r-- | cpp/termbox/term.inl | 426 | ||||
-rw-r--r-- | cpp/termbox/termbox.c | 880 | ||||
-rw-r--r-- | cpp/termbox/termbox.h | 22 | ||||
-rw-r--r-- | cpp/termbox/utf8.c | 94 |
6 files changed, 864 insertions, 864 deletions
diff --git a/cpp/termbox/bytebuffer.inl b/cpp/termbox/bytebuffer.inl index 62e234c0..aae8f073 100644 --- a/cpp/termbox/bytebuffer.inl +++ b/cpp/termbox/bytebuffer.inl @@ -1,79 +1,79 @@ struct bytebuffer { - char *buf; - int len; - int cap; + char *buf; + int len; + int cap; }; static void bytebuffer_reserve(struct bytebuffer *b, int cap) { - if (b->cap >= cap) { - return; - } + if (b->cap >= cap) { + return; + } - // prefer doubling capacity - if (b->cap * 2 >= cap) { - cap = b->cap * 2; - } + // prefer doubling capacity + if (b->cap * 2 >= cap) { + cap = b->cap * 2; + } - char *newbuf = malloc(cap); - if (b->len > 0) { - // copy what was there, b->len > 0 assumes b->buf != null - memcpy(newbuf, b->buf, b->len); - } - if (b->buf) { - // in case there was an allocated buffer, free it - free(b->buf); - } - b->buf = newbuf; - b->cap = cap; + char *newbuf = malloc(cap); + if (b->len > 0) { + // copy what was there, b->len > 0 assumes b->buf != null + memcpy(newbuf, b->buf, b->len); + } + if (b->buf) { + // in case there was an allocated buffer, free it + free(b->buf); + } + b->buf = newbuf; + b->cap = cap; } static void bytebuffer_init(struct bytebuffer *b, int cap) { - b->cap = 0; - b->len = 0; - b->buf = 0; + b->cap = 0; + b->len = 0; + b->buf = 0; - if (cap > 0) { - b->cap = cap; - b->buf = malloc(cap); // just assume malloc works always - } + if (cap > 0) { + b->cap = cap; + b->buf = malloc(cap); // just assume malloc works always + } } static void bytebuffer_free(struct bytebuffer *b) { - if (b->buf) - free(b->buf); + if (b->buf) + free(b->buf); } static void bytebuffer_clear(struct bytebuffer *b) { - b->len = 0; + b->len = 0; } static void bytebuffer_append(struct bytebuffer *b, const char *data, int len) { - bytebuffer_reserve(b, b->len + len); - memcpy(b->buf + b->len, data, len); - b->len += len; + bytebuffer_reserve(b, b->len + len); + memcpy(b->buf + b->len, data, len); + b->len += len; } static void bytebuffer_puts(struct bytebuffer *b, const char *str) { - bytebuffer_append(b, str, strlen(str)); + bytebuffer_append(b, str, strlen(str)); } static void bytebuffer_resize(struct bytebuffer *b, int len) { - bytebuffer_reserve(b, len); - b->len = len; + bytebuffer_reserve(b, len); + b->len = len; } static void bytebuffer_flush(struct bytebuffer *b, int fd) { - int yyy = write(fd, b->buf, b->len); + int yyy = write(fd, b->buf, b->len); (void) yyy; - bytebuffer_clear(b); + bytebuffer_clear(b); } static void bytebuffer_truncate(struct bytebuffer *b, int n) { - if (n <= 0) - return; - if (n > b->len) - n = b->len; - const int nmove = b->len - n; - memmove(b->buf, b->buf+n, nmove); - b->len -= n; + if (n <= 0) + return; + if (n > b->len) + n = b->len; + const int nmove = b->len - n; + memmove(b->buf, b->buf+n, nmove); + b->len -= n; } diff --git a/cpp/termbox/input.inl b/cpp/termbox/input.inl index 8c555114..eee888f2 100644 --- a/cpp/termbox/input.inl +++ b/cpp/termbox/input.inl @@ -3,130 +3,130 @@ // s2 should be null-terminated static bool starts_with(const char *s1, int len, const char *s2) { - int n = 0; - while (*s2 && n < len) { - if (*s1++ != *s2++) - return false; - n++; - } - return *s2 == 0; + int n = 0; + while (*s2 && n < len) { + if (*s1++ != *s2++) + return false; + n++; + } + return *s2 == 0; } // convert escape sequence to event, and return consumed bytes on success (failure == 0) static int parse_escape_seq(struct tb_event *event, const char *buf, int len) { - if (len >= 6 && starts_with(buf, len, "\033[M")) { + if (len >= 6 && starts_with(buf, len, "\033[M")) { - switch (buf[3] & 3) { - case 0: - if (buf[3] == 0x60) - event->key = TB_KEY_MOUSE_WHEEL_UP; - else - event->key = TB_KEY_MOUSE_LEFT; - break; - case 1: - if (buf[3] == 0x61) - event->key = TB_KEY_MOUSE_WHEEL_DOWN; - else - event->key = TB_KEY_MOUSE_MIDDLE; - break; - case 2: - event->key = TB_KEY_MOUSE_RIGHT; - break; - case 3: - event->key = TB_KEY_MOUSE_RELEASE; - break; - default: - return -6; - } - event->type = TB_EVENT_MOUSE; // TB_EVENT_KEY by default + switch (buf[3] & 3) { + case 0: + if (buf[3] == 0x60) + event->key = TB_KEY_MOUSE_WHEEL_UP; + else + event->key = TB_KEY_MOUSE_LEFT; + break; + case 1: + if (buf[3] == 0x61) + event->key = TB_KEY_MOUSE_WHEEL_DOWN; + else + event->key = TB_KEY_MOUSE_MIDDLE; + break; + case 2: + event->key = TB_KEY_MOUSE_RIGHT; + break; + case 3: + event->key = TB_KEY_MOUSE_RELEASE; + break; + default: + return -6; + } + event->type = TB_EVENT_MOUSE; // TB_EVENT_KEY by default - // the coord is 1,1 for upper left - event->x = buf[4] - 1 - 32; - event->y = buf[5] - 1 - 32; + // the coord is 1,1 for upper left + event->x = buf[4] - 1 - 32; + event->y = buf[5] - 1 - 32; - return 6; - } + return 6; + } - // it's pretty simple here, find 'starts_with' match and return - // success, else return failure - int i; - for (i = 0; keys[i]; i++) { - if (starts_with(buf, len, keys[i])) { - event->ch = 0; - event->key = 0xFFFF-i; - return strlen(keys[i]); - } - } - return 0; + // it's pretty simple here, find 'starts_with' match and return + // success, else return failure + int i; + for (i = 0; keys[i]; i++) { + if (starts_with(buf, len, keys[i])) { + event->ch = 0; + event->key = 0xFFFF-i; + return strlen(keys[i]); + } + } + return 0; } static bool extract_event(struct tb_event *event, struct bytebuffer *inbuf, int inputmode) { - const char *buf = inbuf->buf; - const int len = inbuf->len; - if (len == 0) - return false; + const char *buf = inbuf->buf; + const int len = inbuf->len; + if (len == 0) + return false; - if (buf[0] == '\033') { - int n = parse_escape_seq(event, buf, len); - if (n != 0) { - bool success = true; - if (n < 0) { - success = false; - n = -n; - } - bytebuffer_truncate(inbuf, n); - return success; - } else { - // it's not escape sequence, then it's ALT or ESC, - // check inputmode - if (inputmode&TB_INPUT_ESC) { - // if we're in escape mode, fill ESC event, pop - // buffer, return success - event->ch = 0; - event->key = TB_KEY_ESC; - event->mod = 0; - bytebuffer_truncate(inbuf, 1); - return true; - } - if (inputmode&TB_INPUT_ALT) { - // if we're in alt mode, set ALT modifier to - // event and redo parsing - event->mod = TB_MOD_ALT; - bytebuffer_truncate(inbuf, 1); - return extract_event(event, inbuf, inputmode); - } - assert(!"never got here"); - } - } + if (buf[0] == '\033') { + int n = parse_escape_seq(event, buf, len); + if (n != 0) { + bool success = true; + if (n < 0) { + success = false; + n = -n; + } + bytebuffer_truncate(inbuf, n); + return success; + } else { + // it's not escape sequence, then it's ALT or ESC, + // check inputmode + if (inputmode&TB_INPUT_ESC) { + // if we're in escape mode, fill ESC event, pop + // buffer, return success + event->ch = 0; + event->key = TB_KEY_ESC; + event->mod = 0; + bytebuffer_truncate(inbuf, 1); + return true; + } + if (inputmode&TB_INPUT_ALT) { + // if we're in alt mode, set ALT modifier to + // event and redo parsing + event->mod = TB_MOD_ALT; + bytebuffer_truncate(inbuf, 1); + return extract_event(event, inbuf, inputmode); + } + assert(!"never got here"); + } + } - // if we're here, this is not an escape sequence and not an alt sequence - // so, it's a FUNCTIONAL KEY or a UNICODE character + // if we're here, this is not an escape sequence and not an alt sequence + // so, it's a FUNCTIONAL KEY or a UNICODE character - // first of all check if it's a functional key - if ((unsigned char)buf[0] <= TB_KEY_SPACE || - (unsigned char)buf[0] == TB_KEY_BACKSPACE2) - { - // fill event, pop buffer, return success */ - event->ch = 0; - event->key = (uint16_t)buf[0]; - bytebuffer_truncate(inbuf, 1); - return true; - } + // first of all check if it's a functional key + if ((unsigned char)buf[0] <= TB_KEY_SPACE || + (unsigned char)buf[0] == TB_KEY_BACKSPACE2) + { + // fill event, pop buffer, return success */ + event->ch = 0; + event->key = (uint16_t)buf[0]; + bytebuffer_truncate(inbuf, 1); + return true; + } - // feh... we got utf8 here + // feh... we got utf8 here - // check if there is all bytes - if (len >= tb_utf8_char_length(buf[0])) { - /* everything ok, fill event, pop buffer, return success */ - tb_utf8_char_to_unicode(&event->ch, buf); - event->key = 0; - bytebuffer_truncate(inbuf, tb_utf8_char_length(buf[0])); - return true; - } + // check if there is all bytes + if (len >= tb_utf8_char_length(buf[0])) { + /* everything ok, fill event, pop buffer, return success */ + tb_utf8_char_to_unicode(&event->ch, buf); + event->key = 0; + bytebuffer_truncate(inbuf, tb_utf8_char_length(buf[0])); + return true; + } - // event isn't recognized, perhaps there is not enough bytes in utf8 - // sequence - return false; + // event isn't recognized, perhaps there is not enough bytes in utf8 + // sequence + return false; } diff --git a/cpp/termbox/term.inl b/cpp/termbox/term.inl index 80812b40..45be181b 100644 --- a/cpp/termbox/term.inl +++ b/cpp/termbox/term.inl @@ -1,83 +1,83 @@ enum { - T_ENTER_CA, - T_EXIT_CA, - T_SHOW_CURSOR, - T_HIDE_CURSOR, - T_CLEAR_SCREEN, - T_SGR0, - T_UNDERLINE, - T_BOLD, - T_BLINK, - T_REVERSE, - T_ENTER_KEYPAD, - T_EXIT_KEYPAD, - T_ENTER_MOUSE, - T_EXIT_MOUSE, - T_FUNCS_NUM, + T_ENTER_CA, + T_EXIT_CA, + T_SHOW_CURSOR, + T_HIDE_CURSOR, + T_CLEAR_SCREEN, + T_SGR0, + T_UNDERLINE, + T_BOLD, + T_BLINK, + T_REVERSE, + T_ENTER_KEYPAD, + T_EXIT_KEYPAD, + T_ENTER_MOUSE, + T_EXIT_MOUSE, + T_FUNCS_NUM, }; #define EUNSUPPORTED_TERM -1 // rxvt-256color static const char *rxvt_256color_keys[] = { - "\033[11~","\033[12~","\033[13~","\033[14~","\033[15~","\033[17~","\033[18~","\033[19~","\033[20~","\033[21~","\033[23~","\033[24~","\033[2~","\033[3~","\033[7~","\033[8~","\033[5~","\033[6~","\033[A","\033[B","\033[D","\033[C", 0 + "\033[11~","\033[12~","\033[13~","\033[14~","\033[15~","\033[17~","\033[18~","\033[19~","\033[20~","\033[21~","\033[23~","\033[24~","\033[2~","\033[3~","\033[7~","\033[8~","\033[5~","\033[6~","\033[A","\033[B","\033[D","\033[C", 0 }; static const char *rxvt_256color_funcs[] = { - "\0337\033[?47h", "\033[2J\033[?47l\0338", "\033[?25h", "\033[?25l", "\033[H\033[2J", "\033[m", "\033[4m", "\033[1m", "\033[5m", "\033[7m", "\033=", "\033>", "\033[?1000h", "\033[?1000l", + "\0337\033[?47h", "\033[2J\033[?47l\0338", "\033[?25h", "\033[?25l", "\033[H\033[2J", "\033[m", "\033[4m", "\033[1m", "\033[5m", "\033[7m", "\033=", "\033>", "\033[?1000h", "\033[?1000l", }; // Eterm static const char *eterm_keys[] = { - "\033[11~","\033[12~","\033[13~","\033[14~","\033[15~","\033[17~","\033[18~","\033[19~","\033[20~","\033[21~","\033[23~","\033[24~","\033[2~","\033[3~","\033[7~","\033[8~","\033[5~","\033[6~","\033[A","\033[B","\033[D","\033[C", 0 + "\033[11~","\033[12~","\033[13~","\033[14~","\033[15~","\033[17~","\033[18~","\033[19~","\033[20~","\033[21~","\033[23~","\033[24~","\033[2~","\033[3~","\033[7~","\033[8~","\033[5~","\033[6~","\033[A","\033[B","\033[D","\033[C", 0 }; static const char *eterm_funcs[] = { - "\0337\033[?47h", "\033[2J\033[?47l\0338", "\033[?25h", "\033[?25l", "\033[H\033[2J", "\033[m", "\033[4m", "\033[1m", "\033[5m", "\033[7m", "", "", "", "", + "\0337\033[?47h", "\033[2J\033[?47l\0338", "\033[?25h", "\033[?25l", "\033[H\033[2J", "\033[m", "\033[4m", "\033[1m", "\033[5m", "\033[7m", "", "", "", "", }; // screen static const char *screen_keys[] = { - "\033OP","\033OQ","\033OR","\033OS","\033[15~","\033[17~","\033[18~","\033[19~","\033[20~","\033[21~","\033[23~","\033[24~","\033[2~","\033[3~","\033[1~","\033[4~","\033[5~","\033[6~","\033OA","\033OB","\033OD","\033OC", 0 + "\033OP","\033OQ","\033OR","\033OS","\033[15~","\033[17~","\033[18~","\033[19~","\033[20~","\033[21~","\033[23~","\033[24~","\033[2~","\033[3~","\033[1~","\033[4~","\033[5~","\033[6~","\033OA","\033OB","\033OD","\033OC", 0 }; static const char *screen_funcs[] = { - "\033[?1049h", "\033[?1049l", "\033[34h\033[?25h", "\033[?25l", "\033[H\033[J", "\033[m", "\033[4m", "\033[1m", "\033[5m", "\033[7m", "\033[?1h\033=", "\033[?1l\033>", "\033[?1000h", "\033[?1000l", + "\033[?1049h", "\033[?1049l", "\033[34h\033[?25h", "\033[?25l", "\033[H\033[J", "\033[m", "\033[4m", "\033[1m", "\033[5m", "\033[7m", "\033[?1h\033=", "\033[?1l\033>", "\033[?1000h", "\033[?1000l", }; // rxvt-unicode static const char *rxvt_unicode_keys[] = { - "\033[11~","\033[12~","\033[13~","\033[14~","\033[15~","\033[17~","\033[18~","\033[19~","\033[20~","\033[21~","\033[23~","\033[24~","\033[2~","\033[3~","\033[7~","\033[8~","\033[5~","\033[6~","\033[A","\033[B","\033[D","\033[C", 0 + "\033[11~","\033[12~","\033[13~","\033[14~","\033[15~","\033[17~","\033[18~","\033[19~","\033[20~","\033[21~","\033[23~","\033[24~","\033[2~","\033[3~","\033[7~","\033[8~","\033[5~","\033[6~","\033[A","\033[B","\033[D","\033[C", 0 }; static const char *rxvt_unicode_funcs[] = { - "\033[?1049h", "\033[r\033[?1049l", "\033[?25h", "\033[?25l", "\033[H\033[2J", "\033[m\033(B", "\033[4m", "\033[1m", "\033[5m", "\033[7m", "\033=", "\033>", "\033[?1000h", "\033[?1000l", + "\033[?1049h", "\033[r\033[?1049l", "\033[?25h", "\033[?25l", "\033[H\033[2J", "\033[m\033(B", "\033[4m", "\033[1m", "\033[5m", "\033[7m", "\033=", "\033>", "\033[?1000h", "\033[?1000l", }; // linux static const char *linux_keys[] = { - "\033[[A","\033[[B","\033[[C","\033[[D","\033[[E","\033[17~","\033[18~","\033[19~","\033[20~","\033[21~","\033[23~","\033[24~","\033[2~","\033[3~","\033[1~","\033[4~","\033[5~","\033[6~","\033[A","\033[B","\033[D","\033[C", 0 + "\033[[A","\033[[B","\033[[C","\033[[D","\033[[E","\033[17~","\033[18~","\033[19~","\033[20~","\033[21~","\033[23~","\033[24~","\033[2~","\033[3~","\033[1~","\033[4~","\033[5~","\033[6~","\033[A","\033[B","\033[D","\033[C", 0 }; static const char *linux_funcs[] = { - "", "", "\033[?25h\033[?0c", "\033[?25l\033[?1c", "\033[H\033[J", "\033[0;10m", "\033[4m", "\033[1m", "\033[5m", "\033[7m", "", "", "", "", + "", "", "\033[?25h\033[?0c", "\033[?25l\033[?1c", "\033[H\033[J", "\033[0;10m", "\033[4m", "\033[1m", "\033[5m", "\033[7m", "", "", "", "", }; // xterm static const char *xterm_keys[] = { - "\033OP","\033OQ","\033OR","\033OS","\033[15~","\033[17~","\033[18~","\033[19~","\033[20~","\033[21~","\033[23~","\033[24~","\033[2~","\033[3~","\033OH","\033OF","\033[5~","\033[6~","\033OA","\033OB","\033OD","\033OC", 0 + "\033OP","\033OQ","\033OR","\033OS","\033[15~","\033[17~","\033[18~","\033[19~","\033[20~","\033[21~","\033[23~","\033[24~","\033[2~","\033[3~","\033OH","\033OF","\033[5~","\033[6~","\033OA","\033OB","\033OD","\033OC", 0 }; static const char *xterm_funcs[] = { - "\033[?1049h", "\033[?1049l", "\033[?12l\033[?25h", "\033[?25l", "\033[H\033[2J", "\033(B\033[m", "\033[4m", "\033[1m", "\033[5m", "\033[7m", "\033[?1h\033=", "\033[?1l\033>", "\033[?1000h", "\033[?1000l", + "\033[?1049h", "\033[?1049l", "\033[?12l\033[?25h", "\033[?25l", "\033[H\033[2J", "\033(B\033[m", "\033[4m", "\033[1m", "\033[5m", "\033[7m", "\033[?1h\033=", "\033[?1l\033>", "\033[?1000h", "\033[?1000l", }; static struct term { - const char *name; - const char **keys; - const char **funcs; + const char *name; + const char **keys; + const char **funcs; } terms[] = { - {"rxvt-256color", rxvt_256color_keys, rxvt_256color_funcs}, - {"Eterm", eterm_keys, eterm_funcs}, - {"screen", screen_keys, screen_funcs}, - {"rxvt-unicode", rxvt_unicode_keys, rxvt_unicode_funcs}, - {"linux", linux_keys, linux_funcs}, - {"xterm", xterm_keys, xterm_funcs}, - {0, 0, 0}, + {"rxvt-256color", rxvt_256color_keys, rxvt_256color_funcs}, + {"Eterm", eterm_keys, eterm_funcs}, + {"screen", screen_keys, screen_funcs}, + {"rxvt-unicode", rxvt_unicode_keys, rxvt_unicode_funcs}, + {"linux", linux_keys, linux_funcs}, + {"xterm", xterm_keys, xterm_funcs}, + {0, 0, 0}, }; static bool init_from_terminfo = false; @@ -85,48 +85,48 @@ static const char **keys; static const char **funcs; static int try_compatible(const char *term, const char *name, - const char **tkeys, const char **tfuncs) + const char **tkeys, const char **tfuncs) { - if (strstr(term, name)) { - keys = tkeys; - funcs = tfuncs; - return 0; - } + if (strstr(term, name)) { + keys = tkeys; + funcs = tfuncs; + return 0; + } - return EUNSUPPORTED_TERM; + return EUNSUPPORTED_TERM; } static int init_term_builtin(void) { - int i; - const char *term = getenv("TERM"); - - if (term) { - for (i = 0; terms[i].name; i++) { - if (!strcmp(terms[i].name, term)) { - keys = terms[i].keys; - funcs = terms[i].funcs; - return 0; - } - } - - /* let's do some heuristic, maybe it's a compatible terminal */ - if (try_compatible(term, "xterm", xterm_keys, xterm_funcs) == 0) - return 0; - if (try_compatible(term, "rxvt", rxvt_unicode_keys, rxvt_unicode_funcs) == 0) - return 0; - if (try_compatible(term, "linux", linux_keys, linux_funcs) == 0) - return 0; - if (try_compatible(term, "Eterm", eterm_keys, eterm_funcs) == 0) - return 0; - if (try_compatible(term, "screen", screen_keys, screen_funcs) == 0) - return 0; - /* let's assume that 'cygwin' is xterm compatible */ - if (try_compatible(term, "cygwin", xterm_keys, xterm_funcs) == 0) - return 0; - } - - return EUNSUPPORTED_TERM; + int i; + const char *term = getenv("TERM"); + + if (term) { + for (i = 0; terms[i].name; i++) { + if (!strcmp(terms[i].name, term)) { + keys = terms[i].keys; + funcs = terms[i].funcs; + return 0; + } + } + + /* let's do some heuristic, maybe it's a compatible terminal */ + if (try_compatible(term, "xterm", xterm_keys, xterm_funcs) == 0) + return 0; + if (try_compatible(term, "rxvt", rxvt_unicode_keys, rxvt_unicode_funcs) == 0) + return 0; + if (try_compatible(term, "linux", linux_keys, linux_funcs) == 0) + return 0; + if (try_compatible(term, "Eterm", eterm_keys, eterm_funcs) == 0) + return 0; + if (try_compatible(term, "screen", screen_keys, screen_funcs) == 0) + return 0; + /* let's assume that 'cygwin' is xterm compatible */ + if (try_compatible(term, "cygwin", xterm_keys, xterm_funcs) == 0) + return 0; + } + + return EUNSUPPORTED_TERM; } //---------------------------------------------------------------------- @@ -134,90 +134,90 @@ static int init_term_builtin(void) //---------------------------------------------------------------------- static char *read_file(const char *file) { - FILE *f = fopen(file, "rb"); - if (!f) - return 0; - - struct stat st; - if (fstat(fileno(f), &st) != 0) { - fclose(f); - return 0; - } - - char *data = malloc(st.st_size); - if (!data) { - fclose(f); - return 0; - } - - if (fread(data, 1, st.st_size, f) != (size_t)st.st_size) { - fclose(f); - free(data); - return 0; - } - - fclose(f); - return data; + FILE *f = fopen(file, "rb"); + if (!f) + return 0; + + struct stat st; + if (fstat(fileno(f), &st) != 0) { + fclose(f); + return 0; + } + + char *data = malloc(st.st_size); + if (!data) { + fclose(f); + return 0; + } + + if (fread(data, 1, st.st_size, f) != (size_t)st.st_size) { + fclose(f); + free(data); + return 0; + } + + fclose(f); + return data; } static char *terminfo_try_path(const char *path, const char *term) { - char tmp[4096]; - snprintf(tmp, sizeof(tmp), "%s/%c/%s", path, term[0], term); - tmp[sizeof(tmp)-1] = '\0'; - char *data = read_file(tmp); - if (data) { - return data; - } - - // fallback to darwin specific dirs structure - snprintf(tmp, sizeof(tmp), "%s/%x/%s", path, term[0], term); - tmp[sizeof(tmp)-1] = '\0'; - return read_file(tmp); + char tmp[4096]; + snprintf(tmp, sizeof(tmp), "%s/%c/%s", path, term[0], term); + tmp[sizeof(tmp)-1] = '\0'; + char *data = read_file(tmp); + if (data) { + return data; + } + + // fallback to darwin specific dirs structure + snprintf(tmp, sizeof(tmp), "%s/%x/%s", path, term[0], term); + tmp[sizeof(tmp)-1] = '\0'; + return read_file(tmp); } static char *load_terminfo(void) { - char tmp[4096]; - const char *term = getenv("TERM"); - if (!term) { - return 0; - } - - // if TERMINFO is set, no other directory should be searched - const char *terminfo = getenv("TERMINFO"); - if (terminfo) { - return terminfo_try_path(terminfo, term); - } - - // next, consider ~/.terminfo - const char *home = getenv("HOME"); - if (home) { - snprintf(tmp, sizeof(tmp), "%s/.terminfo", home); - tmp[sizeof(tmp)-1] = '\0'; - char *data = terminfo_try_path(tmp, term); - if (data) - return data; - } - - // next, TERMINFO_DIRS - const char *dirs = getenv("TERMINFO_DIRS"); - if (dirs) { - snprintf(tmp, sizeof(tmp), "%s", dirs); - tmp[sizeof(tmp)-1] = '\0'; - char *dir = strtok(tmp, ":"); - while (dir) { - const char *cdir = dir; - if (strcmp(cdir, "") == 0) { - cdir = "/usr/share/terminfo"; - } - char *data = terminfo_try_path(cdir, term); - if (data) - return data; - dir = strtok(0, ":"); - } - } - - // fallback to /usr/share/terminfo - return terminfo_try_path("/usr/share/terminfo", term); + char tmp[4096]; + const char *term = getenv("TERM"); + if (!term) { + return 0; + } + + // if TERMINFO is set, no other directory should be searched + const char *terminfo = getenv("TERMINFO"); + if (terminfo) { + return terminfo_try_path(terminfo, term); + } + + // next, consider ~/.terminfo + const char *home = getenv("HOME"); + if (home) { + snprintf(tmp, sizeof(tmp), "%s/.terminfo", home); + tmp[sizeof(tmp)-1] = '\0'; + char *data = terminfo_try_path(tmp, term); + if (data) + return data; + } + + // next, TERMINFO_DIRS + const char *dirs = getenv("TERMINFO_DIRS"); + if (dirs) { + snprintf(tmp, sizeof(tmp), "%s", dirs); + tmp[sizeof(tmp)-1] = '\0'; + char *dir = strtok(tmp, ":"); + while (dir) { + const char *cdir = dir; + if (strcmp(cdir, "") == 0) { + cdir = "/usr/share/terminfo"; + } + char *data = terminfo_try_path(cdir, term); + if (data) + return data; + dir = strtok(0, ":"); + } + } + + // fallback to /usr/share/terminfo + return terminfo_try_path("/usr/share/terminfo", term); } #define TI_MAGIC 0432 @@ -225,78 +225,78 @@ static char *load_terminfo(void) { #define TB_KEYS_NUM 22 static const char *terminfo_copy_string(char *data, int str, int table) { - const int16_t off = *(int16_t*)(data + str); - const char *src = data + table + off; - int len = strlen(src); - char *dst = malloc(len+1); - strcpy(dst, src); - return dst; + const int16_t off = *(int16_t*)(data + str); + const char *src = data + table + off; + int len = strlen(src); + char *dst = malloc(len+1); + strcpy(dst, src); + return dst; } static const int16_t ti_funcs[] = { - 28, 40, 16, 13, 5, 39, 36, 27, 26, 34, 89, 88, + 28, 40, 16, 13, 5, 39, 36, 27, 26, 34, 89, 88, }; static const int16_t ti_keys[] = { - 66, 68 /* apparently not a typo; 67 is F10 for whatever reason */, 69, - 70, 71, 72, 73, 74, 75, 67, 216, 217, 77, 59, 76, 164, 82, 81, 87, 61, - 79, 83, + 66, 68 /* apparently not a typo; 67 is F10 for whatever reason */, 69, + 70, 71, 72, 73, 74, 75, 67, 216, 217, 77, 59, 76, 164, 82, 81, 87, 61, + 79, 83, }; static int init_term(void) { - int i; - char *data = load_terminfo(); - if (!data) { - init_from_terminfo = false; - return init_term_builtin(); - } - - int16_t *header = (int16_t*)data; - if ((header[1] + header[2]) % 2) { - // old quirk to align everything on word boundaries - header[2] += 1; - } - - const int str_offset = TI_HEADER_LENGTH + - header[1] + header[2] + 2 * header[3]; - const int table_offset = str_offset + 2 * header[4]; - - keys = malloc(sizeof(const char*) * (TB_KEYS_NUM+1)); - for (i = 0; i < TB_KEYS_NUM; i++) { - keys[i] = terminfo_copy_string(data, - str_offset + 2 * ti_keys[i], table_offset); - } - keys[TB_KEYS_NUM] = 0; - - funcs = malloc(sizeof(const char*) * T_FUNCS_NUM); - // the last two entries are reserved for mouse. because the table offset is - // not there, the two entries have to fill in manually - for (i = 0; i < T_FUNCS_NUM-2; i++) { - funcs[i] = terminfo_copy_string(data, - str_offset + 2 * ti_funcs[i], table_offset); - } - - funcs[T_FUNCS_NUM-2] = "\033[?1000h"; - funcs[T_FUNCS_NUM-1] = "\033[?1000l"; - - init_from_terminfo = true; - free(data); - return 0; + int i; + char *data = load_terminfo(); + if (!data) { + init_from_terminfo = false; + return init_term_builtin(); + } + + int16_t *header = (int16_t*)data; + if ((header[1] + header[2]) % 2) { + // old quirk to align everything on word boundaries + header[2] += 1; + } + + const int str_offset = TI_HEADER_LENGTH + + header[1] + header[2] + 2 * header[3]; + const int table_offset = str_offset + 2 * header[4]; + + keys = malloc(sizeof(const char*) * (TB_KEYS_NUM+1)); + for (i = 0; i < TB_KEYS_NUM; i++) { + keys[i] = terminfo_copy_string(data, + str_offset + 2 * ti_keys[i], table_offset); + } + keys[TB_KEYS_NUM] = 0; + + funcs = malloc(sizeof(const char*) * T_FUNCS_NUM); + // the last two entries are reserved for mouse. because the table offset is + // not there, the two entries have to fill in manually + for (i = 0; i < T_FUNCS_NUM-2; i++) { + funcs[i] = terminfo_copy_string(data, + str_offset + 2 * ti_funcs[i], table_offset); + } + + funcs[T_FUNCS_NUM-2] = "\033[?1000h"; + funcs[T_FUNCS_NUM-1] = "\033[?1000l"; + + init_from_terminfo = true; + free(data); + return 0; } static void shutdown_term(void) { - if (init_from_terminfo) { - int i; - for (i = 0; i < TB_KEYS_NUM; i++) { - free((void*)keys[i]); - } - // the last two entries are reserved for mouse. because the table offset - // is not there, the two entries have to fill in manually and do not - // need to be freed. - for (i = 0; i < T_FUNCS_NUM-2; i++) { - free((void*)funcs[i]); - } - free(keys); - free(funcs); - } + if (init_from_terminfo) { + int i; + for (i = 0; i < TB_KEYS_NUM; i++) { + free((void*)keys[i]); + } + // the last two entries are reserved for mouse. because the table offset + // is not there, the two entries have to fill in manually and do not + // need to be freed. + for (i = 0; i < T_FUNCS_NUM-2; i++) { + free((void*)funcs[i]); + } + free(keys); + free(funcs); + } } diff --git a/cpp/termbox/termbox.c b/cpp/termbox/termbox.c index f32d8f07..6035b0c1 100644 --- a/cpp/termbox/termbox.c +++ b/cpp/termbox/termbox.c @@ -21,9 +21,9 @@ int snprintf(char *str, size_t size, const char *format, ...); // until we enab #include "input.inl" struct cellbuf { - int width; - int height; - struct tb_cell *cells; + int width; + int height; + struct tb_cell *cells; }; #define CELL(buf, x, y) (buf)->cells[(y) * (buf)->width + (x)] @@ -79,604 +79,604 @@ static volatile int buffer_size_change_request; int tb_init(void) { - inout = open("/dev/tty", O_RDWR); - if (inout == -1) { - return TB_EFAILED_TO_OPEN_TTY; - } + inout = open("/dev/tty", O_RDWR); + if (inout == -1) { + return TB_EFAILED_TO_OPEN_TTY; + } - if (init_term() < 0) { - close(inout); - return TB_EUNSUPPORTED_TERMINAL; - } + if (init_term() < 0) { + close(inout); + return TB_EUNSUPPORTED_TERMINAL; + } - if (pipe(winch_fds) < 0) { - close(inout); - return TB_EPIPE_TRAP_ERROR; - } + if (pipe(winch_fds) < 0) { + close(inout); + return TB_EPIPE_TRAP_ERROR; + } - struct sigaction sa; - memset(&sa, 0, sizeof(sa)); - sa.sa_handler = sigwinch_handler; - sa.sa_flags = 0; - sigaction(SIGWINCH, &sa, 0); + struct sigaction sa; + memset(&sa, 0, sizeof(sa)); + sa.sa_handler = sigwinch_handler; + sa.sa_flags = 0; + sigaction(SIGWINCH, &sa, 0); - tcgetattr(inout, &orig_tios); + tcgetattr(inout, &orig_tios); - struct termios tios; - memcpy(&tios, &orig_tios, sizeof(tios)); + struct termios tios; + memcpy(&tios, &orig_tios, sizeof(tios)); - tios.c_iflag &= ~(IGNBRK | BRKINT | PARMRK | ISTRIP + tios.c_iflag &= ~(IGNBRK | BRKINT | PARMRK | ISTRIP | INLCR | IGNCR | ICRNL | IXON); - tios.c_oflag &= ~OPOST; - tios.c_lflag &= ~(ECHO | ECHONL | ICANON | ISIG | IEXTEN); - tios.c_cflag &= ~(CSIZE | PARENB); - tios.c_cflag |= CS8; - tios.c_cc[VMIN] = 0; - tios.c_cc[VTIME] = 0; - tcsetattr(inout, TCSAFLUSH, &tios); + tios.c_oflag &= ~OPOST; + tios.c_lflag &= ~(ECHO | ECHONL | ICANON | ISIG | IEXTEN); + tios.c_cflag &= ~(CSIZE | PARENB); + tios.c_cflag |= CS8; + tios.c_cc[VMIN] = 0; + tios.c_cc[VTIME] = 0; + tcsetattr(inout, TCSAFLUSH, &tios); - bytebuffer_init(&input_buffer, 128); - bytebuffer_init(&output_buffer, 32 * 1024); + bytebuffer_init(&input_buffer, 128); + bytebuffer_init(&output_buffer, 32 * 1024); - bytebuffer_puts(&output_buffer, funcs[T_ENTER_CA]); - bytebuffer_puts(&output_buffer, funcs[T_ENTER_KEYPAD]); - bytebuffer_puts(&output_buffer, funcs[T_HIDE_CURSOR]); - send_clear(); + bytebuffer_puts(&output_buffer, funcs[T_ENTER_CA]); + bytebuffer_puts(&output_buffer, funcs[T_ENTER_KEYPAD]); + bytebuffer_puts(&output_buffer, funcs[T_HIDE_CURSOR]); + send_clear(); - update_term_size(); - cellbuf_init(&back_buffer, termw, termh); - cellbuf_init(&front_buffer, termw, termh); - cellbuf_clear(&back_buffer); - cellbuf_clear(&front_buffer); + update_term_size(); + cellbuf_init(&back_buffer, termw, termh); + cellbuf_init(&front_buffer, termw, termh); + cellbuf_clear(&back_buffer); + cellbuf_clear(&front_buffer); - return 0; + return 0; } void tb_shutdown(void) { - if (termw == -1) { - fputs("tb_shutdown() should not be called twice.", stderr); - abort(); - } - - bytebuffer_puts(&output_buffer, funcs[T_SHOW_CURSOR]); - bytebuffer_puts(&output_buffer, funcs[T_SGR0]); - bytebuffer_puts(&output_buffer, funcs[T_CLEAR_SCREEN]); - bytebuffer_puts(&output_buffer, funcs[T_EXIT_CA]); - bytebuffer_puts(&output_buffer, funcs[T_EXIT_KEYPAD]); - bytebuffer_puts(&output_buffer, funcs[T_EXIT_MOUSE]); - bytebuffer_flush(&output_buffer, inout); - tcsetattr(inout, TCSAFLUSH, &orig_tios); - - shutdown_term(); - close(inout); - close(winch_fds[0]); - close(winch_fds[1]); - - cellbuf_free(&back_buffer); - cellbuf_free(&front_buffer); - bytebuffer_free(&output_buffer); - bytebuffer_free(&input_buffer); - termw = termh = -1; + if (termw == -1) { + fputs("tb_shutdown() should not be called twice.", stderr); + abort(); + } + + bytebuffer_puts(&output_buffer, funcs[T_SHOW_CURSOR]); + bytebuffer_puts(&output_buffer, funcs[T_SGR0]); + bytebuffer_puts(&output_buffer, funcs[T_CLEAR_SCREEN]); + bytebuffer_puts(&output_buffer, funcs[T_EXIT_CA]); + bytebuffer_puts(&output_buffer, funcs[T_EXIT_KEYPAD]); + bytebuffer_puts(&output_buffer, funcs[T_EXIT_MOUSE]); + bytebuffer_flush(&output_buffer, inout); + tcsetattr(inout, TCSAFLUSH, &orig_tios); + + shutdown_term(); + close(inout); + close(winch_fds[0]); + close(winch_fds[1]); + + cellbuf_free(&back_buffer); + cellbuf_free(&front_buffer); + bytebuffer_free(&output_buffer); + bytebuffer_free(&input_buffer); + termw = termh = -1; } void tb_present(void) { - int x,y,w,i; - struct tb_cell *back, *front; - - /* invalidate cursor position */ - lastx = LAST_COORD_INIT; - lasty = LAST_COORD_INIT; - - if (buffer_size_change_request) { - update_size(); - buffer_size_change_request = 0; - } - - for (y = 0; y < front_buffer.height; ++y) { - for (x = 0; x < front_buffer.width; ) { - back = &CELL(&back_buffer, x, y); - front = &CELL(&front_buffer, x, y); - w = wcwidth(back->ch); - if (w < 1) w = 1; - if (memcmp(back, front, sizeof(struct tb_cell)) == 0) { - x += w; - continue; - } - memcpy(front, back, sizeof(struct tb_cell)); - send_attr(back->fg, back->bg); - if (w > 1 && x >= front_buffer.width - (w - 1)) { - // Not enough room for wide ch, so send spaces - for (i = x; i < front_buffer.width; ++i) { - send_char(i, y, ' '); - } - } else { - send_char(x, y, back->ch); - for (i = 1; i < w; ++i) { - front = &CELL(&front_buffer, x + i, y); - front->ch = 0; - front->fg = back->fg; - front->bg = back->bg; - } - } - x += w; - } - } - if (!IS_CURSOR_HIDDEN(cursor_x, cursor_y)) - write_cursor(cursor_x, cursor_y); - bytebuffer_flush(&output_buffer, inout); + int x,y,w,i; + struct tb_cell *back, *front; + + /* invalidate cursor position */ + lastx = LAST_COORD_INIT; + lasty = LAST_COORD_INIT; + + if (buffer_size_change_request) { + update_size(); + buffer_size_change_request = 0; + } + + for (y = 0; y < front_buffer.height; ++y) { + for (x = 0; x < front_buffer.width; ) { + back = &CELL(&back_buffer, x, y); + front = &CELL(&front_buffer, x, y); + w = wcwidth(back->ch); + if (w < 1) w = 1; + if (memcmp(back, front, sizeof(struct tb_cell)) == 0) { + x += w; + continue; + } + memcpy(front, back, sizeof(struct tb_cell)); + send_attr(back->fg, back->bg); + if (w > 1 && x >= front_buffer.width - (w - 1)) { + // Not enough room for wide ch, so send spaces + for (i = x; i < front_buffer.width; ++i) { + send_char(i, y, ' '); + } + } else { + send_char(x, y, back->ch); + for (i = 1; i < w; ++i) { + front = &CELL(&front_buffer, x + i, y); + front->ch = 0; + front->fg = back->fg; + front->bg = back->bg; + } + } + x += w; + } + } + if (!IS_CURSOR_HIDDEN(cursor_x, cursor_y)) + write_cursor(cursor_x, cursor_y); + bytebuffer_flush(&output_buffer, inout); } void tb_set_cursor(int cx, int cy) { - if (IS_CURSOR_HIDDEN(cursor_x, cursor_y) && !IS_CURSOR_HIDDEN(cx, cy)) - bytebuffer_puts(&output_buffer, funcs[T_SHOW_CURSOR]); + if (IS_CURSOR_HIDDEN(cursor_x, cursor_y) && !IS_CURSOR_HIDDEN(cx, cy)) + bytebuffer_puts(&output_buffer, funcs[T_SHOW_CURSOR]); - if (!IS_CURSOR_HIDDEN(cursor_x, cursor_y) && IS_CURSOR_HIDDEN(cx, cy)) - bytebuffer_puts(&output_buffer, funcs[T_HIDE_CURSOR]); + if (!IS_CURSOR_HIDDEN(cursor_x, cursor_y) && IS_CURSOR_HIDDEN(cx, cy)) + bytebuffer_puts(&output_buffer, funcs[T_HIDE_CURSOR]); - cursor_x = cx; - cursor_y = cy; - if (!IS_CURSOR_HIDDEN(cursor_x, cursor_y)) - write_cursor(cursor_x, cursor_y); + cursor_x = cx; + cursor_y = cy; + if (!IS_CURSOR_HIDDEN(cursor_x, cursor_y)) + write_cursor(cursor_x, cursor_y); } void tb_put_cell(int x, int y, const struct tb_cell *cell) { - if ((unsigned)x >= (unsigned)back_buffer.width) - return; - if ((unsigned)y >= (unsigned)back_buffer.height) - return; - CELL(&back_buffer, x, y) = *cell; + if ((unsigned)x >= (unsigned)back_buffer.width) + return; + if ((unsigned)y >= (unsigned)back_buffer.height) + return; + CELL(&back_buffer, x, y) = *cell; } void tb_change_cell(int x, int y, uint32_t ch, uint16_t fg, uint16_t bg) { - struct tb_cell c = {ch, fg, bg}; - tb_put_cell(x, y, &c); + struct tb_cell c = {ch, fg, bg}; + tb_put_cell(x, y, &c); } void tb_blit(int x, int y, int w, int h, const struct tb_cell *cells) { - if (x + w < 0 || x >= back_buffer.width) - return; - if (y + h < 0 || y >= back_buffer.height) - return; - int xo = 0, yo = 0, ww = w, hh = h; - if (x < 0) { - xo = -x; - ww -= xo; - x = 0; - } - if (y < 0) { - yo = -y; - hh -= yo; - y = 0; - } - if (ww > back_buffer.width - x) - ww = back_buffer.width - x; - if (hh > back_buffer.height - y) - hh = back_buffer.height - y; - - int sy; - struct tb_cell *dst = &CELL(&back_buffer, x, y); - const struct tb_cell *src = cells + yo * w + xo; - size_t size = sizeof(struct tb_cell) * ww; - - for (sy = 0; sy < hh; ++sy) { - memcpy(dst, src, size); - dst += back_buffer.width; - src += w; - } + if (x + w < 0 || x >= back_buffer.width) + return; + if (y + h < 0 || y >= back_buffer.height) + return; + int xo = 0, yo = 0, ww = w, hh = h; + if (x < 0) { + xo = -x; + ww -= xo; + x = 0; + } + if (y < 0) { + yo = -y; + hh -= yo; + y = 0; + } + if (ww > back_buffer.width - x) + ww = back_buffer.width - x; + if (hh > back_buffer.height - y) + hh = back_buffer.height - y; + + int sy; + struct tb_cell *dst = &CELL(&back_buffer, x, y); + const struct tb_cell *src = cells + yo * w + xo; + size_t size = sizeof(struct tb_cell) * ww; + + for (sy = 0; sy < hh; ++sy) { + memcpy(dst, src, size); + dst += back_buffer.width; + src += w; + } } struct tb_cell *tb_cell_buffer() { - return back_buffer.cells; + return back_buffer.cells; } int tb_poll_event(struct tb_event *event) { - return wait_fill_event(event, 0); + return wait_fill_event(event, 0); } int tb_peek_event(struct tb_event *event, int timeout) { - struct timeval tv; - tv.tv_sec = timeout / 1000; - tv.tv_usec = (timeout - (tv.tv_sec * 1000)) * 1000; - return wait_fill_event(event, &tv); + struct timeval tv; + tv.tv_sec = timeout / 1000; + tv.tv_usec = (timeout - (tv.tv_sec * 1000)) * 1000; + return wait_fill_event(event, &tv); } int tb_width(void) { - return termw; + return termw; } int tb_height(void) { - return termh; + return termh; } void tb_clear(void) { - if (buffer_size_change_request) { - update_size(); - buffer_size_change_request = 0; - } - cellbuf_clear(&back_buffer); + if (buffer_size_change_request) { + update_size(); + buffer_size_change_request = 0; + } + cellbuf_clear(&back_buffer); } int tb_select_input_mode(int mode) { - if (mode) { - inputmode = mode; - if (mode&TB_INPUT_MOUSE) { - bytebuffer_puts(&output_buffer, funcs[T_ENTER_MOUSE]); - bytebuffer_flush(&output_buffer, inout); - } else { - bytebuffer_puts(&output_buffer, funcs[T_EXIT_MOUSE]); - bytebuffer_flush(&output_buffer, inout); - } - } - return inputmode; + if (mode) { + inputmode = mode; + if (mode&TB_INPUT_MOUSE) { + bytebuffer_puts(&output_buffer, funcs[T_ENTER_MOUSE]); + bytebuffer_flush(&output_buffer, inout); + } else { + bytebuffer_puts(&output_buffer, funcs[T_EXIT_MOUSE]); + bytebuffer_flush(&output_buffer, inout); + } + } + return inputmode; } int tb_select_output_mode(int mode) { - if (mode) - outputmode = mode; - return outputmode; + if (mode) + outputmode = mode; + return outputmode; } void tb_set_clear_attributes(uint16_t fg, uint16_t bg) { - foreground = fg; - background = bg; + foreground = fg; + background = bg; } /* -------------------------------------------------------- */ static int convertnum(uint32_t num, char* buf) { - int i, l = 0; - int ch; - do { - buf[l++] = '0' + (num % 10); - num /= 10; - } while (num); - for(i = 0; i < l / 2; i++) { - ch = buf[i]; - buf[i] = buf[l - 1 - i]; - buf[l - 1 - i] = ch; - } - return l; + int i, l = 0; + int ch; + do { + buf[l++] = '0' + (num % 10); + num /= 10; + } while (num); + for(i = 0; i < l / 2; i++) { + ch = buf[i]; + buf[i] = buf[l - 1 - i]; + buf[l - 1 - i] = ch; + } + return l; } #define WRITE_LITERAL(X) bytebuffer_append(&output_buffer, (X), sizeof(X)-1) #define WRITE_INT(X) bytebuffer_append(&output_buffer, buf, convertnum((X), buf)) static void write_cursor(int x, int y) { - char buf[32]; - WRITE_LITERAL("\033["); - WRITE_INT(y+1); - WRITE_LITERAL(";"); - WRITE_INT(x+1); - WRITE_LITERAL("H"); + char buf[32]; + WRITE_LITERAL("\033["); + WRITE_INT(y+1); + WRITE_LITERAL(";"); + WRITE_INT(x+1); + WRITE_LITERAL("H"); } // can only be called in NORMAL output mode static void write_sgr_fg(uint16_t fg) { - char buf[32]; + char buf[32]; - WRITE_LITERAL("\033[3"); - WRITE_INT(fg-1); - WRITE_LITERAL("m"); + WRITE_LITERAL("\033[3"); + WRITE_INT(fg-1); + WRITE_LITERAL("m"); } // can only be called in NORMAL output mode static void write_sgr_bg(uint16_t bg) { - char buf[32]; + char buf[32]; - WRITE_LITERAL("\033[4"); - WRITE_INT(bg-1); - WRITE_LITERAL("m"); + WRITE_LITERAL("\033[4"); + WRITE_INT(bg-1); + WRITE_LITERAL("m"); } static void write_sgr(uint16_t fg, uint16_t bg) { - char buf[32]; - - switch (outputmode) { - case TB_OUTPUT_256: - case TB_OUTPUT_216: - case TB_OUTPUT_GRAYSCALE: - WRITE_LITERAL("\033[38;5;"); - WRITE_INT(fg); - WRITE_LITERAL("m"); - WRITE_LITERAL("\033[48;5;"); - WRITE_INT(bg); - WRITE_LITERAL("m"); - break; - case TB_OUTPUT_NORMAL: - default: - WRITE_LITERAL("\033[3"); - WRITE_INT(fg-1); - WRITE_LITERAL(";4"); - WRITE_INT(bg-1); - WRITE_LITERAL("m"); - } + char buf[32]; + + switch (outputmode) { + case TB_OUTPUT_256: + case TB_OUTPUT_216: + case TB_OUTPUT_GRAYSCALE: + WRITE_LITERAL("\033[38;5;"); + WRITE_INT(fg); + WRITE_LITERAL("m"); + WRITE_LITERAL("\033[48;5;"); + WRITE_INT(bg); + WRITE_LITERAL("m"); + break; + case TB_OUTPUT_NORMAL: + default: + WRITE_LITERAL("\033[3"); + WRITE_INT(fg-1); + WRITE_LITERAL(";4"); + WRITE_INT(bg-1); + WRITE_LITERAL("m"); + } } static void cellbuf_init(struct cellbuf *buf, int width, int height) { - buf->cells = (struct tb_cell*)malloc(sizeof(struct tb_cell) * width * height); - assert(buf->cells); - buf->width = width; - buf->height = height; + buf->cells = (struct tb_cell*)malloc(sizeof(struct tb_cell) * width * height); + assert(buf->cells); + buf->width = width; + buf->height = height; } static void cellbuf_resize(struct cellbuf *buf, int width, int height) { - if (buf->width == width && buf->height == height) - return; + if (buf->width == width && buf->height == height) + return; - int oldw = buf->width; - int oldh = buf->height; - struct tb_cell *oldcells = buf->cells; + int oldw = buf->width; + int oldh = buf->height; + struct tb_cell *oldcells = buf->cells; - cellbuf_init(buf, width, height); - cellbuf_clear(buf); + cellbuf_init(buf, width, height); + cellbuf_clear(buf); - int minw = (width < oldw) ? width : oldw; - int minh = (height < oldh) ? height : oldh; - int i; + int minw = (width < oldw) ? width : oldw; + int minh = (height < oldh) ? height : oldh; + int i; - for (i = 0; i < minh; ++i) { - struct tb_cell *csrc = oldcells + (i * oldw); - struct tb_cell *cdst = buf->cells + (i * width); - memcpy(cdst, csrc, sizeof(struct tb_cell) * minw); - } + for (i = 0; i < minh; ++i) { + struct tb_cell *csrc = oldcells + (i * oldw); + struct tb_cell *cdst = buf->cells + (i * width); + memcpy(cdst, csrc, sizeof(struct tb_cell) * minw); + } - free(oldcells); + free(oldcells); } static void cellbuf_clear(struct cellbuf *buf) { - int i; - int ncells = buf->width * buf->height; + int i; + int ncells = buf->width * buf->height; - for (i = 0; i < ncells; ++i) { - buf->cells[i].ch = ' '; - buf->cells[i].fg = foreground; - buf->cells[i].bg = background; - } + for (i = 0; i < ncells; ++i) { + buf->cells[i].ch = ' '; + buf->cells[i].fg = foreground; + buf->cells[i].bg = background; + } } static void cellbuf_free(struct cellbuf *buf) { - free(buf->cells); + free(buf->cells); } static void get_term_size(int *w, int *h) { - struct winsize sz; - memset(&sz, 0, sizeof(sz)); + struct winsize sz; + memset(&sz, 0, sizeof(sz)); - ioctl(inout, TIOCGWINSZ, &sz); + ioctl(inout, TIOCGWINSZ, &sz); - if (w) *w = sz.ws_col; - if (h) *h = sz.ws_row; + if (w) *w = sz.ws_col; + if (h) *h = sz.ws_row; } static void update_term_size(void) { - struct winsize sz; - memset(&sz, 0, sizeof(sz)); + struct winsize sz; + memset(&sz, 0, sizeof(sz)); - ioctl(inout, TIOCGWINSZ, &sz); + ioctl(inout, TIOCGWINSZ, &sz); - termw = sz.ws_col; - termh = sz.ws_row; + termw = sz.ws_col; + termh = sz.ws_row; } static void send_attr(uint16_t fg, uint16_t bg) { #define LAST_ATTR_INIT 0xFFFF - static uint16_t lastfg = LAST_ATTR_INIT, lastbg = LAST_ATTR_INIT; - if (fg != lastfg || bg != lastbg) { - bytebuffer_puts(&output_buffer, funcs[T_SGR0]); - - uint16_t fgcol; - uint16_t bgcol; - - switch (outputmode) { - case TB_OUTPUT_256: - fgcol = fg & 0xFF; - bgcol = bg & 0xFF; - break; - - case TB_OUTPUT_216: - fgcol = fg & 0xFF; if (fgcol > 215) fgcol = 7; - bgcol = bg & 0xFF; if (bgcol > 215) bgcol = 0; - fgcol += 0x10; - bgcol += 0x10; - break; - - case TB_OUTPUT_GRAYSCALE: - fgcol = fg & 0xFF; if (fgcol > 23) fgcol = 23; - bgcol = bg & 0xFF; if (bgcol > 23) bgcol = 0; - fgcol += 0xe8; - bgcol += 0xe8; - break; - - case TB_OUTPUT_NORMAL: - default: - fgcol = fg & 0x0F; - bgcol = bg & 0x0F; - } - - if (fg & TB_BOLD) - bytebuffer_puts(&output_buffer, funcs[T_BOLD]); - if (bg & TB_BOLD) - bytebuffer_puts(&output_buffer, funcs[T_BLINK]); - if (fg & TB_UNDERLINE) - bytebuffer_puts(&output_buffer, funcs[T_UNDERLINE]); - if ((fg & TB_REVERSE) || (bg & TB_REVERSE)) - bytebuffer_puts(&output_buffer, funcs[T_REVERSE]); - - switch (outputmode) { - case TB_OUTPUT_256: - case TB_OUTPUT_216: - case TB_OUTPUT_GRAYSCALE: - write_sgr(fgcol, bgcol); - break; - - case TB_OUTPUT_NORMAL: - default: - if (fgcol != TB_DEFAULT) { - if (bgcol != TB_DEFAULT) - write_sgr(fgcol, bgcol); - else - write_sgr_fg(fgcol); - } else if (bgcol != TB_DEFAULT) { - write_sgr_bg(bgcol); - } - } - - lastfg = fg; - lastbg = bg; - } + static uint16_t lastfg = LAST_ATTR_INIT, lastbg = LAST_ATTR_INIT; + if (fg != lastfg || bg != lastbg) { + bytebuffer_puts(&output_buffer, funcs[T_SGR0]); + + uint16_t fgcol; + uint16_t bgcol; + + switch (outputmode) { + case TB_OUTPUT_256: + fgcol = fg & 0xFF; + bgcol = bg & 0xFF; + break; + + case TB_OUTPUT_216: + fgcol = fg & 0xFF; if (fgcol > 215) fgcol = 7; + bgcol = bg & 0xFF; if (bgcol > 215) bgcol = 0; + fgcol += 0x10; + bgcol += 0x10; + break; + + case TB_OUTPUT_GRAYSCALE: + fgcol = fg & 0xFF; if (fgcol > 23) fgcol = 23; + bgcol = bg & 0xFF; if (bgcol > 23) bgcol = 0; + fgcol += 0xe8; + bgcol += 0xe8; + break; + + case TB_OUTPUT_NORMAL: + default: + fgcol = fg & 0x0F; + bgcol = bg & 0x0F; + } + + if (fg & TB_BOLD) + bytebuffer_puts(&output_buffer, funcs[T_BOLD]); + if (bg & TB_BOLD) + bytebuffer_puts(&output_buffer, funcs[T_BLINK]); + if (fg & TB_UNDERLINE) + bytebuffer_puts(&output_buffer, funcs[T_UNDERLINE]); + if ((fg & TB_REVERSE) || (bg & TB_REVERSE)) + bytebuffer_puts(&output_buffer, funcs[T_REVERSE]); + + switch (outputmode) { + case TB_OUTPUT_256: + case TB_OUTPUT_216: + case TB_OUTPUT_GRAYSCALE: + write_sgr(fgcol, bgcol); + break; + + case TB_OUTPUT_NORMAL: + default: + if (fgcol != TB_DEFAULT) { + if (bgcol != TB_DEFAULT) + write_sgr(fgcol, bgcol); + else + write_sgr_fg(fgcol); + } else if (bgcol != TB_DEFAULT) { + write_sgr_bg(bgcol); + } + } + + lastfg = fg; + lastbg = bg; + } } static void send_char(int x, int y, uint32_t c) { - char buf[7]; - int bw = tb_utf8_unicode_to_char(buf, c); - buf[bw] = '\0'; - if (x-1 != lastx || y != lasty) - write_cursor(x, y); - lastx = x; lasty = y; - if(!c) buf[0] = ' '; // replace 0 with whitespace - bytebuffer_puts(&output_buffer, buf); + char buf[7]; + int bw = tb_utf8_unicode_to_char(buf, c); + buf[bw] = '\0'; + if (x-1 != lastx || y != lasty) + write_cursor(x, y); + lastx = x; lasty = y; + if(!c) buf[0] = ' '; // replace 0 with whitespace + bytebuffer_puts(&output_buffer, buf); } static void send_clear(void) { - send_attr(foreground, background); - bytebuffer_puts(&output_buffer, funcs[T_CLEAR_SCREEN]); - if (!IS_CURSOR_HIDDEN(cursor_x, cursor_y)) - write_cursor(cursor_x, cursor_y); - bytebuffer_flush(&output_buffer, inout); + send_attr(foreground, background); + bytebuffer_puts(&output_buffer, funcs[T_CLEAR_SCREEN]); + if (!IS_CURSOR_HIDDEN(cursor_x, cursor_y)) + write_cursor(cursor_x, cursor_y); + bytebuffer_flush(&output_buffer, inout); - /* we need to invalidate cursor position too and these two vars are - * used only for simple cursor positioning optimization, cursor - * actually may be in the correct place, but we simply discard - * optimization once and it gives us simple solution for the case when - * cursor moved */ - lastx = LAST_COORD_INIT; - lasty = LAST_COORD_INIT; + /* we need to invalidate cursor position too and these two vars are + * used only for simple cursor positioning optimization, cursor + * actually may be in the correct place, but we simply discard + * optimization once and it gives us simple solution for the case when + * cursor moved */ + lastx = LAST_COORD_INIT; + lasty = LAST_COORD_INIT; } static void sigwinch_handler(int xxx) { - (void) xxx; - const int zzz = 1; - int yyy = write(winch_fds[1], &zzz, sizeof(int)); - (void) yyy; + (void) xxx; + const int zzz = 1; + int yyy = write(winch_fds[1], &zzz, sizeof(int)); + (void) yyy; } static void update_size(void) { - update_term_size(); - cellbuf_resize(&back_buffer, termw, termh); - cellbuf_resize(&front_buffer, termw, termh); - cellbuf_clear(&front_buffer); - send_clear(); + update_term_size(); + cellbuf_resize(&back_buffer, termw, termh); + cellbuf_resize(&front_buffer, termw, termh); + cellbuf_clear(&front_buffer); + send_clear(); } static int read_up_to(int n) { - assert(n > 0); - const int prevlen = input_buffer.len; - bytebuffer_resize(&input_buffer, prevlen + n); - - int read_n = 0; - while (read_n <= n) { - ssize_t r = 0; - if (read_n < n) { - r = read(inout, input_buffer.buf + prevlen + read_n, n - read_n); - } + assert(n > 0); + const int prevlen = input_buffer.len; + bytebuffer_resize(&input_buffer, prevlen + n); + + int read_n = 0; + while (read_n <= n) { + ssize_t r = 0; + if (read_n < n) { + r = read(inout, input_buffer.buf + prevlen + read_n, n - read_n); + } #ifdef __CYGWIN__ - // While linux man for tty says when VMIN == 0 && VTIME == 0, read - // should return 0 when there is nothing to read, cygwin's read returns - // -1. Not sure why and if it's correct to ignore it, but let's pretend - // it's zero. - if (r < 0) r = 0; + // While linux man for tty says when VMIN == 0 && VTIME == 0, read + // should return 0 when there is nothing to read, cygwin's read returns + // -1. Not sure why and if it's correct to ignore it, but let's pretend + // it's zero. + if (r < 0) r = 0; #endif - if (r < 0) { - // EAGAIN / EWOULDBLOCK shouldn't occur here - assert(errno != EAGAIN && errno != EWOULDBLOCK); - return -1; - } else if (r > 0) { - read_n += r; - } else { - bytebuffer_resize(&input_buffer, prevlen + read_n); - return read_n; - } - } - assert(!"unreachable"); - return 0; + if (r < 0) { + // EAGAIN / EWOULDBLOCK shouldn't occur here + assert(errno != EAGAIN && errno != EWOULDBLOCK); + return -1; + } else if (r > 0) { + read_n += r; + } else { + bytebuffer_resize(&input_buffer, prevlen + read_n); + return read_n; + } + } + assert(!"unreachable"); + return 0; } static int wait_fill_event(struct tb_event *event, struct timeval *timeout) { - // ;-) + // ;-) #define ENOUGH_DATA_FOR_PARSING 64 - fd_set events; - memset(event, 0, sizeof(struct tb_event)); - - // try to extract event from input buffer, return on success - event->type = TB_EVENT_KEY; - if (extract_event(event, &input_buffer, inputmode)) - return event->type; - - // it looks like input buffer is incomplete, let's try the short path, - // but first make sure there is enough space - int n = read_up_to(ENOUGH_DATA_FOR_PARSING); - if (n < 0) - return -1; - if (n > 0 && extract_event(event, &input_buffer, inputmode)) - return event->type; - - // n == 0, or not enough data, let's go to select - while (1) { - FD_ZERO(&events); - FD_SET(inout, &events); - FD_SET(winch_fds[0], &events); - int maxfd = (winch_fds[0] > inout) ? winch_fds[0] : inout; - int result = select(maxfd+1, &events, 0, 0, timeout); - if (!result) - return 0; - - if (FD_ISSET(inout, &events)) { - event->type = TB_EVENT_KEY; - n = read_up_to(ENOUGH_DATA_FOR_PARSING); - if (n < 0) - return -1; - - if (n == 0) - continue; - - if (extract_event(event, &input_buffer, inputmode)) - return event->type; - } - if (FD_ISSET(winch_fds[0], &events)) { - event->type = TB_EVENT_RESIZE; - int zzz = 0; - int yyy = read(winch_fds[0], &zzz, sizeof(int)); - (void) yyy; - buffer_size_change_request = 1; - get_term_size(&event->w, &event->h); - return TB_EVENT_RESIZE; - } - } + fd_set events; + memset(event, 0, sizeof(struct tb_event)); + + // try to extract event from input buffer, return on success + event->type = TB_EVENT_KEY; + if (extract_event(event, &input_buffer, inputmode)) + return event->type; + + // it looks like input buffer is incomplete, let's try the short path, + // but first make sure there is enough space + int n = read_up_to(ENOUGH_DATA_FOR_PARSING); + if (n < 0) + return -1; + if (n > 0 && extract_event(event, &input_buffer, inputmode)) + return event->type; + + // n == 0, or not enough data, let's go to select + while (1) { + FD_ZERO(&events); + FD_SET(inout, &events); + FD_SET(winch_fds[0], &events); + int maxfd = (winch_fds[0] > inout) ? winch_fds[0] : inout; + int result = select(maxfd+1, &events, 0, 0, timeout); + if (!result) + return 0; + + if (FD_ISSET(inout, &events)) { + event->type = TB_EVENT_KEY; + n = read_up_to(ENOUGH_DATA_FOR_PARSING); + if (n < 0) + return -1; + + if (n == 0) + continue; + + if (extract_event(event, &input_buffer, inputmode)) + return event->type; + } + if (FD_ISSET(winch_fds[0], &events)) { + event->type = TB_EVENT_RESIZE; + int zzz = 0; + int yyy = read(winch_fds[0], &zzz, sizeof(int)); + (void) yyy; + buffer_size_change_request = 1; + get_term_size(&event->w, &event->h); + return TB_EVENT_RESIZE; + } + } } diff --git a/cpp/termbox/termbox.h b/cpp/termbox/termbox.h index 85a8cf12..65a965fc 100644 --- a/cpp/termbox/termbox.h +++ b/cpp/termbox/termbox.h @@ -133,9 +133,9 @@ extern "C" { * - 'bg' background color and attributes */ struct tb_cell { - uint32_t ch; - uint16_t fg; - uint16_t bg; + uint32_t ch; + uint16_t fg; + uint16_t bg; }; #define TB_EVENT_KEY 1 @@ -148,14 +148,14 @@ struct tb_cell { * TB_EVENT_MOUSE. */ struct tb_event { - uint8_t type; - uint8_t mod; - uint16_t key; - uint32_t ch; - int32_t w; - int32_t h; - int32_t x; - int32_t y; + uint8_t type; + uint8_t mod; + uint16_t key; + uint32_t ch; + int32_t w; + int32_t h; + int32_t x; + int32_t y; }; /* Error codes returned by tb_init(). All of them are self-explanatory, except diff --git a/cpp/termbox/utf8.c b/cpp/termbox/utf8.c index 0c37dae5..26c0c27b 100644 --- a/cpp/termbox/utf8.c +++ b/cpp/termbox/utf8.c @@ -12,68 +12,68 @@ static const unsigned char utf8_length[256] = { }; static const unsigned char utf8_mask[6] = { - 0x7F, - 0x1F, - 0x0F, - 0x07, - 0x03, - 0x01 + 0x7F, + 0x1F, + 0x0F, + 0x07, + 0x03, + 0x01 }; int tb_utf8_char_length(char c) { - return utf8_length[(unsigned char)c]; + return utf8_length[(unsigned char)c]; } int tb_utf8_char_to_unicode(uint32_t *out, const char *c) { - if (*c == 0) - return TB_EOF; + if (*c == 0) + return TB_EOF; - int i; - unsigned char len = tb_utf8_char_length(*c); - unsigned char mask = utf8_mask[len-1]; - uint32_t result = c[0] & mask; - for (i = 1; i < len; ++i) { - result <<= 6; - result |= c[i] & 0x3f; - } + int i; + unsigned char len = tb_utf8_char_length(*c); + unsigned char mask = utf8_mask[len-1]; + uint32_t result = c[0] & mask; + for (i = 1; i < len; ++i) { + result <<= 6; + result |= c[i] & 0x3f; + } - *out = result; - return (int)len; + *out = result; + return (int)len; } int tb_utf8_unicode_to_char(char *out, uint32_t c) { - int len = 0; - int first; - int i; + int len = 0; + int first; + int i; - if (c < 0x80) { - first = 0; - len = 1; - } else if (c < 0x800) { - first = 0xc0; - len = 2; - } else if (c < 0x10000) { - first = 0xe0; - len = 3; - } else if (c < 0x200000) { - first = 0xf0; - len = 4; - } else if (c < 0x4000000) { - first = 0xf8; - len = 5; - } else { - first = 0xfc; - len = 6; - } + if (c < 0x80) { + first = 0; + len = 1; + } else if (c < 0x800) { + first = 0xc0; + len = 2; + } else if (c < 0x10000) { + first = 0xe0; + len = 3; + } else if (c < 0x200000) { + first = 0xf0; + len = 4; + } else if (c < 0x4000000) { + first = 0xf8; + len = 5; + } else { + first = 0xfc; + len = 6; + } - for (i = len - 1; i > 0; --i) { - out[i] = (c & 0x3f) | 0x80; - c >>= 6; - } - out[0] = c | first; + for (i = len - 1; i > 0; --i) { + out[i] = (c & 0x3f) | 0x80; + c >>= 6; + } + out[0] = c | first; - return len; + return len; } |