cacalabs
/
libcaca
kopia lustrzana https://github.com/cacalabs/libcaca.git
1
0
Forkuj 0
Kod Zgłoszenia 0 Wydania 7 Wiki Aktywność
Nie możesz wybrać więcej, niż 25 tematów Tematy muszą się zaczynać od litery lub cyfry, mogą zawierać myślniki ('-') i mogą mieć do 35 znaków.
289 Commity
1 Gałąź
284 MiB
 
 
 
 
 
 
Drzewo: 4ce99f0aff
Gałęzie Tagi
${ item.name }
Utwórz gałąź ${ searchTerm }
z '4ce99f0aff'
${ noResults }
libcaca/src/graphics.c

2024 wiersze
55 KiB
Czysty Wina Historia 

  1. /*

  2.  *  libcaca       ASCII-Art library

  3.  *  Copyright (c) 2002, 2003 Sam Hocevar <sam@zoy.org>

  4.  *                All Rights Reserved

  5.  *

  6.  *  This library is free software; you can redistribute it and/or

  7.  *  modify it under the terms of the GNU Lesser General Public

  8.  *  License as published by the Free Software Foundation; either

  9.  *  version 2 of the License, or (at your option) any later version.

  10.  *

  11.  *  This library is distributed in the hope that it will be useful,

  12.  *  but WITHOUT ANY WARRANTY; without even the implied warranty of

  13.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

  14.  *  Lesser General Public License for more details.

  15.  *

  16.  *  You should have received a copy of the GNU Lesser General Public

  17.  *  License along with this library; if not, write to the Free Software

  18.  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA

  19.  *  02111-1307  USA

  20.  */

  21. 

  22. /** \file graphics.c

  23.  *  \version \$Id$

  24.  *  \author Sam Hocevar <sam@zoy.org>

  25.  *  \brief Character drawing

  26.  *

  27.  *  This file contains character and string drawing functions.

  28.  */

  29. 

  30. #include "config.h"

  31. 

  32. #if defined(USE_SLANG)

  33. #   if defined(HAVE_SLANG_SLANG_H)

  34. #       include <slang/slang.h>

  35. #   else

  36. #       include <slang.h>

  37. #   endif

  38. #endif

  39. #if defined(USE_NCURSES)

  40. #   if defined(HAVE_NCURSES_H)

  41. #       include <ncurses.h>

  42. #   else

  43. #       include <curses.h>

  44. #   endif

  45. #endif

  46. #if defined(USE_CONIO)

  47. #   include <conio.h>

  48. #   if defined(SCREENUPDATE_IN_PC_H)

  49. #       include <pc.h>

  50. #   endif

  51. #endif

  52. #if defined(USE_X11)

  53. #   include <X11/Xlib.h>

  54. #   if defined(HAVE_X11_XKBLIB_H)

  55. #       include <X11/XKBlib.h>

  56. #   endif

  57. #endif

  58. #if defined(USE_WIN32)

  59. #   include <windows.h>

  60. #endif

  61. #if defined(USE_GL)

  62. #   include <GL/gl.h>

  63. #   include <GL/glut.h>

  64. #endif

  65. #if defined(HAVE_INTTYPES_H) || defined(_DOXYGEN_SKIP_ME)

  66. #   include <inttypes.h>

  67. #else

  68. typedef unsigned char uint8_t;

  69. #endif

  70. 

  71. #include <stdio.h> /* BUFSIZ */

  72. #include <string.h>

  73. #include <stdlib.h>

  74. #if defined(HAVE_UNISTD_H)

  75. #   include <unistd.h>

  76. #endif

  77. #include <stdarg.h>

  78. 

  79. #if defined(HAVE_SIGNAL_H)

  80. #   include <signal.h>

  81. #endif

  82. #if defined(HAVE_SYS_IOCTL_H)

  83. #   include <sys/ioctl.h>

  84. #endif

  85. 

  86. #include "caca.h"

  87. #include "caca_internals.h"

  88. 

  89. /*

  90.  * Global variables

  91.  */

  92. #if !defined(_DOXYGEN_SKIP_ME)

  93. unsigned int _caca_width = 0;

  94. unsigned int _caca_height = 0;

  95. int _caca_resize = 0;

  96. int _caca_resize_event = 0;

  97. #endif

  98. 

  99. /*

  100.  * Local variables

  101.  */

  102. #if !defined(_DOXYGEN_SKIP_ME)

  103. static uint8_t *cache_char, *cache_attr;

  104. #endif

  105. 

  106. #if defined(USE_NCURSES)

  107. static int ncurses_attr[16*16];

  108. #endif

  109. 

  110. #if defined(USE_SLANG)

  111. /* Tables generated by test/optipal.c */

  112. static int const slang_palette[2*16*16] =

  113. {

  114.      1,  0,   2,  0,   3,  0,   4,  0,   5,  0,   6,  0,   7,  0,   8,  0,

  115.      9,  0,  10,  0,  11,  0,  12,  0,  13,  0,  14,  0,  15,  0,   0,  8,

  116.      8,  7,   7,  8,  15,  7,   7, 15,  15,  9,   9, 15,   1,  9,   9,  1,

  117.      7,  9,   9,  7,   8,  1,   1,  8,   0,  1,  15, 10,  10, 15,   2, 10,

  118.     10,  2,   7, 10,  10,  7,   8,  2,   2,  8,   0,  2,  15, 11,  11, 15,

  119.      3, 11,  11,  3,   7, 11,  11,  7,   8,  3,   3,  8,   0,  3,  15, 12,

  120.     12, 15,   4, 12,  12,  4,   7, 12,  12,  7,   8,  4,   4,  8,   0,  4,

  121.     15, 13,  13, 15,   5, 13,  13,  5,   7, 13,  13,  7,   8,  5,   5,  8,

  122.      0,  5,  15, 14,  14, 15,   6, 14,  14,  6,   7, 14,  14,  7,   8,  6,

  123.      6,  8,   0,  6,   4,  6,   6,  4,  12, 14,  14, 12,   6,  2,   2,  6,

  124.     14, 10,  10, 14,   2,  3,   3,  2,  10, 11,  11, 10,   3,  1,   1,  3,

  125.     11,  9,   9, 11,   1,  5,   5,  1,   9, 13,  13,  9,   5,  4,   4,  5,

  126.     13, 12,  12, 13,   4, 14,   6, 12,  12,  6,  14,  4,   6, 10,   2, 14,

  127.     14,  2,  10,  6,   2, 11,   3, 10,  10,  3,  11,  2,   3,  9,   1, 11,

  128.     11,  1,   9,  3,   1, 13,   5,  9,   9,  5,  13,  1,   5, 12,   4, 13,

  129.     13,  4,  12,  5,   0,  7,   0, 15,  15,  8,   8, 15,  15,  1,   7,  1,

  130.      1,  6,   2,  5,   3,  4,   4,  3,   5,  2,   6,  1,   0,  0,   1,  1,

  131.      9,  6,  10,  5,  11,  4,  12,  3,  13,  2,  14,  1,   2,  2,   3,  3,

  132.      4,  4,   5,  5,   6,  6,   7,  7,  14,  9,   1, 15,   8,  9,   8,  8,

  133.      9,  9,   1,  7,   0,  9,   9,  8,   6,  9,  13, 10,   2, 15,   8, 10,

  134.      7,  2,  15,  2,   2,  7,   0, 10,  10,  8,   5, 10,  12, 11,   3, 15,

  135.      8, 11,   7,  3,  15,  3,   3,  7,   0, 11,  11,  8,   4, 11,  11, 12,

  136.      4, 15,   8, 12,   7,  4,  15,  4,   4,  7,   0, 12,  12,  8,   3, 12,

  137.     10, 13,   5, 15,   8, 13,   7,  5,  15,  5,   5,  7,   0, 13,  13,  8,

  138.      2, 13,   9, 14,   6, 15,   8, 14,   7,  6,  15,  6,   6,  7,   0, 14,

  139.     14,  8,   1, 14,   5,  6,   2,  4,  13, 14,  10, 12,   4,  2,   3,  6,

  140.     12, 10,  11, 14,   6,  3,   1,  2,  14, 11,   9, 10,   2,  1,   5,  3,

  141.     10,  9,  13, 11,   3,  5,   4,  1,  11, 13,  12,  9,   1,  4,   6,  5,

  142.      9, 12,  14, 13,   5, 14,   2, 12,  13,  6,  10,  4,   4, 10,   3, 14,

  143.     12,  2,  11,  6,   6, 11,   1, 10,  14,  3,   9,  2,   2,  9,   5, 11,

  144.     10,  1,  13,  3,   3, 13,   4,  9,  11,  5,  12,  1,   1, 12,   6, 13,

  145.      9,  4,  14,  5,  10, 10,  11, 11,  12, 12,  13, 13,  14, 14,  15, 15,

  146. };

  147. 

  148. static int const slang_assoc[16*16] =

  149. {

  150.     134, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,

  151.     28, 135, 214, 86, 219, 91, 133, 127, 26, 23, 240, 112, 245, 117, 141, 126,

  152.     37, 211, 142, 83, 206, 132, 78, 160, 35, 237, 32, 109, 232, 140, 104, 161,

  153.     46, 87, 82, 143, 131, 215, 210, 169, 44, 113, 108, 41, 139, 241, 236, 170,

  154.     55, 222, 203, 130, 144, 94, 75, 178, 53, 248, 229, 138, 50, 120, 101, 179,

  155.     64, 90, 129, 218, 95, 145, 223, 187, 62, 116, 137, 244, 121, 59, 249, 188,

  156.     73, 128, 79, 207, 74, 202, 146, 196, 71, 136, 105, 233, 100, 228, 68, 197,

  157.     122, 153, 162, 171, 180, 189, 198, 147, 16, 25, 34, 43, 52, 61, 70, 18,

  158.     15, 27, 36, 45, 54, 63, 72, 17, 151, 155, 164, 173, 182, 191, 200, 124,

  159.     154, 22, 238, 110, 243, 115, 156, 24, 150, 152, 216, 88, 221, 93, 148, 20,

  160.     163, 235, 31, 107, 230, 165, 102, 33, 159, 213, 250, 85, 208, 157, 80, 29,

  161.     172, 111, 106, 40, 174, 239, 234, 42, 168, 89, 84, 251, 166, 217, 212, 38,

  162.     181, 246, 227, 183, 49, 118, 99, 51, 177, 224, 205, 175, 252, 96, 77, 47,

  163.     190, 114, 192, 242, 119, 58, 247, 60, 186, 92, 184, 220, 97, 253, 225, 56,

  164.     199, 201, 103, 231, 98, 226, 67, 69, 195, 193, 81, 209, 76, 204, 254, 65,

  165.     123, 149, 158, 167, 176, 185, 194, 19, 125, 21, 30, 39, 48, 57, 66, 255,

  166. };

  167. #endif

  168. 

  169. #if defined(USE_CONIO)

  170. static struct text_info conio_ti;

  171. static char *conio_screen;

  172. #endif

  173. 

  174. #if defined(USE_X11) && !defined(_DOXYGEN_SKIP_ME)

  175. Display *x11_dpy;

  176. Window x11_window;

  177. Pixmap x11_pixmap;

  178. GC x11_gc;

  179. long int x11_event_mask = KeyPressMask | KeyReleaseMask | ButtonPressMask

  180.             | ButtonReleaseMask | PointerMotionMask | StructureNotifyMask

  181.             | ExposureMask;

  182. int x11_font_width, x11_font_height;

  183. unsigned int x11_new_width, x11_new_height;

  184. static int x11_colors[16];

  185. static Font x11_font;

  186. static XFontStruct *x11_font_struct;

  187. static int x11_font_offset;

  188. #if defined(HAVE_X11_XKBLIB_H)

  189. static Bool x11_detect_autorepeat;

  190. #endif

  191. #endif

  192. 

  193. #if defined(USE_WIN32)

  194. HANDLE win32_hin, win32_hout;

  195. static HANDLE win32_front, win32_back;

  196. static CHAR_INFO *win32_buffer;

  197. 

  198. static int const win32_fg_palette[] =

  199. {

  200.     0,

  201.     FOREGROUND_BLUE,

  202.     FOREGROUND_GREEN,

  203.     FOREGROUND_GREEN | FOREGROUND_BLUE,

  204.     FOREGROUND_RED,

  205.     FOREGROUND_RED | FOREGROUND_BLUE,

  206.     FOREGROUND_RED | FOREGROUND_GREEN,

  207.     FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE,

  208.     FOREGROUND_INTENSITY,

  209.     FOREGROUND_INTENSITY | FOREGROUND_BLUE,

  210.     FOREGROUND_INTENSITY | FOREGROUND_GREEN,

  211.     FOREGROUND_INTENSITY | FOREGROUND_GREEN | FOREGROUND_BLUE,

  212.     FOREGROUND_INTENSITY | FOREGROUND_RED,

  213.     FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_BLUE,

  214.     FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN,

  215.     FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE

  216. };

  217. 

  218. static int const win32_bg_palette[] =

  219. {

  220.     0,

  221.     BACKGROUND_BLUE,

  222.     BACKGROUND_GREEN,

  223.     BACKGROUND_GREEN | BACKGROUND_BLUE,

  224.     BACKGROUND_RED,

  225.     BACKGROUND_RED | BACKGROUND_BLUE,

  226.     BACKGROUND_RED | BACKGROUND_GREEN,

  227.     BACKGROUND_RED | BACKGROUND_GREEN | BACKGROUND_BLUE,

  228.     BACKGROUND_INTENSITY,

  229.     BACKGROUND_INTENSITY | BACKGROUND_BLUE,

  230.     BACKGROUND_INTENSITY | BACKGROUND_GREEN,

  231.     BACKGROUND_INTENSITY | BACKGROUND_GREEN | BACKGROUND_BLUE,

  232.     BACKGROUND_INTENSITY | BACKGROUND_RED,

  233.     BACKGROUND_INTENSITY | BACKGROUND_RED | BACKGROUND_BLUE,

  234.     BACKGROUND_INTENSITY | BACKGROUND_RED | BACKGROUND_GREEN,

  235.     BACKGROUND_INTENSITY | BACKGROUND_RED | BACKGROUND_GREEN | BACKGROUND_BLUE

  236. };

  237. #endif

  238. #if defined(USE_GL)

  239. 

  240. static unsigned int const gl_bg_palette[] =

  241. {

  242.     0,

  243.     0x0000007F,

  244.     0x00007F00,

  245.     0x00007F7F,

  246.     0x007F0000,

  247.     0x007F007F,

  248.     0x007F7F00,

  249.     0x007F7F7F,

  250.     // + intensity

  251.     0x00000000,

  252.     0x000000FF,

  253.     0x0000FF00,

  254.     0x0000FFFF,

  255.     0x00FF0000,

  256.     0x00FF00FF,

  257.     0x00FFFF00,

  258.     0x00FFFFFF,

  259. 

  260. };

  261. 

  262. int gl_window;

  263. unsigned int gl_width, gl_height;

  264. float gl_font_width, gl_font_height;

  265. float gl_incx, gl_incy;

  266. int id[94];

  267. unsigned char gl_resized=0, gl_bit=0;

  268. unsigned char gl_mouse_changed=0, gl_mouse_clicked=0;

  269. unsigned int gl_mouse_x, gl_mouse_y;

  270. unsigned int gl_mouse_button=0, gl_mouse_state=0;

  271. #endif

  272. 

  273. 

  274. static char *_caca_empty_line;

  275. static char *_caca_scratch_line;

  276. 

  277. static unsigned int _caca_delay;

  278. static unsigned int _caca_rendertime;

  279. 

  280. #if defined(OPTIMISE_SLANG_PALETTE)

  281. static int _caca_fgisbg = 0;

  282. #endif

  283. static enum caca_color _caca_fgcolor = CACA_COLOR_LIGHTGRAY;

  284. static enum caca_color _caca_bgcolor = CACA_COLOR_BLACK;

  285. 

  286. /*

  287.  * Local functions

  288.  */

  289. static void caca_handle_resize(void);

  290. 

  291. #if defined(USE_SLANG)

  292. static void slang_init_palette(void);

  293. #endif

  294. 

  295. #if defined(HAVE_SIGNAL) && (defined(USE_NCURSES) || defined(USE_SLANG))

  296. static RETSIGTYPE sigwinch_handler(int);

  297. #endif

  298. 

  299. #if defined(USE_X11)

  300. static int x11_error_handler(Display *, XErrorEvent *);

  301. #endif

  302. 

  303. #if defined(USE_GL)

  304. unsigned char gl_key = 0;

  305. int gl_special_key=0;

  306. int gl_new_width;

  307. int gl_new_height;

  308. 

  309. 

  310. static void gl_handle_keyboard(unsigned char key, int x, int y)

  311. {

  312.   gl_key = key;

  313. }

  314. static void gl_handle_special_key(int key, int x, int y)

  315. {

  316.   gl_special_key = key;

  317. }

  318. static void gl_handle_reshape (int w, int h)

  319. {

  320.   if(gl_bit) /* Do not handle reshaping at the first time*/

  321.     {

  322. 

  323.       gl_new_width = w;

  324.       gl_new_height = h;

  325. 

  326.       gl_resized = 1;

  327.     }

  328.   else

  329.     gl_bit=1;

  330. }

  331. static void gl_handle_mouse(int button, int state, int x, int y) 

  332. {

  333.   gl_mouse_clicked = 1;

  334.   gl_mouse_button = button;

  335.   gl_mouse_state = state;

  336.   gl_mouse_x = x/gl_font_width;

  337.   gl_mouse_y = y/gl_font_height;

  338.   gl_mouse_changed = 1;

  339. }

  340. static void gl_handle_mouse_motion(int x, int y) 

  341. {

  342.   gl_mouse_x = x/gl_font_width;

  343.   gl_mouse_y = y/gl_font_height;

  344.   gl_mouse_changed = 1;

  345. }

  346. 

  347. #endif

  348. 

  349. 

  350. 

  351. /** \brief Set the default colour pair.

  352.  *

  353.  *  This function sets the default colour pair. String functions such as

  354.  *  caca_printf() and graphical primitive functions such as caca_draw_line()

  355.  *  will use these colour pairs.

  356.  *

  357.  *  \param fgcolor The requested foreground colour.

  358.  *  \param bgcolor The requested background colour.

  359.  */

  360. void caca_set_color(enum caca_color fgcolor, enum caca_color bgcolor)

  361. {

  362.     if(fgcolor < 0 || fgcolor > 15 || bgcolor < 0 || bgcolor > 15)

  363.         return;

  364. 

  365.     _caca_fgcolor = fgcolor;

  366.     _caca_bgcolor = bgcolor;

  367. 

  368.     switch(_caca_driver)

  369.     {

  370. #if defined(USE_SLANG)

  371.     case CACA_DRIVER_SLANG:

  372. 

  373. #if defined(OPTIMISE_SLANG_PALETTE)

  374.         /* If foreground == background, discard this colour pair. Functions

  375.          * such as caca_putchar will print spaces instead of characters */

  376.         if(fgcolor != bgcolor)

  377.             _caca_fgisbg = 0;

  378.         else

  379.         {

  380.             _caca_fgisbg = 1;

  381.             if(fgcolor == CACA_COLOR_BLACK)

  382.                 fgcolor = CACA_COLOR_WHITE;

  383.             else if(fgcolor == CACA_COLOR_WHITE

  384.                      || fgcolor <= CACA_COLOR_LIGHTGRAY)

  385.                 fgcolor = CACA_COLOR_BLACK;

  386.             else

  387.                 fgcolor = CACA_COLOR_WHITE;

  388.         }

  389. #endif

  390. 

  391. #if defined(OPTIMISE_SLANG_PALETTE)

  392.         SLsmg_set_color(slang_assoc[fgcolor + 16 * bgcolor]);

  393. #else

  394.         SLsmg_set_color(fgcolor + 16 * bgcolor);

  395. #endif

  396.         break;

  397. #endif

  398. #if defined(USE_NCURSES)

  399.     case CACA_DRIVER_NCURSES:

  400.         attrset(ncurses_attr[fgcolor + 16 * bgcolor]);

  401.         break;

  402. #endif

  403. #if defined(USE_CONIO)

  404.     case CACA_DRIVER_CONIO:

  405.         textbackground(bgcolor);

  406.         textcolor(fgcolor);

  407.         break;

  408. #endif

  409. #if defined(USE_X11)

  410.     case CACA_DRIVER_X11:

  411.         /* Nothing to do */

  412.         break;

  413. #endif

  414. #if defined(USE_WIN32)

  415.     case CACA_DRIVER_WIN32:

  416.         /* Nothing to do */

  417.         break;

  418. #endif

  419. #if defined(USE_GL)

  420.     case CACA_DRIVER_GL:

  421.         /* Nothing to do */

  422.         break;

  423. #endif

  424. #if defined(USE_NULL)

  425.     case CACA_DRIVER_NULL:

  426.         /* Nothing to do */

  427.         break;

  428. #endif

  429.     default:

  430.         break;

  431.     }

  432. }

  433. 

  434. /** \brief Get the current foreground colour.

  435.  *

  436.  *  This function returns the current foreground colour that was set with

  437.  *  caca_set_color().

  438.  *

  439.  *  \return The current foreground colour.

  440.  */

  441. enum caca_color caca_get_fg_color(void)

  442. {

  443.     return _caca_fgcolor;

  444. }

  445. 

  446. /** \brief Get the current background colour.

  447.  *

  448.  *  This function returns the current background colour that was set with

  449.  *  caca_set_color().

  450.  *

  451.  *  \return The current background colour.

  452.  */

  453. enum caca_color caca_get_bg_color(void)

  454. {

  455.     return _caca_bgcolor;

  456. }

  457. 

  458. /** \brief Print a character.

  459.  *

  460.  *  This function prints a character at the given coordinates, using the

  461.  *  default foreground and background values. If the coordinates are outside

  462.  *  the screen boundaries, nothing is printed.

  463.  *

  464.  *  \param x X coordinate.

  465.  *  \param y Y coordinate.

  466.  *  \param c The character to print.

  467.  */

  468. void caca_putchar(int x, int y, char c)

  469. {

  470. #if defined(USE_CONIO)

  471.     char *data;

  472. #endif

  473.     if(x < 0 || x >= (int)_caca_width ||

  474.        y < 0 || y >= (int)_caca_height)

  475.         return;

  476. 

  477.     cache_char[x + y * _caca_width] = c;

  478.     cache_attr[x + y * _caca_width] = (_caca_bgcolor << 4) | _caca_fgcolor;

  479. 

  480.     switch(_caca_driver)

  481.     {

  482. #if defined(USE_SLANG)

  483.     case CACA_DRIVER_SLANG:

  484.         SLsmg_gotorc(y, x);

  485. #if defined(OPTIMISE_SLANG_PALETTE)

  486.         if(_caca_fgisbg)

  487.             SLsmg_write_char(' ');

  488.         else

  489. #endif

  490.             SLsmg_write_char(c);

  491.         break;

  492. #endif

  493. #if defined(USE_NCURSES)

  494.     case CACA_DRIVER_NCURSES:

  495.         move(y, x);

  496.         addch(c);

  497.         break;

  498. #endif

  499. #if defined(USE_CONIO)

  500.     case CACA_DRIVER_CONIO:

  501.         data = conio_screen + 2 * (x + y * _caca_width);

  502.         data[0] = c;

  503.         data[1] = (_caca_bgcolor << 4) | _caca_fgcolor;

  504.         break;

  505. #endif

  506. #if defined(USE_X11)

  507.     case CACA_DRIVER_X11:

  508.         break;

  509. #endif

  510. #if defined(USE_WIN32)

  511.     case CACA_DRIVER_WIN32:

  512.         break;

  513. #endif

  514. #if defined(USE_GL)

  515.     case CACA_DRIVER_GL:

  516.         break;

  517. #endif

  518. #if defined(USE_NULL)

  519.     case CACA_DRIVER_NULL:

  520.         break;

  521. #endif

  522.     default:

  523.         break;

  524.     }

  525. }

  526. 

  527. /** \brief Print a string.

  528.  *

  529.  *  This function prints a string at the given coordinates, using the

  530.  *  default foreground and background values. The coordinates may be outside

  531.  *  the screen boundaries (eg. a negative Y coordinate) and the string will

  532.  *  be cropped accordingly if it is too long.

  533.  *

  534.  *  \param x X coordinate.

  535.  *  \param y Y coordinate.

  536.  *  \param s The string to print.

  537.  */

  538. void caca_putstr(int x, int y, char const *s)

  539. {

  540.     char *charbuf;

  541.     char *attrbuf;

  542.     char const *t;

  543.     unsigned int len;

  544. 

  545.     if(y < 0 || y >= (int)_caca_height || x >= (int)_caca_width)

  546.         return;

  547. 

  548.     len = strlen(s);

  549. 

  550.     if(x < 0)

  551.     {

  552.         if(len < (unsigned int)-x)

  553.             return;

  554.         len -= -x;

  555.         s += -x;

  556.         x = 0;

  557.     }

  558. 

  559.     if(x + len >= _caca_width)

  560.     {

  561.         len = _caca_width - x;

  562.         memcpy(_caca_scratch_line, s, len);

  563.         _caca_scratch_line[len] = '\0';

  564.         s = _caca_scratch_line;

  565.     }

  566. 

  567.     charbuf = cache_char + x + y * _caca_width;

  568.     attrbuf = cache_attr + x + y * _caca_width;

  569.     t = s;

  570.     while(*t)

  571.     {

  572.         *charbuf++ = *t++;

  573.         *attrbuf++ = (_caca_bgcolor << 4) | _caca_fgcolor;

  574.     }

  575. 

  576.     switch(_caca_driver)

  577.     {

  578. #if defined(USE_SLANG)

  579.     case CACA_DRIVER_SLANG:

  580.         SLsmg_gotorc(y, x);

  581. #if defined(OPTIMISE_SLANG_PALETTE)

  582.         if(_caca_fgisbg)

  583.             SLsmg_write_string(_caca_empty_line + _caca_width - len);

  584.         else

  585. #endif

  586.         {

  587.             union { char *ch; const char *constch; } u;

  588.             u.constch = s;

  589.             SLsmg_write_string(u.ch);

  590.         }

  591.         break;

  592. #endif

  593. #if defined(USE_NCURSES)

  594.     case CACA_DRIVER_NCURSES:

  595.         move(y, x);

  596.         addstr(s);

  597.         break;

  598. #endif

  599. #if defined(USE_CONIO)

  600.     case CACA_DRIVER_CONIO:

  601.         charbuf = conio_screen + 2 * (x + y * _caca_width);

  602.         while(*s)

  603.         {

  604.             *charbuf++ = *s++;

  605.             *charbuf++ = (_caca_bgcolor << 4) | _caca_fgcolor;

  606.         }

  607.         break;

  608. #endif

  609. #if defined(USE_X11)

  610.     case CACA_DRIVER_X11:

  611.         break;

  612. #endif

  613. #if defined(USE_WIN32)

  614.     case CACA_DRIVER_WIN32:

  615.         break;

  616. #endif

  617. #if defined(USE_GL)

  618.     case CACA_DRIVER_GL:

  619.         break;

  620. #endif

  621. #if defined(USE_NULL)

  622.     case CACA_DRIVER_NULL:

  623.         break;

  624. #endif

  625.     default:

  626.         break;

  627.     }

  628. }

  629. 

  630. /** \brief Format a string.

  631.  *

  632.  *  This function formats a string at the given coordinates, using the

  633.  *  default foreground and background values. The coordinates may be outside

  634.  *  the screen boundaries (eg. a negative Y coordinate) and the string will

  635.  *  be cropped accordingly if it is too long. The syntax of the format

  636.  *  string is the same as for the C printf() function.

  637.  *

  638.  *  \param x X coordinate.

  639.  *  \param y Y coordinate.

  640.  *  \param format The format string to print.

  641.  *  \param ... Arguments to the format string.

  642.  */

  643. void caca_printf(int x, int y, char const *format, ...)

  644. {

  645.     char tmp[BUFSIZ];

  646.     char *buf = tmp;

  647.     va_list args;

  648. 

  649.     if(y < 0 || y >= (int)_caca_height || x >= (int)_caca_width)

  650.         return;

  651. 

  652.     if(_caca_width - x + 1 > BUFSIZ)

  653.         buf = malloc(_caca_width - x + 1);

  654. 

  655.     va_start(args, format);

  656. #if defined(HAVE_VSNPRINTF)

  657.     vsnprintf(buf, _caca_width - x + 1, format, args);

  658. #else

  659.     vsprintf(buf, format, args);

  660. #endif

  661.     buf[_caca_width - x] = '\0';

  662.     va_end(args);

  663. 

  664.     caca_putstr(x, y, buf);

  665. 

  666.     if(buf != tmp)

  667.         free(buf);

  668. }

  669. 

  670. /** \brief Get the screen.

  671.  *

  672.  *  This function fills a byte array with the character values.

  673.  */

  674. void caca_get_screen(char *buffer)

  675. {

  676.     unsigned int x, y;

  677. 

  678.     for(y = 0; y < _caca_height; y++)

  679.     {

  680.         for(x = 0; x < _caca_width; x++)

  681.         {

  682.             *buffer++ = cache_attr[x + y * _caca_width];

  683.             *buffer++ = cache_char[x + y * _caca_width];

  684.         }

  685.     }

  686. }

  687. 

  688. /** \brief Clear the screen.

  689.  *

  690.  *  This function clears the screen using a black background.

  691.  */

  692. void caca_clear(void)

  693. {

  694.     enum caca_color oldfg = caca_get_fg_color();

  695.     enum caca_color oldbg = caca_get_bg_color();

  696.     int y = _caca_height;

  697. 

  698.     caca_set_color(CACA_COLOR_LIGHTGRAY, CACA_COLOR_BLACK);

  699. 

  700.     /* We could use SLsmg_cls() etc., but drawing empty lines is much faster */

  701.     while(y--)

  702.         caca_putstr(0, y, _caca_empty_line);

  703. 

  704.     caca_set_color(oldfg, oldbg);

  705. }

  706. 

  707. #if !defined(_DOXYGEN_SKIP_ME)

  708. int _caca_init_graphics(void)

  709. {

  710. #if defined(HAVE_SIGNAL) && (defined(USE_NCURSES) || defined(USE_SLANG))

  711.     signal(SIGWINCH, sigwinch_handler);

  712. #endif

  713. 

  714. #if defined(USE_SLANG)

  715.     if(_caca_driver == CACA_DRIVER_SLANG)

  716.     {

  717.         slang_init_palette();

  718. 

  719.         /* Disable alt charset support so that we get a chance to have all

  720.          * 256 colour pairs */

  721.         SLtt_Has_Alt_Charset = 0;

  722. 

  723.         _caca_width = SLtt_Screen_Cols;

  724.         _caca_height = SLtt_Screen_Rows;

  725.     }

  726.     else

  727. #endif

  728. #if defined(USE_NCURSES)

  729.     if(_caca_driver == CACA_DRIVER_NCURSES)

  730.     {

  731.         static int curses_colors[] =

  732.         {

  733.             /* Standard curses colours */

  734.             COLOR_BLACK,

  735.             COLOR_BLUE,

  736.             COLOR_GREEN,

  737.             COLOR_CYAN,

  738.             COLOR_RED,

  739.             COLOR_MAGENTA,

  740.             COLOR_YELLOW,

  741.             COLOR_WHITE,

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

  743.             COLOR_BLACK + 8,

  744.             COLOR_BLUE + 8,

  745.             COLOR_GREEN + 8,

  746.             COLOR_CYAN + 8,

  747.             COLOR_RED + 8,

  748.             COLOR_MAGENTA + 8,

  749.             COLOR_YELLOW + 8,

  750.             COLOR_WHITE + 8

  751.         };

  752. 

  753.         int fg, bg, max;

  754. 

  755.         /* Activate colour */

  756.         start_color();

  757. 

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

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

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

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

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

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

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

  765. 

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

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

  768.             {

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

  770.                  * is light gray on black, since some terminals don't like

  771.                  * this colour pair to be redefined. */

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

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

  774.                 ncurses_attr[fg + 16 * bg] = COLOR_PAIR(col);

  775. 

  776.                 if(max == 8)

  777.                 {

  778.                     /* Bright fg on simple bg */

  779.                     ncurses_attr[fg + 8 + 16 * bg] = A_BOLD | COLOR_PAIR(col);

  780.                     /* Simple fg on bright bg */

  781.                     ncurses_attr[fg + 16 * (bg + 8)] = A_BLINK

  782.                                                         | COLOR_PAIR(col);

  783.                     /* Bright fg on bright bg */

  784.                     ncurses_attr[fg + 8 + 16 * (bg + 8)] = A_BLINK | A_BOLD

  785.                                                             | COLOR_PAIR(col);

  786.                 }

  787.             }

  788. 

  789.         _caca_width = COLS;

  790.         _caca_height = LINES;

  791.     }

  792.     else

  793. #endif

  794. #if defined(USE_CONIO)

  795.     if(_caca_driver == CACA_DRIVER_CONIO)

  796.     {

  797.         gettextinfo(&conio_ti);

  798.         conio_screen = malloc(2 * conio_ti.screenwidth

  799.                                  * conio_ti.screenheight * sizeof(char));

  800.         if(conio_screen == NULL)

  801.             return -1;

  802. #   if defined(SCREENUPDATE_IN_PC_H)

  803.         ScreenRetrieve(conio_screen);

  804. #   else

  805.         /* FIXME */

  806. #   endif

  807.         _caca_width = conio_ti.screenwidth;

  808.         _caca_height = conio_ti.screenheight;

  809.     }

  810.     else

  811. #endif

  812. #if defined(USE_X11)

  813.     if(_caca_driver == CACA_DRIVER_X11)

  814.     {

  815.         static int x11_palette[] =

  816.         {

  817.             /* Standard curses colours */

  818.             0x0,    0x0,    0x0,

  819.             0x0,    0x0,    0x8000,

  820.             0x0,    0x8000, 0x0,

  821.             0x0,    0x8000, 0x8000,

  822.             0x8000, 0x0,    0x0,

  823.             0x8000, 0x0,    0x8000,

  824.             0x8000, 0x8000, 0x0,

  825.             0x8000, 0x8000, 0x8000,

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

  827.             0x4000, 0x4000, 0x4000,

  828.             0x4000, 0x4000, 0xffff,

  829.             0x4000, 0xffff, 0x4000,

  830.             0x4000, 0xffff, 0xffff,

  831.             0xffff, 0x4000, 0x4000,

  832.             0xffff, 0x4000, 0xffff,

  833.             0xffff, 0xffff, 0x4000,

  834.             0xffff, 0xffff, 0xffff,

  835.         };

  836. 

  837.         Colormap colormap;

  838.         XSetWindowAttributes x11_winattr;

  839.         int (*old_error_handler)(Display *, XErrorEvent *);

  840.         char const *font_name = "8x13bold";

  841.         int i;

  842. 

  843.         if(getenv("CACA_GEOMETRY") && *(getenv("CACA_GEOMETRY")))

  844.             sscanf(getenv("CACA_GEOMETRY"),

  845.                    "%ux%u", &_caca_width, &_caca_height);

  846. 

  847.         if(!_caca_width)

  848.             _caca_width = 80;

  849.         if(!_caca_height)

  850.             _caca_height = 32;

  851. 

  852.         x11_dpy = XOpenDisplay(NULL);

  853.         if(x11_dpy == NULL)

  854.             return -1;

  855. 

  856.         if(getenv("CACA_FONT") && *(getenv("CACA_FONT")))

  857.             font_name = getenv("CACA_FONT");

  858. 

  859.         /* Ignore font errors */

  860.         old_error_handler = XSetErrorHandler(x11_error_handler);

  861. 

  862.         x11_font = XLoadFont(x11_dpy, font_name);

  863.         if(!x11_font)

  864.         {

  865.             XCloseDisplay(x11_dpy);

  866.             return -1;

  867.         }

  868. 

  869.         x11_font_struct = XQueryFont(x11_dpy, x11_font);

  870.         if(!x11_font_struct)

  871.         {

  872.             XUnloadFont(x11_dpy, x11_font);

  873.             XCloseDisplay(x11_dpy);

  874.             return -1;

  875.         }

  876. 

  877.         /* Reset the default X11 error handler */

  878.         XSetErrorHandler(old_error_handler);

  879. 

  880.         x11_font_width = x11_font_struct->max_bounds.width;

  881.         x11_font_height = x11_font_struct->max_bounds.ascent

  882.                              + x11_font_struct->max_bounds.descent;

  883.         x11_font_offset = x11_font_struct->max_bounds.descent;

  884. 

  885.         colormap = DefaultColormap(x11_dpy, DefaultScreen(x11_dpy));

  886.         for(i = 0; i < 16; i++)

  887.         {

  888.             XColor color;

  889.             color.red = x11_palette[i * 3];

  890.             color.green = x11_palette[i * 3 + 1];

  891.             color.blue = x11_palette[i * 3 + 2];

  892.             XAllocColor(x11_dpy, colormap, &color);

  893.             x11_colors[i] = color.pixel;

  894.         }

  895. 

  896.         x11_winattr.backing_store = Always;

  897.         x11_winattr.background_pixel = x11_colors[0];

  898.         x11_winattr.event_mask = ExposureMask | StructureNotifyMask;

  899. 

  900.         x11_window = XCreateWindow(x11_dpy, DefaultRootWindow(x11_dpy), 0, 0,

  901.                                    _caca_width * x11_font_width,

  902.                                    _caca_height * x11_font_height,

  903.                                    0, 0, InputOutput, 0,

  904.                                    CWBackingStore | CWBackPixel | CWEventMask,

  905.                                    &x11_winattr);

  906. 

  907.         XStoreName(x11_dpy, x11_window, "caca for X");

  908. 

  909.         XSelectInput(x11_dpy, x11_window, StructureNotifyMask);

  910.         XMapWindow(x11_dpy, x11_window);

  911. 

  912.         x11_gc = XCreateGC(x11_dpy, x11_window, 0, NULL);

  913.         XSetForeground(x11_dpy, x11_gc, x11_colors[15]);

  914.         XSetFont(x11_dpy, x11_gc, x11_font);

  915. 

  916.         for(;;)

  917.         {

  918.             XEvent event;

  919.             XNextEvent(x11_dpy, &event);

  920.             if (event.type == MapNotify)

  921.                 break;

  922.         }

  923. 

  924.         /* Disable autorepeat */

  925. #if defined(HAVE_X11_XKBLIB_H)

  926.         XkbSetDetectableAutoRepeat(x11_dpy, True, &x11_detect_autorepeat);

  927.         if(!x11_detect_autorepeat)

  928.             XAutoRepeatOff(x11_dpy);

  929. #endif

  930. 

  931.         XSelectInput(x11_dpy, x11_window, x11_event_mask);

  932. 

  933.         XSync(x11_dpy, False);

  934. 

  935.         x11_pixmap = XCreatePixmap(x11_dpy, x11_window,

  936.                                    _caca_width * x11_font_width,

  937.                                    _caca_height * x11_font_height,

  938.                                    DefaultDepth(x11_dpy,

  939.                                                 DefaultScreen(x11_dpy)));

  940. 

  941.         x11_new_width = x11_new_height = 0;

  942.     }

  943.     else

  944. #endif

  945. #if defined(USE_WIN32)

  946.     if(_caca_driver == CACA_DRIVER_WIN32)

  947.     {

  948.         CONSOLE_CURSOR_INFO cci;

  949.         CONSOLE_SCREEN_BUFFER_INFO csbi;

  950.         COORD size;

  951. 

  952.         win32_front = CreateConsoleScreenBuffer(GENERIC_READ | GENERIC_WRITE,

  953.                                                 0, NULL,

  954.                                                 CONSOLE_TEXTMODE_BUFFER, NULL);

  955.         if(!win32_front || win32_front == INVALID_HANDLE_VALUE)

  956.             return -1;

  957. 

  958.         win32_back = CreateConsoleScreenBuffer(GENERIC_READ | GENERIC_WRITE,

  959.                                                0, NULL,

  960.                                                CONSOLE_TEXTMODE_BUFFER, NULL);

  961.         if(!win32_back || win32_back == INVALID_HANDLE_VALUE)

  962.             return -1;

  963. 

  964.         if(!GetConsoleScreenBufferInfo(win32_hout, &csbi))

  965.             return -1;

  966. 

  967.         /* Sample code to get the biggest possible window */

  968.         //size = GetLargestConsoleWindowSize(win32_hout);

  969. 

  970.         _caca_width = csbi.srWindow.Right - csbi.srWindow.Left + 1;

  971.         _caca_height = csbi.srWindow.Bottom - csbi.srWindow.Top + 1;

  972. 

  973.         size.X = _caca_width;

  974.         size.Y = _caca_height;

  975.         SetConsoleScreenBufferSize(win32_front, size);

  976.         SetConsoleScreenBufferSize(win32_back, size);

  977. 

  978.         SetConsoleMode(win32_front, 0);

  979.         SetConsoleMode(win32_back, 0);

  980. 

  981.         GetConsoleCursorInfo(win32_front, &cci);

  982.         cci.dwSize = 0;

  983.         cci.bVisible = FALSE;

  984.         SetConsoleCursorInfo(win32_front, &cci);

  985.         SetConsoleCursorInfo(win32_back, &cci);

  986. 

  987.         SetConsoleActiveScreenBuffer(win32_front);

  988. 

  989.         win32_buffer = malloc(_caca_width * _caca_height * sizeof(CHAR_INFO));

  990.         if(win32_buffer == NULL)

  991.             return -1;

  992.     }

  993.     else

  994. #endif

  995. #if defined(USE_GL)

  996.       if(_caca_driver == CACA_DRIVER_GL)

  997.         {

  998.           int i;

  999.           char *empty;

  1000. 

  1001.           if(getenv("CACA_GEOMETRY") && *(getenv("CACA_GEOMETRY")))

  1002.             sscanf(getenv("CACA_GEOMETRY"),

  1003.                    "%ux%u", &_caca_width, &_caca_height);

  1004. 

  1005.         if(!_caca_width)

  1006.             _caca_width = 80;

  1007.         if(!_caca_height)

  1008.             _caca_height = 32;

  1009. 

  1010.           gl_font_width = 9;

  1011.           gl_font_height = 15;

  1012. 

  1013.           gl_width =  _caca_width*gl_font_width;

  1014.           gl_height = _caca_height*gl_font_height;

  1015. 

  1016.           glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE);

  1017.           glutInitWindowSize(gl_width, gl_height);

  1018.           gl_window = glutCreateWindow("caca for GL");

  1019. 

  1020.           gluOrtho2D(0,gl_width, gl_height, 0);

  1021. 

  1022.           glDisable(GL_CULL_FACE);

  1023.           glDisable(GL_DEPTH_TEST);

  1024. 

  1025.           glutKeyboardFunc(gl_handle_keyboard);

  1026.           glutSpecialFunc(gl_handle_special_key);

  1027.           glutReshapeFunc(gl_handle_reshape);

  1028. 

  1029. 	  glutMouseFunc(gl_handle_mouse);

  1030. 	  glutMotionFunc(gl_handle_mouse_motion);

  1031. 	  glutPassiveMotionFunc(gl_handle_mouse_motion);

  1032. 

  1033. 

  1034.           glLoadIdentity();

  1035. 

  1036.           glMatrixMode(GL_PROJECTION);

  1037.           glPushMatrix();

  1038.           glLoadIdentity();

  1039.           gluOrtho2D(0, gl_width, gl_height, 0);

  1040. 

  1041.           glMatrixMode(GL_MODELVIEW);

  1042. 

  1043. 

  1044.           glClear(GL_COLOR_BUFFER_BIT);

  1045. 

  1046. 

  1047. 

  1048.           empty = malloc(16*16*4);

  1049.           if(empty == NULL)

  1050.             return -1;

  1051. 

  1052.           memset(empty, 255, 16*16*4);

  1053.           glEnable(GL_TEXTURE_2D);

  1054. 

  1055.           for(i=0;i<94;i++)

  1056.             {

  1057.               glGenTextures(1,&id[i]);

  1058.               glBindTexture(GL_TEXTURE_2D, id[i]);

  1059.               glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);

  1060.               glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

  1061.               glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB8,

  1062.                            16,16,

  1063.                            0, GL_RGB, GL_UNSIGNED_BYTE, empty);

  1064.             }

  1065.           for(i=0;i<94;i++)

  1066.             {

  1067. 

  1068.               glDisable(GL_TEXTURE_2D);

  1069.               glClear(GL_COLOR_BUFFER_BIT);

  1070. 

  1071.               glColor3f(1,1,1);

  1072.               glRasterPos2f(0,15);

  1073.               glutBitmapCharacter(GLUT_BITMAP_9_BY_15,i+32);

  1074. 

  1075. 

  1076.               glEnable(GL_TEXTURE_2D);

  1077.               glBindTexture(GL_TEXTURE_2D,id[i]);

  1078.               glCopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 0, gl_height-16, 16,16, 0);

  1079. 

  1080.               glutMainLoopEvent();

  1081.               glutPostRedisplay();

  1082.             }

  1083.         }

  1084.     else

  1085. #endif

  1086. #if defined(USE_NULL)

  1087.       if(_caca_driver == CACA_DRIVER_NULL)

  1088.         {

  1089.           if(getenv("CACA_GEOMETRY") && *(getenv("CACA_GEOMETRY")))

  1090.             sscanf(getenv("CACA_GEOMETRY"),

  1091.                    "%ux%u", &_caca_width, &_caca_height);

  1092.           if(!_caca_width)

  1093.             _caca_width = 80;

  1094.           if(!_caca_height)

  1095.             _caca_height = 32;

  1096.         }

  1097.       else

  1098. #endif

  1099.     {

  1100.         /* Dummy */

  1101.     }

  1102. 

  1103.     cache_char = malloc(_caca_width * _caca_height * sizeof(uint8_t));

  1104.     if(cache_char == NULL)

  1105.         return -1;

  1106. 

  1107.     cache_attr = malloc(_caca_width * _caca_height * sizeof(uint8_t));

  1108.     if(cache_attr == NULL)

  1109.     {

  1110.         free(cache_char);

  1111.         return -1;

  1112.     }

  1113. 

  1114.     memset(cache_char, 0, _caca_width * _caca_height * sizeof(uint8_t));

  1115.     memset(cache_attr, 0, _caca_width * _caca_height * sizeof(uint8_t));

  1116. 

  1117.     _caca_empty_line = malloc(_caca_width + 1);

  1118.     memset(_caca_empty_line, ' ', _caca_width);

  1119.     _caca_empty_line[_caca_width] = '\0';

  1120. 

  1121.     _caca_scratch_line = malloc(_caca_width + 1);

  1122. 

  1123.     _caca_delay = 0;

  1124.     _caca_rendertime = 0;

  1125. 

  1126.     return 0;

  1127. }

  1128. 

  1129. int _caca_end_graphics(void)

  1130. {

  1131.     free(cache_char);

  1132.     free(cache_attr);

  1133. 

  1134. #if defined(USE_SLANG)

  1135.     /* Nothing to do */

  1136. #endif

  1137. #if defined(USE_NCURSES)

  1138.     /* Nothing to do */

  1139. #endif

  1140. #if defined(USE_CONIO)

  1141.     if(_caca_driver == CACA_DRIVER_CONIO)

  1142.     {

  1143.         free(conio_screen);

  1144.     }

  1145.     else

  1146. #endif

  1147. #if defined(USE_X11)

  1148.     if(_caca_driver == CACA_DRIVER_X11)

  1149.     {

  1150.         XSync(x11_dpy, False);

  1151. #if defined(HAVE_X11_XKBLIB_H)

  1152.         if(!x11_detect_autorepeat)

  1153.             XAutoRepeatOn(x11_dpy);

  1154. #endif

  1155.         XFreePixmap(x11_dpy, x11_pixmap);

  1156.         XFreeFont(x11_dpy, x11_font_struct);

  1157.         XFreeGC(x11_dpy, x11_gc);

  1158.         XUnmapWindow(x11_dpy, x11_window);

  1159.         XDestroyWindow(x11_dpy, x11_window);

  1160.         XCloseDisplay(x11_dpy);

  1161.     }

  1162.     else

  1163. #endif

  1164. #if defined(USE_WIN32)

  1165.     if(_caca_driver == CACA_DRIVER_WIN32)

  1166.     {

  1167.         SetConsoleActiveScreenBuffer(win32_hout);

  1168.         CloseHandle(win32_back);

  1169.         CloseHandle(win32_front);

  1170.     }

  1171.     else

  1172. #endif

  1173. #if defined(USE_GL)

  1174.       if(_caca_driver == CACA_DRIVER_GL)

  1175.         {

  1176.           glutDestroyWindow(gl_window);

  1177.         }

  1178.       else

  1179. #endif

  1180. #if defined(USE_NULL)

  1181.       if(_caca_driver == CACA_DRIVER_NULL)

  1182.         {

  1183.           /* I'm bored to write 'nothing to do'.

  1184.            * So I don't.

  1185.            */

  1186.         }

  1187.       else

  1188. #endif

  1189.     {

  1190.         /* Dummy */

  1191.     }

  1192. 

  1193.     free(_caca_empty_line);

  1194. 

  1195.     return 0;

  1196. }

  1197. #endif /* _DOXYGEN_SKIP_ME */

  1198. 

  1199. /** \brief Set the window title.

  1200.  *

  1201.  *  If libcaca runs in a window, try to change its title. This works with

  1202.  *  the X11 and Win32 drivers.

  1203.  *

  1204.  *  \param title The desired window title.

  1205.  *  \return 0 upon success, a non-zero value if an error occurs.

  1206.  */

  1207. int caca_set_window_title(char const *title)

  1208. {

  1209. #if defined(USE_X11)

  1210.     if(_caca_driver == CACA_DRIVER_X11)

  1211.     {

  1212.         XStoreName(x11_dpy, x11_window, title);

  1213.     }

  1214.     else

  1215. #endif

  1216. #if defined(USE_WIN32)

  1217.     if(_caca_driver == CACA_DRIVER_WIN32)

  1218.     {

  1219.         SetConsoleTitle(title);

  1220.     }

  1221.     else

  1222. #endif

  1223. #if defined(USE_GL)

  1224.       if(_caca_driver == CACA_DRIVER_GL)

  1225.         {

  1226.           glutSetWindowTitle(title);

  1227.         }

  1228.       else

  1229. #endif

  1230.     {

  1231.         /* Not supported */

  1232.         return -1;

  1233.     }

  1234. 

  1235.     return 0;

  1236. }

  1237. 

  1238. /** \brief Get the window width.

  1239.  *

  1240.  *  If libcaca runs in a window, get the usable window width. This value can

  1241.  *  be used for aspect ratio calculation. If libcaca does not run in a window

  1242.  *  or if there is no way to know the font size, assume a 6x10 font is being

  1243.  *  used. Note that the units are not necessarily pixels.

  1244.  *

  1245.  *  \return The window width.

  1246.  */

  1247. unsigned int caca_get_window_width(void)

  1248. {

  1249. #if defined(USE_X11)

  1250.     if(_caca_driver == CACA_DRIVER_X11)

  1251.     {

  1252.         return _caca_width * x11_font_width;

  1253.     }

  1254.     else

  1255. #endif

  1256. #if defined(USE_WIN32)

  1257.     if(_caca_driver == CACA_DRIVER_WIN32)

  1258.     {

  1259.         /* FIXME */

  1260.     }

  1261.     else

  1262. #endif

  1263. #if defined(USE_GL)

  1264.       if(_caca_driver == CACA_DRIVER_GL)

  1265.         {

  1266.           return gl_width;

  1267.         }

  1268.       else

  1269. #endif

  1270.     {

  1271.         /* Dummy */

  1272.     }

  1273. 

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

  1275.     return _caca_width * 6;

  1276. }

  1277. 

  1278. /** \brief Get the window height.

  1279.  *

  1280.  *  If libcaca runs in a window, get the usable window height. This value can

  1281.  *  be used for aspect ratio calculation. If libcaca does not run in a window

  1282.  *  or if there is no way to know the font size, assume a 6x10 font is being

  1283.  *  used. Note that the units are not necessarily pixels.

  1284.  *

  1285.  *  \return The window height.

  1286.  */

  1287. unsigned int caca_get_window_height(void)

  1288. {

  1289. #if defined(USE_X11)

  1290.     if(_caca_driver == CACA_DRIVER_X11)

  1291.     {

  1292.         return _caca_height * x11_font_height;

  1293.     }

  1294.     else

  1295. #endif

  1296. #if defined(USE_WIN32)

  1297.     if(_caca_driver == CACA_DRIVER_WIN32)

  1298.     {

  1299.         /* FIXME */

  1300.     }

  1301.     else

  1302. #endif

  1303. #if defined(USE_GL)

  1304.       if(_caca_driver == CACA_DRIVER_GL)

  1305.         {

  1306.           return gl_height;

  1307.         }

  1308.       else

  1309. #endif

  1310.     {

  1311.         /* Dummy */

  1312.     }

  1313. 

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

  1315.     return _caca_height * 10;

  1316. }

  1317. 

  1318. /** \brief Set the refresh delay.

  1319.  *

  1320.  *  This function sets the refresh delay in microseconds. The refresh delay

  1321.  *  is used by caca_refresh() to achieve constant framerate. See the

  1322.  *  caca_refresh() documentation for more details.

  1323.  *

  1324.  *  If the argument is zero, constant framerate is disabled. This is the

  1325.  *  default behaviour.

  1326.  *

  1327.  *  \param usec The refresh delay in microseconds.

  1328.  */

  1329. void caca_set_delay(unsigned int usec)

  1330. {

  1331.     _caca_delay = usec;

  1332. }

  1333. 

  1334. /** \brief Get the average rendering time.

  1335.  *

  1336.  *  This function returns the average rendering time, which is the average

  1337.  *  measured time between two caca_refresh() calls, in microseconds. If

  1338.  *  constant framerate was activated by calling caca_set_delay(), the average

  1339.  *  rendering time will not be considerably shorter than the requested delay

  1340.  *  even if the real rendering time was shorter.

  1341.  *

  1342.  *  \return The render time in microseconds.

  1343.  */

  1344. unsigned int caca_get_rendertime(void)

  1345. {

  1346.     return _caca_rendertime;

  1347. }

  1348. 

  1349. /** \brief Flush pending changes and redraw the screen.

  1350.  *

  1351.  *  This function flushes all graphical operations and prints them to the

  1352.  *  screen. Nothing will show on the screen until caca_refresh() is

  1353.  *  called.

  1354.  *

  1355.  *  If caca_set_delay() was called with a non-zero value, caca_refresh()

  1356.  *  will use that value to achieve constant framerate: if two consecutive

  1357.  *  calls to caca_refresh() are within a time range shorter than the value

  1358.  *  set with caca_set_delay(), the second call will wait a bit before

  1359.  *  performing the screen refresh.

  1360.  */

  1361. void caca_refresh(void)

  1362. {

  1363. #if !defined(_DOXYGEN_SKIP_ME)

  1364. #define IDLE_USEC 10000

  1365. #endif

  1366.     static struct caca_timer timer = CACA_TIMER_INITIALIZER;

  1367.     static int lastticks = 0;

  1368.     int ticks = lastticks + _caca_getticks(&timer);

  1369. 

  1370. #if defined(USE_SLANG)

  1371.     if(_caca_driver == CACA_DRIVER_SLANG)

  1372.     {

  1373.         SLsmg_refresh();

  1374.     }

  1375.     else

  1376. #endif

  1377. #if defined(USE_NCURSES)

  1378.     if(_caca_driver == CACA_DRIVER_NCURSES)

  1379.     {

  1380.         refresh();

  1381.     }

  1382.     else

  1383. #endif

  1384. #if defined(USE_CONIO)

  1385.     if(_caca_driver == CACA_DRIVER_CONIO)

  1386.     {

  1387. #   if defined(SCREENUPDATE_IN_PC_H)

  1388.         ScreenUpdate(conio_screen);

  1389. #   else

  1390.         /* FIXME */

  1391. #   endif

  1392.     }

  1393.     else

  1394. #endif

  1395. #if defined(USE_X11)

  1396.     if(_caca_driver == CACA_DRIVER_X11)

  1397.     {

  1398.         unsigned int x, y, len;

  1399. 

  1400.         /* First draw the background colours. Splitting the process in two

  1401.          * loops like this is actually slightly faster. */

  1402.         for(y = 0; y < _caca_height; y++)

  1403.         {

  1404.             for(x = 0; x < _caca_width; x += len)

  1405.             {

  1406.                 uint8_t *attr = cache_attr + x + y * _caca_width;

  1407. 

  1408.                 len = 1;

  1409.                 while(x + len < _caca_width

  1410.                        && (attr[len] >> 4) == (attr[0] >> 4))

  1411.                     len++;

  1412. 

  1413.                 XSetForeground(x11_dpy, x11_gc, x11_colors[attr[0] >> 4]);

  1414.                 XFillRectangle(x11_dpy, x11_pixmap, x11_gc,

  1415.                                x * x11_font_width, y * x11_font_height,

  1416.                                len * x11_font_width, x11_font_height);

  1417.             }

  1418.         }

  1419. 

  1420.         /* Then print the foreground characters */

  1421.         for(y = 0; y < _caca_height; y++)

  1422.         {

  1423.             for(x = 0; x < _caca_width; x += len)

  1424.             {

  1425.                 uint8_t *attr = cache_attr + x + y * _caca_width;

  1426. 

  1427.                 len = 1;

  1428. 

  1429.                 /* Skip spaces */

  1430.                 if(cache_char[x + y * _caca_width] == ' ')

  1431.                     continue;

  1432. 

  1433.                 while(x + len < _caca_width

  1434.                        && (attr[len] & 0xf) == (attr[0] & 0xf))

  1435.                     len++;

  1436. 

  1437.                 XSetForeground(x11_dpy, x11_gc, x11_colors[attr[0] & 0xf]);

  1438.                 XDrawString(x11_dpy, x11_pixmap, x11_gc, x * x11_font_width,

  1439.                             (y + 1) * x11_font_height - x11_font_offset,

  1440.                             cache_char + x + y * _caca_width, len);

  1441.             }

  1442.         }

  1443. 

  1444.         XCopyArea(x11_dpy, x11_pixmap, x11_window, x11_gc, 0, 0,

  1445.                   _caca_width * x11_font_width, _caca_height * x11_font_height,

  1446.                   0, 0);

  1447.         XFlush(x11_dpy);

  1448.     }

  1449.     else

  1450. #endif

  1451. #if defined(USE_WIN32)

  1452.     if(_caca_driver == CACA_DRIVER_WIN32)

  1453.     {

  1454.         COORD size, pos;

  1455.         SMALL_RECT rect;

  1456.         unsigned int i;

  1457. 

  1458.         /* Render everything to our back buffer */

  1459.         for(i = 0; i < _caca_width * _caca_height; i++)

  1460.         {

  1461.             win32_buffer[i].Char.AsciiChar = cache_char[i];

  1462.             win32_buffer[i].Attributes = win32_fg_palette[cache_attr[i] & 0xf]

  1463.                                        | win32_bg_palette[cache_attr[i] >> 4];

  1464.         }

  1465. 

  1466.         /* Blit the back buffer to the front buffer */

  1467.         size.X = _caca_width;

  1468.         size.Y = _caca_height;

  1469.         pos.X = pos.Y = 0;

  1470.         rect.Left = rect.Top = 0;

  1471.         rect.Right = _caca_width - 1;

  1472.         rect.Bottom = _caca_height - 1;

  1473.         WriteConsoleOutput(win32_front, win32_buffer, size, pos, &rect);

  1474.     }

  1475.     else

  1476. #endif

  1477. #if defined(USE_GL)

  1478.       if(_caca_driver == CACA_DRIVER_GL)

  1479.         {

  1480.           unsigned int x, y, offsetx, offsety;

  1481. 

  1482. 

  1483.           glClear(GL_COLOR_BUFFER_BIT);

  1484. 

  1485.           offsety=0;

  1486.                 for(y=0;y<gl_height;y+=gl_font_height)

  1487.             {

  1488.               offsetx = 0;

  1489.             for(x=0;x<gl_width;x+=gl_font_width)

  1490.               {

  1491.                 uint8_t *attr = cache_attr + offsetx + offsety * _caca_width;

  1492.                 int offset;

  1493.                 float  br, bg, bb;

  1494.                 offset = attr[0]>>4;

  1495. 

  1496.                 br = ((gl_bg_palette[offset]&0x00FF0000)>>16)/255.0f;

  1497.                 bg = ((gl_bg_palette[offset]&0x0000FF00)>>8)/255.0f;

  1498.                 bb = ((gl_bg_palette[offset]&0x000000FF))/255.0f;

  1499. 

  1500.                 glDisable(GL_TEXTURE_2D);

  1501.                 glColor3f(br, bg, bb);

  1502.                 glBegin(GL_QUADS);

  1503.                 glVertex2f(x,y);

  1504.                 glVertex2f(x+gl_font_width,y);

  1505.                 glVertex2f(x+gl_font_width,y+gl_font_height);

  1506.                 glVertex2f(x,y+gl_font_height);

  1507.                 glEnd();

  1508. 

  1509. 

  1510.                   offsetx++;

  1511.               }

  1512. 

  1513.             offsety++;

  1514.             }

  1515. 

  1516. 

  1517. 

  1518.           /* 2nd pass, avoids changing render state too much */

  1519.           glEnable(GL_BLEND);

  1520.           glEnable(GL_TEXTURE_2D);

  1521.           glBlendFunc(GL_ONE, GL_ONE);

  1522. 

  1523.           offsety=0;

  1524.                 for(y=0;y<gl_height;y+=gl_font_height)

  1525.             {

  1526.               offsetx = 0;

  1527.               for(x=0;x<gl_width;x+=gl_font_width)

  1528.                 {

  1529.                   uint8_t *attr = cache_attr + offsetx + offsety * _caca_width;

  1530.                   unsigned char *chr = cache_char + offsetx + offsety * _caca_width;

  1531.                   float fr, fg, fb;

  1532. 

  1533. 

  1534.                   fr = ((gl_bg_palette[attr[0] & 0xf]&0x00FF0000)>>16)/255.0f;

  1535.                   fg = ((gl_bg_palette[attr[0] & 0xf]&0x0000FF00)>>8)/255.0f;

  1536.                   fb = ((gl_bg_palette[attr[0] & 0xf]&0x000000FF))/255.0f;

  1537. 

  1538.                   if(chr[0] != ' ')

  1539.                     {

  1540.                       glBindTexture(GL_TEXTURE_2D, id[chr[0]-32]);

  1541. 

  1542.                       glColor3f(fr, fg, fb);

  1543.                       glBegin(GL_QUADS);

  1544.                       glTexCoord2f(0,1);

  1545.                       glVertex2f(x,y);

  1546.                       glTexCoord2f(0.5,1);

  1547.                       glVertex2f(x+gl_font_width,y);

  1548.                       glTexCoord2f(0.5,0);

  1549.                       glVertex2f(x+gl_font_width,y+gl_font_height);

  1550.                       glTexCoord2f(0,0);

  1551.                       glVertex2f(x,y+gl_font_height);

  1552.                       glEnd();

  1553.                     }

  1554.                   offsetx++;

  1555.                 }

  1556.               offsety++;

  1557.             }

  1558.           glDisable(GL_BLEND);

  1559.           glDisable(GL_TEXTURE_2D);

  1560. 

  1561. 

  1562. 

  1563.           glutMainLoopEvent();

  1564.           glutSwapBuffers();

  1565.           glutPostRedisplay();

  1566.         }

  1567. else

  1568. #endif

  1569. #if defined(USE_NULL)

  1570.       if(_caca_driver == CACA_DRIVER_NULL)

  1571.         {

  1572.           /* Do I told you about my cat ? */

  1573.         }

  1574. #endif

  1575.     {

  1576.         /* Dummy */

  1577.     }

  1578. 

  1579.     if(_caca_resize)

  1580.     {

  1581.         _caca_resize = 0;

  1582.         caca_handle_resize();

  1583.     }

  1584. 

  1585.     /* Wait until _caca_delay + time of last call */

  1586.     ticks += _caca_getticks(&timer);

  1587.     for(ticks += _caca_getticks(&timer);

  1588.         ticks + IDLE_USEC < (int)_caca_delay;

  1589.         ticks += _caca_getticks(&timer))

  1590.     {

  1591.         _caca_sleep(IDLE_USEC);

  1592.     }

  1593. 

  1594.     /* Update the sliding mean of the render time */

  1595.     _caca_rendertime = (7 * _caca_rendertime + ticks) / 8;

  1596. 

  1597.     lastticks = ticks - _caca_delay;

  1598. 

  1599.     /* If we drifted too much, it's bad, bad, bad. */

  1600.     if(lastticks > (int)_caca_delay)

  1601.         lastticks = 0;

  1602. }

  1603. 

  1604. /*

  1605.  * XXX: following functions are loca

  1606.  */

  1607. static void caca_handle_resize(void)

  1608. {

  1609.     unsigned int old_width = _caca_width;

  1610.     unsigned int old_height = _caca_height;

  1611. 

  1612. #if defined(USE_SLANG)

  1613.     if(_caca_driver == CACA_DRIVER_SLANG)

  1614.     {

  1615.         SLtt_get_screen_size();

  1616.         _caca_width = SLtt_Screen_Cols;

  1617.         _caca_height = SLtt_Screen_Rows;

  1618. 

  1619.         if(_caca_width != old_width || _caca_height != old_height)

  1620.             SLsmg_reinit_smg();

  1621.     }

  1622.     else

  1623. #endif

  1624. #if defined(USE_NCURSES)

  1625.     if(_caca_driver == CACA_DRIVER_NCURSES)

  1626.     {

  1627.         struct winsize size;

  1628. 

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

  1630.         {

  1631.             _caca_width = size.ws_col;

  1632.             _caca_height = size.ws_row;

  1633. #if defined(HAVE_RESIZE_TERM)

  1634.             resize_term(_caca_height, _caca_width);

  1635. #else

  1636.             resizeterm(_caca_height, _caca_width);

  1637. #endif

  1638.             wrefresh(curscr);

  1639.         }

  1640.     }

  1641.     else

  1642. #endif

  1643. #if defined(USE_CONIO)

  1644.     if(_caca_driver == CACA_DRIVER_CONIO)

  1645.     {

  1646.     }

  1647.     else

  1648. #endif

  1649. #if defined(USE_X11)

  1650.     if(_caca_driver == CACA_DRIVER_X11)

  1651.     {

  1652.         Pixmap new_pixmap;

  1653. 

  1654.         _caca_width = x11_new_width;

  1655.         _caca_height = x11_new_height;

  1656. 

  1657.         new_pixmap = XCreatePixmap(x11_dpy, x11_window,

  1658.                                    _caca_width * x11_font_width,

  1659.                                    _caca_height * x11_font_height,

  1660.                                    DefaultDepth(x11_dpy,

  1661.                                                 DefaultScreen(x11_dpy)));

  1662.         XCopyArea(x11_dpy, x11_pixmap, new_pixmap, x11_gc, 0, 0,

  1663.                   old_width * x11_font_width, old_height * x11_font_height,

  1664.                   0, 0);

  1665.         XFreePixmap(x11_dpy, x11_pixmap);

  1666.         x11_pixmap = new_pixmap;

  1667.     }

  1668.     else

  1669. #endif

  1670. #if defined(USE_WIN32)

  1671.     if(_caca_driver == CACA_DRIVER_WIN32)

  1672.     {

  1673.     }

  1674.     else

  1675. #endif

  1676. #if defined(USE_GL)

  1677.     if(_caca_driver == CACA_DRIVER_GL)

  1678.     {

  1679.       gl_width = gl_new_width;

  1680.       gl_height = gl_new_height;

  1681. 

  1682.       _caca_width = gl_width/gl_font_width;

  1683.       _caca_height = (gl_height/gl_font_height)+1;

  1684. 

  1685.       glMatrixMode(GL_PROJECTION);

  1686.       glPushMatrix();

  1687.       glLoadIdentity();

  1688. 

  1689.       glViewport(0,0,gl_width, gl_height);

  1690.       gluOrtho2D(0, gl_width, gl_height, 0);

  1691.       glMatrixMode(GL_MODELVIEW);

  1692. 

  1693.     }

  1694.     else

  1695. #endif

  1696. #if defined(USE_NULL)

  1697.     if(_caca_driver == CACA_DRIVER_NULL)

  1698.     {

  1699.       /* \_o< pOaK */

  1700.       /* By the way, we should never reach this,

  1701.        * as events are not handled

  1702.        */

  1703.     }

  1704. #endif

  1705.     {

  1706.         /* Dummy */

  1707.     }

  1708. 

  1709.     if(_caca_width != old_width || _caca_height != old_height)

  1710.     {

  1711.         free(cache_char);

  1712.         free(cache_attr);

  1713. 

  1714.         cache_char = malloc(_caca_width * _caca_height * sizeof(uint8_t));

  1715.         memset(cache_char, 0, _caca_width * _caca_height * sizeof(uint8_t));

  1716.         cache_attr = malloc(_caca_width * _caca_height * sizeof(uint8_t));

  1717.         memset(cache_attr, 0, _caca_width * _caca_height * sizeof(uint8_t));

  1718.     }

  1719. 

  1720.     if(_caca_width != old_width)

  1721.     {

  1722.         free(_caca_empty_line);

  1723.         _caca_empty_line = malloc(_caca_width + 1);

  1724.         memset(_caca_empty_line, ' ', _caca_width);

  1725.         _caca_empty_line[_caca_width] = '\0';

  1726. 

  1727.         free(_caca_scratch_line);

  1728.         _caca_scratch_line = malloc(_caca_width + 1);

  1729.     }

  1730. }

  1731. 

  1732. #if defined(USE_SLANG)

  1733. static void slang_init_palette(void)

  1734. {

  1735.     /* See SLang ref., 5.4.4. */

  1736.     static char *slang_colors[16] =

  1737.     {

  1738.         /* Standard colours */

  1739.         "black",

  1740.         "blue",

  1741.         "green",

  1742.         "cyan",

  1743.         "red",

  1744.         "magenta",

  1745.         "brown",

  1746.         "lightgray",

  1747.         /* Bright colours */

  1748.         "gray",

  1749.         "brightblue",

  1750.         "brightgreen",

  1751.         "brightcyan",

  1752.         "brightred",

  1753.         "brightmagenta",

  1754.         "yellow",

  1755.         "white",

  1756.     };

  1757. 

  1758. #if defined(OPTIMISE_SLANG_PALETTE)

  1759.     int i;

  1760. 

  1761.     for(i = 0; i < 16 * 16; i++)

  1762.         SLtt_set_color(i, NULL, slang_colors[slang_palette[i * 2]],

  1763.                                 slang_colors[slang_palette[i * 2 + 1]]);

  1764. #else

  1765.     int fg, bg;

  1766. 

  1767.     for(bg = 0; bg < 16; bg++)

  1768.         for(fg = 0; fg < 16; fg++)

  1769.         {

  1770.             int i = fg + 16 * bg;

  1771.             SLtt_set_color(i, NULL, slang_colors[fg], slang_colors[bg]);

  1772.         }

  1773. #endif

  1774. }

  1775. #endif /* USE_SLANG */

  1776. 

  1777. #if defined(USE_X11)

  1778. static int x11_error_handler(Display *dpy, XErrorEvent *event)

  1779. {

  1780.     /* Ignore the error */

  1781.     return 0;

  1782. }

  1783. #endif

  1784. 

  1785. #if defined(HAVE_SIGNAL) && (defined(USE_NCURSES) || defined(USE_SLANG))

  1786. static RETSIGTYPE sigwinch_handler(int sig)

  1787. {

  1788.     _caca_resize_event = 1;

  1789. 

  1790.     signal(SIGWINCH, sigwinch_handler);;

  1791. }

  1792. #endif

  1793. 

  1794. /* Exporters */

  1795. 

  1796. /* HTML */

  1797. 

  1798. /** \brief Generate HTML representation of current image.

  1799.  *

  1800.  *  This function generates and returns the HTML representation of

  1801.  *  the current image.

  1802.  */

  1803. char* caca_get_html(void)

  1804. {

  1805.     static int const palette[] =

  1806.     {

  1807.         0x000, 0x008, 0x080, 0x088, 0x800, 0x808, 0x880, 0x888,

  1808.         0x444, 0x44f, 0x4f4, 0x4ff, 0xf44, 0xf4f, 0xff4, 0xfff,

  1809.     };

  1810.     char *buffer, *cur;

  1811.     unsigned int x, y, len;

  1812. 

  1813.     /* 13000 -> css palette

  1814.      * 40 -> max size used for a pixel (plus 10, never know)*/

  1815.     /* FIXME: Check this value */

  1816.     buffer = malloc((13000 + ((_caca_width*_caca_height) * 40)) * sizeof(char));

  1817.     cur = buffer;

  1818. 

  1819.     /* HTML header */

  1820.     cur += sprintf(cur, "<html>\n<head>\n<title>Generated by libcaca %s</title>\n", VERSION);

  1821. 

  1822.     /* CSS */

  1823.     cur += sprintf(cur, "<style>\n");

  1824.     cur += sprintf(cur, ".caca { font-family: monospace, fixed; font-weight: bold; }");

  1825.     for(x = 0; x < 0x100; x++)

  1826.     {

  1827.         cur += sprintf(cur, ".b%02x { color:#%03x; background-color:#%03x; }\n",

  1828.                        x, palette[x & 0xf ], palette[x >> 4]);

  1829.     }

  1830.     cur += sprintf(cur, "</style>\n</head>\n<body>\n");

  1831. 

  1832.     cur += sprintf(cur, "<div cellpadding='0' cellspacing='0' style='%s'>\n",

  1833.                         "font-family: monospace, fixed; font-weight: bold;");

  1834. 

  1835.     for(y = 0; y < _caca_height; y++)

  1836.     {

  1837.         uint8_t *lineattr = cache_attr + y * _caca_width;

  1838.         uint8_t *linechar = cache_char + y * _caca_width;

  1839. 

  1840.         for(x = 0; x < _caca_width; x += len)

  1841.         {

  1842.             cur += sprintf(cur, "<span class='b%02x'>", lineattr[x]);

  1843. 

  1844.             for(len = 0;

  1845.                 x + len < _caca_width && lineattr[x + len] == lineattr[x];

  1846.                 len++)

  1847.             {

  1848.                 if(linechar[x + len] == ' ')

  1849.                     cur += sprintf(cur, "&nbsp;");

  1850.                 else

  1851.                     cur += sprintf(cur, "%c", linechar[x + len]);

  1852.             }

  1853.             cur += sprintf(cur, "</span>");

  1854.         }

  1855.         /* New line */

  1856.         cur += sprintf(cur, "<br />\n");

  1857.     }

  1858. 

  1859.     cur += sprintf(cur, "</div></body></html>\n");

  1860. 

  1861.     /* Crop to really used size */

  1862.     buffer = realloc(buffer, (strlen(buffer) + 1) * sizeof(char));

  1863. 

  1864.     return buffer;

  1865. }

  1866. 

  1867. /** \brief Generate HTML3 representation of current image.

  1868.  *

  1869.  *  This function generates and returns the HTML3 representation of

  1870.  *  the current image. It is way bigger than caca_get_html(), but

  1871.  *  permits viewing in old browsers (or limited ones such as links)

  1872.  *  Won't work under gecko (mozilla rendering engine) unless you set

  1873.  *  a correct header.

  1874.  */

  1875. char* caca_get_html3(void)

  1876. {

  1877.     static int const palette[] =

  1878.     {

  1879.         0x000000, 0x000088, 0x008800, 0x008888,

  1880.         0x880000, 0x880088, 0x888800, 0x888888,

  1881.         0x444444, 0x4444ff, 0x44ff44, 0x44ffff,

  1882.         0xff4444, 0xff44ff, 0xffff44, 0xffffff,

  1883.     };

  1884.     char *buffer, *cur;

  1885.     unsigned int x, y, len;

  1886. 

  1887.     /* 13000 -> css palette

  1888.      * 40 -> max size used for a pixel (plus 10, never know) */

  1889.     buffer = malloc((13000 + ((_caca_width*_caca_height)*40))*sizeof(char));

  1890.     cur = buffer;

  1891. 

  1892.     /* Table */

  1893.     cur += sprintf(cur, "<table cols='%d' cellpadding='0' cellspacing='0'>\n",

  1894.                         _caca_height);

  1895. 

  1896.     for(y = 0; y < _caca_height; y++)

  1897.     {

  1898.         uint8_t *lineattr = cache_attr + y * _caca_width;

  1899.         uint8_t *linechar = cache_char + y * _caca_width;

  1900. 

  1901.         cur += sprintf(cur, "<tr>");

  1902. 

  1903.         for(x = 0; x < _caca_width; x += len)

  1904.         {

  1905.             int i;

  1906. 

  1907.             /* Use colspan option to factorize cells with same attributes

  1908.              * (see below) */

  1909.             len = 1;

  1910.             while(x + len < _caca_width && lineattr[x + len] == lineattr[x])

  1911.                 len++;

  1912. 

  1913.             cur += sprintf(cur, "<td bgcolor=#%06x", palette[lineattr[x] >> 4]);

  1914. 

  1915.             if(len > 1)

  1916.                 cur += sprintf(cur, " colspan=%d", len);

  1917. 

  1918.             cur += sprintf(cur, "><font color=#%06x>",

  1919.                                 palette[lineattr[x] & 0x0f]);

  1920. 

  1921.             for(i = 0; i < len; i++)

  1922.             {

  1923.                 if(linechar[x + i] == ' ')

  1924.                     cur += sprintf(cur, "&nbsp;");

  1925.                 else

  1926.                     cur += sprintf(cur, "%c", linechar[x + i]);

  1927.             }

  1928. 

  1929.             cur += sprintf(cur, "</font></td>");

  1930.         }

  1931.         cur += sprintf(cur, "</tr>\n");

  1932.     }

  1933. 

  1934.     /* Footer */

  1935.     cur += sprintf(cur, "</table>\n");

  1936. 

  1937.     /* Crop to really used size */

  1938.     buffer = realloc(buffer, (strlen(buffer) + 1) * sizeof(char));

  1939. 

  1940.     return buffer;

  1941. }

  1942. 

  1943. /** \brief Generate IRC representation of current image.

  1944.  *

  1945.  *  This function generates and returns an IRC representation of

  1946.  *  the current image.

  1947.  */

  1948. char* caca_get_irc(void)

  1949. {

  1950.     static int const palette[] =

  1951.     {

  1952.         1, 2, 3, 10, 5, 6, 7, 15, /* Dark */

  1953.         14, 12, 9, 11, 4, 13, 8, 0, /* Light */

  1954.     };

  1955. 

  1956.     char *buffer, *cur;

  1957.     unsigned int x, y;

  1958. 

  1959.     /* 11 bytes assumed for max length per pixel. Worst case scenario:

  1960.      * ^Cxx,yy   6 bytes

  1961.      * ^B^B      2 bytes

  1962.      * c         1 byte

  1963.      * \r\n      2 bytes

  1964.      * In real life, the average bytes per pixel value will be around 5.

  1965.      */

  1966.     buffer = malloc((2 + (_caca_width * _caca_height * 11)) * sizeof(char));

  1967.     cur = buffer;

  1968. 

  1969.     *cur++ = '\x0f';

  1970. 

  1971.     for(y = 0; y < _caca_height; y++)

  1972.     {

  1973.         uint8_t *lineattr = cache_attr + y * _caca_width;

  1974.         uint8_t *linechar = cache_char + y * _caca_width;

  1975. 

  1976.         uint8_t prevfg = -1;

  1977.         uint8_t prevbg = -1;

  1978. 

  1979.         for(x = 0; x < _caca_width; x++)

  1980.         {

  1981.             uint8_t fg = palette[lineattr[x] & 0x0f];

  1982.             uint8_t bg = palette[lineattr[x] >> 4];

  1983.             uint8_t c = linechar[x];

  1984. 

  1985.             if(bg == prevbg)

  1986.             {

  1987.                 if(fg == prevfg)

  1988.                     ; /* Same fg/bg, do nothing */

  1989.                 else if(c == ' ')

  1990.                     fg = prevfg; /* Hackety hack */

  1991.                 else

  1992.                 {

  1993.                     cur += sprintf(cur, "\x03%d", fg);

  1994.                     if(c >= '0' && c <= '9')

  1995.                         cur += sprintf(cur, "\x02\x02");

  1996.                 }

  1997.             }

  1998.             else

  1999.             {

  2000.                 if(fg == prevfg)

  2001.                     cur += sprintf(cur, "\x03,%d", bg);

  2002.                 else

  2003.                     cur += sprintf(cur, "\x03%d,%d", fg, bg);

  2004. 

  2005.                 if(c >= '0' && c <= '9')

  2006.                     cur += sprintf(cur, "\x02\x02");

  2007.             }

  2008.             *cur++ = c;

  2009.             prevfg = fg;

  2010.             prevbg = bg;

  2011.         }

  2012.         *cur++ = '\r';

  2013.         *cur++ = '\n';

  2014.     }

  2015. 

  2016.     *cur++ = '\x0f';

  2017. 

  2018.     /* Crop to really used size */

  2019.     buffer = realloc(buffer, (strlen(buffer) + 1) * sizeof(char));

  2020. 

  2021.     return buffer;

  2022. }