1 /*- 2 * SPDX-License-Identifier: BSD-2-Clause 3 * 4 * Copyright (c) 2008-2009 Ed Schouten <ed@FreeBSD.org> 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 19 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 26 * SUCH DAMAGE. 27 * 28 * $FreeBSD$ 29 */ 30 31 #include <sys/ioctl.h> 32 33 #include <assert.h> 34 #include <errno.h> 35 #include <inttypes.h> 36 #include <locale.h> 37 #include <stdio.h> 38 #include <stdlib.h> 39 #include <unistd.h> 40 41 #include <ncurses.h> 42 #if defined(__FreeBSD__) 43 #include <libutil.h> 44 #elif defined(__linux__) 45 #include <pty.h> 46 #else 47 #include <util.h> 48 #endif 49 50 #include <teken.h> 51 52 static tf_bell_t test_bell; 53 static tf_cursor_t test_cursor; 54 static tf_putchar_t test_putchar; 55 static tf_fill_t test_fill; 56 static tf_copy_t test_copy; 57 static tf_param_t test_param; 58 static tf_respond_t test_respond; 59 60 static teken_funcs_t tf = { 61 .tf_bell = test_bell, 62 .tf_cursor = test_cursor, 63 .tf_putchar = test_putchar, 64 .tf_fill = test_fill, 65 .tf_copy = test_copy, 66 .tf_param = test_param, 67 .tf_respond = test_respond, 68 }; 69 70 struct pixel { 71 teken_char_t c; 72 teken_attr_t a; 73 }; 74 75 #define NCOLS 80 76 #define NROWS 24 77 static struct pixel buffer[NCOLS][NROWS]; 78 79 static int ptfd; 80 81 static void 82 printchar(const teken_pos_t *p) 83 { 84 int y, x, attr = 0; 85 struct pixel *px; 86 char str[5] = { 0 }; 87 88 assert(p->tp_row < NROWS); 89 assert(p->tp_col < NCOLS); 90 91 px = &buffer[p->tp_col][p->tp_row]; 92 /* No need to print right hand side of CJK character manually. */ 93 if (px->a.ta_format & TF_CJK_RIGHT) 94 return; 95 96 /* Convert Unicode to UTF-8. */ 97 if (px->c < 0x80) { 98 str[0] = px->c; 99 } else if (px->c < 0x800) { 100 str[0] = 0xc0 | (px->c >> 6); 101 str[1] = 0x80 | (px->c & 0x3f); 102 } else if (px->c < 0x10000) { 103 str[0] = 0xe0 | (px->c >> 12); 104 str[1] = 0x80 | ((px->c >> 6) & 0x3f); 105 str[2] = 0x80 | (px->c & 0x3f); 106 } else { 107 str[0] = 0xf0 | (px->c >> 18); 108 str[1] = 0x80 | ((px->c >> 12) & 0x3f); 109 str[2] = 0x80 | ((px->c >> 6) & 0x3f); 110 str[3] = 0x80 | (px->c & 0x3f); 111 } 112 113 if (px->a.ta_format & TF_BOLD) 114 attr |= A_BOLD; 115 if (px->a.ta_format & TF_UNDERLINE) 116 attr |= A_UNDERLINE; 117 if (px->a.ta_format & TF_BLINK) 118 attr |= A_BLINK; 119 if (px->a.ta_format & TF_REVERSE) 120 attr |= A_REVERSE; 121 122 bkgdset(attr | COLOR_PAIR(teken_256to8(px->a.ta_fgcolor) + 123 8 * teken_256to8(px->a.ta_bgcolor))); 124 getyx(stdscr, y, x); 125 mvaddstr(p->tp_row, p->tp_col, str); 126 move(y, x); 127 } 128 129 static void 130 test_bell(void *s __unused) 131 { 132 133 beep(); 134 } 135 136 static void 137 test_cursor(void *s __unused, const teken_pos_t *p) 138 { 139 140 move(p->tp_row, p->tp_col); 141 } 142 143 static void 144 test_putchar(void *s __unused, const teken_pos_t *p, teken_char_t c, 145 const teken_attr_t *a) 146 { 147 148 buffer[p->tp_col][p->tp_row].c = c; 149 buffer[p->tp_col][p->tp_row].a = *a; 150 printchar(p); 151 } 152 153 static void 154 test_fill(void *s, const teken_rect_t *r, teken_char_t c, 155 const teken_attr_t *a) 156 { 157 teken_pos_t p; 158 159 /* Braindead implementation of fill() - just call putchar(). */ 160 for (p.tp_row = r->tr_begin.tp_row; p.tp_row < r->tr_end.tp_row; p.tp_row++) 161 for (p.tp_col = r->tr_begin.tp_col; p.tp_col < r->tr_end.tp_col; p.tp_col++) 162 test_putchar(s, &p, c, a); 163 } 164 165 static void 166 test_copy(void *s __unused, const teken_rect_t *r, const teken_pos_t *p) 167 { 168 int nrow, ncol, x, y; /* Has to be signed - >= 0 comparison */ 169 teken_pos_t d; 170 171 /* 172 * Copying is a little tricky. We must make sure we do it in 173 * correct order, to make sure we don't overwrite our own data. 174 */ 175 176 nrow = r->tr_end.tp_row - r->tr_begin.tp_row; 177 ncol = r->tr_end.tp_col - r->tr_begin.tp_col; 178 179 if (p->tp_row < r->tr_begin.tp_row) { 180 /* Copy from top to bottom. */ 181 if (p->tp_col < r->tr_begin.tp_col) { 182 /* Copy from left to right. */ 183 for (y = 0; y < nrow; y++) { 184 d.tp_row = p->tp_row + y; 185 for (x = 0; x < ncol; x++) { 186 d.tp_col = p->tp_col + x; 187 buffer[d.tp_col][d.tp_row] = 188 buffer[r->tr_begin.tp_col + x][r->tr_begin.tp_row + y]; 189 printchar(&d); 190 } 191 } 192 } else { 193 /* Copy from right to left. */ 194 for (y = 0; y < nrow; y++) { 195 d.tp_row = p->tp_row + y; 196 for (x = ncol - 1; x >= 0; x--) { 197 d.tp_col = p->tp_col + x; 198 buffer[d.tp_col][d.tp_row] = 199 buffer[r->tr_begin.tp_col + x][r->tr_begin.tp_row + y]; 200 printchar(&d); 201 } 202 } 203 } 204 } else { 205 /* Copy from bottom to top. */ 206 if (p->tp_col < r->tr_begin.tp_col) { 207 /* Copy from left to right. */ 208 for (y = nrow - 1; y >= 0; y--) { 209 d.tp_row = p->tp_row + y; 210 for (x = 0; x < ncol; x++) { 211 d.tp_col = p->tp_col + x; 212 buffer[d.tp_col][d.tp_row] = 213 buffer[r->tr_begin.tp_col + x][r->tr_begin.tp_row + y]; 214 printchar(&d); 215 } 216 } 217 } else { 218 /* Copy from right to left. */ 219 for (y = nrow - 1; y >= 0; y--) { 220 d.tp_row = p->tp_row + y; 221 for (x = ncol - 1; x >= 0; x--) { 222 d.tp_col = p->tp_col + x; 223 buffer[d.tp_col][d.tp_row] = 224 buffer[r->tr_begin.tp_col + x][r->tr_begin.tp_row + y]; 225 printchar(&d); 226 } 227 } 228 } 229 } 230 } 231 232 static void 233 test_param(void *s __unused, int cmd, unsigned int value) 234 { 235 236 switch (cmd) { 237 case TP_SHOWCURSOR: 238 curs_set(value); 239 break; 240 case TP_KEYPADAPP: 241 keypad(stdscr, value ? TRUE : FALSE); 242 break; 243 } 244 } 245 246 static void 247 test_respond(void *s __unused, const void *buf, size_t len) 248 { 249 250 write(ptfd, buf, len); 251 } 252 253 static void 254 redraw_border(void) 255 { 256 unsigned int i; 257 258 for (i = 0; i < NROWS; i++) 259 mvaddch(i, NCOLS, '|'); 260 for (i = 0; i < NCOLS; i++) 261 mvaddch(NROWS, i, '-'); 262 263 mvaddch(NROWS, NCOLS, '+'); 264 } 265 266 static void 267 redraw_all(void) 268 { 269 teken_pos_t tp; 270 271 for (tp.tp_row = 0; tp.tp_row < NROWS; tp.tp_row++) 272 for (tp.tp_col = 0; tp.tp_col < NCOLS; tp.tp_col++) 273 printchar(&tp); 274 275 redraw_border(); 276 } 277 278 int 279 main(int argc __unused, char *argv[] __unused) 280 { 281 struct winsize ws; 282 teken_t t; 283 teken_pos_t tp; 284 fd_set rfds; 285 char b[256]; 286 ssize_t bl; 287 const int ccolors[8] = { 288 COLOR_BLACK, COLOR_RED, COLOR_GREEN, COLOR_YELLOW, 289 COLOR_BLUE, COLOR_MAGENTA, COLOR_CYAN, COLOR_WHITE 290 }; 291 int i, j; 292 293 setlocale(LC_CTYPE, "UTF-8"); 294 295 tp.tp_row = ws.ws_row = NROWS; 296 tp.tp_col = ws.ws_col = NCOLS; 297 298 switch (forkpty(&ptfd, NULL, NULL, &ws)) { 299 case -1: 300 perror("forkpty"); 301 exit(1); 302 case 0: 303 setenv("TERM", "xterm", 1); 304 setenv("LC_CTYPE", "UTF-8", 0); 305 execlp("zsh", "-zsh", NULL); 306 execlp("bash", "-bash", NULL); 307 execlp("sh", "-sh", NULL); 308 _exit(1); 309 } 310 311 teken_init(&t, &tf, NULL); 312 teken_set_winsize(&t, &tp); 313 314 initscr(); 315 raw(); 316 start_color(); 317 for (i = 0; i < 8; i++) 318 for (j = 0; j < 8; j++) 319 init_pair(i + 8 * j, ccolors[i], ccolors[j]); 320 321 redraw_border(); 322 323 FD_ZERO(&rfds); 324 325 for (;;) { 326 FD_SET(STDIN_FILENO, &rfds); 327 FD_SET(ptfd, &rfds); 328 329 if (select(ptfd + 1, &rfds, NULL, NULL, NULL) < 0) { 330 if (errno == EINTR) { 331 redraw_all(); 332 refresh(); 333 continue; 334 } 335 break; 336 } 337 338 if (FD_ISSET(STDIN_FILENO, &rfds)) { 339 bl = read(STDIN_FILENO, b, sizeof b); 340 if (bl <= 0) 341 break; 342 write(ptfd, b, bl); 343 } 344 345 if (FD_ISSET(ptfd, &rfds)) { 346 bl = read(ptfd, b, sizeof b); 347 if (bl <= 0) 348 break; 349 teken_input(&t, b, bl); 350 refresh(); 351 } 352 } 353 354 endwin(); 355 356 return (0); 357 } 358