cacalabs
/
libcaca
peilaus alkaen https://github.com/cacalabs/libcaca.git
1
0
Fork 0
Koodi Ongelmat 0 Julkaisut 7 Wiki Toiminta
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.
586 Commitit
1 Haara
77 MiB
 
 
 
 
 
 
Puu: 72ec70454e
Branchit Tagit
${ item.name }
Create branch ${ searchTerm }
from '72ec70454e'
${ noResults }
libcaca/caca/driver_x11.c

608 rivejä
20 KiB
Raaka Blame Historia 

  1. /*

  2.  *  libcaca       Colour ASCII-Art library

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

  4.  *                All Rights Reserved

  5.  *

  6.  *  $Id$

  7.  *

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

  9.  *  modify it under the terms of the Do What The Fuck You Want To

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

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

  12.  */

  13. 

  14. /*

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

  16.  */

  17. 

  18. #include "config.h"

  19. 

  20. #if defined(USE_X11)

  21. 

  22. #include <X11/Xlib.h>

  23. #include <X11/Xutil.h>

  24. #include <X11/keysym.h>

  25. #if defined(HAVE_X11_XKBLIB_H)

  26. #   include <X11/XKBlib.h>

  27. #endif

  28. 

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

  30. #include <stdlib.h>

  31. 

  32. #include "caca.h"

  33. #include "caca_internals.h"

  34. #include "cucul.h"

  35. #include "cucul_internals.h"

  36. 

  37. /*

  38.  * Local functions

  39.  */

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

  41. 

  42. struct driver_private

  43. {

  44.     Display *dpy;

  45.     Window window;

  46.     Pixmap pixmap;

  47.     GC gc;

  48.     long int event_mask;

  49.     int font_width, font_height;

  50.     int colors[4096];

  51.     Font font;

  52.     XFontStruct *font_struct;

  53.     int font_offset;

  54.     Cursor pointer;

  55.     Atom wm_protocols;

  56.     Atom wm_delete_window;

  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.     Colormap colormap;

  65.     XSetWindowAttributes x11_winattr;

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

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

  68.     char const *geometry;

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

  70.     int i;

  71. 

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

  73. 

  74. #if defined(HAVE_GETENV)

  75.     geometry = getenv("CACA_GEOMETRY");

  76.     if(geometry && *geometry)

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

  78. #endif

  79. 

  80.     if(width && height)

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

  82. 

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

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

  85.         return -1;

  86. 

  87. #if defined(HAVE_GETENV)

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

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

  90.         parser = fonts;

  91.     else

  92. #endif

  93.         parser = fonts + 1;

  94. 

  95.     /* Ignore font errors */

  96.     old_error_handler = XSetErrorHandler(x11_error_handler);

  97. 

  98.     /* Parse our font list */

  99.     for( ; ; parser++)

  100.     {

  101.         if(!*parser)

  102.         {

  103.             XSetErrorHandler(old_error_handler);

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

  105.             return -1;

  106.         }

  107. 

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

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

  110.             continue;

  111. 

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

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

  114.         {

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

  116.             continue;

  117.         }

  118. 

  119.         break;

  120.     }

  121. 

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

  123.     XSetErrorHandler(old_error_handler);

  124. 

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

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

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

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

  129. 

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

  131.     for(i = 0x000; i < 0x1000; i++)

  132.     {

  133.         XColor color;

  134.         color.red = ((i & 0xf00) >> 8) * 0x1111;

  135.         color.green = ((i & 0x0f0) >> 4) * 0x1111;

  136.         color.blue = (i & 0x00f) * 0x1111;

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

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

  139.     }

  140. 

  141.     x11_winattr.backing_store = Always;

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

  143.     x11_winattr.event_mask = ExposureMask | StructureNotifyMask;

  144. 

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

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

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

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

  149.                       0, 0, InputOutput, 0,

  150.                       CWBackingStore | CWBackPixel | CWEventMask,

  151.                       &x11_winattr);

  152. 

  153.     kk->drv.p->wm_protocols =

  154.         XInternAtom(kk->drv.p->dpy, "WM_PROTOCOLS", True);

  155.     kk->drv.p->wm_delete_window =

  156.         XInternAtom(kk->drv.p->dpy, "WM_DELETE_WINDOW", True);

  157. 

  158.     if(kk->drv.p->wm_protocols != None && kk->drv.p->wm_delete_window != None)

  159.         XSetWMProtocols(kk->drv.p->dpy, kk->drv.p->window,

  160.                         &kk->drv.p->wm_delete_window, 1);

  161. 

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

  163. 

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

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

  166. 

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

  168.     XSetForeground(kk->drv.p->dpy, kk->drv.p->gc, kk->drv.p->colors[0x888]);

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

  170. 

  171.     for(;;)

  172.     {

  173.         XEvent xevent;

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

  175.         if (xevent.type == MapNotify)

  176.             break;

  177.     }

  178. 

  179. #if defined(HAVE_X11_XKBLIB_H)

  180.     /* Disable autorepeat */

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

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

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

  184. #endif

  185. 

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

  187.           | ButtonReleaseMask | PointerMotionMask | StructureNotifyMask

  188.           | ExposureMask;

  189. 

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

  191. 

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

  193. 

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

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

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

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

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

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

  200. 

  201.     return 0;

  202. }

  203. 

  204. static int x11_end_graphics(caca_t *kk)

  205. {

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

  207. #if defined(HAVE_X11_XKBLIB_H)

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

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

  210. #endif

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

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

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

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

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

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

  217. 

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

  219. 

  220.     return 0;

  221. }

  222. 

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

  224. {

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

  226.     return 0;

  227. }

  228. 

  229. static unsigned int x11_get_window_width(caca_t *kk)

  230. {

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

  232. }

  233. 

  234. static unsigned int x11_get_window_height(caca_t *kk)

  235. {

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

  237. }

  238. 

  239. static void x11_display(caca_t *kk)

  240. {

  241.     unsigned int x, y, len;

  242. 

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

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

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

  246.     {

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

  248.         {

  249.             uint32_t *attr = kk->qq->attr + x + y * kk->qq->width;

  250.             uint16_t bg = _cucul_argb32_to_rgb12bg(*attr);

  251. 

  252.             len = 1;

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

  254.                    && _cucul_argb32_to_rgb12bg(attr[len]) == bg)

  255.                 len++;

  256. 

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

  258.                            kk->drv.p->colors[bg]);

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

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

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

  262.         }

  263.     }

  264. 

  265.     /* Then print the foreground characters */

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

  267.     {

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

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

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

  271. 

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

  273.         {

  274.             uint32_t *attr = kk->qq->attr + x + y * kk->qq->width;

  275. 

  276.             /* Skip spaces */

  277.             if(*chars == 0x00000020)

  278.                 continue;

  279. 

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

  281.                            kk->drv.p->colors[_cucul_argb32_to_rgb12fg(*attr)]);

  282. 

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

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

  285.             {

  286.                 char c = (uint8_t)*chars;

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

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

  289.                 continue;

  290.             }

  291. 

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

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

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

  295.             switch(*chars)

  296.             {

  297.                 case 0x00002580: /* ▀ */

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

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

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

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

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

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

  304.                     break;

  305.                 case 0x00002584: /* ▄ */

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

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

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

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

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

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

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

  313.                     break;

  314.                 case 0x00002588: /* █ */

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

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

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

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

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

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

  321.                     break;

  322.                 case 0x0000258c: /* ▌ */

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

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

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

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

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

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

  329.                     break;

  330.                 case 0x00002590: /* ▐ */

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

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

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

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

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

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

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

  338.                     break;

  339.                 case 0x00002593: /* ▓ */

  340.                 case 0x00002592: /* ▒ */

  341.                 case 0x00002591: /* ░ */

  342.                 {

  343.                     /* FIXME: this sucks utterly */

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

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

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

  347.                     {

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

  349.                             continue;

  350. 

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

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

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

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

  355.                     }

  356.                     break;

  357.                 }

  358.                 default:

  359.                 {

  360.                     char c;

  361.                     c = '?';

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

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

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

  365.                     break;

  366.                 }

  367.             }

  368.         }

  369.     }

  370. 

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

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

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

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

  375.               0, 0);

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

  377. }

  378. 

  379. static void x11_handle_resize(caca_t *kk)

  380. {

  381.     Pixmap new_pixmap;

  382. 

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

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

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

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

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

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

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

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

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

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

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

  394. }

  395. 

  396. static int x11_get_event(caca_t *kk, caca_event_t *ev)

  397. {

  398.     XEvent xevent;

  399.     char key;

  400. 

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

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

  403.     {

  404.         KeySym keysym;

  405. 

  406.         /* Expose event */

  407.         if(xevent.type == Expose)

  408.         {

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

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

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

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

  413.             continue;

  414.         }

  415. 

  416.         /* Resize event */

  417.         if(xevent.type == ConfigureNotify)

  418.         {

  419.             unsigned int w, h;

  420. 

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

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

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

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

  425. 

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

  427.                 continue;

  428. 

  429.             kk->resize.w = w;

  430.             kk->resize.h = h;

  431.             kk->resize.resized = 1;

  432. 

  433.             continue;

  434.         }

  435. 

  436.         /* Check for mouse motion events */

  437.         if(xevent.type == MotionNotify)

  438.         {

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

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

  441. 

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

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

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

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

  446. 

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

  448.                 continue;

  449. 

  450.             kk->mouse.x = newx;

  451.             kk->mouse.y = newy;

  452. 

  453.             ev->type = CACA_EVENT_MOUSE_MOTION;

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

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

  456.             return 1;

  457.         }

  458. 

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

  460.         if(xevent.type == ButtonPress)

  461.         {

  462.             ev->type = CACA_EVENT_MOUSE_PRESS;

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

  464.             return 1;

  465.         }

  466. 

  467.         if(xevent.type == ButtonRelease)

  468.         {

  469.             ev->type = CACA_EVENT_MOUSE_RELEASE;

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

  471.             return 1;

  472.         }

  473. 

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

  475.         if(xevent.type == KeyPress)

  476.             ev->type = CACA_EVENT_KEY_PRESS;

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

  478.             ev->type = CACA_EVENT_KEY_RELEASE;

  479.         else

  480.             continue;

  481. 

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

  483.         {

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

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

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

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

  488.             return 1;

  489.         }

  490. 

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

  492.         switch(keysym)

  493.         {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  513. 

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

  515.         }

  516. 

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

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

  519.         return 1;

  520.     }

  521. 

  522.     while(XCheckTypedEvent(kk->drv.p->dpy, ClientMessage, &xevent))

  523.     {

  524.         if(xevent.xclient.message_type != kk->drv.p->wm_protocols)

  525.             continue;

  526. 

  527.         if((Atom)xevent.xclient.data.l[0] == kk->drv.p->wm_delete_window)

  528.         {

  529.             ev->type = CACA_EVENT_QUIT;

  530.             return 1;

  531.         }

  532.     }

  533. 

  534.     ev->type = CACA_EVENT_NONE;

  535.     return 0;

  536. }

  537. 

  538. static void x11_set_mouse(caca_t *kk, int flags)

  539. {

  540.     Cursor no_ptr;

  541.     Pixmap bm_no;

  542.     XColor black, dummy;

  543.     Colormap colormap;

  544.     static char const empty[] = { 0, 0, 0, 0, 0, 0, 0, 0 };

  545. 

  546.     if(flags)

  547.     {

  548.         XDefineCursor(kk->drv.p->dpy,kk->drv.p->window, 0);

  549.         return;

  550.     }

  551. 

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

  553.     if(!XAllocNamedColor(kk->drv.p->dpy, colormap, "black", &black, &dummy))

  554.     {

  555.         return;

  556.     }

  557.     bm_no = XCreateBitmapFromData(kk->drv.p->dpy, kk->drv.p->window,

  558.                                   empty, 8, 8);

  559.     no_ptr = XCreatePixmapCursor(kk->drv.p->dpy, bm_no, bm_no,

  560.                                  &black, &black, 0, 0);

  561.     XDefineCursor(kk->drv.p->dpy, kk->drv.p->window, no_ptr);

  562.     XFreeCursor(kk->drv.p->dpy, no_ptr);

  563.     if(bm_no != None)

  564.         XFreePixmap(kk->drv.p->dpy, bm_no);

  565.     XFreeColors(kk->drv.p->dpy, colormap, &black.pixel, 1, 0);

  566. 

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

  568. }

  569. 

  570. /*

  571.  * XXX: following functions are local

  572.  */

  573. 

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

  575. {

  576.     /* Ignore the error */

  577.     return 0;

  578. }

  579. 

  580. /*

  581.  * Driver initialisation

  582.  */

  583. 

  584. int x11_install(caca_t *kk)

  585. {

  586. #if defined(HAVE_GETENV)

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

  588.         return -1;

  589. #endif

  590. 

  591.     kk->drv.driver = CACA_DRIVER_X11;

  592. 

  593.     kk->drv.init_graphics = x11_init_graphics;

  594.     kk->drv.end_graphics = x11_end_graphics;

  595.     kk->drv.set_window_title = x11_set_window_title;

  596.     kk->drv.get_window_width = x11_get_window_width;

  597.     kk->drv.get_window_height = x11_get_window_height;

  598.     kk->drv.display = x11_display;

  599.     kk->drv.handle_resize = x11_handle_resize;

  600.     kk->drv.get_event = x11_get_event;

  601.     kk->drv.set_mouse = x11_set_mouse;

  602. 

  603.     return 0;

  604. }

  605. 

  606. #endif /* USE_X11 */