cacalabs
/
libcaca
şunun yansıması https://github.com/cacalabs/libcaca.git
1
0
Çatalla 0
Kod Konular 0 Sürümler 7 Wiki Aktivite
25'ten fazla konu seçemezsiniz Konular bir harf veya rakamla başlamalı, kısa çizgiler ('-') içerebilir ve en fazla 35 karakter uzunluğunda olabilir.
1875 İşleme
1 Dal
232 MiB
 
 
 
 
 
 
Ağaç: d70c958c8c
Dallar Biçim İmleri
${ item.name }
${ searchTerm } dalı oluştur
'd70c958c8c'den
${ noResults }
libcaca/caca/driver/ncurses.c

873 satır
21 KiB
Ham Suçlama Geçmiş 

  1. /*

  2.  *  libcaca       Colour ASCII-Art library

  3.  *  Copyright (c) 2002-2010 Sam Hocevar <sam@hocevar.net>

  4.  *                2007 Ben Wiley Sittler <bsittler@gmail.com>

  5.  *                All Rights Reserved

  6.  *

  7.  *  This library is free software. It comes without any warranty, to

  8.  *  the extent permitted by applicable law. You can redistribute it

  9.  *  and/or modify it under the terms of the Do What The Fuck You Want

  10.  *  To Public License, Version 2, as published by Sam Hocevar. See

  11.  *  http://sam.zoy.org/wtfpl/COPYING for more details.

  12.  */

  13. 

  14. /*

  15.  *  This file contains the libcaca Ncurses input and output driver

  16.  */

  17. 

  18. #include "config.h"

  19. 

  20. #if defined USE_NCURSES

  21. 

  22. #if defined HAVE_NCURSESW_NCURSES_H

  23. #   include <ncursesw/ncurses.h>

  24. #elif defined HAVE_NCURSES_NCURSES_H

  25. #   include <ncurses/ncurses.h>

  26. #elif defined HAVE_NCURSES_H

  27. #   include <ncurses.h>

  28. #else

  29. #   include <curses.h>

  30. #endif

  31. 

  32. #include <stdlib.h>

  33. #include <string.h>

  34. 

  35. #if defined HAVE_UNISTD_H

  36. #   include <unistd.h>

  37. #endif

  38. #if defined HAVE_SIGNAL_H

  39. #   include <signal.h>

  40. #endif

  41. #if defined HAVE_SYS_IOCTL_H

  42. #   include <sys/ioctl.h>

  43. #endif

  44. #if defined HAVE_LOCALE_H

  45. #   include <locale.h>

  46. #endif

  47. #if defined HAVE_TERMIOS_H

  48. #   include <termios.h>

  49. #endif

  50. 

  51. #include "caca.h"

  52. #include "caca_internals.h"

  53. 

  54. /*

  55.  * Emulation for missing ACS_* in older curses

  56.  */

  57. 

  58. #ifndef ACS_BLOCK

  59. #define ACS_BLOCK '#'

  60. #endif

  61. 

  62. #ifndef ACS_BOARD

  63. #define ACS_BOARD '#'

  64. #endif

  65. 

  66. #ifndef ACS_BTEE

  67. #define ACS_BTEE '+'

  68. #endif

  69. 

  70. #ifndef ACS_BULLET

  71. #define ACS_BULLET '.'

  72. #endif

  73. 

  74. #ifndef ACS_CKBOARD

  75. #define ACS_CKBOARD ':'

  76. #endif

  77. 

  78. #ifndef ACS_DARROW

  79. #define ACS_DARROW 'v'

  80. #endif

  81. 

  82. #ifndef ACS_DEGREE

  83. #define ACS_DEGREE '\''

  84. #endif

  85. 

  86. #ifndef ACS_DIAMOND

  87. #define ACS_DIAMOND '+'

  88. #endif

  89. 

  90. #ifndef ACS_GEQUAL

  91. #define ACS_GEQUAL '>'

  92. #endif

  93. 

  94. #ifndef ACS_HLINE

  95. #define ACS_HLINE '-'

  96. #endif

  97. 

  98. #ifndef ACS_LANTERN

  99. #define ACS_LANTERN '#'

  100. #endif

  101. 

  102. #ifndef ACS_LARROW

  103. #define ACS_LARROW '<'

  104. #endif

  105. 

  106. #ifndef ACS_LEQUAL

  107. #define ACS_LEQUAL '<'

  108. #endif

  109. 

  110. #ifndef ACS_LLCORNER

  111. #define ACS_LLCORNER '+'

  112. #endif

  113. 

  114. #ifndef ACS_LRCORNER

  115. #define ACS_LRCORNER '+'

  116. #endif

  117. 

  118. #ifndef ACS_LTEE

  119. #define ACS_LTEE '+'

  120. #endif

  121. 

  122. #ifndef ACS_NEQUAL

  123. #define ACS_NEQUAL '!'

  124. #endif

  125. 

  126. #ifndef ACS_PI

  127. #define ACS_PI '*'

  128. #endif

  129. 

  130. #ifndef ACS_STERLING

  131. #define ACS_STERLING 'f'

  132. #endif

  133. 

  134. #ifndef ACS_PLMINUS

  135. #define ACS_PLMINUS '#'

  136. #endif

  137. 

  138. #ifndef ACS_PLUS

  139. #define ACS_PLUS '+'

  140. #endif

  141. 

  142. #ifndef ACS_RARROW

  143. #define ACS_RARROW '>'

  144. #endif

  145. 

  146. #ifndef ACS_RTEE

  147. #define ACS_RTEE '+'

  148. #endif

  149. 

  150. #ifndef ACS_S1

  151. #define ACS_S1 '-'

  152. #endif

  153. 

  154. #ifndef ACS_S3

  155. #define ACS_S3 '-'

  156. #endif

  157. 

  158. #ifndef ACS_S7

  159. #define ACS_S7 '-'

  160. #endif

  161. 

  162. #ifndef ACS_S9

  163. #define ACS_S9 '-'

  164. #endif

  165. 

  166. #ifndef ACS_TTEE

  167. #define ACS_TTEE '+'

  168. #endif

  169. 

  170. #ifndef ACS_UARROW

  171. #define ACS_UARROW '^'

  172. #endif

  173. 

  174. #ifndef ACS_ULCORNER

  175. #define ACS_ULCORNER '+'

  176. #endif

  177. 

  178. #ifndef ACS_URCORNER

  179. #define ACS_URCORNER '+'

  180. #endif

  181. 

  182. #ifndef ACS_VLINE

  183. #define ACS_VLINE '|'

  184. #endif

  185. 

  186. /*

  187.  * Local functions

  188.  */

  189. 

  190. #if defined HAVE_SIGNAL

  191. static RETSIGTYPE sigwinch_handler(int);

  192. static caca_display_t *sigwinch_d; /* FIXME: we ought to get rid of this */

  193. #endif

  194. #if defined HAVE_GETENV && defined HAVE_PUTENV

  195. static void ncurses_install_terminal(caca_display_t *);

  196. static void ncurses_uninstall_terminal(caca_display_t *);

  197. #endif

  198. static void ncurses_write_utf32(uint32_t);

  199. 

  200. struct driver_private

  201. {

  202.     int attr[16*16];

  203.     mmask_t oldmask;

  204.     char *term;

  205. };

  206. 

  207. static int ncurses_init_graphics(caca_display_t *dp)

  208. {

  209.     static int curses_colors[] =

  210.     {

  211.         /* Standard curses colours */

  212.         COLOR_BLACK,

  213.         COLOR_BLUE,

  214.         COLOR_GREEN,

  215.         COLOR_CYAN,

  216.         COLOR_RED,

  217.         COLOR_MAGENTA,

  218.         COLOR_YELLOW,

  219.         COLOR_WHITE,

  220.         /* Extra values for xterm-16color */

  221.         COLOR_BLACK + 8,

  222.         COLOR_BLUE + 8,

  223.         COLOR_GREEN + 8,

  224.         COLOR_CYAN + 8,

  225.         COLOR_RED + 8,

  226.         COLOR_MAGENTA + 8,

  227.         COLOR_YELLOW + 8,

  228.         COLOR_WHITE + 8

  229.     };

  230. 

  231.     mmask_t newmask;

  232.     int fg, bg, max;

  233. 

  234.     dp->drv.p = malloc(sizeof(struct driver_private));

  235. 

  236. #if defined HAVE_GETENV && defined HAVE_PUTENV

  237.     ncurses_install_terminal(dp);

  238. #endif

  239. 

  240. #if defined HAVE_SIGNAL

  241.     sigwinch_d = dp;

  242.     signal(SIGWINCH, sigwinch_handler);

  243. #endif

  244. 

  245. #if defined HAVE_LOCALE_H

  246.     setlocale(LC_ALL, "");

  247. #endif

  248. 

  249.     _caca_set_term_title("caca for ncurses");

  250. 

  251.     initscr();

  252.     keypad(stdscr, TRUE);

  253.     nonl();

  254.     raw();

  255.     noecho();

  256.     nodelay(stdscr, TRUE);

  257.     curs_set(0);

  258. 

  259.     /* Activate mouse */

  260.     newmask = REPORT_MOUSE_POSITION | ALL_MOUSE_EVENTS;

  261.     mousemask(newmask, &dp->drv.p->oldmask);

  262.     mouseinterval(-1); /* No click emulation */

  263. 

  264.     /* Set the escape delay to a ridiculously low value */

  265. #if defined set_escdelay

  266.     set_escdelay(10);

  267. #else

  268.     ESCDELAY = 10;

  269. #endif

  270. 

  271.     /* Activate colour */

  272.     start_color();

  273. 

  274.     /* If COLORS == 16, it means the terminal supports full bright colours

  275.      * using setab and setaf (will use \e[90m \e[91m etc. for colours >= 8),

  276.      * we can build 16*16 colour pairs.

  277.      * If COLORS == 8, it means the terminal does not know about bright

  278.      * colours and we need to get them through A_BOLD and A_BLINK (\e[1m

  279.      * and \e[5m). We can only build 8*8 colour pairs. */

  280.     max = COLORS >= 16 ? 16 : 8;

  281. 

  282.     for(bg = 0; bg < max; bg++)

  283.         for(fg = 0; fg < max; fg++)

  284.         {

  285.             /* Use ((max + 7 - fg) % max) instead of fg so that colour 0

  286.              * is light gray on black. Some terminals don't like this

  287.              * colour pair to be redefined. */

  288.             int col = ((max + 7 - fg) % max) + max * bg;

  289.             init_pair(col, curses_colors[fg], curses_colors[bg]);

  290.             dp->drv.p->attr[fg + 16 * bg] = COLOR_PAIR(col);

  291. 

  292.             if(max == 8)

  293.             {

  294.                 /* Bright fg on simple bg */

  295.                 dp->drv.p->attr[fg + 8 + 16 * bg] = A_BOLD | COLOR_PAIR(col);

  296.                 /* Simple fg on bright bg */

  297.                 dp->drv.p->attr[fg + 16 * (bg + 8)] = A_BLINK

  298.                                                     | COLOR_PAIR(col);

  299.                 /* Bright fg on bright bg */

  300.                 dp->drv.p->attr[fg + 8 + 16 * (bg + 8)] = A_BLINK | A_BOLD

  301.                                                         | COLOR_PAIR(col);

  302.             }

  303.         }

  304. 

  305.     caca_add_dirty_rect(dp->cv, 0, 0, dp->cv->width, dp->cv->height);

  306.     dp->resize.allow = 1;

  307.     caca_set_canvas_size(dp->cv, COLS, LINES);

  308.     dp->resize.allow = 0;

  309. 

  310.     return 0;

  311. }

  312. 

  313. static int ncurses_end_graphics(caca_display_t *dp)

  314. {

  315.     _caca_set_term_title("");

  316.     mousemask(dp->drv.p->oldmask, NULL);

  317.     curs_set(1);

  318.     noraw();

  319.     endwin();

  320. 

  321. #if defined HAVE_GETENV && defined HAVE_PUTENV

  322.     ncurses_uninstall_terminal(dp);

  323. #endif

  324. 

  325.     free(dp->drv.p);

  326. 

  327.     return 0;

  328. }

  329. 

  330. static int ncurses_set_display_title(caca_display_t *dp, char const *title)

  331. {

  332.     _caca_set_term_title(title);

  333. 

  334.     return 0;

  335. }

  336. 

  337. static int ncurses_get_display_width(caca_display_t const *dp)

  338. {

  339.     /* Fallback to a 6x10 font */

  340.     return caca_get_canvas_width(dp->cv) * 6;

  341. }

  342. 

  343. static int ncurses_get_display_height(caca_display_t const *dp)

  344. {

  345.     /* Fallback to a 6x10 font */

  346.     return caca_get_canvas_height(dp->cv) * 10;

  347. }

  348. 

  349. static void ncurses_display(caca_display_t *dp)

  350. {

  351.     int x, y, i;

  352. 

  353.     for(i = 0; i < caca_get_dirty_rect_count(dp->cv); i++)

  354.     {

  355.         uint32_t const *cvchars, *cvattrs;

  356.         int dx, dy, dw, dh;

  357. 

  358.         caca_get_dirty_rect(dp->cv, i, &dx, &dy, &dw, &dh);

  359. 

  360.         cvchars = caca_get_canvas_chars(dp->cv) + dx + dy * dp->cv->width;

  361.         cvattrs = caca_get_canvas_attrs(dp->cv) + dx + dy * dp->cv->width;

  362. 

  363.         for(y = dy; y < dy + dh; y++)

  364.         {

  365.             move(y, dx);

  366.             for(x = dx; x < dx + dw; x++)

  367.             {

  368.                 (void)attrset(dp->drv.p->attr[caca_attr_to_ansi(*cvattrs++)]);

  369.                 ncurses_write_utf32(*cvchars++);

  370.             }

  371. 

  372.             cvchars += dp->cv->width - dw;

  373.             cvattrs += dp->cv->width - dw;

  374.         }

  375.     }

  376. 

  377.     x = caca_wherex(dp->cv);

  378.     y = caca_wherey(dp->cv);

  379.     move(y, x);

  380. 

  381.     refresh();

  382. }

  383. 

  384. static void ncurses_handle_resize(caca_display_t *dp)

  385. {

  386.     struct winsize size;

  387. 

  388. #if defined HAVE_SYS_IOCTL_H

  389.     if(ioctl(fileno(stdout), TIOCGWINSZ, &size) == 0)

  390.     {

  391.         dp->resize.w = size.ws_col;

  392.         dp->resize.h = size.ws_row;

  393. #if defined HAVE_RESIZE_TERM

  394.         resize_term(dp->resize.h, dp->resize.w);

  395. #else

  396.         resizeterm(dp->resize.h, dp->resize.w);

  397. #endif

  398.         wrefresh(curscr);

  399.         return;

  400.     }

  401. #endif

  402. 

  403.     /* Fallback */

  404.     dp->resize.w = caca_get_canvas_width(dp->cv);

  405.     dp->resize.h = caca_get_canvas_height(dp->cv);

  406. }

  407. 

  408. static int ncurses_get_event(caca_display_t *dp, caca_privevent_t *ev)

  409. {

  410.     int intkey;

  411. 

  412.     intkey = getch();

  413.     if(intkey == ERR)

  414.     {

  415.         ev->type = CACA_EVENT_NONE;

  416.         return 0;

  417.     }

  418. 

  419.     if(intkey < 0x7f)

  420.     {

  421.         ev->type = CACA_EVENT_KEY_PRESS;

  422.         ev->data.key.ch = intkey;

  423.         ev->data.key.utf32 = intkey;

  424.         ev->data.key.utf8[0] = intkey;

  425.         ev->data.key.utf8[1] = '\0';

  426.         return 1;

  427.     }

  428. 

  429.     /* If the key was UTF-8, parse the whole sequence */

  430.     if(intkey >= 0x80 && intkey < 0x100)

  431.     {

  432.         int keys[7]; /* Necessary for ungetch(); */

  433.         char utf8[7];

  434.         uint32_t utf32;

  435.         size_t i, bytes = 0;

  436. 

  437.         keys[0] = intkey;

  438.         utf8[0] = intkey;

  439. 

  440.         for(i = 1; i < 6; i++)

  441.         {

  442.             keys[i] = getch();

  443.             utf8[i] = (unsigned char)keys[i];

  444.         }

  445. 

  446.         utf8[i] = '\0';

  447.         utf32 = caca_utf8_to_utf32(utf8, &bytes);

  448. 

  449.         while(i > bytes)

  450.             ungetch(keys[--i]);

  451. 

  452.         if(bytes)

  453.         {

  454.             ev->type = CACA_EVENT_KEY_PRESS;

  455.             ev->data.key.ch = 0;

  456.             ev->data.key.utf32 = utf32;

  457.             strcpy(ev->data.key.utf8, utf8);

  458.             return 1;

  459.         }

  460.     }

  461. 

  462.     if(intkey == KEY_MOUSE)

  463.     {

  464.         MEVENT mevent;

  465.         getmouse(&mevent);

  466. 

  467.         switch(mevent.bstate)

  468.         {

  469. #define PRESS(x) ev->data.mouse.button = x; \

  470.                  ev->type = CACA_EVENT_MOUSE_PRESS; _push_event(dp, ev)

  471. #define RELEASE(x) ev->data.mouse.button = x; \

  472.                    ev->type = CACA_EVENT_MOUSE_RELEASE; _push_event(dp, ev)

  473. #define CLICK(x) PRESS(x); RELEASE(x)

  474.             case BUTTON1_PRESSED: PRESS(1); break;

  475.             case BUTTON1_RELEASED: RELEASE(1); break;

  476.             case BUTTON1_CLICKED: CLICK(1); break;

  477.             case BUTTON1_DOUBLE_CLICKED: CLICK(1); CLICK(1); break;

  478.             case BUTTON1_TRIPLE_CLICKED: CLICK(1); CLICK(1); CLICK(1); break;

  479. #if defined BUTTON1_RESERVED_EVENT

  480.             case BUTTON1_RESERVED_EVENT: break;

  481. #endif

  482. 

  483.             case BUTTON2_PRESSED: PRESS(2); break;

  484.             case BUTTON2_RELEASED: RELEASE(2); break;

  485.             case BUTTON2_CLICKED: CLICK(2); break;

  486.             case BUTTON2_DOUBLE_CLICKED: CLICK(2); CLICK(2); break;

  487.             case BUTTON2_TRIPLE_CLICKED: CLICK(2); CLICK(2); CLICK(2); break;

  488. #if defined BUTTON2_RESERVED_EVENT

  489.             case BUTTON2_RESERVED_EVENT: break;

  490. #endif

  491. 

  492.             case BUTTON3_PRESSED: PRESS(3); break;

  493.             case BUTTON3_RELEASED: RELEASE(3); break;

  494.             case BUTTON3_CLICKED: CLICK(3); break;

  495.             case BUTTON3_DOUBLE_CLICKED: CLICK(3); CLICK(3); break;

  496.             case BUTTON3_TRIPLE_CLICKED: CLICK(3); CLICK(3); CLICK(3); break;

  497. #if defined BUTTON3_RESERVED_EVENT

  498.             case BUTTON3_RESERVED_EVENT: break;

  499. #endif

  500. 

  501.             case BUTTON4_PRESSED: PRESS(4); break;

  502.             case BUTTON4_RELEASED: RELEASE(4); break;

  503.             case BUTTON4_CLICKED: CLICK(4); break;

  504.             case BUTTON4_DOUBLE_CLICKED: CLICK(4); CLICK(4); break;

  505.             case BUTTON4_TRIPLE_CLICKED: CLICK(4); CLICK(4); CLICK(4); break;

  506. #if defined BUTTON4_RESERVED_EVENT

  507.             case BUTTON4_RESERVED_EVENT: break;

  508. #endif

  509. 

  510.             default:

  511.                 break;

  512. #undef PRESS

  513. #undef RELEASE

  514. #undef CLICK

  515.         }

  516. 

  517.         if(dp->mouse.x == mevent.x && dp->mouse.y == mevent.y)

  518.             return _pop_event(dp, ev);

  519. 

  520.         dp->mouse.x = mevent.x;

  521.         dp->mouse.y = mevent.y;

  522. 

  523.         ev->type = CACA_EVENT_MOUSE_MOTION;

  524.         ev->data.mouse.x = dp->mouse.x;

  525.         ev->data.mouse.y = dp->mouse.y;

  526.         return 1;

  527.     }

  528. 

  529.     switch(intkey)

  530.     {

  531.         case KEY_UP: ev->data.key.ch = CACA_KEY_UP; break;

  532.         case KEY_DOWN: ev->data.key.ch = CACA_KEY_DOWN; break;

  533.         case KEY_LEFT: ev->data.key.ch = CACA_KEY_LEFT; break;

  534.         case KEY_RIGHT: ev->data.key.ch = CACA_KEY_RIGHT; break;

  535. 

  536.         case KEY_IC: ev->data.key.ch = CACA_KEY_INSERT; break;

  537.         case KEY_DC: ev->data.key.ch = CACA_KEY_DELETE; break;

  538.         case 0x7f:

  539.         case KEY_BACKSPACE: ev->data.key.ch = CACA_KEY_BACKSPACE; break;

  540.         case KEY_HOME: ev->data.key.ch = CACA_KEY_HOME; break;

  541.         case KEY_END: ev->data.key.ch = CACA_KEY_END; break;

  542.         case KEY_PPAGE: ev->data.key.ch = CACA_KEY_PAGEUP; break;

  543.         case KEY_NPAGE: ev->data.key.ch = CACA_KEY_PAGEDOWN; break;

  544. 

  545.         case KEY_F(1): ev->data.key.ch = CACA_KEY_F1; break;

  546.         case KEY_F(2): ev->data.key.ch = CACA_KEY_F2; break;

  547.         case KEY_F(3): ev->data.key.ch = CACA_KEY_F3; break;

  548.         case KEY_F(4): ev->data.key.ch = CACA_KEY_F4; break;

  549.         case KEY_F(5): ev->data.key.ch = CACA_KEY_F5; break;

  550.         case KEY_F(6): ev->data.key.ch = CACA_KEY_F6; break;

  551.         case KEY_F(7): ev->data.key.ch = CACA_KEY_F7; break;

  552.         case KEY_F(8): ev->data.key.ch = CACA_KEY_F8; break;

  553.         case KEY_F(9): ev->data.key.ch = CACA_KEY_F9; break;

  554.         case KEY_F(10): ev->data.key.ch = CACA_KEY_F10; break;

  555.         case KEY_F(11): ev->data.key.ch = CACA_KEY_F11; break;

  556.         case KEY_F(12): ev->data.key.ch = CACA_KEY_F12; break;

  557. 

  558.         default:

  559.             /* Unknown key */

  560.             ev->type = CACA_EVENT_NONE; return 0;

  561.     }

  562. 

  563.     ev->type = CACA_EVENT_KEY_PRESS;

  564.     ev->data.key.utf32 = 0;

  565.     ev->data.key.utf8[0] = '\0';

  566.     return 1;

  567. }

  568. 

  569. static void ncurses_set_cursor(caca_display_t *dp, int flags)

  570. {

  571.     if (!flags)

  572.         curs_set(0);

  573.     else if (curs_set(2) == ERR)

  574.         curs_set(1);

  575. }

  576. 

  577. /*

  578.  * XXX: following functions are local

  579.  */

  580. 

  581. #if defined HAVE_SIGNAL

  582. static RETSIGTYPE sigwinch_handler(int sig)

  583. {

  584.     sigwinch_d->resize.resized = 1;

  585. 

  586.     signal(SIGWINCH, sigwinch_handler);

  587. }

  588. #endif

  589. 

  590. #if defined HAVE_GETENV && defined HAVE_PUTENV

  591. static void ncurses_install_terminal(caca_display_t *dp)

  592. {

  593.     char *term, *colorterm;

  594. 

  595.     dp->drv.p->term = NULL;

  596. 

  597.     term = getenv("TERM");

  598.     colorterm = getenv("COLORTERM");

  599. 

  600.     if(!term || strcmp(term, "xterm"))

  601.         return;

  602. 

  603.     /* If we are using gnome-terminal, it's really a 16 colour terminal.

  604.      * Ditto if we are using xfce4-terminal, or Konsole. */

  605.     if((colorterm && (!strcmp(colorterm, "gnome-terminal")

  606.                        || !strcmp(colorterm, "Terminal")))

  607.          || getenv("KONSOLE_DCOP_SESSION"))

  608.     {

  609.         SCREEN *screen;

  610.         screen = newterm("xterm-16color", stdout, stdin);

  611.         if(screen == NULL)

  612.             return;

  613.         endwin();

  614.         (void)putenv("TERM=xterm-16color");

  615.         dp->drv.p->term = strdup(term);

  616.         return;

  617.     }

  618. }

  619. 

  620. static void ncurses_uninstall_terminal(caca_display_t *dp)

  621. {

  622.     /* Needs to be persistent because we use putenv() */

  623.     static char termenv[1024];

  624. 

  625.     if(!dp->drv.p->term)

  626.         return;

  627. 

  628.     snprintf(termenv, 1023, "TERM=%s", dp->drv.p->term);

  629.     free(dp->drv.p->term);

  630.     (void)putenv(termenv);

  631. }

  632. #endif

  633. 

  634. static void ncurses_write_utf32(uint32_t ch)

  635. {

  636. #if defined HAVE_NCURSESW_NCURSES_H

  637.     char buf[10];

  638.     int bytes;

  639. #endif

  640. 

  641.     if(ch == CACA_MAGIC_FULLWIDTH)

  642.         return;

  643. 

  644. #if defined HAVE_NCURSESW_NCURSES_H

  645.     bytes = caca_utf32_to_utf8(buf, ch);

  646.     buf[bytes] = '\0';

  647.     addstr(buf);

  648. #else

  649.     if(ch < 0x80)

  650.     {

  651.         addch(ch);

  652.     }

  653.     else

  654.     {

  655.         chtype cch;

  656.         chtype cch2;

  657. 

  658.         cch = '?';

  659.         cch2 = ' ';

  660.         if ((ch > 0x0000ff00) && (ch < 0x0000ff5f))

  661.         {

  662.             cch = ch - 0x0000ff00 + ' ';

  663.         }

  664.         switch (ch)

  665.         {

  666.         case 0x000000a0: /* <nbsp> */

  667.         case 0x00003000: /* 　 */

  668.             cch = ' ';

  669.             break;

  670.         case 0x000000a3: /* £ */

  671.             cch = ACS_STERLING;

  672.             break;

  673.         case 0x000000b0: /* ° */

  674.             cch = ACS_DEGREE;

  675.             break;

  676.         case 0x000000b1: /* ± */

  677.             cch = ACS_PLMINUS;

  678.             break;

  679.         case 0x000000b7: /* · */

  680.         case 0x00002219: /* ∙ */

  681.         case 0x000030fb: /* ・ */

  682.             cch = ACS_BULLET;

  683.             break;

  684.         case 0x000003c0: /* π */

  685.             cch = ACS_PI;

  686.             break;

  687.         case 0x00002018: /* ‘ */

  688.         case 0x00002019: /* ’ */

  689.             cch = '\'';

  690.             break;

  691.         case 0x0000201c: /* “ */

  692.         case 0x0000201d: /* ” */

  693.             cch = '"';

  694.             break;

  695.         case 0x00002190: /* ← */

  696.             cch = ACS_LARROW;

  697.             break;

  698.         case 0x00002191: /* ↑ */

  699.             cch = ACS_UARROW;

  700.             break;

  701.         case 0x00002192: /* → */

  702.             cch = ACS_RARROW;

  703.             break;

  704.         case 0x00002193: /* ↓ */

  705.             cch = ACS_DARROW;

  706.             break;

  707.         case 0x00002260: /* ≠ */

  708.             cch = ACS_NEQUAL;

  709.             break;

  710.         case 0x00002261: /* ≡ */

  711.             cch = '=';

  712.             break;

  713.         case 0x00002264: /* ≤ */

  714.             cch = ACS_LEQUAL;

  715.             break;

  716.         case 0x00002265: /* ≥ */

  717.             cch = ACS_GEQUAL;

  718.             break;

  719.         case 0x000023ba: /* ⎺ */

  720.             cch = ACS_S1;

  721.             cch2 = cch;

  722.             break;

  723.         case 0x000023bb: /* ⎻ */

  724.             cch = ACS_S3;

  725.             cch2 = cch;

  726.             break;

  727.         case 0x000023bc: /* ⎼ */

  728.             cch = ACS_S7;

  729.             cch2 = cch;

  730.             break;

  731.         case 0x000023bd: /* ⎽ */

  732.             cch = ACS_S9;

  733.             cch2 = cch;

  734.             break;

  735.         case 0x00002500: /* ─ */

  736.         case 0x00002550: /* ═ */

  737.             cch = ACS_HLINE;

  738.             cch2 = cch;

  739.             break;

  740.         case 0x00002502: /* │ */

  741.         case 0x00002551: /* ║ */

  742.             cch = ACS_VLINE;

  743.             break;

  744.         case 0x0000250c: /* ┌ */

  745.         case 0x00002552: /* ╒ */

  746.         case 0x00002553: /* ╓ */

  747.         case 0x00002554: /* ╔ */

  748.             cch = ACS_ULCORNER;

  749.             cch2 = ACS_HLINE;

  750.             break;

  751.         case 0x00002510: /* ┐ */

  752.         case 0x00002555: /* ╕ */

  753.         case 0x00002556: /* ╖ */

  754.         case 0x00002557: /* ╗ */

  755.             cch = ACS_URCORNER;

  756.             break;

  757.         case 0x00002514: /* └ */

  758.         case 0x00002558: /* ╘ */

  759.         case 0x00002559: /* ╙ */

  760.         case 0x0000255a: /* ╚ */

  761.             cch = ACS_LLCORNER;

  762.             cch2 = ACS_HLINE;

  763.             break;

  764.         case 0x00002518: /* ┘ */

  765.         case 0x0000255b: /* ╛ */

  766.         case 0x0000255c: /* ╜ */

  767.         case 0x0000255d: /* ╝ */

  768.             cch = ACS_LRCORNER;

  769.             break;

  770.         case 0x0000251c: /* ├ */

  771.         case 0x0000255e: /* ╞ */

  772.         case 0x0000255f: /* ╟ */

  773.         case 0x00002560: /* ╠ */

  774.             cch = ACS_LTEE;

  775.             cch2 = ACS_HLINE;

  776.             break;

  777.         case 0x00002524: /* ┤ */

  778.         case 0x00002561: /* ╡ */

  779.         case 0x00002562: /* ╢ */

  780.         case 0x00002563: /* ╣ */

  781.             cch = ACS_RTEE;

  782.             break;

  783.         case 0x0000252c: /* ┬ */

  784.         case 0x00002564: /* ╤ */

  785.         case 0x00002565: /* ╥ */

  786.         case 0x00002566: /* ╦ */

  787.             cch = ACS_TTEE;

  788.             cch2 = ACS_HLINE;

  789.             break;

  790.         case 0x00002534: /* ┴ */

  791.         case 0x00002567: /* ╧ */

  792.         case 0x00002568: /* ╨ */

  793.         case 0x00002569: /* ╩ */

  794.             cch = ACS_BTEE;

  795.             cch2 = ACS_HLINE;

  796.             break;

  797.         case 0x0000253c: /* ┼ */

  798.         case 0x0000256a: /* ╪ */

  799.         case 0x0000256b: /* ╫ */

  800.         case 0x0000256c: /* ╬ */

  801.             cch = ACS_PLUS;

  802.             cch2 = ACS_HLINE;

  803.             break;

  804.         case 0x00002591: /* ░ */

  805.             cch = ACS_BOARD;

  806.             cch2 = cch;

  807.             break;

  808.         case 0x00002592: /* ▒ */

  809.         case 0x00002593: /* ▓ */

  810.             cch = ACS_CKBOARD;

  811.             cch2 = cch;

  812.             break;

  813.         case 0x00002580: /* ▀ */

  814.         case 0x00002584: /* ▄ */

  815.         case 0x00002588: /* █ */

  816.         case 0x0000258c: /* ▌ */

  817.         case 0x00002590: /* ▐ */

  818.         case 0x000025a0: /* ■ */

  819.         case 0x000025ac: /* ▬ */

  820.         case 0x000025ae: /* ▮ */

  821.             cch = ACS_BLOCK;

  822.             cch2 = cch;

  823.             break;

  824.         case 0x000025c6: /* ◆ */

  825.         case 0x00002666: /* ♦ */

  826.             cch = ACS_DIAMOND;

  827.             break;

  828.         case 0x00002022: /* • */

  829.         case 0x000025cb: /* ○ */

  830.         case 0x000025cf: /* ● */

  831.         case 0x00002603: /* ☃ */

  832.         case 0x0000263c: /* ☼ */

  833.             cch = ACS_LANTERN;

  834.             break;

  835.         case 0x0000301c: /* 〜 */

  836.             cch = '~';

  837.             break;

  838.         }

  839.         addch(cch);

  840.         if(caca_utf32_is_fullwidth(ch))

  841.         {

  842.             addch(cch2);

  843.         }

  844.     }

  845. #endif

  846. }

  847. 

  848. /*

  849.  * Driver initialisation

  850.  */

  851. 

  852. int ncurses_install(caca_display_t *dp)

  853. {

  854.     dp->drv.id = CACA_DRIVER_NCURSES;

  855.     dp->drv.driver = "ncurses";

  856. 

  857.     dp->drv.init_graphics = ncurses_init_graphics;

  858.     dp->drv.end_graphics = ncurses_end_graphics;

  859.     dp->drv.set_display_title = ncurses_set_display_title;

  860.     dp->drv.get_display_width = ncurses_get_display_width;

  861.     dp->drv.get_display_height = ncurses_get_display_height;

  862.     dp->drv.display = ncurses_display;

  863.     dp->drv.handle_resize = ncurses_handle_resize;

  864.     dp->drv.get_event = ncurses_get_event;

  865.     dp->drv.set_mouse = NULL;

  866.     dp->drv.set_cursor = ncurses_set_cursor;

  867. 

  868.     return 0;

  869. }

  870. 

  871. #endif /* USE_NCURSES */