source: libcaca/trunk/caca/driver_x11.c @ 700

Last change on this file since 700 was 689, checked in by Sam Hocevar, 14 years ago
  • Merged caca_show_cursor() and caca_hide_cursor() into caca_set_mouse() so that we have one function less.
  • Fixed coding style.
  • Removed FUCKING TABS. .------._

_.----' -.

_.--' `.

_.-' ' ' `. _

.- H A H A H A ' M A I S \/.)

. . .-' / `

|-.(-. ' ` |\
. '\\ V I E U X ' ' - -|

/'') - - ` ' '.' |\_)

|'_._ '' P O R C . . /
@) \ ''' . '/

/ | \)..'-. _ _ . ` '/

.'- -'. . )-- '/'' ,._`' ' /

.' - ` ' .' / ' /,;;;, ,_.---' \ / \
(. .'
',`'.--'/ ' /'-----' | ' / ))

'-'/ _.---' \;;'/ , | |`- |

'--'---' |;| / ,,,,;;;;;;;;;;,,,,, |-' / |

|;'| ,;;;;;;;;;;;;;;;; ;;;/ /|`

,,' /

'

  • Property svn:keywords set to Id
File size: 19.4 KB
Line 
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: driver_x11.c 689 2006-03-24 16:51:59Z sam $
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 */
42static int x11_error_handler(Display *, XErrorEvent *);
43
44struct 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
62static 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    kk->drv.p->pointer = None;
213
214    return 0;
215}
216
217static int x11_end_graphics(caca_t *kk)
218{
219    XSync(kk->drv.p->dpy, False);
220#if defined(HAVE_X11_XKBLIB_H)
221    if(!kk->drv.p->autorepeat)
222        XAutoRepeatOn(kk->drv.p->dpy);
223#endif
224    XFreePixmap(kk->drv.p->dpy, kk->drv.p->pixmap);
225    XFreeFont(kk->drv.p->dpy, kk->drv.p->font_struct);
226    XFreeGC(kk->drv.p->dpy, kk->drv.p->gc);
227    XUnmapWindow(kk->drv.p->dpy, kk->drv.p->window);
228    XDestroyWindow(kk->drv.p->dpy, kk->drv.p->window);
229    XCloseDisplay(kk->drv.p->dpy);
230
231    free(kk->drv.p);
232
233    return 0;
234}
235
236static int x11_set_window_title(caca_t *kk, char const *title)
237{
238    XStoreName(kk->drv.p->dpy, kk->drv.p->window, title);
239    return 0;
240}
241
242static unsigned int x11_get_window_width(caca_t *kk)
243{
244    return kk->qq->width * kk->drv.p->font_width;
245}
246
247static unsigned int x11_get_window_height(caca_t *kk)
248{
249    return kk->qq->height * kk->drv.p->font_height;
250}
251
252static void x11_display(caca_t *kk)
253{
254    unsigned int x, y, len;
255
256    /* First draw the background colours. Splitting the process in two
257     * loops like this is actually slightly faster. */
258    for(y = 0; y < kk->qq->height; y++)
259    {
260        for(x = 0; x < kk->qq->width; x += len)
261        {
262            uint8_t *attr = kk->qq->attr + x + y * kk->qq->width;
263
264            len = 1;
265            while(x + len < kk->qq->width
266                   && (attr[len] >> 4) == (attr[0] >> 4))
267                len++;
268
269            XSetForeground(kk->drv.p->dpy, kk->drv.p->gc,
270                           kk->drv.p->colors[attr[0] >> 4]);
271            XFillRectangle(kk->drv.p->dpy, kk->drv.p->pixmap, kk->drv.p->gc,
272                           x * kk->drv.p->font_width, y * kk->drv.p->font_height,
273                           len * kk->drv.p->font_width, kk->drv.p->font_height);
274        }
275    }
276
277    /* Then print the foreground characters */
278    for(y = 0; y < kk->qq->height; y++)
279    {
280        unsigned int yoff = (y + 1) * kk->drv.p->font_height
281                                    - kk->drv.p->font_offset;
282        uint32_t *chars = kk->qq->chars + y * kk->qq->width;
283
284        for(x = 0; x < kk->qq->width; x++, chars++)
285        {
286            uint8_t *attr = kk->qq->attr + x + y * kk->qq->width;
287
288            /* Skip spaces */
289            if(*chars == 0x00000020)
290                continue;
291
292            XSetForeground(kk->drv.p->dpy, kk->drv.p->gc,
293                           kk->drv.p->colors[*attr & 0xf]);
294
295            /* Plain ASCII, no problem. */
296            if(*chars > 0x00000020 && *chars < 0x00000080)
297            {
298                char c = (uint8_t)*chars;
299                XDrawString(kk->drv.p->dpy, kk->drv.p->pixmap, kk->drv.p->gc,
300                            x * kk->drv.p->font_width, yoff, &c, 1);
301                continue;
302            }
303
304            /* We want to be able to print a few special Unicode characters
305             * such as the CP437 gradients and half blocks. For unknown
306             * characters, just print '?'. */
307            switch(*chars)
308            {
309                case 0x00002580: /* ▀ */
310                    XFillRectangle(kk->drv.p->dpy, kk->drv.p->pixmap,
311                                   kk->drv.p->gc,
312                                   x * kk->drv.p->font_width,
313                                   y * kk->drv.p->font_height,
314                                   kk->drv.p->font_width,
315                                   kk->drv.p->font_height / 2);
316                    break;
317                case 0x00002584: /* ▄ */
318                    XFillRectangle(kk->drv.p->dpy, kk->drv.p->pixmap,
319                                   kk->drv.p->gc,
320                                   x * kk->drv.p->font_width,
321                                   (y + 1) * kk->drv.p->font_height
322                                           - kk->drv.p->font_height / 2,
323                                   kk->drv.p->font_width,
324                                   kk->drv.p->font_height / 2);
325                    break;
326                case 0x00002588: /* █ */
327                    XFillRectangle(kk->drv.p->dpy, kk->drv.p->pixmap,
328                                   kk->drv.p->gc,
329                                   x * kk->drv.p->font_width,
330                                   y * kk->drv.p->font_height,
331                                   kk->drv.p->font_width,
332                                   kk->drv.p->font_height);
333                    break;
334                case 0x0000258c: /* ▌ */
335                    XFillRectangle(kk->drv.p->dpy, kk->drv.p->pixmap,
336                                   kk->drv.p->gc,
337                                   x * kk->drv.p->font_width,
338                                   y * kk->drv.p->font_height,
339                                   kk->drv.p->font_width / 2,
340                                   kk->drv.p->font_height);
341                    break;
342                case 0x00002590: /* ▐ */
343                    XFillRectangle(kk->drv.p->dpy, kk->drv.p->pixmap,
344                                   kk->drv.p->gc,
345                                   (x + 1) * kk->drv.p->font_width
346                                           - kk->drv.p->font_width / 2,
347                                   y * kk->drv.p->font_height,
348                                   kk->drv.p->font_width / 2,
349                                   kk->drv.p->font_height);
350                    break;
351                case 0x00002593: /* ▓ */
352                case 0x00002592: /* ▒ */
353                case 0x00002591: /* ░ */
354                {
355                    /* FIXME: this sucks utterly */
356                    int i, j, k = *chars - 0x00002591;
357                    for(j = kk->drv.p->font_height; j--; )
358                        for(i = kk->drv.p->font_width; i--; )
359                    {
360                        if(((i + 2 * (j & 1)) & 3) > k)
361                            continue;
362
363                        XDrawPoint(kk->drv.p->dpy, kk->drv.p->pixmap,
364                                   kk->drv.p->gc,
365                                   x * kk->drv.p->font_width + i,
366                                   y * kk->drv.p->font_height + j);
367                    }
368                    break;
369                }
370                default:
371                {
372                    char c;
373                    c = '?';
374                    XDrawString(kk->drv.p->dpy, kk->drv.p->pixmap,
375                                kk->drv.p->gc,
376                                x * kk->drv.p->font_width, yoff, &c, 1);
377                    break;
378                }
379            }
380        }
381    }
382
383    XCopyArea(kk->drv.p->dpy, kk->drv.p->pixmap, kk->drv.p->window,
384              kk->drv.p->gc, 0, 0,
385              kk->qq->width * kk->drv.p->font_width,
386              kk->qq->height * kk->drv.p->font_height,
387              0, 0);
388    XFlush(kk->drv.p->dpy);
389}
390
391static void x11_handle_resize(caca_t *kk)
392{
393    Pixmap new_pixmap;
394
395    new_pixmap = XCreatePixmap(kk->drv.p->dpy, kk->drv.p->window,
396                               kk->resize.w * kk->drv.p->font_width,
397                               kk->resize.h * kk->drv.p->font_height,
398                               DefaultDepth(kk->drv.p->dpy,
399                                            DefaultScreen(kk->drv.p->dpy)));
400    XCopyArea(kk->drv.p->dpy, kk->drv.p->pixmap, new_pixmap,
401              kk->drv.p->gc, 0, 0,
402              kk->resize.w * kk->drv.p->font_width,
403              kk->resize.h * kk->drv.p->font_height, 0, 0);
404    XFreePixmap(kk->drv.p->dpy, kk->drv.p->pixmap);
405    kk->drv.p->pixmap = new_pixmap;
406}
407
408static int x11_get_event(caca_t *kk, struct caca_event *ev)
409{
410    XEvent xevent;
411    char key;
412
413    while(XCheckWindowEvent(kk->drv.p->dpy, kk->drv.p->window,
414                            kk->drv.p->event_mask, &xevent) == True)
415    {
416        KeySym keysym;
417
418        /* Expose event */
419        if(xevent.type == Expose)
420        {
421            XCopyArea(kk->drv.p->dpy, kk->drv.p->pixmap,
422                      kk->drv.p->window, kk->drv.p->gc, 0, 0,
423                      kk->qq->width * kk->drv.p->font_width,
424                      kk->qq->height * kk->drv.p->font_height, 0, 0);
425            continue;
426        }
427
428        /* Resize event */
429        if(xevent.type == ConfigureNotify)
430        {
431            unsigned int w, h;
432
433            w = (xevent.xconfigure.width + kk->drv.p->font_width / 3)
434                  / kk->drv.p->font_width;
435            h = (xevent.xconfigure.height + kk->drv.p->font_height / 3)
436                  / kk->drv.p->font_height;
437
438            if(!w || !h || (w == kk->qq->width && h == kk->qq->height))
439                continue;
440
441            kk->resize.w = w;
442            kk->resize.h = h;
443            kk->resize.resized = 1;
444
445            continue;
446        }
447
448        /* Check for mouse motion events */
449        if(xevent.type == MotionNotify)
450        {
451            unsigned int newx = xevent.xmotion.x / kk->drv.p->font_width;
452            unsigned int newy = xevent.xmotion.y / kk->drv.p->font_height;
453
454            if(newx >= kk->qq->width)
455                newx = kk->qq->width - 1;
456            if(newy >= kk->qq->height)
457                newy = kk->qq->height - 1;
458
459            if(kk->mouse.x == newx && kk->mouse.y == newy)
460                continue;
461
462            kk->mouse.x = newx;
463            kk->mouse.y = newy;
464
465            ev->type = CACA_EVENT_MOUSE_MOTION;
466            ev->data.mouse.x = kk->mouse.x;
467            ev->data.mouse.y = kk->mouse.y;
468            return 1;
469        }
470
471        /* Check for mouse press and release events */
472        if(xevent.type == ButtonPress)
473        {
474            ev->type = CACA_EVENT_MOUSE_PRESS;
475            ev->data.mouse.button = ((XButtonEvent *)&xevent)->button;
476            return 1;
477        }
478
479        if(xevent.type == ButtonRelease)
480        {
481            ev->type = CACA_EVENT_MOUSE_RELEASE;
482            ev->data.mouse.button = ((XButtonEvent *)&xevent)->button;
483            return 1;
484        }
485
486        /* Check for key press and release events */
487        if(xevent.type == KeyPress)
488            ev->type = CACA_EVENT_KEY_PRESS;
489        else if(xevent.type == KeyRelease)
490            ev->type = CACA_EVENT_KEY_RELEASE;
491        else
492            continue;
493
494        if(XLookupString(&xevent.xkey, &key, 1, NULL, NULL))
495        {
496            ev->data.key.c = key;
497            ev->data.key.ucs4 = key;
498            ev->data.key.utf8[0] = key;
499            ev->data.key.utf8[1] = '\0';
500            return 1;
501        }
502
503        keysym = XKeycodeToKeysym(kk->drv.p->dpy, xevent.xkey.keycode, 0);
504        switch(keysym)
505        {
506            case XK_F1:    ev->data.key.c = CACA_KEY_F1;    break;
507            case XK_F2:    ev->data.key.c = CACA_KEY_F2;    break;
508            case XK_F3:    ev->data.key.c = CACA_KEY_F3;    break;
509            case XK_F4:    ev->data.key.c = CACA_KEY_F4;    break;
510            case XK_F5:    ev->data.key.c = CACA_KEY_F5;    break;
511            case XK_F6:    ev->data.key.c = CACA_KEY_F6;    break;
512            case XK_F7:    ev->data.key.c = CACA_KEY_F7;    break;
513            case XK_F8:    ev->data.key.c = CACA_KEY_F8;    break;
514            case XK_F9:    ev->data.key.c = CACA_KEY_F9;    break;
515            case XK_F10:   ev->data.key.c = CACA_KEY_F10;   break;
516            case XK_F11:   ev->data.key.c = CACA_KEY_F11;   break;
517            case XK_F12:   ev->data.key.c = CACA_KEY_F12;   break;
518            case XK_F13:   ev->data.key.c = CACA_KEY_F13;   break;
519            case XK_F14:   ev->data.key.c = CACA_KEY_F14;   break;
520            case XK_F15:   ev->data.key.c = CACA_KEY_F15;   break;
521            case XK_Left:  ev->data.key.c = CACA_KEY_LEFT;  break;
522            case XK_Right: ev->data.key.c = CACA_KEY_RIGHT; break;
523            case XK_Up:    ev->data.key.c = CACA_KEY_UP;    break;
524            case XK_Down:  ev->data.key.c = CACA_KEY_DOWN;  break;
525
526            default: ev->type = CACA_EVENT_NONE; return 0;
527        }
528
529        ev->data.key.ucs4 = 0;
530        ev->data.key.utf8[0] = '\0';
531        return 1;
532    }
533
534    ev->type = CACA_EVENT_NONE;
535    return 0;
536}
537
538static 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
574static int x11_error_handler(Display *dpy, XErrorEvent *xevent)
575{
576    /* Ignore the error */
577    return 0;
578}
579
580/*
581 * Driver initialisation
582 */
583
584int 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 */
607
Note: See TracBrowser for help on using the repository browser.