cacalabs
/
libcaca
kopie van https://github.com/cacalabs/libcaca.git
1
0
Vork 0
Code Kwesties 0 Publicaties 7 Wiki Activiteit
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
472 Commits
1 Branch
77 MiB
 
 
 
 
 
 
Tree: 10bfc08d26
Branches Labels
${ item.name }
Maak branch ${ searchTerm }
van '10bfc08d26'
${ noResults }
libcaca/caca/driver_x11.c

594 regels
19 KiB
Ruw Blame Geschiedenis 

  1. /*

  2.  *  libcaca       Colour ASCII-Art library

  3.  *  Copyright (c) 2002-2006 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 Do What The Fuck You Want To

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

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

  10.  */

  11. 

  12. /** \file driver_x11.c

  13.  *  \version \$Id$

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

  15.  *  \brief X11 driver

  16.  *

  17.  *  This file contains the libcaca X11 input and output driver

  18.  */

  19. 

  20. #include "config.h"

  21. 

  22. #if defined(USE_X11)

  23. 

  24. #include <X11/Xlib.h>

  25. #include <X11/Xutil.h>

  26. #include <X11/keysym.h>

  27. #if defined(HAVE_X11_XKBLIB_H)

  28. #   include <X11/XKBlib.h>

  29. #endif

  30. 

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

  32. #include <stdlib.h>

  33. 

  34. #include "caca.h"

  35. #include "caca_internals.h"

  36. #include "cucul.h"

  37. #include "cucul_internals.h"

  38. 

  39. /*

  40.  * Local functions

  41.  */

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

  43. 

  44. struct driver_private

  45. {

  46.     Display *dpy;

  47.     Window window;

  48.     Pixmap pixmap;

  49.     GC gc;

  50.     long int event_mask;

  51.     int font_width, font_height;

  52.     int colors[16];

  53.     Font font;

  54.     XFontStruct *font_struct;

  55.     int font_offset;

  56.     Cursor pointer;

  57. #if defined(HAVE_X11_XKBLIB_H)

  58.     Bool autorepeat;

  59. #endif

  60. };

  61. 

  62. static int x11_init_graphics(caca_t *kk)

  63. {

  64.     static int const x11_palette[] =

  65.     {

  66.         /* Standard curses colours */

  67.         0x0,    0x0,    0x0,

  68.         0x0,    0x0,    0x8000,

  69.         0x0,    0x8000, 0x0,

  70.         0x0,    0x8000, 0x8000,

  71.         0x8000, 0x0,    0x0,

  72.         0x8000, 0x0,    0x8000,

  73.         0x8000, 0x8000, 0x0,

  74.         0x8000, 0x8000, 0x8000,

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

  76.         0x4000, 0x4000, 0x4000,

  77.         0x4000, 0x4000, 0xffff,

  78.         0x4000, 0xffff, 0x4000,

  79.         0x4000, 0xffff, 0xffff,

  80.         0xffff, 0x4000, 0x4000,

  81.         0xffff, 0x4000, 0xffff,

  82.         0xffff, 0xffff, 0x4000,

  83.         0xffff, 0xffff, 0xffff,

  84.     };

  85. 

  86.     Colormap colormap;

  87.     XSetWindowAttributes x11_winattr;

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

  89.     char const *fonts[] = { NULL, "8x13bold", "fixed" }, **parser;

  90.     char const *geometry;

  91.     unsigned int width = 0, height = 0;

  92.     int i;

  93. 

  94.     kk->drv.p = malloc(sizeof(struct driver_private));

  95. 

  96. #if defined(HAVE_GETENV)

  97.     geometry = getenv("CACA_GEOMETRY");

  98.     if(geometry && *geometry)

  99.         sscanf(geometry, "%ux%u", &width, &height);

  100. #endif

  101. 

  102.     if(width && height)

  103.         _cucul_set_size(kk->qq, width, height);

  104. 

  105.     kk->drv.p->dpy = XOpenDisplay(NULL);

  106.     if(kk->drv.p->dpy == NULL)

  107.         return -1;

  108. 

  109. #if defined(HAVE_GETENV)

  110.     fonts[0] = getenv("CACA_FONT");

  111.     if(fonts[0] && *fonts[0])

  112.         parser = fonts;

  113.     else

  114. #endif

  115.         parser = fonts + 1;

  116. 

  117.     /* Ignore font errors */

  118.     old_error_handler = XSetErrorHandler(x11_error_handler);

  119. 

  120.     /* Parse our font list */

  121.     for( ; ; parser++)

  122.     {

  123.         if(!*parser)

  124.         {

  125.             XSetErrorHandler(old_error_handler);

  126.             XCloseDisplay(kk->drv.p->dpy);

  127.             return -1;

  128.         }

  129. 

  130.         kk->drv.p->font = XLoadFont(kk->drv.p->dpy, *parser);

  131.         if(!kk->drv.p->font)

  132.             continue;

  133. 

  134.         kk->drv.p->font_struct = XQueryFont(kk->drv.p->dpy, kk->drv.p->font);

  135.         if(!kk->drv.p->font_struct)

  136.         {

  137.             XUnloadFont(kk->drv.p->dpy, kk->drv.p->font);

  138.             continue;

  139.         }

  140. 

  141.         break;

  142.     }

  143. 

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

  145.     XSetErrorHandler(old_error_handler);

  146. 

  147.     kk->drv.p->font_width = kk->drv.p->font_struct->max_bounds.width;

  148.     kk->drv.p->font_height = kk->drv.p->font_struct->max_bounds.ascent

  149.                          + kk->drv.p->font_struct->max_bounds.descent;

  150.     kk->drv.p->font_offset = kk->drv.p->font_struct->max_bounds.descent;

  151. 

  152.     colormap = DefaultColormap(kk->drv.p->dpy, DefaultScreen(kk->drv.p->dpy));

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

  154.     {

  155.         XColor color;

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

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

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

  159.         XAllocColor(kk->drv.p->dpy, colormap, &color);

  160.         kk->drv.p->colors[i] = color.pixel;

  161.     }

  162. 

  163.     x11_winattr.backing_store = Always;

  164.     x11_winattr.background_pixel = kk->drv.p->colors[0];

  165.     x11_winattr.event_mask = ExposureMask | StructureNotifyMask;

  166. 

  167.     kk->drv.p->window =

  168.         XCreateWindow(kk->drv.p->dpy, DefaultRootWindow(kk->drv.p->dpy), 0, 0,

  169.                       kk->qq->width * kk->drv.p->font_width,

  170.                       kk->qq->height * kk->drv.p->font_height,

  171.                       0, 0, InputOutput, 0,

  172.                       CWBackingStore | CWBackPixel | CWEventMask,

  173.                       &x11_winattr);

  174. 

  175.     XStoreName(kk->drv.p->dpy, kk->drv.p->window, "caca for X");

  176. 

  177.     XSelectInput(kk->drv.p->dpy, kk->drv.p->window, StructureNotifyMask);

  178.     XMapWindow(kk->drv.p->dpy, kk->drv.p->window);

  179. 

  180.     kk->drv.p->gc = XCreateGC(kk->drv.p->dpy, kk->drv.p->window, 0, NULL);

  181.     XSetForeground(kk->drv.p->dpy, kk->drv.p->gc, kk->drv.p->colors[15]);

  182.     XSetFont(kk->drv.p->dpy, kk->drv.p->gc, kk->drv.p->font);

  183. 

  184.     for(;;)

  185.     {

  186.         XEvent xevent;

  187.         XNextEvent(kk->drv.p->dpy, &xevent);

  188.         if (xevent.type == MapNotify)

  189.             break;

  190.     }

  191. 

  192. #if defined(HAVE_X11_XKBLIB_H)

  193.     /* Disable autorepeat */

  194.     XkbSetDetectableAutoRepeat(kk->drv.p->dpy, True, &kk->drv.p->autorepeat);

  195.     if(!kk->drv.p->autorepeat)

  196.         XAutoRepeatOff(kk->drv.p->dpy);

  197. #endif

  198. 

  199.     kk->drv.p->event_mask = KeyPressMask | KeyReleaseMask | ButtonPressMask

  200.           | ButtonReleaseMask | PointerMotionMask | StructureNotifyMask

  201.           | ExposureMask;

  202. 

  203.     XSelectInput(kk->drv.p->dpy, kk->drv.p->window, kk->drv.p->event_mask);

  204. 

  205.     XSync(kk->drv.p->dpy, False);

  206. 

  207.     kk->drv.p->pixmap = XCreatePixmap(kk->drv.p->dpy, kk->drv.p->window,

  208.                                    kk->qq->width * kk->drv.p->font_width,

  209.                                    kk->qq->height * kk->drv.p->font_height,

  210.                                    DefaultDepth(kk->drv.p->dpy,

  211.                                             DefaultScreen(kk->drv.p->dpy)));

  212. 

  213. 

  214.     kk->drv.p->pointer = None;

  215. 

  216.     return 0;

  217. }

  218. 

  219. static int x11_end_graphics(caca_t *kk)

  220. {

  221.     XSync(kk->drv.p->dpy, False);

  222. #if defined(HAVE_X11_XKBLIB_H)

  223.     if(!kk->drv.p->autorepeat)

  224.         XAutoRepeatOn(kk->drv.p->dpy);

  225. #endif

  226.     XFreePixmap(kk->drv.p->dpy, kk->drv.p->pixmap);

  227.     XFreeFont(kk->drv.p->dpy, kk->drv.p->font_struct);

  228.     XFreeGC(kk->drv.p->dpy, kk->drv.p->gc);

  229.     XUnmapWindow(kk->drv.p->dpy, kk->drv.p->window);

  230.     XDestroyWindow(kk->drv.p->dpy, kk->drv.p->window);

  231.     XCloseDisplay(kk->drv.p->dpy);

  232. 

  233.     free(kk->drv.p);

  234. 

  235.     return 0;

  236. }

  237. 

  238. static int x11_set_window_title(caca_t *kk, char const *title)

  239. {

  240.     XStoreName(kk->drv.p->dpy, kk->drv.p->window, title);

  241.     return 0;

  242. }

  243. 

  244. static unsigned int x11_get_window_width(caca_t *kk)

  245. {

  246.     return kk->qq->width * kk->drv.p->font_width;

  247. }

  248. 

  249. static unsigned int x11_get_window_height(caca_t *kk)

  250. {

  251.     return kk->qq->height * kk->drv.p->font_height;

  252. }

  253. 

  254. static void x11_display(caca_t *kk)

  255. {

  256.     unsigned int x, y, len;

  257. 

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

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

  260.     for(y = 0; y < kk->qq->height; y++)

  261.     {

  262.         for(x = 0; x < kk->qq->width; x += len)

  263.         {

  264.             uint8_t *attr = kk->qq->attr + x + y * kk->qq->width;

  265. 

  266.             len = 1;

  267.             while(x + len < kk->qq->width

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

  269.                 len++;

  270. 

  271.             XSetForeground(kk->drv.p->dpy, kk->drv.p->gc,

  272.                            kk->drv.p->colors[attr[0] >> 4]);

  273.             XFillRectangle(kk->drv.p->dpy, kk->drv.p->pixmap, kk->drv.p->gc,

  274.                            x * kk->drv.p->font_width, y * kk->drv.p->font_height,

  275.                            len * kk->drv.p->font_width, kk->drv.p->font_height);

  276.         }

  277.     }

  278. 

  279.     /* Then print the foreground characters */

  280.     for(y = 0; y < kk->qq->height; y++)

  281.     {

  282.         unsigned int yoff = (y + 1) * kk->drv.p->font_height

  283.                                     - kk->drv.p->font_offset;

  284.         uint32_t *chars = kk->qq->chars + y * kk->qq->width;

  285. 

  286.         for(x = 0; x < kk->qq->width; x++, chars++)

  287.         {

  288.             uint8_t *attr = kk->qq->attr + x + y * kk->qq->width;

  289. 

  290.             /* Skip spaces */

  291.             if(*chars == 0x00000020)

  292.                 continue;

  293. 

  294.             XSetForeground(kk->drv.p->dpy, kk->drv.p->gc,

  295.                            kk->drv.p->colors[*attr & 0xf]);

  296. 

  297.             /* Plain ASCII, no problem. */

  298.             if(*chars > 0x00000020 && *chars < 0x00000080)

  299.             {

  300.                 char c = (uint8_t)*chars;

  301.                 XDrawString(kk->drv.p->dpy, kk->drv.p->pixmap, kk->drv.p->gc,

  302.                             x * kk->drv.p->font_width, yoff, &c, 1);

  303.                 continue;

  304.             }

  305. 

  306.             /* We want to be able to print a few special Unicode characters

  307.              * such as the CP437 gradients and half blocks. For unknown

  308.              * characters, just print '?'. */

  309.             switch(*chars)

  310.             {

  311.                 case 0x00002580: /* ▀ */

  312.                     XFillRectangle(kk->drv.p->dpy, kk->drv.p->pixmap,

  313.                                    kk->drv.p->gc,

  314.                                    x * kk->drv.p->font_width,

  315.                                    y * kk->drv.p->font_height,

  316.                                    kk->drv.p->font_width,

  317.                                    kk->drv.p->font_height / 2);

  318.                     break;

  319.                 case 0x00002584: /* ▄ */

  320.                     XFillRectangle(kk->drv.p->dpy, kk->drv.p->pixmap,

  321.                                    kk->drv.p->gc,

  322.                                    x * kk->drv.p->font_width,

  323.                                    (y + 1) * kk->drv.p->font_height

  324.                                            - kk->drv.p->font_height / 2,

  325.                                    kk->drv.p->font_width,

  326.                                    kk->drv.p->font_height / 2);

  327.                     break;

  328.                 case 0x00002588: /* █ */

  329.                     XFillRectangle(kk->drv.p->dpy, kk->drv.p->pixmap,

  330.                                    kk->drv.p->gc,

  331.                                    x * kk->drv.p->font_width,

  332.                                    y * kk->drv.p->font_height,

  333.                                    kk->drv.p->font_width,

  334.                                    kk->drv.p->font_height);

  335.                     break;

  336.                 case 0x0000258c: /* ▌ */

  337.                     XFillRectangle(kk->drv.p->dpy, kk->drv.p->pixmap,

  338.                                    kk->drv.p->gc,

  339.                                    x * kk->drv.p->font_width,

  340.                                    y * kk->drv.p->font_height,

  341.                                    kk->drv.p->font_width / 2,

  342.                                    kk->drv.p->font_height);

  343.                     break;

  344.                 case 0x00002590: /* ▐ */

  345.                     XFillRectangle(kk->drv.p->dpy, kk->drv.p->pixmap,

  346.                                    kk->drv.p->gc,

  347.                                    (x + 1) * kk->drv.p->font_width

  348.                                            - kk->drv.p->font_width / 2,

  349.                                    y * kk->drv.p->font_height,

  350.                                    kk->drv.p->font_width / 2,

  351.                                    kk->drv.p->font_height);

  352.                     break;

  353.                 case 0x00002593: /* ▓ */

  354.                 case 0x00002592: /* ▒ */

  355.                 case 0x00002591: /* ░ */

  356.                 {

  357.                     /* FIXME: this sucks utterly */

  358.                     int i, j, k = *chars - 0x00002591;

  359.                     for(j = kk->drv.p->font_height; j--; )

  360.                         for(i = kk->drv.p->font_width; i--; )

  361.                     {

  362.                         if(((i + 2 * (j & 1)) & 3) > k)

  363.                             continue;

  364. 

  365.                         XDrawPoint(kk->drv.p->dpy, kk->drv.p->pixmap,

  366.                                    kk->drv.p->gc,

  367.                                    x * kk->drv.p->font_width + i,

  368.                                    y * kk->drv.p->font_height + j);

  369.                     }

  370.                     break;

  371.                 }

  372.                 default:

  373.                 {

  374.                     char c;

  375.                     c = '?';

  376.                     XDrawString(kk->drv.p->dpy, kk->drv.p->pixmap,

  377.                                 kk->drv.p->gc,

  378.                                 x * kk->drv.p->font_width, yoff, &c, 1);

  379.                     break;

  380.                 }

  381.             }

  382.         }

  383.     }

  384. 

  385.     XCopyArea(kk->drv.p->dpy, kk->drv.p->pixmap, kk->drv.p->window,

  386.               kk->drv.p->gc, 0, 0,

  387.               kk->qq->width * kk->drv.p->font_width,

  388.               kk->qq->height * kk->drv.p->font_height,

  389.               0, 0);

  390.     XFlush(kk->drv.p->dpy);

  391. }

  392. 

  393. static void x11_handle_resize(caca_t *kk)

  394. {

  395.     Pixmap new_pixmap;

  396. 

  397.     new_pixmap = XCreatePixmap(kk->drv.p->dpy, kk->drv.p->window,

  398.                                kk->resize.w * kk->drv.p->font_width,

  399.                                kk->resize.h * kk->drv.p->font_height,

  400.                                DefaultDepth(kk->drv.p->dpy,

  401.                                             DefaultScreen(kk->drv.p->dpy)));

  402.     XCopyArea(kk->drv.p->dpy, kk->drv.p->pixmap, new_pixmap,

  403.               kk->drv.p->gc, 0, 0,

  404.               kk->resize.w * kk->drv.p->font_width,

  405.               kk->resize.h * kk->drv.p->font_height, 0, 0);

  406.     XFreePixmap(kk->drv.p->dpy, kk->drv.p->pixmap);

  407.     kk->drv.p->pixmap = new_pixmap;

  408. }

  409. 

  410. static int x11_get_event(caca_t *kk, struct caca_event *ev)

  411. {

  412.     XEvent xevent;

  413.     char key;

  414. 

  415.     while(XCheckWindowEvent(kk->drv.p->dpy, kk->drv.p->window,

  416.                             kk->drv.p->event_mask, &xevent) == True)

  417.     {

  418.         KeySym keysym;

  419. 

  420.         /* Expose event */

  421.         if(xevent.type == Expose)

  422.         {

  423.             XCopyArea(kk->drv.p->dpy, kk->drv.p->pixmap,

  424.                       kk->drv.p->window, kk->drv.p->gc, 0, 0,

  425.                       kk->qq->width * kk->drv.p->font_width,

  426.                       kk->qq->height * kk->drv.p->font_height, 0, 0);

  427.             continue;

  428.         }

  429. 

  430.         /* Resize event */

  431.         if(xevent.type == ConfigureNotify)

  432.         {

  433.             unsigned int w, h;

  434. 

  435.             w = (xevent.xconfigure.width + kk->drv.p->font_width / 3)

  436.                   / kk->drv.p->font_width;

  437.             h = (xevent.xconfigure.height + kk->drv.p->font_height / 3)

  438.                   / kk->drv.p->font_height;

  439. 

  440.             if(!w || !h || (w == kk->qq->width && h == kk->qq->height))

  441.                 continue;

  442. 

  443.             kk->resize.w = w;

  444.             kk->resize.h = h;

  445.             kk->resize.resized = 1;

  446. 

  447.             continue;

  448.         }

  449. 

  450.         /* Check for mouse motion events */

  451.         if(xevent.type == MotionNotify)

  452.         {

  453.             unsigned int newx = xevent.xmotion.x / kk->drv.p->font_width;

  454.             unsigned int newy = xevent.xmotion.y / kk->drv.p->font_height;

  455. 

  456.             if(newx >= kk->qq->width)

  457.                 newx = kk->qq->width - 1;

  458.             if(newy >= kk->qq->height)

  459.                 newy = kk->qq->height - 1;

  460. 

  461.             if(kk->mouse.x == newx && kk->mouse.y == newy)

  462.                 continue;

  463. 

  464.             kk->mouse.x = newx;

  465.             kk->mouse.y = newy;

  466. 

  467.             ev->type = CACA_EVENT_MOUSE_MOTION;

  468.             ev->data.mouse.x = kk->mouse.x;

  469.             ev->data.mouse.y = kk->mouse.y;

  470.             return 1;

  471.         }

  472. 

  473.         /* Check for mouse press and release events */

  474.         if(xevent.type == ButtonPress)

  475.         {

  476.             ev->type = CACA_EVENT_MOUSE_PRESS;

  477.             ev->data.mouse.button = ((XButtonEvent *)&xevent)->button;

  478.             return 1;

  479.         }

  480. 

  481.         if(xevent.type == ButtonRelease)

  482.         {

  483.             ev->type = CACA_EVENT_MOUSE_RELEASE;

  484.             ev->data.mouse.button = ((XButtonEvent *)&xevent)->button;

  485.             return 1;

  486.         }

  487. 

  488.         /* Check for key press and release events */

  489.         if(xevent.type == KeyPress)

  490.             ev->type = CACA_EVENT_KEY_PRESS;

  491.         else if(xevent.type == KeyRelease)

  492.             ev->type = CACA_EVENT_KEY_RELEASE;

  493.         else

  494.             continue;

  495. 

  496.         if(XLookupString(&xevent.xkey, &key, 1, NULL, NULL))

  497.         {

  498.             ev->data.key.c = key;

  499.             ev->data.key.ucs4 = key;

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

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

  502.             return 1;

  503.         }

  504. 

  505.         keysym = XKeycodeToKeysym(kk->drv.p->dpy, xevent.xkey.keycode, 0);

  506.         switch(keysym)

  507.         {

  508.             case XK_F1:    ev->data.key.c = CACA_KEY_F1;    break;

  509.             case XK_F2:    ev->data.key.c = CACA_KEY_F2;    break;

  510.             case XK_F3:    ev->data.key.c = CACA_KEY_F3;    break;

  511.             case XK_F4:    ev->data.key.c = CACA_KEY_F4;    break;

  512.             case XK_F5:    ev->data.key.c = CACA_KEY_F5;    break;

  513.             case XK_F6:    ev->data.key.c = CACA_KEY_F6;    break;

  514.             case XK_F7:    ev->data.key.c = CACA_KEY_F7;    break;

  515.             case XK_F8:    ev->data.key.c = CACA_KEY_F8;    break;

  516.             case XK_F9:    ev->data.key.c = CACA_KEY_F9;    break;

  517.             case XK_F10:   ev->data.key.c = CACA_KEY_F10;   break;

  518.             case XK_F11:   ev->data.key.c = CACA_KEY_F11;   break;

  519.             case XK_F12:   ev->data.key.c = CACA_KEY_F12;   break;

  520.             case XK_F13:   ev->data.key.c = CACA_KEY_F13;   break;

  521.             case XK_F14:   ev->data.key.c = CACA_KEY_F14;   break;

  522.             case XK_F15:   ev->data.key.c = CACA_KEY_F15;   break;

  523.             case XK_Left:  ev->data.key.c = CACA_KEY_LEFT;  break;

  524.             case XK_Right: ev->data.key.c = CACA_KEY_RIGHT; break;

  525.             case XK_Up:    ev->data.key.c = CACA_KEY_UP;    break;

  526.             case XK_Down:  ev->data.key.c = CACA_KEY_DOWN;  break;

  527. 

  528.             default: ev->type = CACA_EVENT_NONE; return 0;

  529.         }

  530. 

  531.         ev->data.key.ucs4 = 0;

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

  533.         return 1;

  534.     }

  535. 

  536.     ev->type = CACA_EVENT_NONE;

  537.     return 0;

  538. }

  539. 

  540. static void x11_show_cursor(caca_t *kk)

  541. {

  542. 

  543. }

  544. 

  545. static void x11_hide_cursor(caca_t *kk)

  546. {

  547.     XFreeCursor( kk->drv.p->dpy, kk->drv.p->pointer );

  548.     kk->drv.p->pointer = None;

  549.     XUndefineCursor( kk->drv.p->dpy, kk->drv.p->window );

  550.     XSync( kk->drv.p->dpy, False ); /* optional */

  551. 

  552. }

  553. 

  554. 

  555. /*

  556.  * XXX: following functions are local

  557.  */

  558. 

  559. static int x11_error_handler(Display *dpy, XErrorEvent *xevent)

  560. {

  561.     /* Ignore the error */

  562.     return 0;

  563. }

  564. 

  565. /*

  566.  * Driver initialisation

  567.  */

  568. 

  569. int x11_install(caca_t *kk)

  570. {

  571. #if defined(HAVE_GETENV)

  572.     if(!getenv("DISPLAY") || !*(getenv("DISPLAY")))

  573.         return -1;

  574. #endif

  575. 

  576.     kk->drv.driver = CACA_DRIVER_X11;

  577. 

  578.     kk->drv.init_graphics = x11_init_graphics;

  579.     kk->drv.end_graphics = x11_end_graphics;

  580.     kk->drv.set_window_title = x11_set_window_title;

  581.     kk->drv.get_window_width = x11_get_window_width;

  582.     kk->drv.get_window_height = x11_get_window_height;

  583.     kk->drv.display = x11_display;

  584.     kk->drv.handle_resize = x11_handle_resize;

  585.     kk->drv.get_event = x11_get_event;

  586.     kk->drv.show_cursor = x11_show_cursor;

  587.     kk->drv.hide_cursor = x11_hide_cursor;

  588. 

  589.     return 0;

  590. }

  591. 

  592. #endif /* USE_X11 */