1/*-
2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
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
52static tf_bell_t	test_bell;
53static tf_cursor_t	test_cursor;
54static tf_putchar_t	test_putchar;
55static tf_fill_t	test_fill;
56static tf_copy_t	test_copy;
57static tf_param_t	test_param;
58static tf_respond_t	test_respond;
59
60static 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
70struct pixel {
71	teken_char_t	c;
72	teken_attr_t	a;
73};
74
75#define NCOLS	80
76#define NROWS	24
77static struct pixel buffer[NCOLS][NROWS];
78
79static int ptfd;
80
81static void
82printchar(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
129static void
130test_bell(void *s __unused)
131{
132
133	beep();
134}
135
136static void
137test_cursor(void *s __unused, const teken_pos_t *p)
138{
139
140	move(p->tp_row, p->tp_col);
141}
142
143static void
144test_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
153static void
154test_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
165static void
166test_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
232static void
233test_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
246static void
247test_respond(void *s __unused, const void *buf, size_t len)
248{
249
250	write(ptfd, buf, len);
251}
252
253static void
254redraw_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
266static void
267redraw_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
278int
279main(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