sys/dev/syscons/teken/teken_demo.c

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