* Renamed caca_t into caca_display_t.

* Renamed canvas handle variables from "c" to "cv". Eh ouais mon gros.

caca/caca.c

@@ -29,7 +29,7 @@
 #include "caca.h"
 #include "caca_internals.h"
 
-static int caca_init_driver(caca_t *kk);
+static int caca_init_driver(caca_display_t *dp);
 
 /** \brief Attach a caca graphical context to a cucul canvas.
  *
@@ -38,58 +38,58 @@ static int caca_init_driver(caca_t *kk);
  *  libcucul canvas. Everything that gets drawn in the libcucul canvas can
  *  then be displayed by the libcaca driver.
  *
- *  \param c The cucul cavas.
+ *  \param cv The cucul cavas.
  *  \return The caca graphical context or NULL if an error occurred.
  */
-caca_t * caca_attach(cucul_canvas_t * c)
+caca_display_t * caca_attach(cucul_canvas_t * cv)
 {
-    caca_t *kk = malloc(sizeof(caca_t));
+    caca_display_t *dp = malloc(sizeof(caca_display_t));
 
-    kk->c = c;
+    dp->cv = cv;
 
-    if(caca_init_driver(kk))
+    if(caca_init_driver(dp))
     {
-        free(kk);
+        free(dp);
         return NULL;
     }
 
-    if(kk->drv.init_graphics(kk))
+    if(dp->drv.init_graphics(dp))
     {
-        free(kk);
+        free(dp);
         return NULL;
     }
 
     /* Attached! */
-    kk->c->refcount++;
+    dp->cv->refcount++;
 
     /* Graphics stuff */
-    kk->delay = 0;
-    kk->rendertime = 0;
+    dp->delay = 0;
+    dp->rendertime = 0;
 
     /* Events stuff */
 #if defined(USE_SLANG) || defined(USE_NCURSES)
-    kk->events.key_timer.last_sec = 0;
-    kk->events.key_timer.last_usec = 0;
-    kk->events.last_key_ticks = 0;
-    kk->events.autorepeat_ticks = 0;
-    kk->events.last_key_event.type = CACA_EVENT_NONE;
+    dp->events.key_timer.last_sec = 0;
+    dp->events.key_timer.last_usec = 0;
+    dp->events.last_key_ticks = 0;
+    dp->events.autorepeat_ticks = 0;
+    dp->events.last_key_event.type = CACA_EVENT_NONE;
 #endif
 #if defined(USE_SLANG) || defined(USE_NCURSES) || defined(USE_CONIO) || defined(USE_GL)
-    kk->events.queue = 0;
+    dp->events.queue = 0;
 #endif
 
-    kk->timer.last_sec = 0;
-    kk->timer.last_usec = 0;
-    kk->lastticks = 0;
+    dp->timer.last_sec = 0;
+    dp->timer.last_usec = 0;
+    dp->lastticks = 0;
 
     /* Mouse position */
-    kk->mouse.x = kk->c->width / 2;
-    kk->mouse.y = kk->c->height / 2;
+    dp->mouse.x = dp->cv->width / 2;
+    dp->mouse.y = dp->cv->height / 2;
 
     /* Resize events */
-    kk->resize.resized = 0;
+    dp->resize.resized = 0;
 
-    return kk;
+    return dp;
 }
 
 /** \brief Detach a caca graphical context from a cucul backend context.
@@ -98,20 +98,20 @@ caca_t * caca_attach(cucul_canvas_t * c)
  *  libcucul canvas continues to exist and other graphical contexts can be
  *  attached to it afterwards.
  *
- *  \param kk The libcaca graphical context.
+ *  \param dp The libcaca graphical context.
  */
-void caca_detach(caca_t *kk)
+void caca_detach(caca_display_t *dp)
 {
-    kk->drv.end_graphics(kk);
-    kk->c->refcount--;
-    free(kk);
+    dp->drv.end_graphics(dp);
+    dp->cv->refcount--;
+    free(dp);
 }
 
 /*
  * XXX: The following functions are local.
  */
 
-static int caca_init_driver(caca_t *kk)
+static int caca_init_driver(caca_display_t *dp)
 {
 #if defined(HAVE_GETENV) && defined(HAVE_STRCASECMP)
     char *var = getenv("CACA_DRIVER");
@@ -120,51 +120,51 @@ static int caca_init_driver(caca_t *kk)
     if(var && *var)
     {
 #if defined(USE_WIN32)
-        if(!strcasecmp(var, "win32")) return win32_install(kk);
+        if(!strcasecmp(var, "win32")) return win32_install(dp);
 #endif
 #if defined(USE_CONIO)
-        if(!strcasecmp(var, "conio")) return conio_install(kk);
+        if(!strcasecmp(var, "conio")) return conio_install(dp);
 #endif
 #if defined(USE_X11)
-        if(!strcasecmp(var, "x11")) return x11_install(kk);
+        if(!strcasecmp(var, "x11")) return x11_install(dp);
 #endif
 #if defined(USE_GL)
-        if(!strcasecmp(var, "gl")) return gl_install(kk);
+        if(!strcasecmp(var, "gl")) return gl_install(dp);
 #endif
-        if(!strcasecmp(var, "raw")) return raw_install(kk);
+        if(!strcasecmp(var, "raw")) return raw_install(dp);
 #if defined(USE_SLANG)
-        if(!strcasecmp(var, "slang")) return slang_install(kk);
+        if(!strcasecmp(var, "slang")) return slang_install(dp);
 #endif
 #if defined(USE_NCURSES)
-        if(!strcasecmp(var, "ncurses")) return ncurses_install(kk);
+        if(!strcasecmp(var, "ncurses")) return ncurses_install(dp);
 #endif
 #if defined(USE_VGA)
-        if(!strcasecmp(var, "vga")) return vga_install(kk);
+        if(!strcasecmp(var, "vga")) return vga_install(dp);
 #endif
         return -1;
     }
 #endif
 
 #if defined(USE_WIN32)
-    if(win32_install(kk) == 0) return 0;
+    if(win32_install(dp) == 0) return 0;
 #endif
 #if defined(USE_CONIO)
-    if(conio_install(kk) == 0) return 0;
+    if(conio_install(dp) == 0) return 0;
 #endif
 #if defined(USE_VGA)
-    if(vga_install(kk) == 0) return 0;
+    if(vga_install(dp) == 0) return 0;
 #endif
 #if defined(USE_X11)
-    if(x11_install(kk) == 0) return 0;
+    if(x11_install(dp) == 0) return 0;
 #endif
 #if defined(USE_GL)
-    if(gl_install(kk) == 0) return 0;
+    if(gl_install(dp) == 0) return 0;
 #endif
 #if defined(USE_SLANG)
-    if(slang_install(kk) == 0) return 0;
+    if(slang_install(dp) == 0) return 0;
 #endif
 #if defined(USE_NCURSES)
-    if(ncurses_install(kk) == 0) return 0;
+    if(ncurses_install(dp) == 0) return 0;
 #endif
 
     return -1;

caca/caca.h

@@ -88,7 +88,7 @@ extern "C"
 #endif
 
 /** \e libcaca context */
-typedef struct caca caca_t;
+typedef struct caca_display caca_display_t;
 /** event structure */
 typedef struct caca_event caca_event_t;
 
@@ -203,14 +203,14 @@ enum caca_key
  *  initialisation, system information retrieval and configuration.
  *
  *  @{ */
-caca_t * caca_attach(cucul_canvas_t *);
-void caca_detach(caca_t *);
-void caca_set_delay(caca_t *, unsigned int);
-void caca_display(caca_t *);
-unsigned int caca_get_rendertime(caca_t *);
-unsigned int caca_get_window_width(caca_t *);
-unsigned int caca_get_window_height(caca_t *);
-int caca_set_window_title(caca_t *, char const *);
+caca_display_t * caca_attach(cucul_canvas_t *);
+void caca_detach(caca_display_t *);
+void caca_set_delay(caca_display_t *, unsigned int);
+void caca_display(caca_display_t *);
+unsigned int caca_get_rendertime(caca_display_t *);
+unsigned int caca_get_window_width(caca_display_t *);
+unsigned int caca_get_window_height(caca_display_t *);
+int caca_set_window_title(caca_display_t *, char const *);
 /*  @} */
 
 /** \defgroup event Event handling
@@ -219,10 +219,10 @@ int caca_set_window_title(caca_t *, char const *);
  *  clicks.
  *
  *  @{ */
-int caca_get_event(caca_t *, unsigned int, caca_event_t *, int);
-unsigned int caca_get_mouse_x(caca_t *);
-unsigned int caca_get_mouse_y(caca_t *);
-void caca_set_mouse(caca_t *, int);
+int caca_get_event(caca_display_t *, unsigned int, caca_event_t *, int);
+unsigned int caca_get_mouse_x(caca_display_t *);
+unsigned int caca_get_mouse_y(caca_display_t *);
+void caca_set_mouse(caca_display_t *, int);
 /*  @} */
 
 #ifdef __cplusplus

caca/caca_internals.h

@@ -61,26 +61,26 @@ enum caca_driver
 
 /* Available external drivers */
 #if defined(USE_CONIO)
-int conio_install(caca_t *);
+int conio_install(caca_display_t *);
 #endif
 #if defined(USE_GL)
-int gl_install(caca_t *);
+int gl_install(caca_display_t *);
 #endif
 #if defined(USE_NCURSES)
-int ncurses_install(caca_t *);
+int ncurses_install(caca_display_t *);
 #endif
-int raw_install(caca_t *);
+int raw_install(caca_display_t *);
 #if defined(USE_SLANG)
-int slang_install(caca_t *);
+int slang_install(caca_display_t *);
 #endif
 #if defined(USE_VGA)
-int vga_install(caca_t *);
+int vga_install(caca_display_t *);
 #endif
 #if defined(USE_WIN32)
-int win32_install(caca_t *);
+int win32_install(caca_display_t *);
 #endif
 #if defined(USE_X11)
-int x11_install(caca_t *);
+int x11_install(caca_display_t *);
 #endif
 
 /* Timer structure */
@@ -89,11 +89,11 @@ struct caca_timer
     int last_sec, last_usec;
 };
 
-/* Internal caca context */
-struct caca
+/* Internal caca display context */
+struct caca_display
 {
     /* A link to our cucul canvas */
-    cucul_canvas_t *c;
+    cucul_canvas_t *cv;
 
     /* Device-specific functions */
     struct drv
@@ -101,15 +101,15 @@ struct caca
         enum caca_driver driver;
         struct driver_private *p;
 
-        int (* init_graphics) (caca_t *);
-        int (* end_graphics) (caca_t *);
-        int (* set_window_title) (caca_t *, char const *);
-        unsigned int (* get_window_width) (caca_t *);
-        unsigned int (* get_window_height) (caca_t *);
-        void (* display) (caca_t *);
-        void (* handle_resize) (caca_t *);
-        int (* get_event) (caca_t *, caca_event_t *);
-        void (* set_mouse) (caca_t *, int);
+        int (* init_graphics) (caca_display_t *);
+        int (* end_graphics) (caca_display_t *);
+        int (* set_window_title) (caca_display_t *, char const *);
+        unsigned int (* get_window_width) (caca_display_t *);
+        unsigned int (* get_window_height) (caca_display_t *);
+        void (* display) (caca_display_t *);
+        void (* handle_resize) (caca_display_t *);
+        int (* get_event) (caca_display_t *, caca_event_t *);
+        void (* set_mouse) (caca_display_t *, int);
     } drv;
 
     /* Mouse position */
@@ -153,10 +153,10 @@ extern void _caca_sleep(unsigned int);
 extern unsigned int _caca_getticks(caca_timer_t *);
 
 /* Internal event functions */
-extern void _caca_handle_resize(caca_t *);
+extern void _caca_handle_resize(caca_display_t *);
 #if defined(USE_SLANG) || defined(USE_NCURSES) || defined(USE_CONIO) || defined(USE_GL)
-extern void _push_event(caca_t *, caca_event_t *);
-extern int _pop_event(caca_t *, caca_event_t *);
+extern void _push_event(caca_display_t *, caca_event_t *);
+extern int _pop_event(caca_display_t *, caca_event_t *);
 #endif
 
 #endif /* __CACA_INTERNALS_H__ */

caca/driver_conio.c

@@ -38,88 +38,88 @@ struct driver_private
     char *screen;
 };
 
-static int conio_init_graphics(caca_t *kk)
+static int conio_init_graphics(caca_display_t *dp)
 {
-    kk->drv.p = malloc(sizeof(struct driver_private));
+    dp->drv.p = malloc(sizeof(struct driver_private));
 
     _wscroll = 0;
     _setcursortype(_NOCURSOR);
     clrscr();
 
-    gettextinfo(&kk->drv.p->ti);
-    kk->drv.p->screen = malloc(2 * kk->drv.p->ti.screenwidth
-                                 * kk->drv.p->ti.screenheight * sizeof(char));
-    if(kk->drv.p->screen == NULL)
+    gettextinfo(&dp->drv.p->ti);
+    dp->drv.p->screen = malloc(2 * dp->drv.p->ti.screenwidth
+                                 * dp->drv.p->ti.screenheight * sizeof(char));
+    if(dp->drv.p->screen == NULL)
         return -1;
 #   if defined(SCREENUPDATE_IN_PC_H)
-    ScreenRetrieve(kk->drv.p->screen);
+    ScreenRetrieve(dp->drv.p->screen);
 #   else
     /* FIXME */
 #   endif
-    _cucul_set_size(kk->c, kk->drv.p->ti.screenwidth,
-                           kk->drv.p->ti.screenheight);
+    _cucul_set_size(dp->cv, dp->drv.p->ti.screenwidth,
+                            dp->drv.p->ti.screenheight);
     return 0;
 }
 
-static int conio_end_graphics(caca_t *kk)
+static int conio_end_graphics(caca_display_t *dp)
 {
     _wscroll = 1;
     textcolor((enum COLORS)WHITE);
     textbackground((enum COLORS)BLACK);
-    gotoxy(kk->c->width, kk->c->height);
+    gotoxy(dp->cv->width, dp->cv->height);
     cputs("\r\n");
     _setcursortype(_NORMALCURSOR);
 
-    free(kk->drv.p->screen);
-    free(kk->drv.p);
+    free(dp->drv.p->screen);
+    free(dp->drv.p);
 
     return 0;
 }
 
-static int conio_set_window_title(caca_t *kk, char const *title)
+static int conio_set_window_title(caca_display_t *dp, char const *title)
 {
     return 0;
 }
 
-static unsigned int conio_get_window_width(caca_t *kk)
+static unsigned int conio_get_window_width(caca_display_t *dp)
 {
     /* Fallback to a 6x10 font */
-    return kk->c->width * 6;
+    return dp->cv->width * 6;
 }
 
-static unsigned int conio_get_window_height(caca_t *kk)
+static unsigned int conio_get_window_height(caca_display_t *dp)
 {
     /* Fallback to a 6x10 font */
-    return kk->c->height * 10;
+    return dp->cv->height * 10;
 }
 
-static void conio_display(caca_t *kk)
+static void conio_display(caca_display_t *dp)
 {
-    char *screen = kk->drv.p->screen;
-    uint32_t *attr = kk->c->attr;
-    uint32_t *chars = kk->c->chars;
+    char *screen = dp->drv.p->screen;
+    uint32_t *attr = dp->cv->attr;
+    uint32_t *chars = dp->cv->chars;
     int n;
 
-    for(n = kk->c->height * kk->c->width; n--; )
+    for(n = dp->cv->height * dp->cv->width; n--; )
     {
         *screen++ = _cucul_utf32_to_cp437(*chars++);
         *screen++ = _cucul_argb32_to_ansi8(*attr++);
     }
 #   if defined(SCREENUPDATE_IN_PC_H)
-    ScreenUpdate(kk->drv.p->screen);
+    ScreenUpdate(dp->drv.p->screen);
 #   else
     /* FIXME */
 #   endif
 }
 
-static void conio_handle_resize(caca_t *kk)
+static void conio_handle_resize(caca_display_t *dp)
 {
     /* We know nothing about our window */
-    kk->resize.w = kk->c->width;
-    kk->resize.h = kk->c->height;
+    dp->resize.w = dp->cv->width;
+    dp->resize.h = dp->cv->height;
 }
 
-static int conio_get_event(caca_t *kk, caca_event_t *ev)
+static int conio_get_event(caca_display_t *dp, caca_event_t *ev)
 {
     unsigned char ch;
     caca_event_t release;
@@ -140,7 +140,7 @@ static int conio_get_event(caca_t *kk, caca_event_t *ev)
 
     release = *ev;
     release.type = CACA_EVENT_KEY_RELEASE;
-    _push_event(kk, &release);
+    _push_event(dp, &release);
 
     return 1;
 }
@@ -149,19 +149,19 @@ static int conio_get_event(caca_t *kk, caca_event_t *ev)
  * Driver initialisation
  */
 
-int conio_install(caca_t *kk)
+int conio_install(caca_display_t *dp)
 {
-    kk->drv.driver = CACA_DRIVER_CONIO;
-
-    kk->drv.init_graphics = conio_init_graphics;
-    kk->drv.end_graphics = conio_end_graphics;
-    kk->drv.set_window_title = conio_set_window_title;
-    kk->drv.get_window_width = conio_get_window_width;
-    kk->drv.get_window_height = conio_get_window_height;
-    kk->drv.display = conio_display;
-    kk->drv.handle_resize = conio_handle_resize;
-    kk->drv.get_event = conio_get_event;
-    kk->drv.set_mouse = NULL;
+    dp->drv.driver = CACA_DRIVER_CONIO;
+
+    dp->drv.init_graphics = conio_init_graphics;
+    dp->drv.end_graphics = conio_end_graphics;
+    dp->drv.set_window_title = conio_set_window_title;
+    dp->drv.get_window_width = conio_get_window_width;
+    dp->drv.get_window_height = conio_get_window_height;
+    dp->drv.display = conio_display;
+    dp->drv.handle_resize = conio_handle_resize;
+    dp->drv.get_event = conio_get_event;
+    dp->drv.set_mouse = NULL;
 
     return 0;
 }

caca/driver_gl.c

@@ -41,7 +41,7 @@
  * Global variables
  */
 
-static caca_t *gl_kk; /* FIXME: we ought to get rid of this */
+static caca_display_t *gl_d; /* FIXME: we ought to get rid of this */
 
 /*
  * Local functions
@@ -76,7 +76,7 @@ struct driver_private
     float sw, sh;
 };
 
-static int gl_init_graphics(caca_t *kk)
+static int gl_init_graphics(caca_display_t *dp)
 {
     char *empty_texture;
     char const *geometry;
@@ -85,9 +85,9 @@ static int gl_init_graphics(caca_t *kk)
     int argc = 1;
     int i;
 
-    kk->drv.p = malloc(sizeof(struct driver_private));
+    dp->drv.p = malloc(sizeof(struct driver_private));
 
-    gl_kk = kk;
+    gl_d = dp;
 
 #if defined(HAVE_GETENV)
     geometry = getenv("CACA_GEOMETRY");
@@ -96,35 +96,35 @@ static int gl_init_graphics(caca_t *kk)
 #endif
 
     if(width && height)
-        _cucul_set_size(kk->c, width, height);
+        _cucul_set_size(dp->cv, width, height);
 
-    kk->drv.p->font_width = 9;
-    kk->drv.p->font_height = 15;
+    dp->drv.p->font_width = 9;
+    dp->drv.p->font_height = 15;
 
-    kk->drv.p->width = kk->c->width * kk->drv.p->font_width;
-    kk->drv.p->height = kk->c->height * kk->drv.p->font_height;
+    dp->drv.p->width = dp->cv->width * dp->drv.p->font_width;
+    dp->drv.p->height = dp->cv->height * dp->drv.p->font_height;
 
 #ifdef HAVE_GLUTCLOSEFUNC
-    kk->drv.p->close = 0;
+    dp->drv.p->close = 0;
 #endif
-    kk->drv.p->bit = 0;
+    dp->drv.p->bit = 0;
 
-    kk->drv.p->mouse_changed = kk->drv.p->mouse_clicked = 0;
-    kk->drv.p->mouse_button = kk->drv.p->mouse_state = 0;
+    dp->drv.p->mouse_changed = dp->drv.p->mouse_clicked = 0;
+    dp->drv.p->mouse_button = dp->drv.p->mouse_state = 0;
 
-    kk->drv.p->key = 0;
-    kk->drv.p->special_key = 0;
+    dp->drv.p->key = 0;
+    dp->drv.p->special_key = 0;
 
-    kk->drv.p->sw = 9.0f / 16.0f;
-    kk->drv.p->sh = 15.0f / 16.0f;
+    dp->drv.p->sw = 9.0f / 16.0f;
+    dp->drv.p->sh = 15.0f / 16.0f;
 
     glutInit(&argc, argv);
 
     glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE);
-    glutInitWindowSize(kk->drv.p->width, kk->drv.p->height);
-    kk->drv.p->window = glutCreateWindow("caca for GL");
+    glutInitWindowSize(dp->drv.p->width, dp->drv.p->height);
+    dp->drv.p->window = glutCreateWindow("caca for GL");
 
-    gluOrtho2D(0, kk->drv.p->width, kk->drv.p->height, 0);
+    gluOrtho2D(0, dp->drv.p->width, dp->drv.p->height, 0);
 
     glDisable(GL_CULL_FACE);
     glDisable(GL_DEPTH_TEST);
@@ -147,7 +147,7 @@ static int gl_init_graphics(caca_t *kk)
     glMatrixMode(GL_PROJECTION);
     glPushMatrix();
     glLoadIdentity();
-    gluOrtho2D(0, kk->drv.p->width, kk->drv.p->height, 0);
+    gluOrtho2D(0, dp->drv.p->width, dp->drv.p->height, 0);
 
     glMatrixMode(GL_MODELVIEW);
 
@@ -162,8 +162,8 @@ static int gl_init_graphics(caca_t *kk)
 
     for(i = 32; i < 128; i++)
     {
-        glGenTextures(1, (GLuint*)&kk->drv.p->id[i - 32]);
-        glBindTexture(GL_TEXTURE_2D, kk->drv.p->id[i - 32]);
+        glGenTextures(1, (GLuint*)&dp->drv.p->id[i - 32]);
+        glBindTexture(GL_TEXTURE_2D, dp->drv.p->id[i - 32]);
         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
         glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB8,
@@ -180,9 +180,9 @@ static int gl_init_graphics(caca_t *kk)
         glutBitmapCharacter(GLUT_BITMAP_9_BY_15, i);
 
         glEnable(GL_TEXTURE_2D);
-        glBindTexture(GL_TEXTURE_2D, kk->drv.p->id[i - 32]);
+        glBindTexture(GL_TEXTURE_2D, dp->drv.p->id[i - 32]);
         glCopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGB,
-                         0, kk->drv.p->height - 16, 16, 16, 0);
+                         0, dp->drv.p->height - 16, 16, 16, 0);
 
 #ifdef HAVE_GLUTCHECKLOOP
         glutCheckLoop();
@@ -195,41 +195,41 @@ static int gl_init_graphics(caca_t *kk)
     return 0;
 }
 
-static int gl_end_graphics(caca_t *kk)
+static int gl_end_graphics(caca_display_t *dp)
 {
-    glutDestroyWindow(kk->drv.p->window);
-    free(kk->drv.p);
+    glutDestroyWindow(dp->drv.p->window);
+    free(dp->drv.p);
     return 0;
 }
 
-static int gl_set_window_title(caca_t *kk, char const *title)
+static int gl_set_window_title(caca_display_t *dp, char const *title)
 {
     glutSetWindowTitle(title);
     return 0;
 }
 
-static unsigned int gl_get_window_width(caca_t *kk)
+static unsigned int gl_get_window_width(caca_display_t *dp)
 {
-    return kk->drv.p->width;
+    return dp->drv.p->width;
 }
 
-static unsigned int gl_get_window_height(caca_t *kk)
+static unsigned int gl_get_window_height(caca_display_t *dp)
 {
-    return kk->drv.p->height;
+    return dp->drv.p->height;
 }
 
-static void gl_display(caca_t *kk)
+static void gl_display(caca_display_t *dp)
 {
     unsigned int x, y, line;
 
     glClear(GL_COLOR_BUFFER_BIT);
 
     line = 0;
-    for(y = 0; y < kk->drv.p->height; y += kk->drv.p->font_height)
+    for(y = 0; y < dp->drv.p->height; y += dp->drv.p->font_height)
     {
-        uint32_t *attr = kk->c->attr + line * kk->c->width;
+        uint32_t *attr = dp->cv->attr + line * dp->cv->width;
 
-        for(x = 0; x < kk->drv.p->width; x += kk->drv.p->font_width)
+        for(x = 0; x < dp->drv.p->width; x += dp->drv.p->font_width)
         {
             uint16_t bg = _cucul_argb32_to_rgb12bg(*attr++);
             glDisable(GL_TEXTURE_2D);
@@ -238,10 +238,10 @@ static void gl_display(caca_t *kk)
                       (bg & 0x00f) * 8);
             glBegin(GL_QUADS);
                 glVertex2f(x, y);
-                glVertex2f(x + kk->drv.p->font_width, y);
-                glVertex2f(x + kk->drv.p->font_width,
-                           y + kk->drv.p->font_height);
-                glVertex2f(x, y + kk->drv.p->font_height);
+                glVertex2f(x + dp->drv.p->font_width, y);
+                glVertex2f(x + dp->drv.p->font_width,
+                           y + dp->drv.p->font_height);
+                glVertex2f(x, y + dp->drv.p->font_height);
             glEnd();
         }
 
@@ -254,32 +254,32 @@ static void gl_display(caca_t *kk)
     glBlendFunc(GL_ONE, GL_ONE);
 
     line = 0;
-    for(y = 0; y < kk->drv.p->height; y += kk->drv.p->font_height)
+    for(y = 0; y < dp->drv.p->height; y += dp->drv.p->font_height)
     {
-        uint32_t *attr = kk->c->attr + line * kk->c->width;
-        uint32_t *chars = kk->c->chars + line * kk->c->width;
+        uint32_t *attr = dp->cv->attr + line * dp->cv->width;
+        uint32_t *chars = dp->cv->chars + line * dp->cv->width;
 
-        for(x = 0; x < kk->drv.p->width; x += kk->drv.p->font_width)
+        for(x = 0; x < dp->drv.p->width; x += dp->drv.p->font_width)
         {
-            uint32_t c = *chars++;
+            uint32_t cv = *chars++;
 
-            if(c > 0x00000020 && c < 0x00000080)
+            if(cv > 0x00000020 && cv < 0x00000080)
             {
                 uint16_t fg = _cucul_argb32_to_rgb12fg(*attr);
-                glBindTexture(GL_TEXTURE_2D, kk->drv.p->id[c - 32]);
+                glBindTexture(GL_TEXTURE_2D, dp->drv.p->id[cv - 32]);
                 glColor3b(((fg & 0xf00) >> 8) * 8,
                           ((fg & 0x0f0) >> 4) * 8,
                           (fg & 0x00f) * 8);
                 glBegin(GL_QUADS);
-                    glTexCoord2f(0, kk->drv.p->sh);
+                    glTexCoord2f(0, dp->drv.p->sh);
                     glVertex2f(x, y);
-                    glTexCoord2f(kk->drv.p->sw, kk->drv.p->sh);
-                    glVertex2f(x + kk->drv.p->font_width, y);
-                    glTexCoord2f(kk->drv.p->sw, 0);
-                    glVertex2f(x + kk->drv.p->font_width,
-                               y + kk->drv.p->font_height);
+                    glTexCoord2f(dp->drv.p->sw, dp->drv.p->sh);
+                    glVertex2f(x + dp->drv.p->font_width, y);
+                    glTexCoord2f(dp->drv.p->sw, 0);
+                    glVertex2f(x + dp->drv.p->font_width,
+                               y + dp->drv.p->font_height);
                     glTexCoord2f(0, 0);
-                    glVertex2f(x, y + kk->drv.p->font_height);
+                    glVertex2f(x, y + dp->drv.p->font_height);
                 glEnd();
             }
 
@@ -299,21 +299,21 @@ static void gl_display(caca_t *kk)
     glutPostRedisplay();
 }
 
-static void gl_handle_resize(caca_t *kk)
+static void gl_handle_resize(caca_display_t *dp)
 {
-    kk->drv.p->width = kk->drv.p->new_width;
-    kk->drv.p->height = kk->drv.p->new_height;
+    dp->drv.p->width = dp->drv.p->new_width;
+    dp->drv.p->height = dp->drv.p->new_height;
 
     glMatrixMode(GL_PROJECTION);
     glPushMatrix();
     glLoadIdentity();
 
-    glViewport(0, 0, kk->drv.p->width, kk->drv.p->height);
-    gluOrtho2D(0, kk->drv.p->width, kk->drv.p->height, 0);
+    glViewport(0, 0, dp->drv.p->width, dp->drv.p->height);
+    gluOrtho2D(0, dp->drv.p->width, dp->drv.p->height, 0);
     glMatrixMode(GL_MODELVIEW);
 }
 
-static int gl_get_event(caca_t *kk, caca_event_t *ev)
+static int gl_get_event(caca_display_t *dp, caca_event_t *ev)
 {
 #ifdef HAVE_GLUTCHECKLOOP
     glutCheckLoop();
@@ -322,54 +322,54 @@ static int gl_get_event(caca_t *kk, caca_event_t *ev)
 #endif
 
 #ifdef HAVE_GLUTCLOSEFUNC
-    if(kk->drv.p->close)
+    if(dp->drv.p->close)
     {
-        kk->drv.p->close = 0;
+        dp->drv.p->close = 0;
         ev->type = CACA_EVENT_QUIT;
         return 1;
     }
 #endif
 
-    if(kk->resize.resized)
+    if(dp->resize.resized)
     {
         ev->type = CACA_EVENT_RESIZE;
-        ev->data.resize.w = kk->c->width;
-        ev->data.resize.h = kk->c->height;
+        ev->data.resize.w = dp->cv->width;
+        ev->data.resize.h = dp->cv->height;
         return 1;
     }
 
-    if(kk->drv.p->mouse_changed)
+    if(dp->drv.p->mouse_changed)
     {
         ev->type = CACA_EVENT_MOUSE_MOTION;
-        ev->data.mouse.x = kk->mouse.x;
-        ev->data.mouse.y = kk->mouse.y;
-        kk->drv.p->mouse_changed = 0;
+        ev->data.mouse.x = dp->mouse.x;
+        ev->data.mouse.y = dp->mouse.y;
+        dp->drv.p->mouse_changed = 0;
 
-        if(kk->drv.p->mouse_clicked)
+        if(dp->drv.p->mouse_clicked)
         {
-            _push_event(kk, ev);
+            _push_event(dp, ev);
             ev->type = CACA_EVENT_MOUSE_PRESS;
-            ev->data.mouse.button = kk->drv.p->mouse_button;
-            kk->drv.p->mouse_clicked = 0;
+            ev->data.mouse.button = dp->drv.p->mouse_button;
+            dp->drv.p->mouse_clicked = 0;
         }
 
         return 1;
     }
 
-    if(kk->drv.p->key != 0)
+    if(dp->drv.p->key != 0)
     {
         ev->type = CACA_EVENT_KEY_PRESS;
-        ev->data.key.ch = kk->drv.p->key;
-        ev->data.key.ucs4 = (uint32_t)kk->drv.p->key;
-        ev->data.key.utf8[0] = kk->drv.p->key;
+        ev->data.key.ch = dp->drv.p->key;
+        ev->data.key.ucs4 = (uint32_t)dp->drv.p->key;
+        ev->data.key.utf8[0] = dp->drv.p->key;
         ev->data.key.utf8[1] = '\0';
-        kk->drv.p->key = 0;
+        dp->drv.p->key = 0;
         return 1;
     }
 
-    if(kk->drv.p->special_key != 0)
+    if(dp->drv.p->special_key != 0)
     {
-        switch(kk->drv.p->special_key)
+        switch(dp->drv.p->special_key)
         {
             case GLUT_KEY_F1 : ev->data.key.ch = CACA_KEY_F1; break;
             case GLUT_KEY_F2 : ev->data.key.ch = CACA_KEY_F2; break;
@@ -394,7 +394,7 @@ static int gl_get_event(caca_t *kk, caca_event_t *ev)
         ev->data.key.ucs4 = 0;
         ev->data.key.utf8[0] = '\0';
 
-        kk->drv.p->special_key = 0;
+        dp->drv.p->special_key = 0;
         return 1;
     }
 
@@ -403,7 +403,7 @@ static int gl_get_event(caca_t *kk, caca_event_t *ev)
 }
 
 
-static void gl_set_mouse(caca_t *kk, int flag)
+static void gl_set_mouse(caca_display_t *dp, int flag)
 {
     if(flag)
         glutSetCursor(GLUT_CURSOR_RIGHT_ARROW);
@@ -417,72 +417,72 @@ static void gl_set_mouse(caca_t *kk, int flag)
 
 static void gl_handle_keyboard(unsigned char key, int x, int y)
 {
-    caca_t *kk = gl_kk;
+    caca_display_t *dp = gl_d;
 
-    kk->drv.p->key = key;
+    dp->drv.p->key = key;
 }
 
 static void gl_handle_special_key(int key, int x, int y)
 {
-    caca_t *kk = gl_kk;
+    caca_display_t *dp = gl_d;
 
-    kk->drv.p->special_key = key;
+    dp->drv.p->special_key = key;
 }
 
 static void gl_handle_reshape(int w, int h)
 {
-    caca_t *kk = gl_kk;
+    caca_display_t *dp = gl_d;
 
-    if(kk->drv.p->bit) /* Do not handle reshaping at the first time */
+    if(dp->drv.p->bit) /* Do not handle reshaping at the first time */
     {
-        kk->drv.p->new_width = w;
-        kk->drv.p->new_height = h;
+        dp->drv.p->new_width = w;
+        dp->drv.p->new_height = h;
 
-        kk->resize.w = w / kk->drv.p->font_width;
-        kk->resize.h = (h / kk->drv.p->font_height) + 1;
+        dp->resize.w = w / dp->drv.p->font_width;
+        dp->resize.h = (h / dp->drv.p->font_height) + 1;
 
-        kk->resize.resized = 1;
+        dp->resize.resized = 1;
     }
     else
-        kk->drv.p->bit = 1;
+        dp->drv.p->bit = 1;
 }
 
 static void gl_handle_mouse(int button, int state, int x, int y)
 {
-    caca_t *kk = gl_kk;
-
-    kk->drv.p->mouse_clicked = 1;
-    kk->drv.p->mouse_button = button;
-    kk->drv.p->mouse_state = state;
-    kk->drv.p->mouse_x = x / kk->drv.p->font_width;
-    kk->drv.p->mouse_y = y / kk->drv.p->font_height;
-    kk->mouse.x = kk->drv.p->mouse_x;
-    kk->mouse.y = kk->drv.p->mouse_y;
-    kk->drv.p->mouse_changed = 1;
+    caca_display_t *dp = gl_d;
+
+    dp->drv.p->mouse_clicked = 1;
+    dp->drv.p->mouse_button = button;
+    dp->drv.p->mouse_state = state;
+    dp->drv.p->mouse_x = x / dp->drv.p->font_width;
+    dp->drv.p->mouse_y = y / dp->drv.p->font_height;
+    dp->mouse.x = dp->drv.p->mouse_x;
+    dp->mouse.y = dp->drv.p->mouse_y;
+    dp->drv.p->mouse_changed = 1;
 }
 
 static void gl_handle_mouse_motion(int x, int y)
 {
-    caca_t *kk = gl_kk;
-    kk->drv.p->mouse_x = x / kk->drv.p->font_width;
-    kk->drv.p->mouse_y = y / kk->drv.p->font_height;
-    kk->mouse.x = kk->drv.p->mouse_x;
-    kk->mouse.y = kk->drv.p->mouse_y;
-    kk->drv.p->mouse_changed = 1;
+    caca_display_t *dp = gl_d;
+    dp->drv.p->mouse_x = x / dp->drv.p->font_width;
+    dp->drv.p->mouse_y = y / dp->drv.p->font_height;
+    dp->mouse.x = dp->drv.p->mouse_x;
+    dp->mouse.y = dp->drv.p->mouse_y;
+    dp->drv.p->mouse_changed = 1;
 }
 
 #ifdef HAVE_GLUTCLOSEFUNC
 static void gl_handle_close(void)
 {
-    caca_t *kk = gl_kk;
-    kk->drv.p->close = 1;
+    caca_display_t *dp = gl_d;
+    dp->drv.p->close = 1;
 }
 #endif
 
 static void _display(void)
 {
-    caca_t *kk = gl_kk;
-    gl_display(kk);
+    caca_display_t *dp = gl_d;
+    gl_display(dp);
 }
 
 
@@ -490,24 +490,24 @@ static void _display(void)
  * Driver initialisation
  */
 
-int gl_install(caca_t *kk)
+int gl_install(caca_display_t *dp)
 {
 #if defined(HAVE_GETENV) && defined(GLUT_XLIB_IMPLEMENTATION)
     if(!getenv("DISPLAY") || !*(getenv("DISPLAY")))
         return -1;
 #endif
 
-    kk->drv.driver = CACA_DRIVER_GL;
-
-    kk->drv.init_graphics = gl_init_graphics;
-    kk->drv.end_graphics = gl_end_graphics;
-    kk->drv.set_window_title = gl_set_window_title;
-    kk->drv.get_window_width = gl_get_window_width;
-    kk->drv.get_window_height = gl_get_window_height;
-    kk->drv.display = gl_display;
-    kk->drv.handle_resize = gl_handle_resize;
-    kk->drv.get_event = gl_get_event;
-    kk->drv.set_mouse = gl_set_mouse;
+    dp->drv.driver = CACA_DRIVER_GL;
+
+    dp->drv.init_graphics = gl_init_graphics;
+    dp->drv.end_graphics = gl_end_graphics;
+    dp->drv.set_window_title = gl_set_window_title;
+    dp->drv.get_window_width = gl_get_window_width;
+    dp->drv.get_window_height = gl_get_window_height;
+    dp->drv.display = gl_display;
+    dp->drv.handle_resize = gl_handle_resize;
+    dp->drv.get_event = gl_get_event;
+    dp->drv.set_mouse = gl_set_mouse;
 
     return 0;
 }

caca/driver_ncurses.c

@@ -50,7 +50,7 @@
 
 #if defined(HAVE_SIGNAL)
 static RETSIGTYPE sigwinch_handler(int);
-static caca_t *sigwinch_kk; /* FIXME: we ought to get rid of this */
+static caca_display_t *sigwinch_d; /* FIXME: we ought to get rid of this */
 #endif
 #if defined(HAVE_GETENV) && defined(HAVE_PUTENV)
 static void ncurses_check_terminal(void);
@@ -63,7 +63,7 @@ struct driver_private
     mmask_t oldmask;
 };
 
-static int ncurses_init_graphics(caca_t *kk)
+static int ncurses_init_graphics(caca_display_t *dp)
 {
     static int curses_colors[] =
     {
@@ -90,14 +90,14 @@ static int ncurses_init_graphics(caca_t *kk)
     mmask_t newmask;
     int fg, bg, max;
 
-    kk->drv.p = malloc(sizeof(struct driver_private));
+    dp->drv.p = malloc(sizeof(struct driver_private));
 
 #if defined(HAVE_GETENV) && defined(HAVE_PUTENV)
     ncurses_check_terminal();
 #endif
 
 #if defined(HAVE_SIGNAL)
-    sigwinch_kk = kk;
+    sigwinch_d = dp;
     signal(SIGWINCH, sigwinch_handler);
 #endif
 
@@ -111,7 +111,7 @@ static int ncurses_init_graphics(caca_t *kk)
 
     /* Activate mouse */
     newmask = REPORT_MOUSE_POSITION | ALL_MOUSE_EVENTS;
-    mousemask(newmask, &kk->drv.p->oldmask);
+    mousemask(newmask, &dp->drv.p->oldmask);
     mouseinterval(-1); /* No click emulation */
 
     /* Set the escape delay to a ridiculously low value */
@@ -136,95 +136,95 @@ static int ncurses_init_graphics(caca_t *kk)
              * colour pair to be redefined. */
             int col = ((max + 7 - fg) % max) + max * bg;
             init_pair(col, curses_colors[fg], curses_colors[bg]);
-            kk->drv.p->attr[fg + 16 * bg] = COLOR_PAIR(col);
+            dp->drv.p->attr[fg + 16 * bg] = COLOR_PAIR(col);
 
             if(max == 8)
             {
                 /* Bright fg on simple bg */
-                kk->drv.p->attr[fg + 8 + 16 * bg] = A_BOLD | COLOR_PAIR(col);
+                dp->drv.p->attr[fg + 8 + 16 * bg] = A_BOLD | COLOR_PAIR(col);
                 /* Simple fg on bright bg */
-                kk->drv.p->attr[fg + 16 * (bg + 8)] = A_BLINK
+                dp->drv.p->attr[fg + 16 * (bg + 8)] = A_BLINK
                                                     | COLOR_PAIR(col);
                 /* Bright fg on bright bg */
-                kk->drv.p->attr[fg + 8 + 16 * (bg + 8)] = A_BLINK | A_BOLD
+                dp->drv.p->attr[fg + 8 + 16 * (bg + 8)] = A_BLINK | A_BOLD
                                                         | COLOR_PAIR(col);
             }
         }
 
-    _cucul_set_size(kk->c, COLS, LINES);
+    _cucul_set_size(dp->cv, COLS, LINES);
 
     return 0;
 }
 
-static int ncurses_end_graphics(caca_t *kk)
+static int ncurses_end_graphics(caca_display_t *dp)
 {
-    mousemask(kk->drv.p->oldmask, NULL);
+    mousemask(dp->drv.p->oldmask, NULL);
     curs_set(1);
     noraw();
     endwin();
 
-    free(kk->drv.p);
+    free(dp->drv.p);
 
     return 0;
 }
 
-static int ncurses_set_window_title(caca_t *kk, char const *title)
+static int ncurses_set_window_title(caca_display_t *dp, char const *title)
 {
     return 0;
 }
 
-static unsigned int ncurses_get_window_width(caca_t *kk)
+static unsigned int ncurses_get_window_width(caca_display_t *dp)
 {
     /* Fallback to a 6x10 font */
-    return kk->c->width * 6;
+    return dp->cv->width * 6;
 }
 
-static unsigned int ncurses_get_window_height(caca_t *kk)
+static unsigned int ncurses_get_window_height(caca_display_t *dp)
 {
     /* Fallback to a 6x10 font */
-    return kk->c->height * 10;
+    return dp->cv->height * 10;
 }
 
-static void ncurses_display(caca_t *kk)
+static void ncurses_display(caca_display_t *dp)
 {
     int x, y;
-    uint32_t *attr = kk->c->attr;
-    uint32_t *chars = kk->c->chars;
-    for(y = 0; y < (int)kk->c->height; y++)
+    uint32_t *attr = dp->cv->attr;
+    uint32_t *chars = dp->cv->chars;
+    for(y = 0; y < (int)dp->cv->height; y++)
     {
         move(y, 0);
-        for(x = kk->c->width; x--; )
+        for(x = dp->cv->width; x--; )
         {
-            attrset(kk->drv.p->attr[_cucul_argb32_to_ansi8(*attr++)]);
+            attrset(dp->drv.p->attr[_cucul_argb32_to_ansi8(*attr++)]);
             ncurses_write_utf32(*chars++);
         }
     }
     refresh();
 }
 
-static void ncurses_handle_resize(caca_t *kk)
+static void ncurses_handle_resize(caca_display_t *dp)
 {
     struct winsize size;
 
     if(ioctl(fileno(stdout), TIOCGWINSZ, &size) == 0)
     {
-        kk->resize.w = size.ws_col;
-        kk->resize.h = size.ws_row;
+        dp->resize.w = size.ws_col;
+        dp->resize.h = size.ws_row;
 #if defined(HAVE_RESIZE_TERM)
-        resize_term(kk->resize.h, kk->resize.w);
+        resize_term(dp->resize.h, dp->resize.w);
 #else
-        resizeterm(*kk->resize.h, *kk->resize.w);
+        resizeterm(*dp->resize.h, *dp->resize.w);
 #endif
         wrefresh(curscr);
         return;
     }
 
     /* Fallback */
-    kk->resize.w = kk->c->width;
-    kk->resize.h = kk->c->height;
+    dp->resize.w = dp->cv->width;
+    dp->resize.h = dp->cv->height;
 }
 
-static int ncurses_get_event(caca_t *kk, caca_event_t *ev)
+static int ncurses_get_event(caca_display_t *dp, caca_event_t *ev)
 {
     int intkey;
 
@@ -251,128 +251,128 @@ static int ncurses_get_event(caca_t *kk, caca_event_t *ev)
         {
             case BUTTON1_PRESSED:
                 ev->data.mouse.button = 1;
-                ev->type = CACA_EVENT_MOUSE_PRESS; _push_event(kk, ev);
+                ev->type = CACA_EVENT_MOUSE_PRESS; _push_event(dp, ev);
                 break;
             case BUTTON1_RELEASED:
                 ev->data.mouse.button = 1;
-                ev->type = CACA_EVENT_MOUSE_RELEASE; _push_event(kk, ev);
+                ev->type = CACA_EVENT_MOUSE_RELEASE; _push_event(dp, ev);
                 break;
             case BUTTON1_CLICKED:
                 ev->data.mouse.button = 1;
-                ev->type = CACA_EVENT_MOUSE_PRESS; _push_event(kk, ev);
-                ev->type = CACA_EVENT_MOUSE_RELEASE; _push_event(kk, ev);
+                ev->type = CACA_EVENT_MOUSE_PRESS; _push_event(dp, ev);
+                ev->type = CACA_EVENT_MOUSE_RELEASE; _push_event(dp, ev);
                 break;
             case BUTTON1_DOUBLE_CLICKED:
                 ev->data.mouse.button = 1;
-                ev->type = CACA_EVENT_MOUSE_PRESS; _push_event(kk, ev);
-                ev->type = CACA_EVENT_MOUSE_RELEASE; _push_event(kk, ev);
-                ev->type = CACA_EVENT_MOUSE_PRESS; _push_event(kk, ev);
-                ev->type = CACA_EVENT_MOUSE_RELEASE; _push_event(kk, ev);
+                ev->type = CACA_EVENT_MOUSE_PRESS; _push_event(dp, ev);
+                ev->type = CACA_EVENT_MOUSE_RELEASE; _push_event(dp, ev);
+                ev->type = CACA_EVENT_MOUSE_PRESS; _push_event(dp, ev);
+                ev->type = CACA_EVENT_MOUSE_RELEASE; _push_event(dp, ev);
                 break;
             case BUTTON1_TRIPLE_CLICKED:
                 ev->data.mouse.button = 1;
-                ev->type = CACA_EVENT_MOUSE_PRESS; _push_event(kk, ev);
-                ev->type = CACA_EVENT_MOUSE_RELEASE; _push_event(kk, ev);
-                ev->type = CACA_EVENT_MOUSE_PRESS; _push_event(kk, ev);
-                ev->type = CACA_EVENT_MOUSE_RELEASE; _push_event(kk, ev);
-                ev->type = CACA_EVENT_MOUSE_PRESS; _push_event(kk, ev);
-                ev->type = CACA_EVENT_MOUSE_RELEASE; _push_event(kk, ev);
+                ev->type = CACA_EVENT_MOUSE_PRESS; _push_event(dp, ev);
+                ev->type = CACA_EVENT_MOUSE_RELEASE; _push_event(dp, ev);
+                ev->type = CACA_EVENT_MOUSE_PRESS; _push_event(dp, ev);
+                ev->type = CACA_EVENT_MOUSE_RELEASE; _push_event(dp, ev);
+                ev->type = CACA_EVENT_MOUSE_PRESS; _push_event(dp, ev);
+                ev->type = CACA_EVENT_MOUSE_RELEASE; _push_event(dp, ev);
                 break;
             case BUTTON1_RESERVED_EVENT:
                 break;
 
             case BUTTON2_PRESSED:
                 ev->data.mouse.button = 2;
-                ev->type = CACA_EVENT_MOUSE_PRESS; _push_event(kk, ev);
+                ev->type = CACA_EVENT_MOUSE_PRESS; _push_event(dp, ev);
                 break;
             case BUTTON2_RELEASED:
                 ev->data.mouse.button = 2;
-                ev->type = CACA_EVENT_MOUSE_RELEASE; _push_event(kk, ev);
+                ev->type = CACA_EVENT_MOUSE_RELEASE; _push_event(dp, ev);
                 break;
             case BUTTON2_CLICKED:
                 ev->data.mouse.button = 2;
-                ev->type = CACA_EVENT_MOUSE_PRESS; _push_event(kk, ev);
-                ev->type = CACA_EVENT_MOUSE_RELEASE; _push_event(kk, ev);
+                ev->type = CACA_EVENT_MOUSE_PRESS; _push_event(dp, ev);
+                ev->type = CACA_EVENT_MOUSE_RELEASE; _push_event(dp, ev);
                 break;
             case BUTTON2_DOUBLE_CLICKED:
                 ev->data.mouse.button = 2;
-                ev->type = CACA_EVENT_MOUSE_PRESS; _push_event(kk, ev);
-                ev->type = CACA_EVENT_MOUSE_RELEASE; _push_event(kk, ev);
-                ev->type = CACA_EVENT_MOUSE_PRESS; _push_event(kk, ev);
-                ev->type = CACA_EVENT_MOUSE_RELEASE; _push_event(kk, ev);
+                ev->type = CACA_EVENT_MOUSE_PRESS; _push_event(dp, ev);
+                ev->type = CACA_EVENT_MOUSE_RELEASE; _push_event(dp, ev);
+                ev->type = CACA_EVENT_MOUSE_PRESS; _push_event(dp, ev);
+                ev->type = CACA_EVENT_MOUSE_RELEASE; _push_event(dp, ev);
                 break;
             case BUTTON2_TRIPLE_CLICKED:
                 ev->data.mouse.button = 2;
-                ev->type = CACA_EVENT_MOUSE_PRESS; _push_event(kk, ev);
-                ev->type = CACA_EVENT_MOUSE_RELEASE; _push_event(kk, ev);
-                ev->type = CACA_EVENT_MOUSE_PRESS; _push_event(kk, ev);
-                ev->type = CACA_EVENT_MOUSE_RELEASE; _push_event(kk, ev);
-                ev->type = CACA_EVENT_MOUSE_PRESS; _push_event(kk, ev);
-                ev->type = CACA_EVENT_MOUSE_RELEASE; _push_event(kk, ev);
+                ev->type = CACA_EVENT_MOUSE_PRESS; _push_event(dp, ev);
+                ev->type = CACA_EVENT_MOUSE_RELEASE; _push_event(dp, ev);
+                ev->type = CACA_EVENT_MOUSE_PRESS; _push_event(dp, ev);
+                ev->type = CACA_EVENT_MOUSE_RELEASE; _push_event(dp, ev);
+                ev->type = CACA_EVENT_MOUSE_PRESS; _push_event(dp, ev);
+                ev->type = CACA_EVENT_MOUSE_RELEASE; _push_event(dp, ev);
                 break;
             case BUTTON2_RESERVED_EVENT:
                 break;
 
             case BUTTON3_PRESSED:
                 ev->data.mouse.button = 3;
-                ev->type = CACA_EVENT_MOUSE_PRESS; _push_event(kk, ev);
+                ev->type = CACA_EVENT_MOUSE_PRESS; _push_event(dp, ev);
                 break;
             case BUTTON3_RELEASED:
                 ev->data.mouse.button = 3;
-                ev->type = CACA_EVENT_MOUSE_RELEASE; _push_event(kk, ev);
+                ev->type = CACA_EVENT_MOUSE_RELEASE; _push_event(dp, ev);
                 break;
             case BUTTON3_CLICKED:
                 ev->data.mouse.button = 3;
-                ev->type = CACA_EVENT_MOUSE_PRESS; _push_event(kk, ev);
-                ev->type = CACA_EVENT_MOUSE_RELEASE; _push_event(kk, ev);
+                ev->type = CACA_EVENT_MOUSE_PRESS; _push_event(dp, ev);
+                ev->type = CACA_EVENT_MOUSE_RELEASE; _push_event(dp, ev);
                 break;
             case BUTTON3_DOUBLE_CLICKED:
                 ev->data.mouse.button = 3;
-                ev->type = CACA_EVENT_MOUSE_PRESS; _push_event(kk, ev);
-                ev->type = CACA_EVENT_MOUSE_RELEASE; _push_event(kk, ev);
-                ev->type = CACA_EVENT_MOUSE_PRESS; _push_event(kk, ev);
-                ev->type = CACA_EVENT_MOUSE_RELEASE; _push_event(kk, ev);
+                ev->type = CACA_EVENT_MOUSE_PRESS; _push_event(dp, ev);
+                ev->type = CACA_EVENT_MOUSE_RELEASE; _push_event(dp, ev);
+                ev->type = CACA_EVENT_MOUSE_PRESS; _push_event(dp, ev);
+                ev->type = CACA_EVENT_MOUSE_RELEASE; _push_event(dp, ev);
                 break;
             case BUTTON3_TRIPLE_CLICKED:
                 ev->data.mouse.button = 3;
-                ev->type = CACA_EVENT_MOUSE_PRESS; _push_event(kk, ev);
-                ev->type = CACA_EVENT_MOUSE_RELEASE; _push_event(kk, ev);
-                ev->type = CACA_EVENT_MOUSE_PRESS; _push_event(kk, ev);
-                ev->type = CACA_EVENT_MOUSE_RELEASE; _push_event(kk, ev);
-                ev->type = CACA_EVENT_MOUSE_PRESS; _push_event(kk, ev);
-                ev->type = CACA_EVENT_MOUSE_RELEASE; _push_event(kk, ev);
+                ev->type = CACA_EVENT_MOUSE_PRESS; _push_event(dp, ev);
+                ev->type = CACA_EVENT_MOUSE_RELEASE; _push_event(dp, ev);
+                ev->type = CACA_EVENT_MOUSE_PRESS; _push_event(dp, ev);
+                ev->type = CACA_EVENT_MOUSE_RELEASE; _push_event(dp, ev);
+                ev->type = CACA_EVENT_MOUSE_PRESS; _push_event(dp, ev);
+                ev->type = CACA_EVENT_MOUSE_RELEASE; _push_event(dp, ev);
                 break;
             case BUTTON3_RESERVED_EVENT:
                 break;
 
             case BUTTON4_PRESSED:
                 ev->data.mouse.button = 4;
-                ev->type = CACA_EVENT_MOUSE_PRESS; _push_event(kk, ev);
+                ev->type = CACA_EVENT_MOUSE_PRESS; _push_event(dp, ev);
                 break;
             case BUTTON4_RELEASED:
                 ev->data.mouse.button = 4;
-                ev->type = CACA_EVENT_MOUSE_RELEASE; _push_event(kk, ev);
+                ev->type = CACA_EVENT_MOUSE_RELEASE; _push_event(dp, ev);
                 break;
             case BUTTON4_CLICKED:
                 ev->data.mouse.button = 4;
-                ev->type = CACA_EVENT_MOUSE_PRESS; _push_event(kk, ev);
-                ev->type = CACA_EVENT_MOUSE_RELEASE; _push_event(kk, ev);
+                ev->type = CACA_EVENT_MOUSE_PRESS; _push_event(dp, ev);
+                ev->type = CACA_EVENT_MOUSE_RELEASE; _push_event(dp, ev);
                 break;
             case BUTTON4_DOUBLE_CLICKED:
                 ev->data.mouse.button = 4;
-                ev->type = CACA_EVENT_MOUSE_PRESS; _push_event(kk, ev);
-                ev->type = CACA_EVENT_MOUSE_RELEASE; _push_event(kk, ev);
-                ev->type = CACA_EVENT_MOUSE_PRESS; _push_event(kk, ev);
-                ev->type = CACA_EVENT_MOUSE_RELEASE; _push_event(kk, ev);
+                ev->type = CACA_EVENT_MOUSE_PRESS; _push_event(dp, ev);
+                ev->type = CACA_EVENT_MOUSE_RELEASE; _push_event(dp, ev);
+                ev->type = CACA_EVENT_MOUSE_PRESS; _push_event(dp, ev);
+                ev->type = CACA_EVENT_MOUSE_RELEASE; _push_event(dp, ev);
                 break;
             case BUTTON4_TRIPLE_CLICKED:
                 ev->data.mouse.button = 4;
-                ev->type = CACA_EVENT_MOUSE_PRESS; _push_event(kk, ev);
-                ev->type = CACA_EVENT_MOUSE_RELEASE; _push_event(kk, ev);
-                ev->type = CACA_EVENT_MOUSE_PRESS; _push_event(kk, ev);
-                ev->type = CACA_EVENT_MOUSE_RELEASE; _push_event(kk, ev);
-                ev->type = CACA_EVENT_MOUSE_PRESS; _push_event(kk, ev);
-                ev->type = CACA_EVENT_MOUSE_RELEASE; _push_event(kk, ev);
+                ev->type = CACA_EVENT_MOUSE_PRESS; _push_event(dp, ev);
+                ev->type = CACA_EVENT_MOUSE_RELEASE; _push_event(dp, ev);
+                ev->type = CACA_EVENT_MOUSE_PRESS; _push_event(dp, ev);
+                ev->type = CACA_EVENT_MOUSE_RELEASE; _push_event(dp, ev);
+                ev->type = CACA_EVENT_MOUSE_PRESS; _push_event(dp, ev);
+                ev->type = CACA_EVENT_MOUSE_RELEASE; _push_event(dp, ev);
                 break;
             case BUTTON4_RESERVED_EVENT:
                 break;
@@ -381,16 +381,16 @@ static int ncurses_get_event(caca_t *kk, caca_event_t *ev)
                 break;
         }
 
-        if(kk->mouse.x == (unsigned int)mevent.x &&
-           kk->mouse.y == (unsigned int)mevent.y)
-            return _pop_event(kk, ev);
+        if(dp->mouse.x == (unsigned int)mevent.x &&
+           dp->mouse.y == (unsigned int)mevent.y)
+            return _pop_event(dp, ev);
 
-        kk->mouse.x = mevent.x;
-        kk->mouse.y = mevent.y;
+        dp->mouse.x = mevent.x;
+        dp->mouse.y = mevent.y;
 
         ev->type = CACA_EVENT_MOUSE_MOTION;
-        ev->data.mouse.x = kk->mouse.x;
-        ev->data.mouse.y = kk->mouse.y;
+        ev->data.mouse.x = dp->mouse.x;
+        ev->data.mouse.y = dp->mouse.y;
         return 1;
     }
 
@@ -437,7 +437,7 @@ static int ncurses_get_event(caca_t *kk, caca_event_t *ev)
 #if defined(HAVE_SIGNAL)
 static RETSIGTYPE sigwinch_handler(int sig)
 {
-    sigwinch_kk->resize.resized = 1;
+    sigwinch_d->resize.resized = 1;
 
     signal(SIGWINCH, sigwinch_handler);
 }
@@ -481,7 +481,7 @@ static void ncurses_check_terminal(void)
 }
 #endif
 
-static void ncurses_write_utf32(uint32_t c)
+static void ncurses_write_utf32(uint32_t ch)
 {
 #if defined(HAVE_NCURSESW_NCURSES_H)
     static const uint8_t mark[7] =
@@ -493,30 +493,30 @@ static void ncurses_write_utf32(uint32_t c)
     int bytes;
 #endif
 
-    if(c < 0x80)
+    if(ch < 0x80)
     {
-        addch(c);
+        addch(ch);
         return;
     }
 
 #if defined(HAVE_NCURSESW_NCURSES_H)
-    if(c < 0x10000)
+    if(ch < 0x10000)
     {
-        addch(c); /* FIXME: doesn't work either */
+        addch(ch); /* FIXME: doesn't work either */
         return;
     }
 
-    bytes = (c < 0x800) ? 2 : (c < 0x10000) ? 3 : 4;
+    bytes = (ch < 0x800) ? 2 : (ch < 0x10000) ? 3 : 4;
     buf[bytes] = '\0';
     parser = buf + bytes;
 
     switch(bytes)
     {
-        case 4: *--parser = (c | 0x80) & 0xbf; c >>= 6;
-        case 3: *--parser = (c | 0x80) & 0xbf; c >>= 6;
-        case 2: *--parser = (c | 0x80) & 0xbf; c >>= 6;
+        case 4: *--parser = (ch | 0x80) & 0xbf; ch >>= 6;
+        case 3: *--parser = (ch | 0x80) & 0xbf; ch >>= 6;
+        case 2: *--parser = (ch | 0x80) & 0xbf; ch >>= 6;
     }
-    *--parser = c | mark[bytes];
+    *--parser = ch | mark[bytes];
 
     addstr(buf);
 #else
@@ -528,19 +528,19 @@ static void ncurses_write_utf32(uint32_t c)
  * Driver initialisation
  */
 
-int ncurses_install(caca_t *kk)
+int ncurses_install(caca_display_t *dp)
 {
-    kk->drv.driver = CACA_DRIVER_NCURSES;
-
-    kk->drv.init_graphics = ncurses_init_graphics;
-    kk->drv.end_graphics = ncurses_end_graphics;
-    kk->drv.set_window_title = ncurses_set_window_title;
-    kk->drv.get_window_width = ncurses_get_window_width;
-    kk->drv.get_window_height = ncurses_get_window_height;
-    kk->drv.display = ncurses_display;
-    kk->drv.handle_resize = ncurses_handle_resize;
-    kk->drv.get_event = ncurses_get_event;
-    kk->drv.set_mouse = NULL;
+    dp->drv.driver = CACA_DRIVER_NCURSES;
+
+    dp->drv.init_graphics = ncurses_init_graphics;
+    dp->drv.end_graphics = ncurses_end_graphics;
+    dp->drv.set_window_title = ncurses_set_window_title;
+    dp->drv.get_window_width = ncurses_get_window_width;
+    dp->drv.get_window_height = ncurses_get_window_height;
+    dp->drv.display = ncurses_display;
+    dp->drv.handle_resize = ncurses_handle_resize;
+    dp->drv.get_event = ncurses_get_event;
+    dp->drv.set_mouse = NULL;
 
     return 0;
 }

caca/driver_raw.c

@@ -26,52 +26,52 @@
 #include "cucul.h"
 #include "cucul_internals.h"
 
-static int raw_init_graphics(caca_t *kk)
+static int raw_init_graphics(caca_display_t *dp)
 {
     return 0;
 }
 
-static int raw_end_graphics(caca_t *kk)
+static int raw_end_graphics(caca_display_t *dp)
 {
     return 0;
 }
 
-static int raw_set_window_title(caca_t *kk, char const *title)
+static int raw_set_window_title(caca_display_t *dp, char const *title)
 {
     return 0;
 }
 
-static unsigned int raw_get_window_width(caca_t *kk)
+static unsigned int raw_get_window_width(caca_display_t *dp)
 {
     return 0;
 }
 
-static unsigned int raw_get_window_height(caca_t *kk)
+static unsigned int raw_get_window_height(caca_display_t *dp)
 {
     return 0;
 }
 
-static void raw_display(caca_t *kk)
+static void raw_display(caca_display_t *dp)
 {
-    uint32_t *attr = kk->c->attr;
-    uint32_t *chars = kk->c->chars;
+    uint32_t *attr = dp->cv->attr;
+    uint32_t *chars = dp->cv->chars;
     uint32_t w, h;
     unsigned int n;
 
-    w = kk->c->width;
-    h = kk->c->height;
+    w = dp->cv->width;
+    h = dp->cv->height;
 
     fprintf(stdout, "CACA%c%c%c%c%c%c%c%c",
                     (w >> 24), (w >> 16) & 0xff, (w >> 8) & 0xff, w & 0xff,
                     (h >> 24), (h >> 16) & 0xff, (h >> 8) & 0xff, h & 0xff);
 
-    for(n = kk->c->height * kk->c->width; n--; )
+    for(n = dp->cv->height * dp->cv->width; n--; )
     {
-        uint32_t c = *chars++;
+        uint32_t ch = *chars++;
         uint32_t a = *attr++;
 
         fprintf(stdout, "%c%c%c%c%c%c%c%c",
-                (c >> 24), (c >> 16) & 0xff, (c >> 8) & 0xff, c & 0xff,
+                (ch >> 24), (ch >> 16) & 0xff, (ch >> 8) & 0xff, ch & 0xff,
                 (a >> 24), (a >> 16) & 0xff, (a >> 8) & 0xff, a & 0xff);
     }
 
@@ -79,12 +79,12 @@ static void raw_display(caca_t *kk)
     fflush(stdout);
 }
 
-static void raw_handle_resize(caca_t *kk)
+static void raw_handle_resize(caca_display_t *dp)
 {
     ;
 }
 
-static int raw_get_event(caca_t *kk, caca_event_t *ev)
+static int raw_get_event(caca_display_t *dp, caca_event_t *ev)
 {
     ev->type = CACA_EVENT_NONE;
     return 0;
@@ -94,19 +94,19 @@ static int raw_get_event(caca_t *kk, caca_event_t *ev)
  * Driver initialisation
  */
 
-int raw_install(caca_t *kk)
+int raw_install(caca_display_t *dp)
 {
-    kk->drv.driver = CACA_DRIVER_RAW;
-
-    kk->drv.init_graphics = raw_init_graphics;
-    kk->drv.end_graphics = raw_end_graphics;
-    kk->drv.set_window_title = raw_set_window_title;
-    kk->drv.get_window_width = raw_get_window_width;
-    kk->drv.get_window_height = raw_get_window_height;
-    kk->drv.display = raw_display;
-    kk->drv.handle_resize = raw_handle_resize;
-    kk->drv.get_event = raw_get_event;
-    kk->drv.set_mouse = NULL;
+    dp->drv.driver = CACA_DRIVER_RAW;
+
+    dp->drv.init_graphics = raw_init_graphics;
+    dp->drv.end_graphics = raw_end_graphics;
+    dp->drv.set_window_title = raw_set_window_title;
+    dp->drv.get_window_width = raw_get_window_width;
+    dp->drv.get_window_height = raw_get_window_height;
+    dp->drv.display = raw_display;
+    dp->drv.handle_resize = raw_handle_resize;
+    dp->drv.get_event = raw_get_event;
+    dp->drv.set_mouse = NULL;
 
     return 0;
 }

caca/driver_slang.c

@@ -106,20 +106,20 @@ static void slang_write_utf32(uint32_t);
 
 #if defined(HAVE_SIGNAL)
 static RETSIGTYPE sigwinch_handler(int);
-static caca_t *sigwinch_kk; /* FIXME: we ought to get rid of this */
+static caca_display_t *sigwinch_d; /* FIXME: we ought to get rid of this */
 #endif
 #if defined(HAVE_GETENV) && defined(HAVE_PUTENV)
 static void slang_check_terminal(void);
 #endif
 
-static int slang_init_graphics(caca_t *kk)
+static int slang_init_graphics(caca_display_t *dp)
 {
 #if defined(HAVE_GETENV) && defined(HAVE_PUTENV)
     slang_check_terminal();
 #endif
 
 #if defined(HAVE_SIGNAL)
-    sigwinch_kk = kk;
+    sigwinch_d = dp;
     signal(SIGWINCH, sigwinch_handler);
 #endif
 
@@ -164,12 +164,12 @@ static int slang_init_graphics(caca_t *kk)
     SLtt_utf8_enable(1);
 #endif
 
-    _cucul_set_size(kk->c, SLtt_Screen_Cols, SLtt_Screen_Rows);
+    _cucul_set_size(dp->cv, SLtt_Screen_Cols, SLtt_Screen_Rows);
 
     return 0;
 }
 
-static int slang_end_graphics(caca_t *kk)
+static int slang_end_graphics(caca_display_t *dp)
 {
     SLtt_set_mouse_mode(0, 0);
     SLtt_set_cursor_visibility(1);
@@ -179,35 +179,35 @@ static int slang_end_graphics(caca_t *kk)
     return 0;
 }
 
-static int slang_set_window_title(caca_t *kk, char const *title)
+static int slang_set_window_title(caca_display_t *dp, char const *title)
 {
     /* FIXME */
     return 0;
 }
 
-static unsigned int slang_get_window_width(caca_t *kk)
+static unsigned int slang_get_window_width(caca_display_t *dp)
 {
     /* Fallback to a 6x10 font */
-    return kk->c->width * 6;
+    return dp->cv->width * 6;
 }
 
-static unsigned int slang_get_window_height(caca_t *kk)
+static unsigned int slang_get_window_height(caca_display_t *dp)
 {
     /* Fallback to a 6x10 font */
-    return kk->c->height * 10;
+    return dp->cv->height * 10;
 }
 
-static void slang_display(caca_t *kk)
+static void slang_display(caca_display_t *dp)
 {
     int x, y;
-    uint32_t *attr = kk->c->attr;
-    uint32_t *chars = kk->c->chars;
-    for(y = 0; y < (int)kk->c->height; y++)
+    uint32_t *attr = dp->cv->attr;
+    uint32_t *chars = dp->cv->chars;
+    for(y = 0; y < (int)dp->cv->height; y++)
     {
         SLsmg_gotorc(y, 0);
-        for(x = kk->c->width; x--; )
+        for(x = dp->cv->width; x--; )
         {
-            uint32_t c = *chars++;
+            uint32_t ch = *chars++;
 
 #if defined(OPTIMISE_SLANG_PALETTE)
             uint8_t fgcolor = _cucul_argb32_to_ansi4fg(*attr);
@@ -218,7 +218,7 @@ static void slang_display(caca_t *kk)
             if(fgcolor != bgcolor)
             {
                 SLsmg_set_color(slang_assoc[_cucul_argb32_to_ansi8(*attr++)]);
-                slang_write_utf32(c);
+                slang_write_utf32(ch);
             }
             else
             {
@@ -235,24 +235,24 @@ static void slang_display(caca_t *kk)
             }
 #else
             SLsmg_set_color(_cucul_argb32_to_ansi8(*attr++));
-            slang_write_utf32(c);
+            slang_write_utf32(ch);
 #endif
         }
     }
     SLsmg_refresh();
 }
 
-static void slang_handle_resize(caca_t *kk)
+static void slang_handle_resize(caca_display_t *dp)
 {
     SLtt_get_screen_size();
-    kk->resize.w = SLtt_Screen_Cols;
-    kk->resize.h = SLtt_Screen_Rows;
+    dp->resize.w = SLtt_Screen_Cols;
+    dp->resize.h = SLtt_Screen_Rows;
 
-    if(kk->resize.w != kk->c->width || kk->resize.h != kk->c->height)
+    if(dp->resize.w != dp->cv->width || dp->resize.h != dp->cv->height)
         SLsmg_reinit_smg();
 }
 
-static int slang_get_event(caca_t *kk, caca_event_t *ev)
+static int slang_get_event(caca_display_t *dp, caca_event_t *ev)
 {
     int intkey;
 
@@ -289,19 +289,19 @@ static int slang_get_event(caca_t *kk, caca_event_t *ev)
 
         ev->data.mouse.button = button;
         ev->type = CACA_EVENT_MOUSE_PRESS;
-        _push_event(kk, ev);
+        _push_event(dp, ev);
         ev->type = CACA_EVENT_MOUSE_RELEASE;
-        _push_event(kk, ev);
+        _push_event(dp, ev);
 
-        if(kk->mouse.x == x && kk->mouse.y == y)
-            return _pop_event(kk, ev);
+        if(dp->mouse.x == x && dp->mouse.y == y)
+            return _pop_event(dp, ev);
 
-        kk->mouse.x = x;
-        kk->mouse.y = y;
+        dp->mouse.x = x;
+        dp->mouse.y = y;
 
         ev->type = CACA_EVENT_MOUSE_MOTION;
-        ev->data.mouse.x = kk->mouse.x;
-        ev->data.mouse.y = kk->mouse.y;
+        ev->data.mouse.x = dp->mouse.x;
+        ev->data.mouse.y = dp->mouse.y;
         return 1;
     }
 
@@ -388,7 +388,7 @@ static void slang_init_palette(void)
 #endif
 }
 
-static void slang_write_utf32(uint32_t c)
+static void slang_write_utf32(uint32_t ch)
 {
 #ifdef HAVE_SLSMG_UTF8_ENABLE
     static const uint8_t mark[7] =
@@ -400,24 +400,24 @@ static void slang_write_utf32(uint32_t c)
     int bytes;
 #endif
 
-    if(c < 0x80)
+    if(ch < 0x80)
     {
-        SLsmg_write_char(c);
+        SLsmg_write_char(ch);
         return;
     }
 
 #ifdef HAVE_SLSMG_UTF8_ENABLE
-    bytes = (c < 0x800) ? 2 : (c < 0x10000) ? 3 : 4;
+    bytes = (ch < 0x800) ? 2 : (ch < 0x10000) ? 3 : 4;
     buf[bytes] = '\0';
     parser = buf + bytes;
 
     switch(bytes)
     {
-        case 4: *--parser = (c | 0x80) & 0xbf; c >>= 6;
-        case 3: *--parser = (c | 0x80) & 0xbf; c >>= 6;
-        case 2: *--parser = (c | 0x80) & 0xbf; c >>= 6;
+        case 4: *--parser = (ch | 0x80) & 0xbf; ch >>= 6;
+        case 3: *--parser = (ch | 0x80) & 0xbf; ch >>= 6;
+        case 2: *--parser = (ch | 0x80) & 0xbf; ch >>= 6;
     }
-    *--parser = c | mark[bytes];
+    *--parser = ch | mark[bytes];
 
     SLsmg_write_string(buf);
 #else
@@ -428,7 +428,7 @@ static void slang_write_utf32(uint32_t c)
 #if defined(HAVE_SIGNAL)
 static RETSIGTYPE sigwinch_handler(int sig)
 {
-    sigwinch_kk->resize.resized = 1;
+    sigwinch_d->resize.resized = 1;
 
     signal(SIGWINCH, sigwinch_handler);
 }
@@ -466,19 +466,19 @@ static void slang_check_terminal(void)
  * Driver initialisation
  */
 
-int slang_install(caca_t *kk)
+int slang_install(caca_display_t *dp)
 {
-    kk->drv.driver = CACA_DRIVER_SLANG;
-
-    kk->drv.init_graphics = slang_init_graphics;
-    kk->drv.end_graphics = slang_end_graphics;
-    kk->drv.set_window_title = slang_set_window_title;
-    kk->drv.get_window_width = slang_get_window_width;
-    kk->drv.get_window_height = slang_get_window_height;
-    kk->drv.display = slang_display;
-    kk->drv.handle_resize = slang_handle_resize;
-    kk->drv.get_event = slang_get_event;
-    kk->drv.set_mouse = NULL;
+    dp->drv.driver = CACA_DRIVER_SLANG;
+
+    dp->drv.init_graphics = slang_init_graphics;
+    dp->drv.end_graphics = slang_end_graphics;
+    dp->drv.set_window_title = slang_set_window_title;
+    dp->drv.get_window_width = slang_get_window_width;
+    dp->drv.get_window_height = slang_get_window_height;
+    dp->drv.display = slang_display;
+    dp->drv.handle_resize = slang_handle_resize;
+    dp->drv.get_event = slang_get_event;
+    dp->drv.set_mouse = NULL;
 
     return 0;
 }

caca/driver_vga.c

@@ -49,7 +49,7 @@ static uint8_t const vga_colors[][4] =
     { 0x3f,   0x3f, 0x3f, 0x3f },
 };
 
-static int vga_init_graphics(caca_t *kk)
+static int vga_init_graphics(caca_display_t *dp)
 {
     int i;
     uint8_t tmp;
@@ -74,12 +74,12 @@ static int vga_init_graphics(caca_t *kk)
     outb(tmp, 0x3d5);
 
     /* We don't have much choice */
-    _cucul_set_size(kk->c, 80, 25);
+    _cucul_set_size(dp->cv, 80, 25);
 
     return 0;
 }
 
-static int vga_end_graphics(caca_t *kk)
+static int vga_end_graphics(caca_display_t *dp)
 {
     uint8_t tmp;
 
@@ -93,46 +93,46 @@ static int vga_end_graphics(caca_t *kk)
     return 0;
 }
 
-static int vga_set_window_title(caca_t *kk, char const *title)
+static int vga_set_window_title(caca_display_t *dp, char const *title)
 {
     /* Unsupported, of course. */
     return 0;
 }
 
-static unsigned int vga_get_window_width(caca_t *kk)
+static unsigned int vga_get_window_width(caca_display_t *dp)
 {
     /* Fallback to a 320x200 screen */
     return 320;
 }
 
-static unsigned int vga_get_window_height(caca_t *kk)
+static unsigned int vga_get_window_height(caca_display_t *dp)
 {
     /* Fallback to a 320x200 screen */
     return 200;
 }
 
-static void vga_display(caca_t *kk)
+static void vga_display(caca_display_t *dp)
 {
     char *screen = (char *)(intptr_t)0x000b8000;
-    uint32_t *attr = kk->c->attr;
-    uint32_t *chars = kk->c->chars;
+    uint32_t *attr = dp->cv->attr;
+    uint32_t *chars = dp->cv->chars;
     int n;
 
-    for(n = kk->c->height * kk->c->width; n--; )
+    for(n = dp->cv->height * dp->cv->width; n--; )
     {
         *screen++ = _cucul_utf32_to_cp437(*chars++);
         *screen++ = _cucul_argb32_to_ansi8(*attr++);
     }
 }
 
-static void vga_handle_resize(caca_t *kk)
+static void vga_handle_resize(caca_display_t *dp)
 {
     /* We know nothing about our window */
-    kk->resize.w = kk->c->width;
-    kk->resize.h = kk->c->height;
+    dp->resize.w = dp->cv->width;
+    dp->resize.h = dp->cv->height;
 }
 
-static int vga_get_event(caca_t *kk, caca_event-t *ev)
+static int vga_get_event(caca_display_t *dp, caca_event-t *ev)
 {
     /* FIXME */
     ev->type = CACA_EVENT_NONE;
@@ -143,19 +143,19 @@ static int vga_get_event(caca_t *kk, caca_event-t *ev)
  * Driver initialisation
  */
 
-int vga_install(caca_t *kk)
+int vga_install(caca_display_t *dp)
 {
-    kk->drv.driver = CACA_DRIVER_VGA;
-
-    kk->drv.init_graphics = vga_init_graphics;
-    kk->drv.end_graphics = vga_end_graphics;
-    kk->drv.set_window_title = vga_set_window_title;
-    kk->drv.get_window_width = vga_get_window_width;
-    kk->drv.get_window_height = vga_get_window_height;
-    kk->drv.display = vga_display;
-    kk->drv.handle_resize = vga_handle_resize;
-    kk->drv.get_event = vga_get_event;
-    kk->drv.set_mouse = NULL;
+    dp->drv.driver = CACA_DRIVER_VGA;
+
+    dp->drv.init_graphics = vga_init_graphics;
+    dp->drv.end_graphics = vga_end_graphics;
+    dp->drv.set_window_title = vga_set_window_title;
+    dp->drv.get_window_width = vga_get_window_width;
+    dp->drv.get_window_height = vga_get_window_height;
+    dp->drv.display = vga_display;
+    dp->drv.handle_resize = vga_handle_resize;
+    dp->drv.get_event = vga_get_event;
+    dp->drv.set_mouse = NULL;
 
     return 0;
 }

caca/driver_win32.c

@@ -80,171 +80,171 @@ struct driver_private
     CONSOLE_CURSOR_INFO cci;
 };
 
-static int win32_init_graphics(caca_t *kk)
+static int win32_init_graphics(caca_display_t *dp)
 {
     CONSOLE_SCREEN_BUFFER_INFO csbi;
     SMALL_RECT rect;
     COORD size;
 
-    kk->drv.p = malloc(sizeof(struct driver_private));
+    dp->drv.p = malloc(sizeof(struct driver_private));
 
     /* This call is allowed to fail in case we already have a console */
     AllocConsole();
 
-    kk->drv.p->hin = GetStdHandle(STD_INPUT_HANDLE);
-    kk->drv.p->hout = CreateFile("CONOUT$", GENERIC_READ | GENERIC_WRITE,
+    dp->drv.p->hin = GetStdHandle(STD_INPUT_HANDLE);
+    dp->drv.p->hout = CreateFile("CONOUT$", GENERIC_READ | GENERIC_WRITE,
                                  FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
                                  OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
-    if(kk->drv.p->hout == INVALID_HANDLE_VALUE)
+    if(dp->drv.p->hout == INVALID_HANDLE_VALUE)
         return -1;
 
-    GetConsoleCursorInfo(kk->drv.p->hout, &kk->drv.p->cci);
-    kk->drv.p->cci.bVisible = FALSE;
-    SetConsoleCursorInfo(kk->drv.p->hout, &kk->drv.p->cci);
+    GetConsoleCursorInfo(dp->drv.p->hout, &dp->drv.p->cci);
+    dp->drv.p->cci.bVisible = FALSE;
+    SetConsoleCursorInfo(dp->drv.p->hout, &dp->drv.p->cci);
 
-    SetConsoleMode(kk->drv.p->hout, ENABLE_MOUSE_INPUT);
+    SetConsoleMode(dp->drv.p->hout, ENABLE_MOUSE_INPUT);
 
-    kk->drv.p->screen =
+    dp->drv.p->screen =
         CreateConsoleScreenBuffer(GENERIC_READ | GENERIC_WRITE,
                                   0, NULL, CONSOLE_TEXTMODE_BUFFER, NULL);
-    if(!kk->drv.p->screen || kk->drv.p->screen == INVALID_HANDLE_VALUE)
+    if(!dp->drv.p->screen || dp->drv.p->screen == INVALID_HANDLE_VALUE)
         return -1;
 
     /* Set the new console size */
-    size.X = kk->c->width;
-    size.Y = kk->c->height;
-    SetConsoleScreenBufferSize(kk->drv.p->screen, size);
+    size.X = dp->cv->width;
+    size.Y = dp->cv->height;
+    SetConsoleScreenBufferSize(dp->drv.p->screen, size);
 
     rect.Left = rect.Top = 0;
-    rect.Right = kk->c->width - 1;
-    rect.Bottom = kk->c->height - 1;
-    SetConsoleWindowInfo(kk->drv.p->screen, TRUE, &rect);
+    rect.Right = dp->cv->width - 1;
+    rect.Bottom = dp->cv->height - 1;
+    SetConsoleWindowInfo(dp->drv.p->screen, TRUE, &rect);
 
     /* Report our new size to libcucul */
-    if(!GetConsoleScreenBufferInfo(kk->drv.p->screen, &csbi))
+    if(!GetConsoleScreenBufferInfo(dp->drv.p->screen, &csbi))
         return -1;
 
-    _cucul_set_size(kk->c, csbi.srWindow.Right - csbi.srWindow.Left + 1,
-                           csbi.srWindow.Bottom - csbi.srWindow.Top + 1);
+    _cucul_set_size(dp->cv, csbi.srWindow.Right - csbi.srWindow.Left + 1,
+                            csbi.srWindow.Bottom - csbi.srWindow.Top + 1);
 
-    SetConsoleMode(kk->drv.p->screen, 0);
+    SetConsoleMode(dp->drv.p->screen, 0);
 
-    GetConsoleCursorInfo(kk->drv.p->screen, &kk->drv.p->cci);
-    kk->drv.p->cci.dwSize = 0;
-    kk->drv.p->cci.bVisible = FALSE;
-    SetConsoleCursorInfo(kk->drv.p->screen, &kk->drv.p->cci);
+    GetConsoleCursorInfo(dp->drv.p->screen, &dp->drv.p->cci);
+    dp->drv.p->cci.dwSize = 0;
+    dp->drv.p->cci.bVisible = FALSE;
+    SetConsoleCursorInfo(dp->drv.p->screen, &dp->drv.p->cci);
 
-    SetConsoleActiveScreenBuffer(kk->drv.p->screen);
+    SetConsoleActiveScreenBuffer(dp->drv.p->screen);
 
-    kk->drv.p->buffer = malloc(kk->c->width * kk->c->height
+    dp->drv.p->buffer = malloc(dp->cv->width * dp->cv->height
                                * sizeof(CHAR_INFO));
-    if(kk->drv.p->buffer == NULL)
+    if(dp->drv.p->buffer == NULL)
         return -1;
 
     return 0;
 }
 
-static int win32_end_graphics(caca_t *kk)
+static int win32_end_graphics(caca_display_t *dp)
 {
-    SetConsoleActiveScreenBuffer(kk->drv.p->hout);
-    CloseHandle(kk->drv.p->screen);
+    SetConsoleActiveScreenBuffer(dp->drv.p->hout);
+    CloseHandle(dp->drv.p->screen);
 
-    SetConsoleTextAttribute(kk->drv.p->hout, FOREGROUND_INTENSITY
+    SetConsoleTextAttribute(dp->drv.p->hout, FOREGROUND_INTENSITY
                                              | FOREGROUND_RED
                                              | FOREGROUND_GREEN
                                              | FOREGROUND_BLUE);
-    kk->drv.p->cci.bVisible = TRUE;
-    SetConsoleCursorInfo(kk->drv.p->hout, &kk->drv.p->cci);
-    CloseHandle(kk->drv.p->hout);
+    dp->drv.p->cci.bVisible = TRUE;
+    SetConsoleCursorInfo(dp->drv.p->hout, &dp->drv.p->cci);
+    CloseHandle(dp->drv.p->hout);
 
-    free(kk->drv.p);
+    free(dp->drv.p);
 
     return 0;
 }
 
-static int win32_set_window_title(caca_t *kk, char const *title)
+static int win32_set_window_title(caca_display_t *dp, char const *title)
 {
     SetConsoleTitle(title);
     return 0;
 }
 
-static unsigned int win32_get_window_width(caca_t *kk)
+static unsigned int win32_get_window_width(caca_display_t *dp)
 {
     /* FIXME */
 
     /* Fallback to a 6x10 font */
-    return kk->c->width * 6;
+    return dp->cv->width * 6;
 }
 
-static unsigned int win32_get_window_height(caca_t *kk)
+static unsigned int win32_get_window_height(caca_display_t *dp)
 {
     /* FIXME */
 
     /* Fallback to a 6x10 font */
-    return kk->c->height * 10;
+    return dp->cv->height * 10;
 }
 
-static void win32_display(caca_t *kk)
+static void win32_display(caca_display_t *dp)
 {
     COORD size, pos;
     SMALL_RECT rect;
     unsigned int i;
 
     /* Render everything to our screen buffer */
-    for(i = 0; i < kk->c->width * kk->c->height; i++)
+    for(i = 0; i < dp->cv->width * dp->cv->height; i++)
     {
-        uint32_t c = kk->c->chars[i];
+        uint32_t ch = dp->cv->chars[i];
 
 #if 0
-        if(c > 0x00000020 && c < 0x00000080)
-            kk->drv.p->buffer[i].Char.AsciiChar = (uint8_t)c;
+        if(ch > 0x00000020 && ch < 0x00000080)
+            dp->drv.p->buffer[i].Char.AsciiChar = (uint8_t)ch;
         else
-            kk->drv.p->buffer[i].Char.AsciiChar = ' ';
+            dp->drv.p->buffer[i].Char.AsciiChar = ' ';
 #else
-        if(c > 0x00000020 && c < 0x00010000)
-            kk->drv.p->buffer[i].Char.UnicodeChar = (uint16_t)c;
+        if(ch > 0x00000020 && ch < 0x00010000)
+            dp->drv.p->buffer[i].Char.UnicodeChar = (uint16_t)ch;
         else
-            kk->drv.p->buffer[i].Char.UnicodeChar = (uint16_t)' ';
+            dp->drv.p->buffer[i].Char.UnicodeChar = (uint16_t)' ';
 #endif
 
-        kk->drv.p->buffer[i].Attributes =
-                win32_fg_palette[_cucul_argb32_to_ansi4fg(kk->c->attr[i])]
-                 | win32_bg_palette[_cucul_argb32_to_ansi4bg(kk->c->attr[i])];
+        dp->drv.p->buffer[i].Attributes =
+                win32_fg_palette[_cucul_argb32_to_ansi4fg(dp->cv->attr[i])]
+                 | win32_bg_palette[_cucul_argb32_to_ansi4bg(dp->cv->attr[i])];
     }
 
     /* Blit the screen buffer */
-    size.X = kk->c->width;
-    size.Y = kk->c->height;
+    size.X = dp->cv->width;
+    size.Y = dp->cv->height;
     pos.X = pos.Y = 0;
     rect.Left = rect.Top = 0;
-    rect.Right = kk->c->width - 1;
-    rect.Bottom = kk->c->height - 1;
+    rect.Right = dp->cv->width - 1;
+    rect.Bottom = dp->cv->height - 1;
 #if 0
-    WriteConsoleOutput(kk->drv.p->screen, kk->drv.p->buffer, size, pos, &rect);
+    WriteConsoleOutput(dp->drv.p->screen, dp->drv.p->buffer, size, pos, &rect);
 #else
-    WriteConsoleOutputW(kk->drv.p->screen, kk->drv.p->buffer, size, pos, &rect);
+    WriteConsoleOutputW(dp->drv.p->screen, dp->drv.p->buffer, size, pos, &rect);
 #endif
 }
 
-static void win32_handle_resize(caca_t *kk)
+static void win32_handle_resize(caca_display_t *dp)
 {
     /* FIXME: I don't know what to do here. */
-    kk->resize.w = kk->c->width;
-    kk->resize.h = kk->c->height;
+    dp->resize.w = dp->cv->width;
+    dp->resize.h = dp->cv->height;
 }
 
-static int win32_get_event(caca_t *kk, caca_event_t *ev)
+static int win32_get_event(caca_display_t *dp, caca_event_t *ev)
 {
     INPUT_RECORD rec;
     DWORD num;
 
     for( ; ; )
     {
-        GetNumberOfConsoleInputEvents(kk->drv.p->hin, &num);
+        GetNumberOfConsoleInputEvents(dp->drv.p->hin, &num);
         if(num == 0)
             break;
 
-        ReadConsoleInput(kk->drv.p->hin, &rec, 1, &num);
+        ReadConsoleInput(dp->drv.p->hin, &rec, 1, &num);
         if(rec.EventType == KEY_EVENT)
         {
             unsigned int event;
@@ -287,16 +287,16 @@ static int win32_get_event(caca_t *kk, caca_event_t *ev)
             {
                 COORD pos = rec.Event.MouseEvent.dwMousePosition;
 
-                if(kk->mouse.x == (unsigned int)pos.X &&
-                   kk->mouse.y == (unsigned int)pos.Y)
+                if(dp->mouse.x == (unsigned int)pos.X &&
+                   dp->mouse.y == (unsigned int)pos.Y)
                     continue;
 
-                kk->mouse.x = pos.X;
-                kk->mouse.y = pos.Y;
+                dp->mouse.x = pos.X;
+                dp->mouse.y = pos.Y;
 
                 ev->type = CACA_EVENT_MOUSE_MOTION;
-                ev->data.mouse.x = kk->mouse.x;
-                ev->data.mouse.y = kk->mouse.y;
+                ev->data.mouse.x = dp->mouse.x;
+                ev->data.mouse.y = dp->mouse.y;
                 return 1;
             }
 #if 0
@@ -331,19 +331,19 @@ static int win32_get_event(caca_t *kk, caca_event_t *ev)
  * Driver initialisation
  */
 
-int win32_install(caca_t *kk)
+int win32_install(caca_display_t *dp)
 {
-    kk->drv.driver = CACA_DRIVER_WIN32;
-
-    kk->drv.init_graphics = win32_init_graphics;
-    kk->drv.end_graphics = win32_end_graphics;
-    kk->drv.set_window_title = win32_set_window_title;
-    kk->drv.get_window_width = win32_get_window_width;
-    kk->drv.get_window_height = win32_get_window_height;
-    kk->drv.display = win32_display;
-    kk->drv.handle_resize = win32_handle_resize;
-    kk->drv.get_event = win32_get_event;
-    kk->drv.set_mouse = NULL;
+    dp->drv.driver = CACA_DRIVER_WIN32;
+
+    dp->drv.init_graphics = win32_init_graphics;
+    dp->drv.end_graphics = win32_end_graphics;
+    dp->drv.set_window_title = win32_set_window_title;
+    dp->drv.get_window_width = win32_get_window_width;
+    dp->drv.get_window_height = win32_get_window_height;
+    dp->drv.display = win32_display;
+    dp->drv.handle_resize = win32_handle_resize;
+    dp->drv.get_event = win32_get_event;
+    dp->drv.set_mouse = NULL;
 
     return 0;
 }

caca/driver_x11.c

@@ -59,7 +59,7 @@ struct driver_private
 #endif
 };
 
-static int x11_init_graphics(caca_t *kk)
+static int x11_init_graphics(caca_display_t *dp)
 {
     Colormap colormap;
     XSetWindowAttributes x11_winattr;
@@ -69,7 +69,7 @@ static int x11_init_graphics(caca_t *kk)
     unsigned int width = 0, height = 0;
     int i;
 
-    kk->drv.p = malloc(sizeof(struct driver_private));
+    dp->drv.p = malloc(sizeof(struct driver_private));
 
 #if defined(HAVE_GETENV)
     geometry = getenv("CACA_GEOMETRY");
@@ -78,10 +78,10 @@ static int x11_init_graphics(caca_t *kk)
 #endif
 
     if(width && height)
-        _cucul_set_size(kk->c, width, height);
+        _cucul_set_size(dp->cv, width, height);
 
-    kk->drv.p->dpy = XOpenDisplay(NULL);
-    if(kk->drv.p->dpy == NULL)
+    dp->drv.p->dpy = XOpenDisplay(NULL);
+    if(dp->drv.p->dpy == NULL)
         return -1;
 
 #if defined(HAVE_GETENV)
@@ -101,18 +101,18 @@ static int x11_init_graphics(caca_t *kk)
         if(!*parser)
         {
             XSetErrorHandler(old_error_handler);
-            XCloseDisplay(kk->drv.p->dpy);
+            XCloseDisplay(dp->drv.p->dpy);
             return -1;
         }
 
-        kk->drv.p->font = XLoadFont(kk->drv.p->dpy, *parser);
-        if(!kk->drv.p->font)
+        dp->drv.p->font = XLoadFont(dp->drv.p->dpy, *parser);
+        if(!dp->drv.p->font)
             continue;
 
-        kk->drv.p->font_struct = XQueryFont(kk->drv.p->dpy, kk->drv.p->font);
-        if(!kk->drv.p->font_struct)
+        dp->drv.p->font_struct = XQueryFont(dp->drv.p->dpy, dp->drv.p->font);
+        if(!dp->drv.p->font_struct)
         {
-            XUnloadFont(kk->drv.p->dpy, kk->drv.p->font);
+            XUnloadFont(dp->drv.p->dpy, dp->drv.p->font);
             continue;
         }
 
@@ -122,170 +122,170 @@ static int x11_init_graphics(caca_t *kk)
     /* Reset the default X11 error handler */
     XSetErrorHandler(old_error_handler);
 
-    kk->drv.p->font_width = kk->drv.p->font_struct->max_bounds.width;
-    kk->drv.p->font_height = kk->drv.p->font_struct->max_bounds.ascent
-                         + kk->drv.p->font_struct->max_bounds.descent;
-    kk->drv.p->font_offset = kk->drv.p->font_struct->max_bounds.descent;
+    dp->drv.p->font_width = dp->drv.p->font_struct->max_bounds.width;
+    dp->drv.p->font_height = dp->drv.p->font_struct->max_bounds.ascent
+                         + dp->drv.p->font_struct->max_bounds.descent;
+    dp->drv.p->font_offset = dp->drv.p->font_struct->max_bounds.descent;
 
-    colormap = DefaultColormap(kk->drv.p->dpy, DefaultScreen(kk->drv.p->dpy));
+    colormap = DefaultColormap(dp->drv.p->dpy, DefaultScreen(dp->drv.p->dpy));
     for(i = 0x000; i < 0x1000; i++)
     {
         XColor color;
         color.red = ((i & 0xf00) >> 8) * 0x1111;
         color.green = ((i & 0x0f0) >> 4) * 0x1111;
         color.blue = (i & 0x00f) * 0x1111;
-        XAllocColor(kk->drv.p->dpy, colormap, &color);
-        kk->drv.p->colors[i] = color.pixel;
+        XAllocColor(dp->drv.p->dpy, colormap, &color);
+        dp->drv.p->colors[i] = color.pixel;
     }
 
     x11_winattr.backing_store = Always;
-    x11_winattr.background_pixel = kk->drv.p->colors[0x000];
+    x11_winattr.background_pixel = dp->drv.p->colors[0x000];
     x11_winattr.event_mask = ExposureMask | StructureNotifyMask;
 
-    kk->drv.p->window =
-        XCreateWindow(kk->drv.p->dpy, DefaultRootWindow(kk->drv.p->dpy), 0, 0,
-                      kk->c->width * kk->drv.p->font_width,
-                      kk->c->height * kk->drv.p->font_height,
+    dp->drv.p->window =
+        XCreateWindow(dp->drv.p->dpy, DefaultRootWindow(dp->drv.p->dpy), 0, 0,
+                      dp->cv->width * dp->drv.p->font_width,
+                      dp->cv->height * dp->drv.p->font_height,
                       0, 0, InputOutput, 0,
                       CWBackingStore | CWBackPixel | CWEventMask,
                       &x11_winattr);
 
-    kk->drv.p->wm_protocols =
-        XInternAtom(kk->drv.p->dpy, "WM_PROTOCOLS", True);
-    kk->drv.p->wm_delete_window =
-        XInternAtom(kk->drv.p->dpy, "WM_DELETE_WINDOW", True);
+    dp->drv.p->wm_protocols =
+        XInternAtom(dp->drv.p->dpy, "WM_PROTOCOLS", True);
+    dp->drv.p->wm_delete_window =
+        XInternAtom(dp->drv.p->dpy, "WM_DELETE_WINDOW", True);
 
-    if(kk->drv.p->wm_protocols != None && kk->drv.p->wm_delete_window != None)
-        XSetWMProtocols(kk->drv.p->dpy, kk->drv.p->window,
-                        &kk->drv.p->wm_delete_window, 1);
+    if(dp->drv.p->wm_protocols != None && dp->drv.p->wm_delete_window != None)
+        XSetWMProtocols(dp->drv.p->dpy, dp->drv.p->window,
+                        &dp->drv.p->wm_delete_window, 1);
 
-    XStoreName(kk->drv.p->dpy, kk->drv.p->window, "caca for X");
+    XStoreName(dp->drv.p->dpy, dp->drv.p->window, "caca for X");
 
-    XSelectInput(kk->drv.p->dpy, kk->drv.p->window, StructureNotifyMask);
-    XMapWindow(kk->drv.p->dpy, kk->drv.p->window);
+    XSelectInput(dp->drv.p->dpy, dp->drv.p->window, StructureNotifyMask);
+    XMapWindow(dp->drv.p->dpy, dp->drv.p->window);
 
-    kk->drv.p->gc = XCreateGC(kk->drv.p->dpy, kk->drv.p->window, 0, NULL);
-    XSetForeground(kk->drv.p->dpy, kk->drv.p->gc, kk->drv.p->colors[0x888]);
-    XSetFont(kk->drv.p->dpy, kk->drv.p->gc, kk->drv.p->font);
+    dp->drv.p->gc = XCreateGC(dp->drv.p->dpy, dp->drv.p->window, 0, NULL);
+    XSetForeground(dp->drv.p->dpy, dp->drv.p->gc, dp->drv.p->colors[0x888]);
+    XSetFont(dp->drv.p->dpy, dp->drv.p->gc, dp->drv.p->font);
 
     for(;;)
     {
         XEvent xevent;
-        XNextEvent(kk->drv.p->dpy, &xevent);
+        XNextEvent(dp->drv.p->dpy, &xevent);
         if (xevent.type == MapNotify)
             break;
     }
 
 #if defined(HAVE_X11_XKBLIB_H)
     /* Disable autorepeat */
-    XkbSetDetectableAutoRepeat(kk->drv.p->dpy, True, &kk->drv.p->autorepeat);
-    if(!kk->drv.p->autorepeat)
-        XAutoRepeatOff(kk->drv.p->dpy);
+    XkbSetDetectableAutoRepeat(dp->drv.p->dpy, True, &dp->drv.p->autorepeat);
+    if(!dp->drv.p->autorepeat)
+        XAutoRepeatOff(dp->drv.p->dpy);
 #endif
 
-    kk->drv.p->event_mask = KeyPressMask | KeyReleaseMask | ButtonPressMask
+    dp->drv.p->event_mask = KeyPressMask | KeyReleaseMask | ButtonPressMask
           | ButtonReleaseMask | PointerMotionMask | StructureNotifyMask
           | ExposureMask;
 
-    XSelectInput(kk->drv.p->dpy, kk->drv.p->window, kk->drv.p->event_mask);
+    XSelectInput(dp->drv.p->dpy, dp->drv.p->window, dp->drv.p->event_mask);
 
-    XSync(kk->drv.p->dpy, False);
+    XSync(dp->drv.p->dpy, False);
 
-    kk->drv.p->pixmap = XCreatePixmap(kk->drv.p->dpy, kk->drv.p->window,
-                                   kk->c->width * kk->drv.p->font_width,
-                                   kk->c->height * kk->drv.p->font_height,
-                                   DefaultDepth(kk->drv.p->dpy,
-                                            DefaultScreen(kk->drv.p->dpy)));
-    kk->drv.p->pointer = None;
+    dp->drv.p->pixmap = XCreatePixmap(dp->drv.p->dpy, dp->drv.p->window,
+                                   dp->cv->width * dp->drv.p->font_width,
+                                   dp->cv->height * dp->drv.p->font_height,
+                                   DefaultDepth(dp->drv.p->dpy,
+                                            DefaultScreen(dp->drv.p->dpy)));
+    dp->drv.p->pointer = None;
 
     return 0;
 }
 
-static int x11_end_graphics(caca_t *kk)
+static int x11_end_graphics(caca_display_t *dp)
 {
-    XSync(kk->drv.p->dpy, False);
+    XSync(dp->drv.p->dpy, False);
 #if defined(HAVE_X11_XKBLIB_H)
-    if(!kk->drv.p->autorepeat)
-        XAutoRepeatOn(kk->drv.p->dpy);
+    if(!dp->drv.p->autorepeat)
+        XAutoRepeatOn(dp->drv.p->dpy);
 #endif
-    XFreePixmap(kk->drv.p->dpy, kk->drv.p->pixmap);
-    XFreeFont(kk->drv.p->dpy, kk->drv.p->font_struct);
-    XFreeGC(kk->drv.p->dpy, kk->drv.p->gc);
-    XUnmapWindow(kk->drv.p->dpy, kk->drv.p->window);
-    XDestroyWindow(kk->drv.p->dpy, kk->drv.p->window);
-    XCloseDisplay(kk->drv.p->dpy);
+    XFreePixmap(dp->drv.p->dpy, dp->drv.p->pixmap);
+    XFreeFont(dp->drv.p->dpy, dp->drv.p->font_struct);
+    XFreeGC(dp->drv.p->dpy, dp->drv.p->gc);
+    XUnmapWindow(dp->drv.p->dpy, dp->drv.p->window);
+    XDestroyWindow(dp->drv.p->dpy, dp->drv.p->window);
+    XCloseDisplay(dp->drv.p->dpy);
 
-    free(kk->drv.p);
+    free(dp->drv.p);
 
     return 0;
 }
 
-static int x11_set_window_title(caca_t *kk, char const *title)
+static int x11_set_window_title(caca_display_t *dp, char const *title)
 {
-    XStoreName(kk->drv.p->dpy, kk->drv.p->window, title);
+    XStoreName(dp->drv.p->dpy, dp->drv.p->window, title);
     return 0;
 }
 
-static unsigned int x11_get_window_width(caca_t *kk)
+static unsigned int x11_get_window_width(caca_display_t *dp)
 {
-    return kk->c->width * kk->drv.p->font_width;
+    return dp->cv->width * dp->drv.p->font_width;
 }
 
-static unsigned int x11_get_window_height(caca_t *kk)
+static unsigned int x11_get_window_height(caca_display_t *dp)
 {
-    return kk->c->height * kk->drv.p->font_height;
+    return dp->cv->height * dp->drv.p->font_height;
 }
 
-static void x11_display(caca_t *kk)
+static void x11_display(caca_display_t *dp)
 {
     unsigned int x, y, len;
 
     /* First draw the background colours. Splitting the process in two
      * loops like this is actually slightly faster. */
-    for(y = 0; y < kk->c->height; y++)
+    for(y = 0; y < dp->cv->height; y++)
     {
-        for(x = 0; x < kk->c->width; x += len)
+        for(x = 0; x < dp->cv->width; x += len)
         {
-            uint32_t *attr = kk->c->attr + x + y * kk->c->width;
+            uint32_t *attr = dp->cv->attr + x + y * dp->cv->width;
             uint16_t bg = _cucul_argb32_to_rgb12bg(*attr);
 
             len = 1;
-            while(x + len < kk->c->width
+            while(x + len < dp->cv->width
                    && _cucul_argb32_to_rgb12bg(attr[len]) == bg)
                 len++;
 
-            XSetForeground(kk->drv.p->dpy, kk->drv.p->gc,
-                           kk->drv.p->colors[bg]);
-            XFillRectangle(kk->drv.p->dpy, kk->drv.p->pixmap, kk->drv.p->gc,
-                           x * kk->drv.p->font_width, y * kk->drv.p->font_height,
-                           len * kk->drv.p->font_width, kk->drv.p->font_height);
+            XSetForeground(dp->drv.p->dpy, dp->drv.p->gc,
+                           dp->drv.p->colors[bg]);
+            XFillRectangle(dp->drv.p->dpy, dp->drv.p->pixmap, dp->drv.p->gc,
+                           x * dp->drv.p->font_width, y * dp->drv.p->font_height,
+                           len * dp->drv.p->font_width, dp->drv.p->font_height);
         }
     }
 
     /* Then print the foreground characters */
-    for(y = 0; y < kk->c->height; y++)
+    for(y = 0; y < dp->cv->height; y++)
     {
-        unsigned int yoff = (y + 1) * kk->drv.p->font_height
-                                    - kk->drv.p->font_offset;
-        uint32_t *chars = kk->c->chars + y * kk->c->width;
+        unsigned int yoff = (y + 1) * dp->drv.p->font_height
+                                    - dp->drv.p->font_offset;
+        uint32_t *chars = dp->cv->chars + y * dp->cv->width;
 
-        for(x = 0; x < kk->c->width; x++, chars++)
+        for(x = 0; x < dp->cv->width; x++, chars++)
         {
-            uint32_t *attr = kk->c->attr + x + y * kk->c->width;
+            uint32_t *attr = dp->cv->attr + x + y * dp->cv->width;
 
             /* Skip spaces */
             if(*chars == 0x00000020)
                 continue;
 
-            XSetForeground(kk->drv.p->dpy, kk->drv.p->gc,
-                           kk->drv.p->colors[_cucul_argb32_to_rgb12fg(*attr)]);
+            XSetForeground(dp->drv.p->dpy, dp->drv.p->gc,
+                           dp->drv.p->colors[_cucul_argb32_to_rgb12fg(*attr)]);
 
             /* Plain ASCII, no problem. */
             if(*chars > 0x00000020 && *chars < 0x00000080)
             {
-                char c = (uint8_t)*chars;
-                XDrawString(kk->drv.p->dpy, kk->drv.p->pixmap, kk->drv.p->gc,
-                            x * kk->drv.p->font_width, yoff, &c, 1);
+                char ch = (uint8_t)*chars;
+                XDrawString(dp->drv.p->dpy, dp->drv.p->pixmap, dp->drv.p->gc,
+                            x * dp->drv.p->font_width, yoff, &ch, 1);
                 continue;
             }
 
@@ -295,46 +295,46 @@ static void x11_display(caca_t *kk)
             switch(*chars)
             {
                 case 0x00002580: /* ▀ */
-                    XFillRectangle(kk->drv.p->dpy, kk->drv.p->pixmap,
-                                   kk->drv.p->gc,
-                                   x * kk->drv.p->font_width,
-                                   y * kk->drv.p->font_height,
-                                   kk->drv.p->font_width,
-                                   kk->drv.p->font_height / 2);
+                    XFillRectangle(dp->drv.p->dpy, dp->drv.p->pixmap,
+                                   dp->drv.p->gc,
+                                   x * dp->drv.p->font_width,
+                                   y * dp->drv.p->font_height,
+                                   dp->drv.p->font_width,
+                                   dp->drv.p->font_height / 2);
                     break;
                 case 0x00002584: /* ▄ */
-                    XFillRectangle(kk->drv.p->dpy, kk->drv.p->pixmap,
-                                   kk->drv.p->gc,
-                                   x * kk->drv.p->font_width,
-                                   (y + 1) * kk->drv.p->font_height
-                                           - kk->drv.p->font_height / 2,
-                                   kk->drv.p->font_width,
-                                   kk->drv.p->font_height / 2);
+                    XFillRectangle(dp->drv.p->dpy, dp->drv.p->pixmap,
+                                   dp->drv.p->gc,
+                                   x * dp->drv.p->font_width,
+                                   (y + 1) * dp->drv.p->font_height
+                                           - dp->drv.p->font_height / 2,
+                                   dp->drv.p->font_width,
+                                   dp->drv.p->font_height / 2);
                     break;
                 case 0x00002588: /* █ */
-                    XFillRectangle(kk->drv.p->dpy, kk->drv.p->pixmap,
-                                   kk->drv.p->gc,
-                                   x * kk->drv.p->font_width,
-                                   y * kk->drv.p->font_height,
-                                   kk->drv.p->font_width,
-                                   kk->drv.p->font_height);
+                    XFillRectangle(dp->drv.p->dpy, dp->drv.p->pixmap,
+                                   dp->drv.p->gc,
+                                   x * dp->drv.p->font_width,
+                                   y * dp->drv.p->font_height,
+                                   dp->drv.p->font_width,
+                                   dp->drv.p->font_height);
                     break;
                 case 0x0000258c: /* ▌ */
-                    XFillRectangle(kk->drv.p->dpy, kk->drv.p->pixmap,
-                                   kk->drv.p->gc,
-                                   x * kk->drv.p->font_width,
-                                   y * kk->drv.p->font_height,
-                                   kk->drv.p->font_width / 2,
-                                   kk->drv.p->font_height);
+                    XFillRectangle(dp->drv.p->dpy, dp->drv.p->pixmap,
+                                   dp->drv.p->gc,
+                                   x * dp->drv.p->font_width,
+                                   y * dp->drv.p->font_height,
+                                   dp->drv.p->font_width / 2,
+                                   dp->drv.p->font_height);
                     break;
                 case 0x00002590: /* ▐ */
-                    XFillRectangle(kk->drv.p->dpy, kk->drv.p->pixmap,
-                                   kk->drv.p->gc,
-                                   (x + 1) * kk->drv.p->font_width
-                                           - kk->drv.p->font_width / 2,
-                                   y * kk->drv.p->font_height,
-                                   kk->drv.p->font_width / 2,
-                                   kk->drv.p->font_height);
+                    XFillRectangle(dp->drv.p->dpy, dp->drv.p->pixmap,
+                                   dp->drv.p->gc,
+                                   (x + 1) * dp->drv.p->font_width
+                                           - dp->drv.p->font_width / 2,
+                                   y * dp->drv.p->font_height,
+                                   dp->drv.p->font_width / 2,
+                                   dp->drv.p->font_height);
                     break;
                 case 0x00002593: /* ▓ */
                 case 0x00002592: /* ▒ */
@@ -342,74 +342,74 @@ static void x11_display(caca_t *kk)
                 {
                     /* FIXME: this sucks utterly */
                     int i, j, k = *chars - 0x00002591;
-                    for(j = kk->drv.p->font_height; j--; )
-                        for(i = kk->drv.p->font_width; i--; )
+                    for(j = dp->drv.p->font_height; j--; )
+                        for(i = dp->drv.p->font_width; i--; )
                     {
                         if(((i + 2 * (j & 1)) & 3) > k)
                             continue;
 
-                        XDrawPoint(kk->drv.p->dpy, kk->drv.p->pixmap,
-                                   kk->drv.p->gc,
-                                   x * kk->drv.p->font_width + i,
-                                   y * kk->drv.p->font_height + j);
+                        XDrawPoint(dp->drv.p->dpy, dp->drv.p->pixmap,
+                                   dp->drv.p->gc,
+                                   x * dp->drv.p->font_width + i,
+                                   y * dp->drv.p->font_height + j);
                     }
                     break;
                 }
                 default:
                 {
-                    char c;
-                    c = '?';
-                    XDrawString(kk->drv.p->dpy, kk->drv.p->pixmap,
-                                kk->drv.p->gc,
-                                x * kk->drv.p->font_width, yoff, &c, 1);
+                    char ch;
+                    ch = '?';
+                    XDrawString(dp->drv.p->dpy, dp->drv.p->pixmap,
+                                dp->drv.p->gc,
+                                x * dp->drv.p->font_width, yoff, &ch, 1);
                     break;
                 }
             }
         }
     }
 
-    XCopyArea(kk->drv.p->dpy, kk->drv.p->pixmap, kk->drv.p->window,
-              kk->drv.p->gc, 0, 0,
-              kk->c->width * kk->drv.p->font_width,
-              kk->c->height * kk->drv.p->font_height,
+    XCopyArea(dp->drv.p->dpy, dp->drv.p->pixmap, dp->drv.p->window,
+              dp->drv.p->gc, 0, 0,
+              dp->cv->width * dp->drv.p->font_width,
+              dp->cv->height * dp->drv.p->font_height,
               0, 0);
-    XFlush(kk->drv.p->dpy);
+    XFlush(dp->drv.p->dpy);
 }
 
-static void x11_handle_resize(caca_t *kk)
+static void x11_handle_resize(caca_display_t *dp)
 {
     Pixmap new_pixmap;
 
-    new_pixmap = XCreatePixmap(kk->drv.p->dpy, kk->drv.p->window,
-                               kk->resize.w * kk->drv.p->font_width,
-                               kk->resize.h * kk->drv.p->font_height,
-                               DefaultDepth(kk->drv.p->dpy,
-                                            DefaultScreen(kk->drv.p->dpy)));
-    XCopyArea(kk->drv.p->dpy, kk->drv.p->pixmap, new_pixmap,
-              kk->drv.p->gc, 0, 0,
-              kk->resize.w * kk->drv.p->font_width,
-              kk->resize.h * kk->drv.p->font_height, 0, 0);
-    XFreePixmap(kk->drv.p->dpy, kk->drv.p->pixmap);
-    kk->drv.p->pixmap = new_pixmap;
+    new_pixmap = XCreatePixmap(dp->drv.p->dpy, dp->drv.p->window,
+                               dp->resize.w * dp->drv.p->font_width,
+                               dp->resize.h * dp->drv.p->font_height,
+                               DefaultDepth(dp->drv.p->dpy,
+                                            DefaultScreen(dp->drv.p->dpy)));
+    XCopyArea(dp->drv.p->dpy, dp->drv.p->pixmap, new_pixmap,
+              dp->drv.p->gc, 0, 0,
+              dp->resize.w * dp->drv.p->font_width,
+              dp->resize.h * dp->drv.p->font_height, 0, 0);
+    XFreePixmap(dp->drv.p->dpy, dp->drv.p->pixmap);
+    dp->drv.p->pixmap = new_pixmap;
 }
 
-static int x11_get_event(caca_t *kk, caca_event_t *ev)
+static int x11_get_event(caca_display_t *dp, caca_event_t *ev)
 {
     XEvent xevent;
     char key;
 
-    while(XCheckWindowEvent(kk->drv.p->dpy, kk->drv.p->window,
-                            kk->drv.p->event_mask, &xevent) == True)
+    while(XCheckWindowEvent(dp->drv.p->dpy, dp->drv.p->window,
+                            dp->drv.p->event_mask, &xevent) == True)
     {
         KeySym keysym;
 
         /* Expose event */
         if(xevent.type == Expose)
         {
-            XCopyArea(kk->drv.p->dpy, kk->drv.p->pixmap,
-                      kk->drv.p->window, kk->drv.p->gc, 0, 0,
-                      kk->c->width * kk->drv.p->font_width,
-                      kk->c->height * kk->drv.p->font_height, 0, 0);
+            XCopyArea(dp->drv.p->dpy, dp->drv.p->pixmap,
+                      dp->drv.p->window, dp->drv.p->gc, 0, 0,
+                      dp->cv->width * dp->drv.p->font_width,
+                      dp->cv->height * dp->drv.p->font_height, 0, 0);
             continue;
         }
 
@@ -418,17 +418,17 @@ static int x11_get_event(caca_t *kk, caca_event_t *ev)
         {
             unsigned int w, h;
 
-            w = (xevent.xconfigure.width + kk->drv.p->font_width / 3)
-                  / kk->drv.p->font_width;
-            h = (xevent.xconfigure.height + kk->drv.p->font_height / 3)
-                  / kk->drv.p->font_height;
+            w = (xevent.xconfigure.width + dp->drv.p->font_width / 3)
+                  / dp->drv.p->font_width;
+            h = (xevent.xconfigure.height + dp->drv.p->font_height / 3)
+                  / dp->drv.p->font_height;
 
-            if(!w || !h || (w == kk->c->width && h == kk->c->height))
+            if(!w || !h || (w == dp->cv->width && h == dp->cv->height))
                 continue;
 
-            kk->resize.w = w;
-            kk->resize.h = h;
-            kk->resize.resized = 1;
+            dp->resize.w = w;
+            dp->resize.h = h;
+            dp->resize.resized = 1;
 
             continue;
         }
@@ -436,23 +436,23 @@ static int x11_get_event(caca_t *kk, caca_event_t *ev)
         /* Check for mouse motion events */
         if(xevent.type == MotionNotify)
         {
-            unsigned int newx = xevent.xmotion.x / kk->drv.p->font_width;
-            unsigned int newy = xevent.xmotion.y / kk->drv.p->font_height;
+            unsigned int newx = xevent.xmotion.x / dp->drv.p->font_width;
+            unsigned int newy = xevent.xmotion.y / dp->drv.p->font_height;
 
-            if(newx >= kk->c->width)
-                newx = kk->c->width - 1;
-            if(newy >= kk->c->height)
-                newy = kk->c->height - 1;
+            if(newx >= dp->cv->width)
+                newx = dp->cv->width - 1;
+            if(newy >= dp->cv->height)
+                newy = dp->cv->height - 1;
 
-            if(kk->mouse.x == newx && kk->mouse.y == newy)
+            if(dp->mouse.x == newx && dp->mouse.y == newy)
                 continue;
 
-            kk->mouse.x = newx;
-            kk->mouse.y = newy;
+            dp->mouse.x = newx;
+            dp->mouse.y = newy;
 
             ev->type = CACA_EVENT_MOUSE_MOTION;
-            ev->data.mouse.x = kk->mouse.x;
-            ev->data.mouse.y = kk->mouse.y;
+            ev->data.mouse.x = dp->mouse.x;
+            ev->data.mouse.y = dp->mouse.y;
             return 1;
         }
 
@@ -488,7 +488,7 @@ static int x11_get_event(caca_t *kk, caca_event_t *ev)
             return 1;
         }
 
-        keysym = XKeycodeToKeysym(kk->drv.p->dpy, xevent.xkey.keycode, 0);
+        keysym = XKeycodeToKeysym(dp->drv.p->dpy, xevent.xkey.keycode, 0);
         switch(keysym)
         {
             case XK_F1:    ev->data.key.ch = CACA_KEY_F1;    break;
@@ -519,12 +519,12 @@ static int x11_get_event(caca_t *kk, caca_event_t *ev)
         return 1;
     }
 
-    while(XCheckTypedEvent(kk->drv.p->dpy, ClientMessage, &xevent))
+    while(XCheckTypedEvent(dp->drv.p->dpy, ClientMessage, &xevent))
     {
-        if(xevent.xclient.message_type != kk->drv.p->wm_protocols)
+        if(xevent.xclient.message_type != dp->drv.p->wm_protocols)
             continue;
 
-        if((Atom)xevent.xclient.data.l[0] == kk->drv.p->wm_delete_window)
+        if((Atom)xevent.xclient.data.l[0] == dp->drv.p->wm_delete_window)
         {
             ev->type = CACA_EVENT_QUIT;
             return 1;
@@ -535,7 +535,7 @@ static int x11_get_event(caca_t *kk, caca_event_t *ev)
     return 0;
 }
 
-static void x11_set_mouse(caca_t *kk, int flags)
+static void x11_set_mouse(caca_display_t *dp, int flags)
 {
     Cursor no_ptr;
     Pixmap bm_no;
@@ -545,26 +545,26 @@ static void x11_set_mouse(caca_t *kk, int flags)
 
     if(flags)
     {
-        XDefineCursor(kk->drv.p->dpy,kk->drv.p->window, 0);
+        XDefineCursor(dp->drv.p->dpy,dp->drv.p->window, 0);
         return;
     }
 
-    colormap = DefaultColormap(kk->drv.p->dpy, DefaultScreen(kk->drv.p->dpy));
-    if(!XAllocNamedColor(kk->drv.p->dpy, colormap, "black", &black, &dummy))
+    colormap = DefaultColormap(dp->drv.p->dpy, DefaultScreen(dp->drv.p->dpy));
+    if(!XAllocNamedColor(dp->drv.p->dpy, colormap, "black", &black, &dummy))
     {
         return;
     }
-    bm_no = XCreateBitmapFromData(kk->drv.p->dpy, kk->drv.p->window,
+    bm_no = XCreateBitmapFromData(dp->drv.p->dpy, dp->drv.p->window,
                                   empty, 8, 8);
-    no_ptr = XCreatePixmapCursor(kk->drv.p->dpy, bm_no, bm_no,
+    no_ptr = XCreatePixmapCursor(dp->drv.p->dpy, bm_no, bm_no,
                                  &black, &black, 0, 0);
-    XDefineCursor(kk->drv.p->dpy, kk->drv.p->window, no_ptr);
-    XFreeCursor(kk->drv.p->dpy, no_ptr);
+    XDefineCursor(dp->drv.p->dpy, dp->drv.p->window, no_ptr);
+    XFreeCursor(dp->drv.p->dpy, no_ptr);
     if(bm_no != None)
-        XFreePixmap(kk->drv.p->dpy, bm_no);
-    XFreeColors(kk->drv.p->dpy, colormap, &black.pixel, 1, 0);
+        XFreePixmap(dp->drv.p->dpy, bm_no);
+    XFreeColors(dp->drv.p->dpy, colormap, &black.pixel, 1, 0);
 
-    XSync(kk->drv.p->dpy, False);
+    XSync(dp->drv.p->dpy, False);
 }
 
 /*
@@ -581,24 +581,24 @@ static int x11_error_handler(Display *dpy, XErrorEvent *xevent)
  * Driver initialisation
  */
 
-int x11_install(caca_t *kk)
+int x11_install(caca_display_t *dp)
 {
 #if defined(HAVE_GETENV)
     if(!getenv("DISPLAY") || !*(getenv("DISPLAY")))
         return -1;
 #endif
 
-    kk->drv.driver = CACA_DRIVER_X11;
-
-    kk->drv.init_graphics = x11_init_graphics;
-    kk->drv.end_graphics = x11_end_graphics;
-    kk->drv.set_window_title = x11_set_window_title;
-    kk->drv.get_window_width = x11_get_window_width;
-    kk->drv.get_window_height = x11_get_window_height;
-    kk->drv.display = x11_display;
-    kk->drv.handle_resize = x11_handle_resize;
-    kk->drv.get_event = x11_get_event;
-    kk->drv.set_mouse = x11_set_mouse;
+    dp->drv.driver = CACA_DRIVER_X11;
+
+    dp->drv.init_graphics = x11_init_graphics;
+    dp->drv.end_graphics = x11_end_graphics;
+    dp->drv.set_window_title = x11_set_window_title;
+    dp->drv.get_window_width = x11_get_window_width;
+    dp->drv.get_window_height = x11_get_window_height;
+    dp->drv.display = x11_display;
+    dp->drv.handle_resize = x11_handle_resize;
+    dp->drv.get_event = x11_get_event;
+    dp->drv.set_mouse = x11_set_mouse;
 
     return 0;
 }

caca/event.c

@@ -26,8 +26,8 @@
 #include "caca.h"
 #include "caca_internals.h"
 
-static int _get_next_event(caca_t *, caca_event_t *);
-static int _lowlevel_event(caca_t *, caca_event_t *);
+static int _get_next_event(caca_display_t *, caca_event_t *);
+static int _lowlevel_event(caca_display_t *, caca_event_t *);
 
 #if !defined(_DOXYGEN_SKIP_ME)
 /* If no new key was pressed after AUTOREPEAT_THRESHOLD usec, assume the
@@ -50,13 +50,13 @@ static int _lowlevel_event(caca_t *, caca_event_t *);
  *  if no more events are pending in the queue. A negative value causes the
  *  function to wait indefinitely until a matching event is received.
  *
- *  \param kk The libcaca graphical context.
+ *  \param dp The libcaca graphical context.
  *  \param event_mask Bitmask of requested events.
  *  \param timeout A timeout value in microseconds
  *  \param ev A pointer to a caca_event structure.
  *  \return The next matching event in the queue, or 0 if no event is pending.
  */
-int caca_get_event(caca_t *kk, unsigned int event_mask,
+int caca_get_event(caca_display_t *dp, unsigned int event_mask,
                    caca_event_t *ev, int timeout)
 {
     caca_timer_t timer;
@@ -70,7 +70,7 @@ int caca_get_event(caca_t *kk, unsigned int event_mask,
 
     for( ; ; )
     {
-        int ret = _get_next_event(kk, ev);
+        int ret = _get_next_event(dp, ev);
 
         /* If we got the event we wanted, return */
         if(ev->type & event_mask)
@@ -108,15 +108,15 @@ int caca_get_event(caca_t *kk, unsigned int event_mask,
  *  drivers are being used, because mouse position is only detected when
  *  the mouse is clicked. Other drivers such as X11 work well.
  *
- *  \param kk The libcaca graphical context.
+ *  \param dp The libcaca graphical context.
  *  \return The X mouse coordinate.
  */
-unsigned int caca_get_mouse_x(caca_t *kk)
+unsigned int caca_get_mouse_x(caca_display_t *dp)
 {
-    if(kk->mouse.x >= kk->c->width)
-        kk->mouse.x = kk->c->width - 1;
+    if(dp->mouse.x >= dp->cv->width)
+        dp->mouse.x = dp->cv->width - 1;
 
-    return kk->mouse.x;
+    return dp->mouse.x;
 }
 
 /** \brief Return the Y mouse coordinate.
@@ -126,22 +126,22 @@ unsigned int caca_get_mouse_x(caca_t *kk)
  *  drivers are being used, because mouse position is only detected when
  *  the mouse is clicked. Other drivers such as X11 work well.
  *
- *  \param kk The libcaca graphical context.
+ *  \param dp The libcaca graphical context.
  *  \return The Y mouse coordinate.
  */
-unsigned int caca_get_mouse_y(caca_t *kk)
+unsigned int caca_get_mouse_y(caca_display_t *dp)
 {
-    if(kk->mouse.y >= kk->c->height)
-        kk->mouse.y = kk->c->height - 1;
+    if(dp->mouse.y >= dp->cv->height)
+        dp->mouse.y = dp->cv->height - 1;
 
-    return kk->mouse.y;
+    return dp->mouse.y;
 }
 
 /*
  * XXX: The following functions are local.
  */
 
-static int _get_next_event(caca_t *kk, caca_event_t *ev)
+static int _get_next_event(caca_display_t *dp, caca_event_t *ev)
 {
 #if defined(USE_SLANG) || defined(USE_NCURSES)
     unsigned int ticks;
@@ -149,112 +149,112 @@ static int _get_next_event(caca_t *kk, caca_event_t *ev)
     int ret;
 
     /* If we are about to return a resize event, acknowledge it */
-    if(kk->resize.resized)
+    if(dp->resize.resized)
     {
-        kk->resize.resized = 0;
-        _caca_handle_resize(kk);
+        dp->resize.resized = 0;
+        _caca_handle_resize(dp);
         ev->type = CACA_EVENT_RESIZE;
-        ev->data.resize.w = kk->c->width;
-        ev->data.resize.h = kk->c->height;
+        ev->data.resize.w = dp->cv->width;
+        ev->data.resize.h = dp->cv->height;
         return 1;
     }
 
-    ret = _lowlevel_event(kk, ev);
+    ret = _lowlevel_event(dp, ev);
 
 #if defined(USE_SLANG)
-    if(kk->drv.driver != CACA_DRIVER_SLANG)
+    if(dp->drv.driver != CACA_DRIVER_SLANG)
 #endif
 #if defined(USE_NCURSES)
-    if(kk->drv.driver != CACA_DRIVER_NCURSES)
+    if(dp->drv.driver != CACA_DRIVER_NCURSES)
 #endif
     return ret;
 
 #if defined(USE_SLANG) || defined(USE_NCURSES)
     /* Simulate long keypresses using autorepeat features */
-    ticks = _caca_getticks(&kk->events.key_timer);
-    kk->events.last_key_ticks += ticks;
-    kk->events.autorepeat_ticks += ticks;
+    ticks = _caca_getticks(&dp->events.key_timer);
+    dp->events.last_key_ticks += ticks;
+    dp->events.autorepeat_ticks += ticks;
 
     /* Handle autorepeat */
-    if(kk->events.last_key_event.type
-           && kk->events.autorepeat_ticks > AUTOREPEAT_TRIGGER
-           && kk->events.autorepeat_ticks > AUTOREPEAT_THRESHOLD
-           && kk->events.autorepeat_ticks > AUTOREPEAT_RATE)
+    if(dp->events.last_key_event.type
+           && dp->events.autorepeat_ticks > AUTOREPEAT_TRIGGER
+           && dp->events.autorepeat_ticks > AUTOREPEAT_THRESHOLD
+           && dp->events.autorepeat_ticks > AUTOREPEAT_RATE)
     {
-        _push_event(kk, ev);
-        kk->events.autorepeat_ticks -= AUTOREPEAT_RATE;
-        *ev = kk->events.last_key_event;
+        _push_event(dp, ev);
+        dp->events.autorepeat_ticks -= AUTOREPEAT_RATE;
+        *ev = dp->events.last_key_event;
         return 1;
     }
 
     /* We are in autorepeat mode and the same key was just pressed, ignore
      * this event and return the next one by calling ourselves. */
     if(ev->type == CACA_EVENT_KEY_PRESS
-        && kk->events.last_key_event.type
-        && ev->data.key.ch == kk->events.last_key_event.data.key.ch
-        && ev->data.key.ucs4 == kk->events.last_key_event.data.key.ucs4)
+        && dp->events.last_key_event.type
+        && ev->data.key.ch == dp->events.last_key_event.data.key.ch
+        && ev->data.key.ucs4 == dp->events.last_key_event.data.key.ucs4)
     {
-        kk->events.last_key_ticks = 0;
-        return _get_next_event(kk, ev);
+        dp->events.last_key_ticks = 0;
+        return _get_next_event(dp, ev);
     }
 
     /* We are in autorepeat mode, but key has expired or a new key was
      * pressed - store our event and return a key release event first */
-    if(kk->events.last_key_event.type
-          && (kk->events.last_key_ticks > AUTOREPEAT_THRESHOLD
+    if(dp->events.last_key_event.type
+          && (dp->events.last_key_ticks > AUTOREPEAT_THRESHOLD
                || (ev->type & CACA_EVENT_KEY_PRESS)))
     {
-        _push_event(kk, ev);
-        *ev = kk->events.last_key_event;
+        _push_event(dp, ev);
+        *ev = dp->events.last_key_event;
         ev->type = CACA_EVENT_KEY_RELEASE;
-        kk->events.last_key_event.type = CACA_EVENT_NONE;
+        dp->events.last_key_event.type = CACA_EVENT_NONE;
         return 1;
     }
 
     /* A new key was pressed, enter autorepeat mode */
     if(ev->type & CACA_EVENT_KEY_PRESS)
     {
-        kk->events.last_key_ticks = 0;
-        kk->events.autorepeat_ticks = 0;
-        kk->events.last_key_event = *ev;
+        dp->events.last_key_ticks = 0;
+        dp->events.autorepeat_ticks = 0;
+        dp->events.last_key_event = *ev;
     }
 
     return ev->type ? 1 : 0;
 #endif
 }
 
-static int _lowlevel_event(caca_t *kk, caca_event_t *ev)
+static int _lowlevel_event(caca_display_t *dp, caca_event_t *ev)
 {
 #if defined(USE_SLANG) || defined(USE_NCURSES) || defined(USE_CONIO)
-    int ret = _pop_event(kk, ev);
+    int ret = _pop_event(dp, ev);
 
     if(ret)
         return ret;
 #endif
 
-    return kk->drv.get_event(kk, ev);
+    return dp->drv.get_event(dp, ev);
 }
 
 #if defined(USE_SLANG) || defined(USE_NCURSES) || defined(USE_CONIO) || defined(USE_GL)
-void _push_event(caca_t *kk, caca_event_t *ev)
+void _push_event(caca_display_t *dp, caca_event_t *ev)
 {
-    if(!ev->type || kk->events.queue == EVENTBUF_LEN)
+    if(!ev->type || dp->events.queue == EVENTBUF_LEN)
         return;
-    kk->events.buf[kk->events.queue] = *ev;
-    kk->events.queue++;
+    dp->events.buf[dp->events.queue] = *ev;
+    dp->events.queue++;
 }
 
-int _pop_event(caca_t *kk, caca_event_t *ev)
+int _pop_event(caca_display_t *dp, caca_event_t *ev)
 {
     int i;
 
-    if(kk->events.queue == 0)
+    if(dp->events.queue == 0)
         return 0;
 
-    *ev = kk->events.buf[0];
-    for(i = 1; i < kk->events.queue; i++)
-        kk->events.buf[i - 1] = kk->events.buf[i];
-    kk->events.queue--;
+    *ev = dp->events.buf[0];
+    for(i = 1; i < dp->events.queue; i++)
+        dp->events.buf[i - 1] = dp->events.buf[i];
+    dp->events.queue--;
 
     return 1;
 }

caca/graphics.c

@@ -27,13 +27,13 @@
  *  If libcaca runs in a window, try to change its title. This works with
  *  the X11 and Win32 drivers.
  *
- *  \param kk The libcaca graphical context.
+ *  \param dp The libcaca graphical context.
  *  \param title The desired window title.
  *  \return 0 upon success, a non-zero value if an error occurs.
  */
-int caca_set_window_title(caca_t *kk, char const *title)
+int caca_set_window_title(caca_display_t *dp, char const *title)
 {
-    return kk->drv.set_window_title(kk, title);
+    return dp->drv.set_window_title(dp, title);
 }
 
 /** \brief Get the window width.
@@ -43,12 +43,12 @@ int caca_set_window_title(caca_t *kk, char const *title)
  *  or if there is no way to know the font size, most drivers will assume a
  *  6x10 font is being used. Note that the units are not necessarily pixels.
  *
- *  \param kk The libcaca graphical context.
+ *  \param dp The libcaca graphical context.
  *  \return The window width.
  */
-unsigned int caca_get_window_width(caca_t *kk)
+unsigned int caca_get_window_width(caca_display_t *dp)
 {
-    return kk->drv.get_window_width(kk);
+    return dp->drv.get_window_width(dp);
 }
 
 /** \brief Get the window height.
@@ -58,12 +58,12 @@ unsigned int caca_get_window_width(caca_t *kk)
  *  or if there is no way to know the font size, assume a 6x10 font is being
  *  used. Note that the units are not necessarily pixels.
  *
- *  \param kk The libcaca graphical context.
+ *  \param dp The libcaca graphical context.
  *  \return The window height.
  */
-unsigned int caca_get_window_height(caca_t *kk)
+unsigned int caca_get_window_height(caca_display_t *dp)
 {
-    return kk->drv.get_window_height(kk);
+    return dp->drv.get_window_height(dp);
 }
 
 /** \brief Set the refresh delay.
@@ -75,12 +75,12 @@ unsigned int caca_get_window_height(caca_t *kk)
  *  If the argument is zero, constant framerate is disabled. This is the
  *  default behaviour.
  *
- *  \param kk The libcaca graphical context.
+ *  \param dp The libcaca graphical context.
  *  \param usec The refresh delay in microseconds.
  */
-void caca_set_delay(caca_t *kk, unsigned int usec)
+void caca_set_delay(caca_display_t *dp, unsigned int usec)
 {
-    kk->delay = usec;
+    dp->delay = usec;
 }
 
 /** \brief Get the average rendering time.
@@ -91,12 +91,12 @@ void caca_set_delay(caca_t *kk, unsigned int usec)
  *  rendering time will not be considerably shorter than the requested delay
  *  even if the real rendering time was shorter.
  *
- *  \param kk The libcaca graphical context.
+ *  \param dp The libcaca graphical context.
  *  \return The render time in microseconds.
  */
-unsigned int caca_get_rendertime(caca_t *kk)
+unsigned int caca_get_rendertime(caca_display_t *dp)
 {
-    return kk->rendertime;
+    return dp->rendertime;
 }
 
 /** \brief Flush pending changes and redraw the screen.
@@ -111,41 +111,41 @@ unsigned int caca_get_rendertime(caca_t *kk)
  *  set with caca_set_delay(), the second call will wait a bit before
  *  performing the screen refresh.
  *
- *  \param kk The libcaca graphical context.
+ *  \param dp The libcaca graphical context.
  */
-void caca_display(caca_t *kk)
+void caca_display(caca_display_t *dp)
 {
 #if !defined(_DOXYGEN_SKIP_ME)
 #define IDLE_USEC 10000
 #endif
-    int ticks = kk->lastticks + _caca_getticks(&kk->timer);
+    int ticks = dp->lastticks + _caca_getticks(&dp->timer);
 
-    kk->drv.display(kk);
+    dp->drv.display(dp);
 
     /* Once the display is finished, we can ack resizes */
-    if(kk->resize.resized)
+    if(dp->resize.resized)
     {
-        kk->resize.resized = 0;
-        _caca_handle_resize(kk);
+        dp->resize.resized = 0;
+        _caca_handle_resize(dp);
     }
 
-    /* Wait until kk->delay + time of last call */
-    ticks += _caca_getticks(&kk->timer);
-    for(ticks += _caca_getticks(&kk->timer);
-        ticks + IDLE_USEC < (int)kk->delay;
-        ticks += _caca_getticks(&kk->timer))
+    /* Wait until dp->delay + time of last call */
+    ticks += _caca_getticks(&dp->timer);
+    for(ticks += _caca_getticks(&dp->timer);
+        ticks + IDLE_USEC < (int)dp->delay;
+        ticks += _caca_getticks(&dp->timer))
     {
         _caca_sleep(IDLE_USEC);
     }
 
     /* Update the sliding mean of the render time */
-    kk->rendertime = (7 * kk->rendertime + ticks) / 8;
+    dp->rendertime = (7 * dp->rendertime + ticks) / 8;
 
-    kk->lastticks = ticks - kk->delay;
+    dp->lastticks = ticks - dp->delay;
 
     /* If we drifted too much, it's bad, bad, bad. */
-    if(kk->lastticks > (int)kk->delay)
-        kk->lastticks = 0;
+    if(dp->lastticks > (int)dp->delay)
+        dp->lastticks = 0;
 }
 
 /** \brief Show or hide the mouse pointer.
@@ -153,26 +153,26 @@ void caca_display(caca_t *kk)
  *  This function shows or hides the mouse pointer, for devices that
  *  support it.
  *
- *  \param kk The libcaca graphical context.
+ *  \param dp The libcaca graphical context.
  *  \param flag 0 hides the pointer, 1 shows the system's default pointer
  *              (usually an arrow). Other values are reserved for future use.
  */
-void caca_set_mouse(caca_t *kk, int flag)
+void caca_set_mouse(caca_display_t *dp, int flag)
 {
-    if(kk->drv.set_mouse)
-        kk->drv.set_mouse(kk, flag);
+    if(dp->drv.set_mouse)
+        dp->drv.set_mouse(dp, flag);
 }
 
 /*
  * XXX: following functions are local
  */
 
-void _caca_handle_resize(caca_t *kk)
+void _caca_handle_resize(caca_display_t *dp)
 {
-    kk->drv.handle_resize(kk);
+    dp->drv.handle_resize(dp);
 
     /* Tell libcucul we changed size */
-    if(kk->resize.w != kk->c->width || kk->resize.h != kk->c->height)
-        _cucul_set_size(kk->c, kk->resize.w, kk->resize.h);
+    if(dp->resize.w != dp->cv->width || dp->resize.h != dp->cv->height)
+        _cucul_set_size(dp->cv, dp->resize.w, dp->resize.h);
 }
 

cpp/caca++.cpp

@@ -25,61 +25,61 @@ Caca::Caca(void)
 {
 
 }
-Caca::Caca(Cucul *c) 
+Caca::Caca(Cucul *cv) 
 {
-    kk = caca_attach(c->get_cucul_canvas_t());
-    if(!kk) throw -1;
+    dp = caca_attach(cv->get_cucul_canvas_t());
+    if(!dp) throw -1;
 }
 Caca::~Caca() 
 {
-    caca_detach(kk);
+    caca_detach(dp);
 }
-void Caca::attach(Cucul *c)
+void Caca::attach(Cucul *cv)
 {
-    kk = caca_attach(c->get_cucul_canvas_t());
-    if(!kk) throw -1;
+    dp = caca_attach(cv->get_cucul_canvas_t());
+    if(!dp) throw -1;
 }
 void 	Caca::detach ()
 {
-    caca_detach(kk);
+    caca_detach(dp);
 }
 void 	Caca::set_delay (unsigned int d)
 {
-    caca_set_delay(kk, d);
+    caca_set_delay(dp, d);
 }
 void 	Caca::display ()
 {
-    caca_display(kk);
+    caca_display(dp);
 }
 unsigned int 	Caca::get_rendertime ()
 {
-    return caca_get_rendertime(kk);
+    return caca_get_rendertime(dp);
 }
 unsigned int 	Caca::get_window_width ()
 {
-    return caca_get_window_width(kk);
+    return caca_get_window_width(dp);
 }
 unsigned int 	Caca::get_window_height ()
 {
-    return caca_get_window_height(kk);
+    return caca_get_window_height(dp);
 }
 int 	Caca::set_window_title (char const *s)
 {
-    return caca_set_window_title(kk, s);
+    return caca_set_window_title(dp, s);
 }
 int 	Caca::get_event (unsigned int g, Event *n, int aa)
 {
-    return caca_get_event(kk, g, n->e, aa);
+    return caca_get_event(dp, g, n->e, aa);
 }
 unsigned int 	Caca::get_mouse_x ()
 {
-    return caca_get_mouse_x(kk);
+    return caca_get_mouse_x(dp);
 }
 unsigned int 	Caca::get_mouse_y ()
 {
-    return caca_get_mouse_x(kk);
+    return caca_get_mouse_x(dp);
 }
 void 	Caca::set_mouse (int v)
 {
-     caca_set_mouse(kk, v);
+     caca_set_mouse(dp, v);
 }

cpp/caca++.h

@@ -72,7 +72,7 @@ class Caca {
 
     
     private:
-    caca_t *kk;
+    caca_display_t *dp;
 };
 
 

cpp/cucul++.cpp

@@ -20,43 +20,43 @@
 
 Cucul::Cucul() 
 {
-    c = cucul_create(0,0);
-    if(!c) throw -1;
+    cv = cucul_create(0,0);
+    if(!cv) throw -1;
 }
 Cucul::Cucul(int width, int height) 
 {
-    c = cucul_create(width, height);
-    if(!c) throw -1;
+    cv = cucul_create(width, height);
+    if(!cv) throw -1;
 }
 Cucul::~Cucul() 
 {
-    if(c) {
-        cucul_free(c);
+    if(cv) {
+        cucul_free(cv);
     }
 }
 
 cucul_canvas_t *Cucul::get_cucul_canvas_t()
 {
-    return c;
+    return cv;
 }
 
 
 
 void Cucul::set_size(unsigned int width, unsigned int height) 
 {
-    cucul_set_size (c, width, height);
+    cucul_set_size (cv, width, height);
 }
 unsigned int Cucul::get_width(void) 
 {
-    return cucul_get_width (c);
+    return cucul_get_width (cv);
 }
 unsigned int Cucul::get_height(void) 
 {
-    return cucul_get_height (c);
+    return cucul_get_height (cv);
 }
 void Cucul::set_color(unsigned int f, unsigned int b) 
 {
-    cucul_set_color (c, f, b);
+    cucul_set_color (cv, f, b);
 }
 char const * Cucul::get_color_name (unsigned int color) 
 {
@@ -64,11 +64,11 @@ char const * Cucul::get_color_name (unsigned int color)
 }
 void Cucul::putchar (int x, int y, char ch)
 {
-    cucul_putchar (c, x, y, ch);
+    cucul_putchar (cv, x, y, ch);
 }
 void Cucul::putstr (int x, int y, char *str) 
 {
-    cucul_putstr(c, x, y, str);
+    cucul_putstr(cv, x, y, str);
 }
 void 	Cucul::printf ( int x , int y , char const * format,...)
 {
@@ -91,102 +91,102 @@ void 	Cucul::printf ( int x , int y , char const * format,...)
 
 void 	Cucul::clear ()
 {
-    cucul_clear(c);
+    cucul_clear(cv);
 }
 
 void 	Cucul::blit ( int x, int y, Cucul* c1, Cucul* c2)
 {
-    cucul_blit(c, x, y, c1->get_cucul_canvas_t(), c2->get_cucul_canvas_t());
+    cucul_blit(cv, x, y, c1->get_cucul_canvas_t(), c2->get_cucul_canvas_t());
 }
 
 void 	Cucul::invert ()
 {
-    cucul_invert(c);
+    cucul_invert(cv);
 }
 
 void 	Cucul::flip ()
 {
-    cucul_flip(c);
+    cucul_flip(cv);
 }
 
 void 	Cucul::flop ()
 {
-    cucul_flop(c);
+    cucul_flop(cv);
 }
 
 void 	Cucul::rotate ()
 {
-    cucul_rotate(c);
+    cucul_rotate(cv);
 }
 
 void 	Cucul::draw_line (int x1 , int y1, int x2, int y2, char const *ch)
 {
-    cucul_draw_line(c, x1,y1,x2,y2, ch);
+    cucul_draw_line(cv, x1,y1,x2,y2, ch);
 }
  
 void 	Cucul::draw_polyline (int const x[], int const y[], int f, char const *ch)
 {
-    cucul_draw_polyline(c, x, y, f, ch);
+    cucul_draw_polyline(cv, x, y, f, ch);
 }
  
 void 	Cucul::draw_thin_line (int x1 , int y1, int x2, int y2)
 {
-    cucul_draw_thin_line(c, x1, y1, x2, y2);
+    cucul_draw_thin_line(cv, x1, y1, x2, y2);
 }
 
 void 	Cucul::draw_thin_polyline ( int const x[], int const y[], int f)
 {
-    cucul_draw_thin_polyline(c, x, y, f);
+    cucul_draw_thin_polyline(cv, x, y, f);
 }
  
 void 	Cucul::draw_circle ( int x, int y, int d, char const *ch)
 {
-    cucul_draw_circle(c, x, y, d, ch);
+    cucul_draw_circle(cv, x, y, d, ch);
 }
 
 void 	Cucul::draw_ellipse ( int x, int y, int d1, int d2, char const *ch)
 {
-    cucul_draw_ellipse(c, x, y, d1, d2, ch);
+    cucul_draw_ellipse(cv, x, y, d1, d2, ch);
 }
 
 void 	Cucul::draw_thin_ellipse ( int x, int y, int d1, int d2)
 {
-    cucul_draw_thin_ellipse(c, x, y, d1, d2);
+    cucul_draw_thin_ellipse(cv, x, y, d1, d2);
 }
 
 void 	Cucul::fill_ellipse ( int x, int y, int d1, int d2, char const *ch)
 {
-    cucul_fill_ellipse(c, x, y, d1, d2, ch);
+    cucul_fill_ellipse(cv, x, y, d1, d2, ch);
 }
 
 void 	Cucul::draw_box ( int x, int y, int w, int h, char const *ch)
 {
-    cucul_draw_box(c, x, y, w, h, ch);
+    cucul_draw_box(cv, x, y, w, h, ch);
 }
  
 void 	Cucul::draw_thin_box ( int x, int y, int w, int h)
 {
-    cucul_draw_thin_box(c, x, y, w, h);
+    cucul_draw_thin_box(cv, x, y, w, h);
 }
 
 void 	Cucul::fill_box ( int x, int y, int w, int h, char const *ch)
 {
-    cucul_fill_box(c, x, y, w, h, ch);
+    cucul_fill_box(cv, x, y, w, h, ch);
 }
 
 void 	Cucul::draw_triangle ( int x1, int y1, int x2, int y2, int x3, int y3, char const *ch)
 {
-    cucul_draw_triangle(c, x1, y1, x2, y2, x3, y3, ch);
+    cucul_draw_triangle(cv, x1, y1, x2, y2, x3, y3, ch);
 }
 
 void 	Cucul::draw_thin_triangle ( int x1, int y1, int x2, int y2, int x3, int y3)
 {
-    cucul_draw_thin_triangle(c, x1, y1, x2, y2, x3, y3);
+    cucul_draw_thin_triangle(cv, x1, y1, x2, y2, x3, y3);
 }
 
 void 	Cucul::fill_triangle ( int x1, int y1, int x2, int y2, int x3, int y3, const char *ch)
 {
-    cucul_fill_triangle(c, x1, y1, x2, y2, x3, y3, ch);
+    cucul_fill_triangle(cv, x1, y1, x2, y2, x3, y3, ch);
 }
 
 int 	Cucul::rand (int min, int max)
@@ -228,7 +228,7 @@ int 	Cucul::get_sprite_dy (Cucul::Sprite const *s, int v)
 
 void 	Cucul::draw_sprite ( int x, int y, Cucul::Sprite const *s, int v)
 {
-    cucul_draw_sprite(c, x, y, s->sprite, v);
+    cucul_draw_sprite(cv, x, y, s->sprite, v);
 }
 
 void 	Cucul::free_sprite (Cucul::Sprite *s)
@@ -268,9 +268,9 @@ void 	Cucul::set_dither_invert ( Cucul::Dither *d, int i)
     cucul_set_dither_invert(d->dither, i);
 }
 
-void 	Cucul::set_dither_antialias ( Cucul::Dither *d, char const *c)
+void 	Cucul::set_dither_antialias ( Cucul::Dither *d, char const *cv)
 {
-    cucul_set_dither_antialias(d->dither, c);
+    cucul_set_dither_antialias(d->dither, cv);
 }
  
 char const *const * 	Cucul::get_dither_antialias_list ( Cucul::Dither const *d)
@@ -278,9 +278,9 @@ char const *const * 	Cucul::get_dither_antialias_list ( Cucul::Dither const *d)
     return cucul_get_dither_antialias_list(d->dither);
 }
 
-void 	Cucul::set_dither_color ( Cucul::Dither *d, char const *c)
+void 	Cucul::set_dither_color ( Cucul::Dither *d, char const *cv)
 {
-    cucul_set_dither_color(d->dither, c);
+    cucul_set_dither_color(d->dither, cv);
 }
 
 char const *const * 	Cucul::get_dither_color_list ( Cucul::Dither const *d)
@@ -288,9 +288,9 @@ char const *const * 	Cucul::get_dither_color_list ( Cucul::Dither const *d)
     return cucul_get_dither_color_list(d->dither);
 }
  
-void 	Cucul::set_dither_charset ( Cucul::Dither *d, char const *c)
+void 	Cucul::set_dither_charset ( Cucul::Dither *d, char const *cv)
 {
-    cucul_set_dither_charset(d->dither, c);
+    cucul_set_dither_charset(d->dither, cv);
 }
 
 char const *const * 	Cucul::get_dither_charset_list ( Cucul::Dither const *d)
@@ -298,9 +298,9 @@ char const *const * 	Cucul::get_dither_charset_list ( Cucul::Dither const *d)
     return cucul_get_dither_charset_list(d->dither);
 }
  
-void 	Cucul::set_dither_mode ( Cucul::Dither *d, char const *c)
+void 	Cucul::set_dither_mode ( Cucul::Dither *d, char const *cv)
 {
-    cucul_set_dither_mode(d->dither, c);
+    cucul_set_dither_mode(d->dither, cv);
 }
 
 char const *const * 	Cucul::get_dither_mode_list ( Cucul::Dither const *d)
@@ -310,7 +310,7 @@ char const *const * 	Cucul::get_dither_mode_list ( Cucul::Dither const *d)
 
 void 	Cucul::dither_bitmap ( int x, int y, int w, int h,  Cucul::Dither const *d, void *v)
 {
-    cucul_dither_bitmap(c, x, y, w, h, d->dither, v);
+    cucul_dither_bitmap(cv, x, y, w, h, d->dither, v);
 }
 
 void 	Cucul::free_dither ( Cucul::Dither *d)
@@ -342,7 +342,7 @@ unsigned int 	Cucul::get_font_height ( Cucul::Font *f)
 
 void 	Cucul::render_canvas (Cucul::Font *f, unsigned char *buf, unsigned int x, unsigned int y, unsigned int w)
 {
-    cucul_render_canvas(c, f->font, buf, x,y,w);
+    cucul_render_canvas(cv, f->font, buf, x,y,w);
 }
 
 void 	Cucul::free_font ( Cucul::Font *f)
@@ -353,7 +353,7 @@ void 	Cucul::free_font ( Cucul::Font *f)
 Cucul::Buffer * 	Cucul::create_export (char const *buf)
 {
     Cucul::Buffer *b = new Cucul::Buffer();
-    b->buffer = cucul_create_export(c, buf);
+    b->buffer = cucul_create_export(cv, buf);
     return b;
 }
 

cpp/cucul++.h

@@ -65,7 +65,7 @@ class Cucul {
     void set_color(unsigned int f, unsigned int b);
     char const * get_color_name (unsigned int color);
     void 	printf ( int x , int y , char const * format,...);
-    void putchar (int x, int y, char c);
+    void putchar (int x, int y, char ch);
     void putstr (int x, int y, char *str);
     void 	clear ();
     void 	blit ( int, int, Cucul* c1, Cucul* c2);
@@ -126,7 +126,7 @@ class Cucul {
     cucul_canvas_t *get_cucul_canvas_t();
 
  private:
-    cucul_canvas_t *c;
+    cucul_canvas_t *cv;
 
 
 };

cucul/box.c

@@ -26,7 +26,7 @@
 
 /** \brief Draw a box on the canvas using the given character.
  *
- *  \param c The handle to the libcucul canvas.
+ *  \param cv The handle to the libcucul canvas.
  *  \param x1 X coordinate of the upper-left corner of the box.
  *  \param y1 Y coordinate of the upper-left corner of the box.
  *  \param x2 X coordinate of the lower-right corner of the box.
@@ -34,25 +34,25 @@
  *  \param str UTF-8 string containing the character to use to draw the box.
  *  \return void
  */
-void cucul_draw_box(cucul_canvas_t *c, int x1, int y1, int x2, int y2, 
+void cucul_draw_box(cucul_canvas_t *cv, int x1, int y1, int x2, int y2, 
                     char const *str)
 {
-    cucul_draw_line(c, x1, y1, x1, y2, str);
-    cucul_draw_line(c, x1, y2, x2, y2, str);
-    cucul_draw_line(c, x2, y2, x2, y1, str);
-    cucul_draw_line(c, x2, y1, x1, y1, str);
+    cucul_draw_line(cv, x1, y1, x1, y2, str);
+    cucul_draw_line(cv, x1, y2, x2, y2, str);
+    cucul_draw_line(cv, x2, y2, x2, y1, str);
+    cucul_draw_line(cv, x2, y1, x1, y1, str);
 }
 
 /** \brief Draw a thin box on the canvas.
  *
- *  \param c The handle to the libcucul canvas.
+ *  \param cv The handle to the libcucul canvas.
  *  \param x1 X coordinate of the upper-left corner of the box.
  *  \param y1 Y coordinate of the upper-left corner of the box.
  *  \param x2 X coordinate of the lower-right corner of the box.
  *  \param y2 Y coordinate of the lower-right corner of the box.
  *  \return void
  */
-void cucul_draw_thin_box(cucul_canvas_t *c, int x1, int y1, int x2, int y2)
+void cucul_draw_thin_box(cucul_canvas_t *cv, int x1, int y1, int x2, int y2)
 {
     int x, y, xmax, ymax;
 
@@ -68,8 +68,8 @@ void cucul_draw_thin_box(cucul_canvas_t *c, int x1, int y1, int x2, int y2)
         y1 = y2; y2 = tmp;
     }
 
-    xmax = c->width - 1;
-    ymax = c->height - 1;
+    xmax = cv->width - 1;
+    ymax = cv->height - 1;
 
     if(x2 < 0 || y2 < 0 || x1 > xmax || y1 > ymax)
         return;
@@ -77,37 +77,37 @@ void cucul_draw_thin_box(cucul_canvas_t *c, int x1, int y1, int x2, int y2)
     /* Draw edges */
     if(y1 >= 0)
         for(x = x1 < 0 ? 1 : x1 + 1; x < x2 && x < xmax; x++)
-            _cucul_putchar32(c, x, y1, (uint32_t)'-');
+            _cucul_putchar32(cv, x, y1, (uint32_t)'-');
 
     if(y2 <= ymax)
         for(x = x1 < 0 ? 1 : x1 + 1; x < x2 && x < xmax; x++)
-            _cucul_putchar32(c, x, y2, (uint32_t)'-');
+            _cucul_putchar32(cv, x, y2, (uint32_t)'-');
 
     if(x1 >= 0)
         for(y = y1 < 0 ? 1 : y1 + 1; y < y2 && y < ymax; y++)
-            _cucul_putchar32(c, x1, y, (uint32_t)'|');
+            _cucul_putchar32(cv, x1, y, (uint32_t)'|');
 
     if(x2 <= xmax)
         for(y = y1 < 0 ? 1 : y1 + 1; y < y2 && y < ymax; y++)
-            _cucul_putchar32(c, x2, y, (uint32_t)'|');
+            _cucul_putchar32(cv, x2, y, (uint32_t)'|');
 
     /* Draw corners */
     if(x1 >= 0 && y1 >= 0)
-        _cucul_putchar32(c, x1, y1, (uint32_t)',');
+        _cucul_putchar32(cv, x1, y1, (uint32_t)',');
 
     if(x1 >= 0 && y2 <= ymax)
-        _cucul_putchar32(c, x1, y2, (uint32_t)'`');
+        _cucul_putchar32(cv, x1, y2, (uint32_t)'`');
 
     if(x2 <= xmax && y1 >= 0)
-        _cucul_putchar32(c, x2, y1, (uint32_t)'.');
+        _cucul_putchar32(cv, x2, y1, (uint32_t)'.');
 
     if(x2 <= xmax && y2 <= ymax)
-        _cucul_putchar32(c, x2, y2, (uint32_t)'\'');
+        _cucul_putchar32(cv, x2, y2, (uint32_t)'\'');
 }
 
 /** \brief Fill a box on the canvas using the given character.
  *
- *  \param c The handle to the libcucul canvas.
+ *  \param cv The handle to the libcucul canvas.
  *  \param x1 X coordinate of the upper-left corner of the box.
  *  \param y1 Y coordinate of the upper-left corner of the box.
  *  \param x2 X coordinate of the lower-right corner of the box.
@@ -115,7 +115,7 @@ void cucul_draw_thin_box(cucul_canvas_t *c, int x1, int y1, int x2, int y2)
  *  \param str UTF-8 string containing the character to fill the box with.
  *  \return void
  */
-void cucul_fill_box(cucul_canvas_t *c, int x1, int y1, int x2, int y2,
+void cucul_fill_box(cucul_canvas_t *cv, int x1, int y1, int x2, int y2,
                     char const *str)
 {
     int x, y, xmax, ymax;
@@ -133,8 +133,8 @@ void cucul_fill_box(cucul_canvas_t *c, int x1, int y1, int x2, int y2,
         y1 = y2; y2 = tmp;
     }
 
-    xmax = c->width - 1;
-    ymax = c->height - 1;
+    xmax = cv->width - 1;
+    ymax = cv->height - 1;
 
     if(x2 < 0 || y2 < 0 || x1 > xmax || y1 > ymax)
         return;
@@ -148,6 +148,6 @@ void cucul_fill_box(cucul_canvas_t *c, int x1, int y1, int x2, int y2,
 
     for(y = y1; y <= y2; y++)
         for(x = x1; x <= x2; x++)
-            _cucul_putchar32(c, x, y, ch);
+            _cucul_putchar32(cv, x, y, ch);
 }
 

cucul/canvas.c

@@ -46,22 +46,22 @@
  *  replaced with a space. To print a sequence of bytes forming an UTF-8
  *  character, use cucul_putstr() instead.
  *
- *  \param c A handle to the libcucul canvas.
+ *  \param cv A handle to the libcucul canvas.
  *  \param x X coordinate.
  *  \param y Y coordinate.
  *  \param ch The character to print.
  */
-void cucul_putchar(cucul_canvas_t *c, int x, int y, char ch)
+void cucul_putchar(cucul_canvas_t *cv, int x, int y, char ch)
 {
-    if(x < 0 || x >= (int)c->width ||
-       y < 0 || y >= (int)c->height)
+    if(x < 0 || x >= (int)cv->width ||
+       y < 0 || y >= (int)cv->height)
         return;
 
     if((unsigned char)ch < 0x20 || (unsigned char)ch > 0x7f)
         ch = 0x20;
 
-    c->chars[x + y * c->width] = ch;
-    c->attr[x + y * c->width] = (c->bgcolor << 16) | c->fgcolor;
+    cv->chars[x + y * cv->width] = ch;
+    cv->attr[x + y * cv->width] = (cv->bgcolor << 16) | cv->fgcolor;
 }
 
 /** \brief Print a string.
@@ -71,17 +71,17 @@ void cucul_putchar(cucul_canvas_t *c, int x, int y, char ch)
  *  the canvas boundaries (eg. a negative Y coordinate) and the string will
  *  be cropped accordingly if it is too long.
  *
- *  \param c A handle to the libcucul canvas.
+ *  \param cv A handle to the libcucul canvas.
  *  \param x X coordinate.
  *  \param y Y coordinate.
  *  \param s The string to print.
  */
-void cucul_putstr(cucul_canvas_t *c, int x, int y, char const *s)
+void cucul_putstr(cucul_canvas_t *cv, int x, int y, char const *s)
 {
     uint32_t *chars, *attr;
     unsigned int len;
 
-    if(y < 0 || y >= (int)c->height || x >= (int)c->width)
+    if(y < 0 || y >= (int)cv->height || x >= (int)cv->width)
         return;
 
     len = _cucul_strlen_utf8(s);
@@ -95,16 +95,16 @@ void cucul_putstr(cucul_canvas_t *c, int x, int y, char const *s)
         x = 0;
     }
 
-    chars = c->chars + x + y * c->width;
-    attr = c->attr + x + y * c->width;
+    chars = cv->chars + x + y * cv->width;
+    attr = cv->attr + x + y * cv->width;
 
-    if(x + len >= c->width)
-        len = c->width - x;
+    if(x + len >= cv->width)
+        len = cv->width - x;
 
     while(len)
     {
         *chars++ = _cucul_utf8_to_utf32(s);
-        *attr++ = (c->bgcolor << 16) | c->fgcolor;
+        *attr++ = (cv->bgcolor << 16) | cv->fgcolor;
 
         s = _cucul_skip_utf8(s, 1);
         len--;
@@ -119,34 +119,34 @@ void cucul_putstr(cucul_canvas_t *c, int x, int y, char const *s)
  *  be cropped accordingly if it is too long. The syntax of the format
  *  string is the same as for the C printf() function.
  *
- *  \param c A handle to the libcucul canvas.
+ *  \param cv A handle to the libcucul canvas.
  *  \param x X coordinate.
  *  \param y Y coordinate.
  *  \param format The format string to print.
  *  \param ... Arguments to the format string.
  */
-void cucul_printf(cucul_canvas_t *c, int x, int y, char const *format, ...)
+void cucul_printf(cucul_canvas_t *cv, int x, int y, char const *format, ...)
 {
     char tmp[BUFSIZ];
     char *buf = tmp;
     va_list args;
 
-    if(y < 0 || y >= (int)c->height || x >= (int)c->width)
+    if(y < 0 || y >= (int)cv->height || x >= (int)cv->width)
         return;
 
-    if(c->width - x + 1 > BUFSIZ)
-        buf = malloc(c->width - x + 1);
+    if(cv->width - x + 1 > BUFSIZ)
+        buf = malloc(cv->width - x + 1);
 
     va_start(args, format);
 #if defined(HAVE_VSNPRINTF)
-    vsnprintf(buf, c->width - x + 1, format, args);
+    vsnprintf(buf, cv->width - x + 1, format, args);
 #else
     vsprintf(buf, format, args);
 #endif
-    buf[c->width - x] = '\0';
+    buf[cv->width - x] = '\0';
     va_end(args);
 
-    cucul_putstr(c, x, y, buf);
+    cucul_putstr(cv, x, y, buf);
 
     if(buf != tmp)
         free(buf);
@@ -156,20 +156,20 @@ void cucul_printf(cucul_canvas_t *c, int x, int y, char const *format, ...)
  *
  *  This function clears the canvas using a black background.
  */
-void cucul_clear(cucul_canvas_t *c)
+void cucul_clear(cucul_canvas_t *cv)
 {
-    uint16_t oldfg = c->fgcolor;
-    uint16_t oldbg = c->bgcolor;
-    int y = c->height;
+    uint16_t oldfg = cv->fgcolor;
+    uint16_t oldbg = cv->bgcolor;
+    int y = cv->height;
 
-    cucul_set_color(c, CUCUL_COLOR_LIGHTGRAY, CUCUL_COLOR_BLACK);
+    cucul_set_color(cv, CUCUL_COLOR_LIGHTGRAY, CUCUL_COLOR_BLACK);
 
     /* We could use SLsmg_cls() etc., but drawing empty lines is much faster */
     while(y--)
-        cucul_putstr(c, 0, y, c->empty_line);
+        cucul_putstr(cv, 0, y, cv->empty_line);
 
-    c->fgcolor = oldfg;
-    c->bgcolor = oldbg;
+    cv->fgcolor = oldfg;
+    cv->bgcolor = oldbg;
 }
 
 /** \brief Blit a canvas onto another one.
@@ -230,13 +230,13 @@ void cucul_blit(cucul_canvas_t *dst, int x, int y,
  * XXX: The following functions are not exported
  */
 
-void _cucul_putchar32(cucul_canvas_t *c, int x, int y, uint32_t ch)
+void _cucul_putchar32(cucul_canvas_t *cv, int x, int y, uint32_t ch)
 {
-    if(x < 0 || x >= (int)c->width ||
-       y < 0 || y >= (int)c->height)
+    if(x < 0 || x >= (int)cv->width ||
+       y < 0 || y >= (int)cv->height)
         return;
 
-    c->chars[x + y * c->width] = ch;
-    c->attr[x + y * c->width] = (c->bgcolor << 16) | c->fgcolor;
+    cv->chars[x + y * cv->width] = ch;
+    cv->attr[x + y * cv->width] = (cv->bgcolor << 16) | cv->fgcolor;
 }
 

cucul/charset.c

@@ -145,37 +145,37 @@ static uint32_t const cp437_lookup2[] =
     0xb0, 0x2219, 0xb7, 0x221a, 0x207f, 0xb2, 0x25a0, 0xa0
 };
 
-uint8_t _cucul_utf32_to_cp437(uint32_t c)
+uint8_t _cucul_utf32_to_cp437(uint32_t ch)
 {
     unsigned int i;
 
-    if(c < 0x00000020)
+    if(ch < 0x00000020)
         return '?';
 
-    if(c < 0x00000080)
-        return c;
+    if(ch < 0x00000080)
+        return ch;
 
     for(i = 0; i < sizeof(cp437_lookup1) / sizeof(*cp437_lookup1); i++)
-        if(cp437_lookup1[i] == c)
+        if(cp437_lookup1[i] == ch)
             return 0x01 + i;
 
     for(i = 0; i < sizeof(cp437_lookup2) / sizeof(*cp437_lookup2); i++)
-        if(cp437_lookup2[i] == c)
+        if(cp437_lookup2[i] == ch)
             return 0x7f + i;
 
     return '?';
 }
 
-uint32_t _cucul_cp437_to_utf32(uint8_t c)
+uint32_t _cucul_cp437_to_utf32(uint8_t ch)
 {
-    if(c > 0x7f)
-        return cp437_lookup2[c - 0x7f];
+    if(ch > 0x7f)
+        return cp437_lookup2[ch - 0x7f];
 
-    if(c >= 0x20)
-        return (uint32_t)c;
+    if(ch >= 0x20)
+        return (uint32_t)ch;
 
-    if(c > 0)
-        return cp437_lookup1[c - 0x01];
+    if(ch > 0)
+        return cp437_lookup1[ch - 0x01];
 
     return 0x00000000;
 }

cucul/colour.c

@@ -36,17 +36,17 @@ static const uint16_t ansitab[16] =
  *  Color values are those defined in \e cucul.h, such as CUCUL_COLOR_RED
  *  or CUCUL_COLOR_TRANSPARENT.
  *
- *  \param c A handle to the libcucul canvas.
+ *  \param cv A handle to the libcucul canvas.
  *  \param fg The requested foreground colour.
  *  \param bg The requested background colour.
  */
-void cucul_set_color(cucul_canvas_t *c, unsigned char fg, unsigned char bg)
+void cucul_set_color(cucul_canvas_t *cv, unsigned char fg, unsigned char bg)
 {
     if(fg > 0x20 || bg > 0x20)
         return;
 
-    c->fgcolor = fg;
-    c->bgcolor = bg;
+    cv->fgcolor = fg;
+    cv->bgcolor = bg;
 }
 
 /** \brief Set the default colour pair (truecolor version).
@@ -59,11 +59,11 @@ void cucul_set_color(cucul_canvas_t *c, unsigned char fg, unsigned char bg)
  *  instance, 0xf088 is solid dark cyan (A=15 R=0 G=8 B=8), and 0x8fff is
  *  white with 50% alpha (A=8 R=15 G=15 B=15).
  *
- *  \param c A handle to the libcucul canvas.
+ *  \param cv A handle to the libcucul canvas.
  *  \param fg The requested foreground colour.
  *  \param bg The requested background colour.
  */
-void cucul_set_truecolor(cucul_canvas_t *c, unsigned int fg, unsigned int bg)
+void cucul_set_truecolor(cucul_canvas_t *cv, unsigned int fg, unsigned int bg)
 {
     if(fg > 0xffff || bg > 0xffff)
         return;
@@ -74,8 +74,8 @@ void cucul_set_truecolor(cucul_canvas_t *c, unsigned int fg, unsigned int bg)
     if(bg < 0x100)
         bg += 0x100;
 
-    c->fgcolor = fg;
-    c->bgcolor = bg;
+    cv->fgcolor = fg;
+    cv->bgcolor = bg;
 }
 
 /*

cucul/conic.c

@@ -29,7 +29,7 @@ static void ellipsepoints(cucul_canvas_t *, int, int, int, int, uint32_t);
 
 /** \brief Draw a circle on the canvas using the given character.
  *
- *  \param c The handle to the libcucul canvas.
+ *  \param cv The handle to the libcucul canvas.
  *  \param x Center X coordinate.
  *  \param y Center Y coordinate.
  *  \param r Circle radius.
@@ -37,7 +37,7 @@ static void ellipsepoints(cucul_canvas_t *, int, int, int, int, uint32_t);
  *         to draw the circle outline.
  *  \return void
  */
-void cucul_draw_circle(cucul_canvas_t *c, int x, int y, int r, char const *str)
+void cucul_draw_circle(cucul_canvas_t *cv, int x, int y, int r, char const *str)
 {
     int test, dx, dy;
     uint32_t ch = _cucul_utf8_to_utf32(str);
@@ -45,8 +45,8 @@ void cucul_draw_circle(cucul_canvas_t *c, int x, int y, int r, char const *str)
     /* Optimized Bresenham. Kick ass. */
     for(test = 0, dx = 0, dy = r ; dx <= dy ; dx++)
     {
-        ellipsepoints(c, x, y, dx, dy, ch);
-        ellipsepoints(c, x, y, dy, dx, ch);
+        ellipsepoints(cv, x, y, dx, dy, ch);
+        ellipsepoints(cv, x, y, dy, dx, ch);
 
         test += test > 0 ? dx - dy-- : dx;
     }
@@ -54,7 +54,7 @@ void cucul_draw_circle(cucul_canvas_t *c, int x, int y, int r, char const *str)
 
 /** \brief Fill an ellipse on the canvas using the given character.
  *
- *  \param c The handle to the libcucul canvas.
+ *  \param cv The handle to the libcucul canvas.
  *  \param xo Center X coordinate.
  *  \param yo Center Y coordinate.
  *  \param a Ellipse X radius.
@@ -63,7 +63,7 @@ void cucul_draw_circle(cucul_canvas_t *c, int x, int y, int r, char const *str)
  *         to fill the ellipse.
  *  \return void
  */
-void cucul_fill_ellipse(cucul_canvas_t *c, int xo, int yo, int a, int b,
+void cucul_fill_ellipse(cucul_canvas_t *cv, int xo, int yo, int a, int b,
                         char const *str)
 {
     int d2;
@@ -80,15 +80,15 @@ void cucul_fill_ellipse(cucul_canvas_t *c, int xo, int yo, int a, int b,
         else
         {
             d1 += b*b*(2*x*1) + a*a*(-2*y+2);
-            cucul_draw_line(c, xo - x, yo - y, xo + x, yo - y, str);
-            cucul_draw_line(c, xo - x, yo + y, xo + x, yo + y, str);
+            cucul_draw_line(cv, xo - x, yo - y, xo + x, yo - y, str);
+            cucul_draw_line(cv, xo - x, yo + y, xo + x, yo + y, str);
             y--;
         }
         x++;
     }
 
-    cucul_draw_line(c, xo - x, yo - y, xo + x, yo - y, str);
-    cucul_draw_line(c, xo - x, yo + y, xo + x, yo + y, str);
+    cucul_draw_line(cv, xo - x, yo - y, xo + x, yo - y, str);
+    cucul_draw_line(cv, xo - x, yo + y, xo + x, yo + y, str);
 
     d2 = b*b*(x+0.5)*(x+0.5) + a*a*(y-1)*(y-1) - a*a*b*b;
     while(y > 0)
@@ -104,14 +104,14 @@ void cucul_fill_ellipse(cucul_canvas_t *c, int xo, int yo, int a, int b,
         }
 
         y--;
-        cucul_draw_line(c, xo - x, yo - y, xo + x, yo - y, str);
-        cucul_draw_line(c, xo - x, yo + y, xo + x, yo + y, str);
+        cucul_draw_line(cv, xo - x, yo - y, xo + x, yo - y, str);
+        cucul_draw_line(cv, xo - x, yo + y, xo + x, yo + y, str);
     }
 }
 
 /** \brief Draw an ellipse on the canvas using the given character.
  *
- *  \param c The handle to the libcucul canvas.
+ *  \param cv The handle to the libcucul canvas.
  *  \param xo Center X coordinate.
  *  \param yo Center Y coordinate.
  *  \param a Ellipse X radius.
@@ -120,7 +120,7 @@ void cucul_fill_ellipse(cucul_canvas_t *c, int xo, int yo, int a, int b,
  *         to draw the ellipse outline.
  *  \return void
  */
-void cucul_draw_ellipse(cucul_canvas_t *c, int xo, int yo, int a, int b,
+void cucul_draw_ellipse(cucul_canvas_t *cv, int xo, int yo, int a, int b,
                         char const *str)
 {
     int d2;
@@ -129,7 +129,7 @@ void cucul_draw_ellipse(cucul_canvas_t *c, int xo, int yo, int a, int b,
     int d1 = b*b - (a*a*b) + (a*a/4);
     uint32_t ch = _cucul_utf8_to_utf32(str);
 
-    ellipsepoints(c, xo, yo, x, y, ch);
+    ellipsepoints(cv, xo, yo, x, y, ch);
 
     while(a*a*y - a*a/2 > b*b*(x+1))
     {
@@ -143,7 +143,7 @@ void cucul_draw_ellipse(cucul_canvas_t *c, int xo, int yo, int a, int b,
             y--;
         }
         x++;
-        ellipsepoints(c, xo, yo, x, y, ch);
+        ellipsepoints(cv, xo, yo, x, y, ch);
     }
 
     d2 = b*b*(x+0.5)*(x+0.5) + a*a*(y-1)*(y-1) - a*a*b*b;
@@ -160,20 +160,20 @@ void cucul_draw_ellipse(cucul_canvas_t *c, int xo, int yo, int a, int b,
         }
 
         y--;
-        ellipsepoints(c, xo, yo, x, y, ch);
+        ellipsepoints(cv, xo, yo, x, y, ch);
     }
 }
 
 /** \brief Draw a thin ellipse on the canvas.
  *
- *  \param c The handle to the libcucul canvas.
+ *  \param cv The handle to the libcucul canvas.
  *  \param xo Center X coordinate.
  *  \param yo Center Y coordinate.
  *  \param a Ellipse X radius.
  *  \param b Ellipse Y radius.
  *  \return void
  */
-void cucul_draw_thin_ellipse(cucul_canvas_t *c, int xo, int yo, int a, int b)
+void cucul_draw_thin_ellipse(cucul_canvas_t *cv, int xo, int yo, int a, int b)
 {
     /* FIXME: this is not correct */
     int d2;
@@ -181,7 +181,7 @@ void cucul_draw_thin_ellipse(cucul_canvas_t *c, int xo, int yo, int a, int b)
     int y = b;
     int d1 = b*b - (a*a*b) + (a*a/4);
 
-    ellipsepoints(c, xo, yo, x, y, '-');
+    ellipsepoints(cv, xo, yo, x, y, '-');
 
     while(a*a*y - a*a/2 > b*b*(x+1))
     {
@@ -195,7 +195,7 @@ void cucul_draw_thin_ellipse(cucul_canvas_t *c, int xo, int yo, int a, int b)
             y--;
         }
         x++;
-        ellipsepoints(c, xo, yo, x, y, '-');
+        ellipsepoints(cv, xo, yo, x, y, '-');
     }
 
     d2 = b*b*(x+0.5)*(x+0.5) + a*a*(y-1)*(y-1) - a*a*b*b;
@@ -212,34 +212,34 @@ void cucul_draw_thin_ellipse(cucul_canvas_t *c, int xo, int yo, int a, int b)
         }
 
         y--;
-        ellipsepoints(c, xo, yo, x, y, '|');
+        ellipsepoints(cv, xo, yo, x, y, '|');
     }
 }
 
-static void ellipsepoints(cucul_canvas_t *c, int xo, int yo, int x, int y,
+static void ellipsepoints(cucul_canvas_t *cv, int xo, int yo, int x, int y,
                           uint32_t ch)
 {
     uint8_t b = 0;
 
-    if(xo + x >= 0 && xo + x < (int)c->width)
+    if(xo + x >= 0 && xo + x < (int)cv->width)
         b |= 0x1;
-    if(xo - x >= 0 && xo - x < (int)c->width)
+    if(xo - x >= 0 && xo - x < (int)cv->width)
         b |= 0x2;
-    if(yo + y >= 0 && yo + y < (int)c->height)
+    if(yo + y >= 0 && yo + y < (int)cv->height)
         b |= 0x4;
-    if(yo - y >= 0 && yo - y < (int)c->height)
+    if(yo - y >= 0 && yo - y < (int)cv->height)
         b |= 0x8;
 
     if((b & (0x1|0x4)) == (0x1|0x4))
-        _cucul_putchar32(c, xo + x, yo + y, ch);
+        _cucul_putchar32(cv, xo + x, yo + y, ch);
 
     if((b & (0x2|0x4)) == (0x2|0x4))
-        _cucul_putchar32(c, xo - x, yo + y, ch);
+        _cucul_putchar32(cv, xo - x, yo + y, ch);
 
     if((b & (0x1|0x8)) == (0x1|0x8))
-        _cucul_putchar32(c, xo + x, yo - y, ch);
+        _cucul_putchar32(cv, xo + x, yo - y, ch);
 
     if((b & (0x2|0x8)) == (0x2|0x8))
-        _cucul_putchar32(c, xo - x, yo - y, ch);
+        _cucul_putchar32(cv, xo - x, yo - y, ch);
 }
 

cucul/cucul.c

@@ -43,33 +43,33 @@
  */
 cucul_canvas_t * cucul_create(unsigned int width, unsigned int height)
 {
-    cucul_canvas_t *c = malloc(sizeof(cucul_canvas_t));
+    cucul_canvas_t *cv = malloc(sizeof(cucul_canvas_t));
 
-    c->refcount = 0;
+    cv->refcount = 0;
 
-    c->fgcolor = CUCUL_COLOR_LIGHTGRAY;
-    c->bgcolor = CUCUL_COLOR_BLACK;
+    cv->fgcolor = CUCUL_COLOR_LIGHTGRAY;
+    cv->bgcolor = CUCUL_COLOR_BLACK;
 
-    c->width = c->height = 0;
-    c->chars = NULL;
-    c->attr = NULL;
-    c->empty_line = c->scratch_line = NULL;
+    cv->width = cv->height = 0;
+    cv->chars = NULL;
+    cv->attr = NULL;
+    cv->empty_line = cv->scratch_line = NULL;
 
     /* Initialise to a default size. 80x32 is arbitrary but matches AAlib's
      * default X11 window. When a graphic driver attaches to us, it can set
      * a different size. */
     if(width && height)
-        _cucul_set_size(c, width, height);
+        _cucul_set_size(cv, width, height);
     else
-        _cucul_set_size(c, 80, 32);
+        _cucul_set_size(cv, 80, 32);
 
     if(_cucul_init_dither())
     {
-        free(c);
+        free(cv);
         return NULL;
     }
 
-    return c;
+    return cv;
 }
 
 /** \brief Load a memory area into a canvas.
@@ -83,7 +83,7 @@ cucul_canvas_t * cucul_create(unsigned int width, unsigned int height)
  */
 cucul_canvas_t *cucul_load(void *data, unsigned int size)
 {
-    cucul_canvas_t *c;
+    cucul_canvas_t *cv;
     uint8_t *buf = (uint8_t *)data;
     unsigned int width, height, n;
 
@@ -108,24 +108,24 @@ cucul_canvas_t *cucul_load(void *data, unsigned int size)
         || buf[size - 2] != 'A' || buf[size - 1] != 'C')
         return NULL;
 
-    c = cucul_create(width, height);
+    cv = cucul_create(width, height);
 
-    if(!c)
+    if(!cv)
         return NULL;
 
     for(n = height * width; n--; )
     {
-        c->chars[n] = ((uint32_t)buf[12 + 8 * n] << 24)
+        cv->chars[n] = ((uint32_t)buf[12 + 8 * n] << 24)
                      | ((uint32_t)buf[13 + 8 * n] << 16)
                      | ((uint32_t)buf[14 + 8 * n] << 8)
                      | (uint32_t)buf[15 + 8 * n];
-        c->attr[n] = ((uint32_t)buf[16 + 8 * n] << 24)
+        cv->attr[n] = ((uint32_t)buf[16 + 8 * n] << 24)
                     | ((uint32_t)buf[17 + 8 * n] << 16)
                     | ((uint32_t)buf[18 + 8 * n] << 8)
                     | (uint32_t)buf[19 + 8 * n];
     }
 
-    return c;
+    return cv;
 }
 
 /** \brief Resize a canvas.
@@ -143,40 +143,40 @@ cucul_canvas_t *cucul_load(void *data, unsigned int size)
  *  resize through user interaction. See the caca_event() documentation
  *  for more about this.
  *
- *  \param c A libcucul canvas
+ *  \param cv A libcucul canvas
  *  \param width The desired canvas width
  *  \param height The desired canvas height
  */
-void cucul_set_size(cucul_canvas_t *c, unsigned int width, unsigned int height)
+void cucul_set_size(cucul_canvas_t *cv, unsigned int width, unsigned int height)
 {
-    if(c->refcount)
+    if(cv->refcount)
         return;
 
-    _cucul_set_size(c, width, height);
+    _cucul_set_size(cv, width, height);
 }
 
 /** \brief Get the canvas width.
  *
  *  This function returns the current canvas width, in character cells.
  *
- *  \param c A libcucul canvas
+ *  \param cv A libcucul canvas
  *  \return The canvas width.
  */
-unsigned int cucul_get_width(cucul_canvas_t *c)
+unsigned int cucul_get_width(cucul_canvas_t *cv)
 {
-    return c->width;
+    return cv->width;
 }
 
 /** \brief Get the canvas height.
  *
  *  This function returns the current canvas height, in character cells.
  *
- *  \param c A libcucul canvas
+ *  \param cv A libcucul canvas
  *  \return The canvas height.
  */
-unsigned int cucul_get_height(cucul_canvas_t *c)
+unsigned int cucul_get_height(cucul_canvas_t *cv)
 {
-    return c->height;
+    return cv->height;
 }
 
 /** \brief Translate a colour index into the colour's name.
@@ -221,19 +221,19 @@ char const *cucul_get_color_name(unsigned int color)
  *  cucul_free() has been called, no other \e libcucul functions may be used
  *  unless a new call to cucul_create() is done.
  *
- *  \param c A libcucul canvas
+ *  \param cv A libcucul canvas
  */
-void cucul_free(cucul_canvas_t *c)
+void cucul_free(cucul_canvas_t *cv)
 {
     _cucul_end_dither();
 
-    free(c->empty_line);
-    free(c->scratch_line);
+    free(cv->empty_line);
+    free(cv->scratch_line);
 
-    free(c->chars);
-    free(c->attr);
+    free(cv->chars);
+    free(cv->attr);
 
-    free(c);
+    free(cv);
 }
 
 /** \brief Generate a random integer within a range.
@@ -290,23 +290,24 @@ void cucul_free_buffer(cucul_buffer_t *buf)
  * XXX: The following functions are local.
  */
 
-void _cucul_set_size(cucul_canvas_t *c, unsigned int width, unsigned int height)
+void _cucul_set_size(cucul_canvas_t *cv, unsigned int width,
+                                         unsigned int height)
 {
     unsigned int x, y, old_width, old_height, new_size, old_size;
 
-    old_width = c->width;
-    old_height = c->height;
+    old_width = cv->width;
+    old_height = cv->height;
     old_size = old_width * old_height;
 
-    c->width = width;
-    c->height = height;
+    cv->width = width;
+    cv->height = height;
     new_size = width * height;
 
     /* Step 1: if new area is bigger, resize the memory area now. */
     if(new_size > old_size)
     {
-        c->chars = realloc(c->chars, new_size * sizeof(uint32_t));
-        c->attr = realloc(c->attr, new_size * sizeof(uint32_t));
+        cv->chars = realloc(cv->chars, new_size * sizeof(uint32_t));
+        cv->attr = realloc(cv->attr, new_size * sizeof(uint32_t));
     }
 
     /* Step 2: move line data if necessary. */
@@ -324,14 +325,14 @@ void _cucul_set_size(cucul_canvas_t *c, unsigned int width, unsigned int height)
         {
             for(x = old_width; x--; )
             {
-                c->chars[y * width + x] = c->chars[y * old_width + x];
-                c->attr[y * width + x] = c->attr[y * old_width + x];
+                cv->chars[y * width + x] = cv->chars[y * old_width + x];
+                cv->attr[y * width + x] = cv->attr[y * old_width + x];
             }
 
             /* Zero the end of the line */
             for(x = width - old_width; x--; )
-                c->chars[y * width + old_width + x] = (uint32_t)' ';
-            memset(c->attr + y * width + old_width, 0,
+                cv->chars[y * width + old_width + x] = (uint32_t)' ';
+            memset(cv->attr + y * width + old_width, 0,
                    (width - old_width) * 4);
         }
     }
@@ -345,8 +346,8 @@ void _cucul_set_size(cucul_canvas_t *c, unsigned int width, unsigned int height)
         {
             for(x = 0; x < width; x++)
             {
-                c->chars[y * width + x] = c->chars[y * old_width + x];
-                c->attr[y * width + x] = c->attr[y * old_width + x];
+                cv->chars[y * width + x] = cv->chars[y * old_width + x];
+                cv->attr[y * width + x] = cv->attr[y * old_width + x];
             }
         }
     }
@@ -356,26 +357,26 @@ void _cucul_set_size(cucul_canvas_t *c, unsigned int width, unsigned int height)
     {
         /* Zero the bottom of the screen */
         for(x = (height - old_height) * width; x--; )
-            c->chars[old_height * width + x] = (uint32_t)' ';
-        memset(c->attr + old_height * width, 0,
+            cv->chars[old_height * width + x] = (uint32_t)' ';
+        memset(cv->attr + old_height * width, 0,
                (height - old_height) * width * 4);
     }
 
     /* Step 4: if new area is smaller, resize memory area now. */
     if(new_size <= old_size)
     {
-        c->chars = realloc(c->chars, new_size * sizeof(uint32_t));
-        c->attr = realloc(c->attr, new_size * sizeof(uint32_t));
+        cv->chars = realloc(cv->chars, new_size * sizeof(uint32_t));
+        cv->attr = realloc(cv->attr, new_size * sizeof(uint32_t));
     }
 
     /* Recompute the scratch line and the empty line */
     if(width != old_width)
     {
-        c->empty_line = realloc(c->empty_line, width + 1);
-        memset(c->empty_line, ' ', width);
-        c->empty_line[width] = '\0';
+        cv->empty_line = realloc(cv->empty_line, width + 1);
+        memset(cv->empty_line, ' ', width);
+        cv->empty_line[width] = '\0';
 
-        c->scratch_line = realloc(c->scratch_line, width + 1);
+        cv->scratch_line = realloc(cv->scratch_line, width + 1);
     }
 }
 

cucul/dither.c

@@ -693,7 +693,7 @@ char const * const * cucul_get_dither_mode_list(cucul_dither_t const *d)
  *  Dither a bitmap at the given coordinates. The dither can be of any size
  *  and will be stretched to the text area.
  *
- *  \param c A handle to the libcucul canvas.
+ *  \param cv A handle to the libcucul canvas.
  *  \param x1 X coordinate of the upper-left corner of the drawing area.
  *  \param y1 Y coordinate of the upper-left corner of the drawing area.
  *  \param x2 X coordinate of the lower-right corner of the drawing area.
@@ -701,7 +701,7 @@ char const * const * cucul_get_dither_mode_list(cucul_dither_t const *d)
  *  \param d Dither object to be drawn.
  *  \param pixels Bitmap's pixels.
  */
-void cucul_dither_bitmap(cucul_canvas_t *c, int x1, int y1, int x2, int y2,
+void cucul_dither_bitmap(cucul_canvas_t *cv, int x1, int y1, int x2, int y2,
                          cucul_dither_t const *d, void *pixels)
 {
     int *floyd_steinberg, *fs_r, *fs_g, *fs_b;
@@ -730,19 +730,19 @@ void cucul_dither_bitmap(cucul_canvas_t *c, int x1, int y1, int x2, int y2,
     deltay = y2 - y1 + 1;
     dchmax = d->glyph_count;
 
-    fs_length = ((int)c->width <= x2 ? (int)c->width : x2) + 1;
+    fs_length = ((int)cv->width <= x2 ? (int)cv->width : x2) + 1;
     floyd_steinberg = malloc(3 * (fs_length + 2) * sizeof(int));
     memset(floyd_steinberg, 0, 3 * (fs_length + 2) * sizeof(int));
     fs_r = floyd_steinberg + 1;
     fs_g = fs_r + fs_length + 2;
     fs_b = fs_g + fs_length + 2;
 
-    for(y = y1 > 0 ? y1 : 0; y <= y2 && y <= (int)c->height; y++)
+    for(y = y1 > 0 ? y1 : 0; y <= y2 && y <= (int)cv->height; y++)
     {
         int remain_r = 0, remain_g = 0, remain_b = 0;
 
         for(x = x1 > 0 ? x1 : 0, d->init_dither(y);
-            x <= x2 && x <= (int)c->width;
+            x <= x2 && x <= (int)cv->width;
             x++)
     {
         unsigned int i;
@@ -936,8 +936,8 @@ void cucul_dither_bitmap(cucul_canvas_t *c, int x1, int y1, int x2, int y2,
         }
 
         /* Now output the character */
-        cucul_set_color(c, outfg, outbg);
-        cucul_putstr(c, x, y, outch);
+        cucul_set_color(cv, outfg, outbg);
+        cucul_putstr(cv, x, y, outch);
 
        d->increment_dither();
     }

cucul/export.c

@@ -59,10 +59,10 @@ static void export_tga(cucul_canvas_t *, cucul_buffer_t *);
  *
  *  \li \e "tga": export a TGA image.
  *
- *  \param c A libcucul canvas
+ *  \param cv A libcucul canvas
  *  \param format A string describing the requested output format.
  */
-cucul_buffer_t * cucul_create_export(cucul_canvas_t *c, char const *format)
+cucul_buffer_t * cucul_create_export(cucul_canvas_t *cv, char const *format)
 {
     cucul_buffer_t *ex;
 
@@ -71,19 +71,19 @@ cucul_buffer_t * cucul_create_export(cucul_canvas_t *c, char const *format)
     ex->data = NULL;
 
     if(!strcasecmp("ansi", format))
-        export_ansi(c, ex);
+        export_ansi(cv, ex);
     else if(!strcasecmp("html", format))
-        export_html(c, ex);
+        export_html(cv, ex);
     else if(!strcasecmp("html3", format))
-        export_html3(c, ex);
+        export_html3(cv, ex);
     else if(!strcasecmp("irc", format))
-        export_irc(c, ex);
+        export_irc(cv, ex);
     else if(!strcasecmp("ps", format))
-        export_ps(c, ex);
+        export_ps(cv, ex);
     else if(!strcasecmp("svg", format))
-        export_svg(c, ex);
+        export_svg(cv, ex);
     else if(!strcasecmp("tga", format))
-        export_tga(c, ex);
+        export_tga(cv, ex);
 
     if(ex->size == 0)
     {
@@ -125,7 +125,7 @@ char const * const * cucul_get_export_list(void)
  */
 
 /* Generate ANSI representation of current canvas. */
-static void export_ansi(cucul_canvas_t *c, cucul_buffer_t *ex)
+static void export_ansi(cucul_canvas_t *cv, cucul_buffer_t *ex)
 {
     static uint8_t const palette[] =
     {
@@ -139,20 +139,20 @@ static void export_ansi(cucul_canvas_t *c, cucul_buffer_t *ex)
     /* 23 bytes assumed for max length per pixel ('\e[5;1;3x;4y;9x;10ym' plus
      * 4 max bytes for a UTF-8 character).
      * Add height*9 to that (zeroes color at the end and jump to next line) */
-    ex->size = (c->height * 9) + (c->width * c->height * 23);
+    ex->size = (cv->height * 9) + (cv->width * cv->height * 23);
     ex->data = malloc(ex->size);
 
     cur = ex->data;
 
-    for(y = 0; y < c->height; y++)
+    for(y = 0; y < cv->height; y++)
     {
-        uint32_t *lineattr = c->attr + y * c->width;
-        uint32_t *linechar = c->chars + y * c->width;
+        uint32_t *lineattr = cv->attr + y * cv->width;
+        uint32_t *linechar = cv->chars + y * cv->width;
 
         uint8_t prevfg = -1;
         uint8_t prevbg = -1;
 
-        for(x = 0; x < c->width; x++)
+        for(x = 0; x < cv->width; x++)
         {
             uint8_t fg = palette[_cucul_argb32_to_ansi4fg(lineattr[x])];
             uint8_t bg = palette[_cucul_argb32_to_ansi4bg(lineattr[x])];
@@ -192,7 +192,7 @@ static void export_ansi(cucul_canvas_t *c, cucul_buffer_t *ex)
 }
 
 /* Generate HTML representation of current canvas. */
-static void export_html(cucul_canvas_t *c, cucul_buffer_t *ex)
+static void export_html(cucul_canvas_t *cv, cucul_buffer_t *ex)
 {
     char *cur;
     unsigned int x, y, len;
@@ -202,7 +202,7 @@ static void export_html(cucul_canvas_t *c, cucul_buffer_t *ex)
      * A glyph: 47 chars for "<span style="color:#xxx;background-color:#xxx">"
      *          up to 9 chars for "&#xxxxxx;", far less for pure ASCII
      *          7 chars for "</span>" */
-    ex->size = 1000 + c->height * (7 + c->width * (47 + 9 + 7));
+    ex->size = 1000 + cv->height * (7 + cv->width * (47 + 9 + 7));
     ex->data = malloc(ex->size);
 
     cur = ex->data;
@@ -215,12 +215,12 @@ static void export_html(cucul_canvas_t *c, cucul_buffer_t *ex)
     cur += sprintf(cur, "<div cellpadding='0' cellspacing='0' style='%s'>\n",
                         "font-family: monospace, fixed; font-weight: bold;");
 
-    for(y = 0; y < c->height; y++)
+    for(y = 0; y < cv->height; y++)
     {
-        uint32_t *lineattr = c->attr + y * c->width;
-        uint32_t *linechar = c->chars + y * c->width;
+        uint32_t *lineattr = cv->attr + y * cv->width;
+        uint32_t *linechar = cv->chars + y * cv->width;
 
-        for(x = 0; x < c->width; x += len)
+        for(x = 0; x < cv->width; x += len)
         {
             cur += sprintf(cur, "<span style=\"color:#%.03x;"
                                 "background-color:#%.03x\">",
@@ -228,7 +228,7 @@ static void export_html(cucul_canvas_t *c, cucul_buffer_t *ex)
                                 _cucul_argb32_to_rgb12bg(lineattr[x]));
 
             for(len = 0;
-                x + len < c->width && lineattr[x + len] == lineattr[x];
+                x + len < cv->width && lineattr[x + len] == lineattr[x];
                 len++)
             {
                 if(linechar[x + len] <= 0x00000020)
@@ -255,7 +255,7 @@ static void export_html(cucul_canvas_t *c, cucul_buffer_t *ex)
  * but permits viewing in old browsers (or limited ones such as links). It
  * will not work under gecko (mozilla rendering engine) unless you set a
  * correct header. */
-static void export_html3(cucul_canvas_t *c, cucul_buffer_t *ex)
+static void export_html3(cucul_canvas_t *cv, cucul_buffer_t *ex)
 {
     char *cur;
     unsigned int x, y, len;
@@ -265,30 +265,30 @@ static void export_html3(cucul_canvas_t *c, cucul_buffer_t *ex)
      * A glyph: 40 chars for "<td bgcolor=#xxxxxx><font color=#xxxxxx>"
      *          up to 9 chars for "&#xxxxxx;", far less for pure ASCII
      *          12 chars for "</font></td>" */
-    ex->size = 1000 + c->height * (10 + c->width * (40 + 9 + 12));
+    ex->size = 1000 + cv->height * (10 + cv->width * (40 + 9 + 12));
     ex->data = malloc(ex->size);
 
     cur = ex->data;
 
     /* Table */
     cur += sprintf(cur, "<table cols='%d' cellpadding='0' cellspacing='0'>\n",
-                        c->height);
+                        cv->height);
 
-    for(y = 0; y < c->height; y++)
+    for(y = 0; y < cv->height; y++)
     {
-        uint32_t *lineattr = c->attr + y * c->width;
-        uint32_t *linechar = c->chars + y * c->width;
+        uint32_t *lineattr = cv->attr + y * cv->width;
+        uint32_t *linechar = cv->chars + y * cv->width;
 
         cur += sprintf(cur, "<tr>");
 
-        for(x = 0; x < c->width; x += len)
+        for(x = 0; x < cv->width; x += len)
         {
             unsigned int i;
 
             /* Use colspan option to factor cells with same attributes
              * (see below) */
             len = 1;
-            while(x + len < c->width && lineattr[x + len] == lineattr[x])
+            while(x + len < cv->width && lineattr[x + len] == lineattr[x])
                 len++;
 
             cur += sprintf(cur, "<td bgcolor=#%.06x",
@@ -324,7 +324,7 @@ static void export_html3(cucul_canvas_t *c, cucul_buffer_t *ex)
 }
 
 /* Export a text file with IRC colours */
-static void export_irc(cucul_canvas_t *c, cucul_buffer_t *ex)
+static void export_irc(cucul_canvas_t *cv, cucul_buffer_t *ex)
 {
     static uint8_t const palette[] =
     {
@@ -338,25 +338,25 @@ static void export_irc(cucul_canvas_t *c, cucul_buffer_t *ex)
     /* 11 bytes assumed for max length per pixel. Worst case scenario:
      * ^Cxx,yy   6 bytes
      * ^B^B      2 bytes
-     * c         1 byte
+     * ch        1 byte
      * \r\n      2 bytes
      * In real life, the average bytes per pixel value will be around 5.
      */
 
-    ex->size = 2 + (c->width * c->height * 11);
+    ex->size = 2 + (cv->width * cv->height * 11);
     ex->data = malloc(ex->size);
 
     cur = ex->data;
 
-    for(y = 0; y < c->height; y++)
+    for(y = 0; y < cv->height; y++)
     {
-        uint32_t *lineattr = c->attr + y * c->width;
-        uint32_t *linechar = c->chars + y * c->width;
+        uint32_t *lineattr = cv->attr + y * cv->width;
+        uint32_t *linechar = cv->chars + y * cv->width;
 
         uint8_t prevfg = -1;
         uint8_t prevbg = -1;
 
-        for(x = 0; x < c->width; x++)
+        for(x = 0; x < cv->width; x++)
         {
             uint8_t fg = palette[_cucul_argb32_to_ansi4fg(lineattr[x])];
             uint8_t bg = palette[_cucul_argb32_to_ansi4bg(lineattr[x])];
@@ -399,7 +399,7 @@ static void export_irc(cucul_canvas_t *c, cucul_buffer_t *ex)
 }
 
 /* Export a PostScript document. */
-static void export_ps(cucul_canvas_t *c, cucul_buffer_t *ex)
+static void export_ps(cucul_canvas_t *cv, cucul_buffer_t *ex)
 {
     static char const *ps_header =
         "%!\n"
@@ -430,7 +430,7 @@ static void export_ps(cucul_canvas_t *c, cucul_buffer_t *ex)
     unsigned int x, y;
 
     /* 200 is arbitrary but should be ok */
-    ex->size = strlen(ps_header) + (c->width * c->height * 200);
+    ex->size = strlen(ps_header) + (cv->width * cv->height * 200);
     ex->data = malloc(ex->size);
 
     cur = ex->data;
@@ -439,11 +439,11 @@ static void export_ps(cucul_canvas_t *c, cucul_buffer_t *ex)
     cur += sprintf(cur, "%s", ps_header);
 
     /* Background, drawn using csquare macro defined in header */
-    for(y = c->height; y--; )
+    for(y = cv->height; y--; )
     {
-        uint32_t *lineattr = c->attr + y * c->width;
+        uint32_t *lineattr = cv->attr + y * cv->width;
 
-        for(x = 0; x < c->width; x++)
+        for(x = 0; x < cv->width; x++)
         {
             uint8_t argb[8];
             _cucul_argb32_to_argb4(*lineattr++, argb);
@@ -454,17 +454,17 @@ static void export_ps(cucul_canvas_t *c, cucul_buffer_t *ex)
         }
 
         /* Return to beginning of the line, and jump to the next one */
-        cur += sprintf(cur, "-%d 1 translate\n", c->width);
+        cur += sprintf(cur, "-%d 1 translate\n", cv->width);
     }
 
     cur += sprintf(cur, "grestore\n"); /* Restore transformation matrix */
 
-    for(y = c->height; y--; )
+    for(y = cv->height; y--; )
     {
-        uint32_t *lineattr = c->attr + (c->height - y - 1) * c->width;
-        uint32_t *linechar = c->chars + (c->height - y - 1) * c->width;
+        uint32_t *lineattr = cv->attr + (cv->height - y - 1) * cv->width;
+        uint32_t *linechar = cv->chars + (cv->height - y - 1) * cv->width;
 
-        for(x = 0; x < c->width; x++)
+        for(x = 0; x < cv->width; x++)
         {
             uint8_t argb[8];
             uint32_t ch = *linechar++;
@@ -504,7 +504,7 @@ static void export_ps(cucul_canvas_t *c, cucul_buffer_t *ex)
 }
 
 /* Export an SVG vector image */
-static void export_svg(cucul_canvas_t *c, cucul_buffer_t *ex)
+static void export_svg(cucul_canvas_t *cv, cucul_buffer_t *ex)
 {
     static char const svg_header[] =
         "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
@@ -517,23 +517,23 @@ static void export_svg(cucul_canvas_t *c, cucul_buffer_t *ex)
     unsigned int x, y;
 
     /* 200 is arbitrary but should be ok */
-    ex->size = strlen(svg_header) + (c->width * c->height * 200);
+    ex->size = strlen(svg_header) + (cv->width * cv->height * 200);
     ex->data = malloc(ex->size);
 
     cur = ex->data;
 
     /* Header */
-    cur += sprintf(cur, svg_header, c->width * 6, c->height * 10,
-                                    c->width * 6, c->height * 10);
+    cur += sprintf(cur, svg_header, cv->width * 6, cv->height * 10,
+                                    cv->width * 6, cv->height * 10);
 
     cur += sprintf(cur, " <g id=\"mainlayer\" font-size=\"12\">\n");
 
     /* Background */
-    for(y = 0; y < c->height; y++)
+    for(y = 0; y < cv->height; y++)
     {
-        uint32_t *lineattr = c->attr + y * c->width;
+        uint32_t *lineattr = cv->attr + y * cv->width;
 
-        for(x = 0; x < c->width; x++)
+        for(x = 0; x < cv->width; x++)
         {
             cur += sprintf(cur, "<rect style=\"fill:#%.03x\" x=\"%d\" y=\"%d\""
                                 " width=\"6\" height=\"10\"/>\n",
@@ -543,12 +543,12 @@ static void export_svg(cucul_canvas_t *c, cucul_buffer_t *ex)
     }
 
     /* Text */
-    for(y = 0; y < c->height; y++)
+    for(y = 0; y < cv->height; y++)
     {
-        uint32_t *lineattr = c->attr + y * c->width;
-        uint32_t *linechar = c->chars + y * c->width;
+        uint32_t *lineattr = cv->attr + y * cv->width;
+        uint32_t *linechar = cv->chars + y * cv->width;
 
-        for(x = 0; x < c->width; x++)
+        for(x = 0; x < cv->width; x++)
         {
             uint32_t ch = *linechar++;
 
@@ -601,7 +601,7 @@ static void export_svg(cucul_canvas_t *c, cucul_buffer_t *ex)
 }
 
 /* Export a TGA image */
-static void export_tga(cucul_canvas_t *c, cucul_buffer_t *ex)
+static void export_tga(cucul_canvas_t *cv, cucul_buffer_t *ex)
 {
     char const * const * fontlist;
     char * cur;
@@ -614,8 +614,8 @@ static void export_tga(cucul_canvas_t *c, cucul_buffer_t *ex)
 
     f = cucul_load_font(fontlist[0], 0);
 
-    w = cucul_get_width(c) * cucul_get_font_width(f);
-    h = cucul_get_height(c) * cucul_get_font_height(f);
+    w = cucul_get_width(cv) * cucul_get_font_width(f);
+    h = cucul_get_height(cv) * cucul_get_font_height(f);
 
     ex->size = w * h * 4 + 18; /* 32 bpp + 18 bytes for the header */
     ex->data = malloc(ex->size);
@@ -643,7 +643,7 @@ static void export_tga(cucul_canvas_t *c, cucul_buffer_t *ex)
     /* Color Map Data: no colormap */
 
     /* Image Data */
-    cucul_render_canvas(c, f, cur, w, h, 4 * w);
+    cucul_render_canvas(cv, f, cur, w, h, 4 * w);
 
     /* Swap bytes. What a waste of time. */
     for(i = 0; i < w * h * 4; i += 4)

cucul/font.c

@@ -259,21 +259,21 @@ void cucul_free_font(cucul_font_t *f)
  *  This function renders the given canvas on an image buffer using a specific
  *  font. The pixel format is fixed (32-bit ARGB, 8 bits for each component).
  *
- *  The required image width can be computed using \e cucul_get_width(c) and
+ *  The required image width can be computed using \e cucul_get_width(cv) and
  *  \e cucul_get_font_width(f). The required height can be computed using
- *  \e cucul_get_height(c) and \e cucul_get_font_height(f).
+ *  \e cucul_get_height(cv) and \e cucul_get_font_height(f).
  *
  *  Glyphs that do not fit in the image buffer are currently not rendered at
  *  all. They may be cropped instead in future versions.
  *
- *  \param c The canvas to render
+ *  \param cv The canvas to render
  *  \param f The font, as returned by \e cucul_load_font()
  *  \param buf The image buffer
  *  \param width The width (in pixels) of the image buffer
  *  \param height The height (in pixels) of the image buffer
  *  \param pitch The pitch (in bytes) of an image buffer line.
  */
-void cucul_render_canvas(cucul_canvas_t *c, cucul_font_t *f,
+void cucul_render_canvas(cucul_canvas_t *cv, cucul_font_t *f,
                          void *buf, unsigned int width,
                          unsigned int height, unsigned int pitch)
 {
@@ -283,15 +283,15 @@ void cucul_render_canvas(cucul_canvas_t *c, cucul_font_t *f,
     if(f->header.bpp != 8)
         glyph = malloc(f->header.width * f->header.height);
 
-    if(width < c->width * f->header.width)
+    if(width < cv->width * f->header.width)
         xmax = width / f->header.width;
     else
-        xmax = c->width;
+        xmax = cv->width;
 
-    if(height < c->height * f->header.height)
+    if(height < cv->height * f->header.height)
         ymax = height / f->header.height;
     else
-        ymax = c->height;
+        ymax = cv->height;
 
     for(y = 0; y < ymax; y++)
     {
@@ -300,8 +300,8 @@ void cucul_render_canvas(cucul_canvas_t *c, cucul_font_t *f,
             uint8_t argb[8];
             unsigned int starty = y * f->header.height;
             unsigned int startx = x * f->header.width;
-            uint32_t ch = c->chars[y * c->width + x];
-            uint32_t attr = c->attr[y * c->width + x];
+            uint32_t ch = cv->chars[y * cv->width + x];
+            uint32_t attr = cv->attr[y * cv->width + x];
             unsigned int b, i, j;
             struct glyph_info *g;
 

cucul/line.c

@@ -42,7 +42,7 @@ static void draw_thin_line(cucul_canvas_t*, struct line*);
 
 /** \brief Draw a line on the canvas using the given character.
  *
- *  \param c The handle to the libcucul canvas.
+ *  \param cv The handle to the libcucul canvas.
  *  \param x1 X coordinate of the first point.
  *  \param y1 Y coordinate of the first point.
  *  \param x2 X coordinate of the second point.
@@ -50,7 +50,7 @@ static void draw_thin_line(cucul_canvas_t*, struct line*);
  *  \param str UTF-8 string containing the character to use to draw the line.
  *  \return void
  */
-void cucul_draw_line(cucul_canvas_t *c, int x1, int y1, int x2, int y2,
+void cucul_draw_line(cucul_canvas_t *cv, int x1, int y1, int x2, int y2,
                      char const *str)
 {
     struct line s;
@@ -60,7 +60,7 @@ void cucul_draw_line(cucul_canvas_t *c, int x1, int y1, int x2, int y2,
     s.y2 = y2;
     s.ch = _cucul_utf8_to_utf32(str);
     s.draw = draw_solid_line;
-    clip_line(c, &s);
+    clip_line(cv, &s);
 }
 
 /** \brief Draw a polyline.
@@ -70,15 +70,15 @@ void cucul_draw_line(cucul_canvas_t *c, int x1, int y1, int x2, int y2,
  *  draw a polygon you need to specify the starting point at the end of the
  *  list as well.
  *
- *  \param c The handle to the libcucul canvas.
+ *  \param cv The handle to the libcucul canvas.
  *  \param x Array of X coordinates. Must have \p n + 1 elements.
  *  \param y Array of Y coordinates. Must have \p n + 1 elements.
  *  \param n Number of lines to draw.
  *  \param str UTF-8 string containing the character to use to draw the lines.
  *  \return void
  */
-void cucul_draw_polyline(cucul_canvas_t *c, int const x[], int const y[], int n,
-                         char const *str)
+void cucul_draw_polyline(cucul_canvas_t *cv, int const x[], int const y[],
+                         int n, char const *str)
 {
     int i;
     struct line s;
@@ -91,20 +91,20 @@ void cucul_draw_polyline(cucul_canvas_t *c, int const x[], int const y[], int n,
         s.y1 = y[i];
         s.x2 = x[i+1];
         s.y2 = y[i+1];
-        clip_line(c, &s);
+        clip_line(cv, &s);
     }
 }
 
 /** \brief Draw a thin line on the canvas, using ASCII art.
  *
- *  \param c The handle to the libcucul canvas.
+ *  \param cv The handle to the libcucul canvas.
  *  \param x1 X coordinate of the first point.
  *  \param y1 Y coordinate of the first point.
  *  \param x2 X coordinate of the second point.
  *  \param y2 Y coordinate of the second point.
  *  \return void
  */
-void cucul_draw_thin_line(cucul_canvas_t *c, int x1, int y1, int x2, int y2)
+void cucul_draw_thin_line(cucul_canvas_t *cv, int x1, int y1, int x2, int y2)
 {
     struct line s;
     s.x1 = x1;
@@ -112,7 +112,7 @@ void cucul_draw_thin_line(cucul_canvas_t *c, int x1, int y1, int x2, int y2)
     s.x2 = x2;
     s.y2 = y2;
     s.draw = draw_thin_line;
-    clip_line(c, &s);
+    clip_line(cv, &s);
 }
 
 /** \brief Draw an ASCII art thin polyline.
@@ -122,13 +122,14 @@ void cucul_draw_thin_line(cucul_canvas_t *c, int x1, int y1, int x2, int y2)
  *  to draw a polygon you need to specify the starting point at the end of
  *  the list as well.
  *
- *  \param c The handle to the libcucul canvas.
+ *  \param cv The handle to the libcucul canvas.
  *  \param x Array of X coordinates. Must have \p n + 1 elements.
  *  \param y Array of Y coordinates. Must have \p n + 1 elements.
  *  \param n Number of lines to draw.
  *  \return void
  */
-void cucul_draw_thin_polyline(cucul_canvas_t *c, int const x[], int const y[], int n)
+void cucul_draw_thin_polyline(cucul_canvas_t *cv, int const x[], int const y[],
+                              int n)
 {
     int i;
     struct line s;
@@ -140,7 +141,7 @@ void cucul_draw_thin_polyline(cucul_canvas_t *c, int const x[], int const y[], i
         s.y1 = y[i];
         s.x2 = x[i+1];
         s.y2 = y[i+1];
-        clip_line(c, &s);
+        clip_line(cv, &s);
     }
 }
 
@@ -149,12 +150,12 @@ void cucul_draw_thin_polyline(cucul_canvas_t *c, int const x[], int const y[], i
  */
 
 /* Generic Cohen-Sutherland line clipping function. */
-static void clip_line(cucul_canvas_t *c, struct line* s)
+static void clip_line(cucul_canvas_t *cv, struct line* s)
 {
     uint8_t bits1, bits2;
 
-    bits1 = clip_bits(c, s->x1, s->y1);
-    bits2 = clip_bits(c, s->x2, s->y2);
+    bits1 = clip_bits(cv, s->x1, s->y1);
+    bits2 = clip_bits(cv, s->x2, s->y2);
 
     if(bits1 & bits2)
         return;
@@ -162,13 +163,13 @@ static void clip_line(cucul_canvas_t *c, struct line* s)
     if(bits1 == 0)
     {
         if(bits2 == 0)
-            s->draw(c, s);
+            s->draw(cv, s);
         else
         {
             int tmp;
             tmp = s->x1; s->x1 = s->x2; s->x2 = tmp;
             tmp = s->y1; s->y1 = s->y2; s->y2 = tmp;
-            clip_line(c, s);
+            clip_line(cv, s);
         }
 
         return;
@@ -181,7 +182,7 @@ static void clip_line(cucul_canvas_t *c, struct line* s)
     }
     else if(bits1 & (1<<1))
     {
-        int xmax = c->width - 1;
+        int xmax = cv->width - 1;
         s->y1 = s->y2 - (s->x2 - xmax) * (s->y2 - s->y1) / (s->x2 - s->x1);
         s->x1 = xmax;
     }
@@ -192,27 +193,27 @@ static void clip_line(cucul_canvas_t *c, struct line* s)
     }
     else if(bits1 & (1<<3))
     {
-        int ymax = c->height - 1;
+        int ymax = cv->height - 1;
         s->x1 = s->x2 - (s->y2 - ymax) * (s->x2 - s->x1) / (s->y2 - s->y1);
         s->y1 = ymax;
     }
 
-    clip_line(c, s);
+    clip_line(cv, s);
 }
 
 /* Helper function for clip_line(). */
-static uint8_t clip_bits(cucul_canvas_t *c, int x, int y)
+static uint8_t clip_bits(cucul_canvas_t *cv, int x, int y)
 {
     uint8_t b = 0;
 
     if(x < 0)
         b |= (1<<0);
-    else if(x >= (int)c->width)
+    else if(x >= (int)cv->width)
         b |= (1<<1);
 
     if(y < 0)
         b |= (1<<2);
-    else if(y >= (int)c->height)
+    else if(y >= (int)cv->height)
         b |= (1<<3);
 
     return b;
@@ -220,7 +221,7 @@ static uint8_t clip_bits(cucul_canvas_t *c, int x, int y)
 
 /* Solid line drawing function, using Bresenham's mid-point line
  * scan-conversion algorithm. */
-static void draw_solid_line(cucul_canvas_t *c, struct line* s)
+static void draw_solid_line(cucul_canvas_t *cv, struct line* s)
 {
     int x1, y1, x2, y2;
     int dx, dy;
@@ -242,7 +243,7 @@ static void draw_solid_line(cucul_canvas_t *c, struct line* s)
 
         for(; dx>=0; dx--)
         {
-            _cucul_putchar32(c, x1, y1, s->ch);
+            _cucul_putchar32(cv, x1, y1, s->ch);
             if(delta > 0)
             {
                 x1 += xinc;
@@ -264,7 +265,7 @@ static void draw_solid_line(cucul_canvas_t *c, struct line* s)
 
         for(; dy >= 0; dy--)
         {
-            _cucul_putchar32(c, x1, y1, s->ch);
+            _cucul_putchar32(cv, x1, y1, s->ch);
             if(delta > 0)
             {
                 x1 += xinc;
@@ -282,7 +283,7 @@ static void draw_solid_line(cucul_canvas_t *c, struct line* s)
 
 /* Thin line drawing function, using Bresenham's mid-point line
  * scan-conversion algorithm and ASCII art graphics. */
-static void draw_thin_line(cucul_canvas_t *c, struct line* s)
+static void draw_thin_line(cucul_canvas_t *cv, struct line* s)
 {
     uint32_t charmapx[2], charmapy[2];
     int x1, y1, x2, y2;
@@ -329,7 +330,7 @@ static void draw_thin_line(cucul_canvas_t *c, struct line* s)
         {
             if(delta > 0)
             {
-                _cucul_putchar32(c, x1, y1, charmapy[1]);
+                _cucul_putchar32(cv, x1, y1, charmapy[1]);
                 x1++;
                 y1 += yinc;
                 delta += dpru;
@@ -338,9 +339,9 @@ static void draw_thin_line(cucul_canvas_t *c, struct line* s)
             else
             {
                 if(prev)
-                    _cucul_putchar32(c, x1, y1, charmapy[0]);
+                    _cucul_putchar32(cv, x1, y1, charmapy[0]);
                 else
-                    _cucul_putchar32(c, x1, y1, (uint32_t)'-');
+                    _cucul_putchar32(cv, x1, y1, (uint32_t)'-');
                 x1++;
                 delta += dpr;
                 prev = 0;
@@ -357,15 +358,15 @@ static void draw_thin_line(cucul_canvas_t *c, struct line* s)
         {
             if(delta > 0)
             {
-                _cucul_putchar32(c, x1, y1, charmapx[0]);
-                _cucul_putchar32(c, x1 + 1, y1, charmapx[1]);
+                _cucul_putchar32(cv, x1, y1, charmapx[0]);
+                _cucul_putchar32(cv, x1 + 1, y1, charmapx[1]);
                 x1++;
                 y1 += yinc;
                 delta += dpru;
             }
             else
             {
-                _cucul_putchar32(c, x1, y1, (uint32_t)'|');
+                _cucul_putchar32(cv, x1, y1, (uint32_t)'|');
                 y1 += yinc;
                 delta += dpr;
             }

cucul/sprite.c

@@ -246,14 +246,15 @@ int cucul_get_sprite_dy(cucul_sprite_t const *sprite, int f)
 /** \brief Draw a sprite's specific frame at the given coordinates. If the
  *         frame does not exist, nothing is displayed.
  *
- *  \param c A libcucul canvas
+ *  \param cv A libcucul canvas
  *  \param x The X coordinate.
  *  \param y The Y coordinate.
  *  \param sprite The sprite.
  *  \param f The frame index.
  *  \return void
  */
-void cucul_draw_sprite(cucul_canvas_t *c, int x, int y, cucul_sprite_t const *sprite, int f)
+void cucul_draw_sprite(cucul_canvas_t *cv, int x, int y,
+                       cucul_sprite_t const *sprite, int f)
 {
     int i, j;
     unsigned int oldfg, oldbg;
@@ -267,8 +268,8 @@ void cucul_draw_sprite(cucul_canvas_t *c, int x, int y, cucul_sprite_t const *sp
 
     frame = &sprite->frames[f];
 
-    oldfg = c->fgcolor;
-    oldbg = c->bgcolor;
+    oldfg = cv->fgcolor;
+    oldbg = cv->bgcolor;
 
     for(j = 0; j < frame->h; j++)
     {
@@ -277,14 +278,14 @@ void cucul_draw_sprite(cucul_canvas_t *c, int x, int y, cucul_sprite_t const *sp
             int col = frame->color[frame->w * j + i];
             if(col >= 0)
             {
-                cucul_set_color(c, col, CUCUL_COLOR_BLACK);
-                cucul_putchar(c, x + i - frame->dx, y + j - frame->dy,
+                cucul_set_color(cv, col, CUCUL_COLOR_BLACK);
+                cucul_putchar(cv, x + i - frame->dx, y + j - frame->dy,
                               frame->chars[frame->w * j + i]);
             }
         }
     }
 
-    cucul_set_color(c, oldfg, oldbg);
+    cucul_set_color(cv, oldfg, oldbg);
 }
 
 /** \brief Free the memory associated with a sprite.

cucul/transform.c

@@ -32,14 +32,14 @@ static uint32_t rotatechar(uint32_t ch);
  *  This function inverts a canvas' colours (black becomes white, red
  *  becomes cyan, etc.) without changing the characters in it.
  *
- *  \param c The canvas to invert.
+ *  \param cv The canvas to invert.
  */
-void cucul_invert(cucul_canvas_t *c)
+void cucul_invert(cucul_canvas_t *cv)
 {
-    uint32_t *attr = c->attr;
+    uint32_t *attr = cv->attr;
     unsigned int i;
 
-    for(i = c->height * c->width; i--; )
+    for(i = cv->height * cv->width; i--; )
     {
         *attr = *attr ^ 0x000f000f;
         attr++;
@@ -51,18 +51,18 @@ void cucul_invert(cucul_canvas_t *c)
  *  This function flips a canvas horizontally, choosing characters that
  *  look like the mirrored version wherever possible.
  *
- *  \param c The canvas to flip.
+ *  \param cv The canvas to flip.
  */
-void cucul_flip(cucul_canvas_t *c)
+void cucul_flip(cucul_canvas_t *cv)
 {
     unsigned int y;
 
-    for(y = 0; y < c->height; y++)
+    for(y = 0; y < cv->height; y++)
     {
-        uint32_t *cleft = c->chars + y * c->width;
-        uint32_t *cright = cleft + c->width - 1;
-        uint32_t *aleft = c->attr + y * c->width;
-        uint32_t *aright = aleft + c->width - 1;
+        uint32_t *cleft = cv->chars + y * cv->width;
+        uint32_t *cright = cleft + cv->width - 1;
+        uint32_t *aleft = cv->attr + y * cv->width;
+        uint32_t *aright = aleft + cv->width - 1;
 
         while(cleft < cright)
         {
@@ -88,18 +88,18 @@ void cucul_flip(cucul_canvas_t *c)
  *  This function flips a canvas vertically, choosing characters that
  *  look like the mirrored version wherever possible.
  *
- *  \param c The canvas to flop.
+ *  \param cv The canvas to flop.
  */
-void cucul_flop(cucul_canvas_t *c)
+void cucul_flop(cucul_canvas_t *cv)
 {
     unsigned int x;
 
-    for(x = 0; x < c->width; x++)
+    for(x = 0; x < cv->width; x++)
     {
-        uint32_t *ctop = c->chars + x;
-        uint32_t *cbottom = ctop + c->width * (c->height - 1);
-        uint32_t *atop = c->attr + x;
-        uint32_t *abottom = atop + c->width * (c->height - 1);
+        uint32_t *ctop = cv->chars + x;
+        uint32_t *cbottom = ctop + cv->width * (cv->height - 1);
+        uint32_t *atop = cv->attr + x;
+        uint32_t *abottom = atop + cv->width * (cv->height - 1);
 
         while(ctop < cbottom)
         {
@@ -112,8 +112,8 @@ void cucul_flop(cucul_canvas_t *c)
             /* Swap characters */
             ch = *cbottom; *cbottom = flopchar(*ctop); *ctop = flopchar(ch);
 
-            ctop += c->width; cbottom -= c->width;
-            atop += c->width; abottom -= c->width;
+            ctop += cv->width; cbottom -= cv->width;
+            atop += cv->width; abottom -= cv->width;
         }
 
         if(ctop == cbottom)
@@ -127,14 +127,14 @@ void cucul_flop(cucul_canvas_t *c)
  *  choosing characters that look like the mirrored version wherever
  *  possible.
  *
- *  \param c The canvas to rotate.
+ *  \param cv The canvas to rotate.
  */
-void cucul_rotate(cucul_canvas_t *c)
+void cucul_rotate(cucul_canvas_t *cv)
 {
-    uint32_t *cbegin = c->chars;
-    uint32_t *cend = cbegin + c->width * c->height - 1;
-    uint32_t *abegin = c->attr;
-    uint32_t *aend = abegin + c->width * c->height - 1;
+    uint32_t *cbegin = cv->chars;
+    uint32_t *cend = cbegin + cv->width * cv->height - 1;
+    uint32_t *abegin = cv->attr;
+    uint32_t *aend = abegin + cv->width * cv->height - 1;
 
     while(cbegin < cend)
     {

cucul/triangle.c

@@ -26,7 +26,7 @@
 
 /** \brief Draw a triangle on the canvas using the given character.
  *
- *  \param c The handle to the libcucul canvas.
+ *  \param cv The handle to the libcucul canvas.
  *  \param x1 X coordinate of the first point.
  *  \param y1 Y coordinate of the first point.
  *  \param x2 X coordinate of the second point.
@@ -37,17 +37,17 @@
  *         to draw the triangle outline.
  *  \return void
  */
-void cucul_draw_triangle(cucul_canvas_t *c, int x1, int y1, int x2, int y2,
+void cucul_draw_triangle(cucul_canvas_t *cv, int x1, int y1, int x2, int y2,
                          int x3, int y3, char const *str)
 {
-    cucul_draw_line(c, x1, y1, x2, y2, str);
-    cucul_draw_line(c, x2, y2, x3, y3, str);
-    cucul_draw_line(c, x3, y3, x1, y1, str);
+    cucul_draw_line(cv, x1, y1, x2, y2, str);
+    cucul_draw_line(cv, x2, y2, x3, y3, str);
+    cucul_draw_line(cv, x3, y3, x1, y1, str);
 }
 
 /** \brief Draw a thin triangle on the canvas.
  *
- *  \param c The handle to the libcucul canvas.
+ *  \param cv The handle to the libcucul canvas.
  *  \param x1 X coordinate of the first point.
  *  \param y1 Y coordinate of the first point.
  *  \param x2 X coordinate of the second point.
@@ -56,17 +56,17 @@ void cucul_draw_triangle(cucul_canvas_t *c, int x1, int y1, int x2, int y2,
  *  \param y3 Y coordinate of the third point.
  *  \return void
  */
-void cucul_draw_thin_triangle(cucul_canvas_t *c, int x1, int y1, int x2, int y2,
-                              int x3, int y3)
+void cucul_draw_thin_triangle(cucul_canvas_t *cv, int x1, int y1,
+                              int x2, int y2, int x3, int y3)
 {
-    cucul_draw_thin_line(c, x1, y1, x2, y2);
-    cucul_draw_thin_line(c, x2, y2, x3, y3);
-    cucul_draw_thin_line(c, x3, y3, x1, y1);
+    cucul_draw_thin_line(cv, x1, y1, x2, y2);
+    cucul_draw_thin_line(cv, x2, y2, x3, y3);
+    cucul_draw_thin_line(cv, x3, y3, x1, y1);
 }
 
 /** \brief Fill a triangle on the canvas using the given character.
  *
- *  \param c The handle to the libcucul canvas.
+ *  \param cv The handle to the libcucul canvas.
  *  \param x1 X coordinate of the first point.
  *  \param y1 Y coordinate of the first point.
  *  \param x2 X coordinate of the second point.
@@ -77,7 +77,7 @@ void cucul_draw_thin_triangle(cucul_canvas_t *c, int x1, int y1, int x2, int y2,
  *         to fill the triangle.
  *  \return void
  */
-void cucul_fill_triangle(cucul_canvas_t *c, int x1, int y1, int x2, int y2,
+void cucul_fill_triangle(cucul_canvas_t *cv, int x1, int y1, int x2, int y2,
                          int x3, int y3, char const *str)
 {
     int x, y, xa, xb, xmax, ymax;
@@ -86,13 +86,13 @@ void cucul_fill_triangle(cucul_canvas_t *c, int x1, int y1, int x2, int y2,
     /* Bubble-sort y1 <= y2 <= y3 */
     if(y1 > y2)
     {
-        cucul_fill_triangle(c, x2, y2, x1, y1, x3, y3, str);
+        cucul_fill_triangle(cv, x2, y2, x1, y1, x3, y3, str);
         return;
     }
 
     if(y2 > y3)
     {
-        cucul_fill_triangle(c, x1, y1, x3, y3, x2, y2, str);
+        cucul_fill_triangle(cv, x1, y1, x3, y3, x2, y2, str);
         return;
     }
 
@@ -101,8 +101,8 @@ void cucul_fill_triangle(cucul_canvas_t *c, int x1, int y1, int x2, int y2,
     x2 *= 4;
     x3 *= 4;
 
-    xmax = c->width - 1;
-    ymax = c->height - 1;
+    xmax = cv->width - 1;
+    ymax = cv->height - 1;
 
     ch = _cucul_utf8_to_utf32(str);
 
@@ -136,7 +136,7 @@ void cucul_fill_triangle(cucul_canvas_t *c, int x1, int y1, int x2, int y2,
         if(xb > xmax) xb = xmax;
 
         for(x = xa; x <= xb; x++)
-            _cucul_putchar32(c, x, y, ch);
+            _cucul_putchar32(cv, x, y, ch);
     }
 }
 

src/aafire.c

@@ -39,8 +39,8 @@
 #endif
 #define MAXTABLE (256*5)
 #ifdef LIBCACA
-static cucul_canvas_t *c;
-static caca_t *kk;
+static cucul_canvas_t *cv;
+static caca_display_t *dp;
 static int XSIZ, YSIZ;
 static cucul_dither_t *cucul_dither;
 static char *bitmap;
@@ -100,21 +100,21 @@ initialize (void)
 #endif
 
 #ifdef LIBCACA
-  c = cucul_create(80, 32);
-  if (!c)
+  cv = cucul_create(80, 32);
+  if (!cv)
     {
       printf ("Failed to initialize libcucul\n");
       exit (1);
     }
-  kk = caca_attach(c);
-  if (!kk)
+  dp = caca_attach(cv);
+  if (!dp)
     {
       printf ("Failed to initialize libcaca\n");
       exit (1);
     }
-  caca_set_delay(kk, 10000);
-  XSIZ = cucul_get_width(c) * 2;
-  YSIZ = cucul_get_height(c) * 2 - 4;
+  caca_set_delay(dp, 10000);
+  XSIZ = cucul_get_width(cv) * 2;
+  YSIZ = cucul_get_height(cv) * 2 - 4;
 #else
   context = aa_autoinit (&aa_defparams);
   if (context == NULL)
@@ -142,8 +142,8 @@ initialize (void)
 #ifdef LIBCACA
   cucul_dither = cucul_create_dither(8, XSIZ, YSIZ - 2, XSIZ, 0, 0, 0, 0);
   cucul_set_dither_palette(cucul_dither, r, g, b, a);
-  bitmap = malloc(4 * cucul_get_width(c) * cucul_get_height(c) * sizeof(char));
-  memset(bitmap, 0, 4 * cucul_get_width(c) * cucul_get_height(c));
+  bitmap = malloc(4 * cucul_get_width(cv) * cucul_get_height(cv) * sizeof(char));
+  memset(bitmap, 0, 4 * cucul_get_width(cv) * cucul_get_height(cv));
 #else
   aa_hidecursor (context);
 #endif
@@ -152,8 +152,8 @@ static void
 uninitialize (void)
 {
 #ifdef LIBCACA
-  caca_detach(kk);
-  cucul_free(c);
+  caca_detach(dp);
+  cucul_free(cv);
 #else
   aa_close (context);
 #endif
@@ -235,14 +235,14 @@ drawfire (void)
   firemain ();
 #ifdef LIBCACA
 paused:
-  cucul_dither_bitmap(c, 0, 0,
-                      cucul_get_width(c) - 1, cucul_get_height(c) - 1,
+  cucul_dither_bitmap(cv, 0, 0,
+                      cucul_get_width(cv) - 1, cucul_get_height(cv) - 1,
                       cucul_dither, bitmap);
-  cucul_set_color(c, CUCUL_COLOR_WHITE, CUCUL_COLOR_BLUE);
-  cucul_putstr(c, cucul_get_width(c) - 30, cucul_get_height(c) - 2,
+  cucul_set_color(cv, CUCUL_COLOR_WHITE, CUCUL_COLOR_BLUE);
+  cucul_putstr(cv, cucul_get_width(cv) - 30, cucul_get_height(cv) - 2,
                " -=[ Powered by libcaca ]=- ");
   
-  caca_display(kk);
+  caca_display(dp);
   /*XSIZ = caca_get_width() * 2;
   YSIZ = caca_get_height() * 2 - 4;*/
 #else
@@ -266,7 +266,7 @@ game (void)
     {
 #ifdef LIBCACA
       caca_event_t ev;
-      if(caca_get_event(kk, CACA_EVENT_KEY_PRESS, &ev, 0))
+      if(caca_get_event(dp, CACA_EVENT_KEY_PRESS, &ev, 0))
         {
           switch(ev.data.key.ch)
             {

src/cacaball.c

@@ -42,9 +42,9 @@ static unsigned char metaball[METASIZE * METASIZE];
 
 int main(int argc, char **argv)
 {
-    cucul_canvas_t *c; caca_t *kk;
+    cucul_canvas_t *cv; caca_display_t *dp;
     unsigned int r[256], g[256], b[256], a[256];
-    float d[METABALLS], di[METABALLS], dj[METABALLS], dk[METABALLS];
+    float dd[METABALLS], di[METABALLS], dj[METABALLS], dk[METABALLS];
     unsigned int x[METABALLS], y[METABALLS];
     cucul_dither_t *cucul_dither;
     float i = 10.0, j = 17.0, k = 11.0;
@@ -53,14 +53,14 @@ int main(int argc, char **argv)
     double frameOffset40[360];
     double frameOffset80[360];
 
-    c = cucul_create(0, 0);
-    if(!c)
+    cv = cucul_create(0, 0);
+    if(!cv)
         return 1;
-    kk = caca_attach(c);
-    if(!kk)
+    dp = caca_attach(cv);
+    if(!dp)
         return 1;
 
-    caca_set_delay(kk, 20000);
+    caca_set_delay(dp, 20000);
 
     /* Make the palette eatable by libcaca */
     for(p = 0; p < 256; p++)
@@ -77,7 +77,7 @@ int main(int argc, char **argv)
 
     for(p = 0; p < METABALLS; p++)
     {
-        d[p] = cucul_rand(0, 100);
+        dd[p] = cucul_rand(0, 100);
         di[p] = (float)cucul_rand(500, 4000) / 6000.0;
         dj[p] = (float)cucul_rand(500, 4000) / 6000.0;
         dk[p] = (float)cucul_rand(500, 4000) / 6000.0;
@@ -93,7 +93,7 @@ int main(int argc, char **argv)
     for(;;)
     {
         caca_event_t ev;
-        if(caca_get_event(kk, CACA_EVENT_KEY_PRESS, &ev, 0))
+        if(caca_get_event(dp, CACA_EVENT_KEY_PRESS, &ev, 0))
         {
             switch(ev.data.key.ch)
             {
@@ -133,7 +133,7 @@ int main(int argc, char **argv)
         for(p = 0; p < METABALLS; p++)
         {
             float u = di[p] * i + dj[p] * j + dk[p] * sin(di[p] * k);
-            float v = d[p] + di[p] * j + dj[p] * k + dk[p] * sin(dk[p] * i);
+            float v = dd[p] + di[p] * j + dj[p] * k + dk[p] * sin(dk[p] * i);
             u = sin(i + u * 2.1) * (1.0 + sin(u));
             v = sin(j + v * 1.9) * (1.0 + sin(v));
             x[p] = (XSIZ - METASIZE) / 2 + u * (XSIZ - METASIZE) / 4;
@@ -153,21 +153,21 @@ int main(int argc, char **argv)
 
 paused:
         /* Draw our virtual buffer to screen, letting libcucul resize it */
-        cucul_dither_bitmap(c, 0, 0,
-                          cucul_get_width(c) - 1, cucul_get_height(c) - 1,
+        cucul_dither_bitmap(cv, 0, 0,
+                          cucul_get_width(cv) - 1, cucul_get_height(cv) - 1,
                           cucul_dither, pixels + (METASIZE / 2) * (1 + XSIZ));
-        cucul_set_color(c, CUCUL_COLOR_WHITE, CUCUL_COLOR_BLUE);
-        cucul_putstr(c, cucul_get_width(c) - 30, cucul_get_height(c) - 2,
+        cucul_set_color(cv, CUCUL_COLOR_WHITE, CUCUL_COLOR_BLUE);
+        cucul_putstr(cv, cucul_get_width(cv) - 30, cucul_get_height(cv) - 2,
                      " -=[ Powered by libcaca ]=- ");
 
-        caca_display(kk);
+        caca_display(dp);
     }
 
     /* End, bye folks */
 end:
     cucul_free_dither(cucul_dither);
-    caca_detach(kk);
-    cucul_free(c);
+    caca_detach(dp);
+    cucul_free(cv);
 
     return 0;
 }

src/cacamoir.c

@@ -37,19 +37,19 @@ static void draw_line(int, int, char);
 
 int main (int argc, char **argv)
 {
-    cucul_canvas_t *c; caca_t *kk;
+    cucul_canvas_t *cv; caca_display_t *dp;
     unsigned int red[256], green[256], blue[256], alpha[256];
     cucul_dither_t *dither;
     int i, x, y, frame = 0, pause = 0;
 
-    c = cucul_create(0, 0);
-    if(!c)
+    cv = cucul_create(0, 0);
+    if(!cv)
         return 1;
-    kk = caca_attach(c);
-    if(!kk)
+    dp = caca_attach(cv);
+    if(!dp)
         return 1;
 
-    caca_set_delay(kk, 20000);
+    caca_set_delay(dp, 20000);
 
     /* Fill various tables */
     for(i = 0 ; i < 256; i++)
@@ -69,7 +69,7 @@ int main (int argc, char **argv)
     for(;;)
     {
         caca_event_t ev;
-        if(caca_get_event(kk, CACA_EVENT_KEY_PRESS, &ev, 0))
+        if(caca_get_event(dp, CACA_EVENT_KEY_PRESS, &ev, 0))
         {
             switch(ev.data.key.ch)
             {
@@ -106,19 +106,19 @@ int main (int argc, char **argv)
         frame++;
 
 paused:
-        cucul_dither_bitmap(c, 0, 0,
-                            cucul_get_width(c) - 1, cucul_get_height(c) - 1,
+        cucul_dither_bitmap(cv, 0, 0,
+                            cucul_get_width(cv) - 1, cucul_get_height(cv) - 1,
                             dither, screen);
-        cucul_set_color(c, CUCUL_COLOR_WHITE, CUCUL_COLOR_BLUE);
-        cucul_putstr(c, cucul_get_width(c) - 30, cucul_get_height(c) - 2,
+        cucul_set_color(cv, CUCUL_COLOR_WHITE, CUCUL_COLOR_BLUE);
+        cucul_putstr(cv, cucul_get_width(cv) - 30, cucul_get_height(cv) - 2,
                      " -=[ Powered by libcaca ]=- ");
-        caca_display(kk);
+        caca_display(dp);
     }
 
 end:
     cucul_free_dither(dither);
-    caca_detach(kk);
-    cucul_free(c);
+    caca_detach(dp);
+    cucul_free(cv);
 
     return 0;
 }

src/cacaplas.c

@@ -40,23 +40,23 @@ static void do_plasma(unsigned char *,
 
 int main (int argc, char **argv)
 {
-    cucul_canvas_t *c, *c2, *mask; caca_t *kk;
+    cucul_canvas_t *cv, *c2, *mask; caca_display_t *dp;
     unsigned int red[256], green[256], blue[256], alpha[256];
     double r[3], R[6];
     cucul_dither_t *dither;
     int i, x, y, frame = 0, pause = 0;
 
-    c = cucul_create(0, 0);
-    if(!c)
+    cv = cucul_create(0, 0);
+    if(!cv)
         return 1;
-    kk = caca_attach(c);
-    if(!kk)
+    dp = caca_attach(cv);
+    if(!dp)
         return 1;
 
-    caca_set_delay(kk, 20000);
+    caca_set_delay(dp, 20000);
 
-    c2 = cucul_create(cucul_get_width(c), cucul_get_height(c));
-    mask = cucul_create(cucul_get_width(c), cucul_get_height(c));
+    c2 = cucul_create(cucul_get_width(cv), cucul_get_height(cv));
+    mask = cucul_create(cucul_get_width(cv), cucul_get_height(cv));
 
     /* Fill various tables */
     for(i = 0 ; i < 256; i++)
@@ -85,7 +85,7 @@ int main (int argc, char **argv)
     for(;;) 
     {
         caca_event_t ev;
-        if(caca_get_event(kk, CACA_EVENT_KEY_PRESS, &ev, 0))
+        if(caca_get_event(dp, CACA_EVENT_KEY_PRESS, &ev, 0))
         {
             switch(ev.data.key.ch)
             {
@@ -119,26 +119,26 @@ int main (int argc, char **argv)
         frame++;
 
 paused:
-        cucul_dither_bitmap(c, 0, 0,
-                            cucul_get_width(c) - 1, cucul_get_height(c) - 1,
+        cucul_dither_bitmap(cv, 0, 0,
+                            cucul_get_width(cv) - 1, cucul_get_height(cv) - 1,
                             dither, screen);
 
-        cucul_blit(c2, 0, 0, c, NULL);
+        cucul_blit(c2, 0, 0, cv, NULL);
         cucul_invert(c2);
 
 
-        cucul_blit(c, 0, 0, c2, mask);
+        cucul_blit(cv, 0, 0, c2, mask);
 
-        cucul_set_color(c, CUCUL_COLOR_WHITE, CUCUL_COLOR_BLUE);
-        cucul_putstr(c, cucul_get_width(c) - 30, cucul_get_height(c) - 2,
+        cucul_set_color(cv, CUCUL_COLOR_WHITE, CUCUL_COLOR_BLUE);
+        cucul_putstr(cv, cucul_get_width(cv) - 30, cucul_get_height(cv) - 2,
                      " -=[ Powered by libcaca ]=- ");
-        caca_display(kk);
+        caca_display(dp);
     }
 
 end:
     cucul_free_dither(dither);
-    caca_detach(kk);
-    cucul_free(c);
+    caca_detach(dp);
+    cucul_free(cv);
 
     return 0;
 }

src/cacaplay.c

@@ -27,8 +27,8 @@ int main(int argc, char **argv)
 {
     struct stat statbuf;
     caca_event_t ev;
-    cucul_canvas_t *c;
-    caca_t *kk;
+    cucul_canvas_t *cv;
+    caca_display_t *dp;
     void *buffer;
     int fd;
 
@@ -53,28 +53,28 @@ int main(int argc, char **argv)
 
     buffer = malloc(statbuf.st_size);
     read(fd, buffer, statbuf.st_size);
-    c = cucul_load(buffer, statbuf.st_size);
+    cv = cucul_load(buffer, statbuf.st_size);
     free(buffer);
 
-    if(!c)
+    if(!cv)
     {
         fprintf(stderr, "%s: invalid caca file %s.\n", argv[0], argv[1]);
         return 1;
     }
 
-    kk = caca_attach(c);
+    dp = caca_attach(cv);
 
-    caca_display(kk);
+    caca_display(dp);
 
-    while(caca_get_event(kk, CACA_EVENT_KEY_PRESS, &ev, -1))
+    while(caca_get_event(dp, CACA_EVENT_KEY_PRESS, &ev, -1))
     {
         if(ev.data.key.ch == CACA_KEY_ESCAPE)
             break;
     }
 
     /* Clean up */
-    caca_detach(kk);
-    cucul_free(c);
+    caca_detach(dp);
+    cucul_free(cv);
 
     return 0;
 }

src/cacaview.c

@@ -41,7 +41,7 @@
 #define PAD_STEP 0.15
 
 /* libcucul/libcaca contexts */
-cucul_canvas_t *c; caca_t *kk;
+cucul_canvas_t *cv; caca_display_t *dp;
 
 /* Local functions */
 static void print_status(void);
@@ -68,25 +68,25 @@ int main(int argc, char **argv)
     int i;
 
     /* Initialise libcucul */
-    c = cucul_create(0, 0);
-    if(!c)
+    cv = cucul_create(0, 0);
+    if(!cv)
     {
         fprintf(stderr, "%s: unable to initialise libcucul\n", argv[0]);
         return 1;
     }
 
-    kk = caca_attach(c);
-    if(!kk)
+    dp = caca_attach(cv);
+    if(!dp)
     {
         fprintf(stderr, "%s: unable to initialise libcaca\n", argv[0]);
         return 1;
     }
 
     /* Set the window title */
-    caca_set_window_title(kk, "cacaview");
+    caca_set_window_title(dp, "cacaview");
 
-    ww = cucul_get_width(c);
-    wh = cucul_get_height(c);
+    ww = cucul_get_width(cv);
+    wh = cucul_get_height(cv);
 
     /* Fill the zoom table */
     zoomtab[0] = 1.0;
@@ -131,9 +131,9 @@ int main(int argc, char **argv)
         int event;
 
         if(update)
-            event = caca_get_event(kk, event_mask, &ev, 0);
+            event = caca_get_event(dp, event_mask, &ev, 0);
         else
-            event = caca_get_event(kk, event_mask, &ev, -1);
+            event = caca_get_event(dp, event_mask, &ev, -1);
 
         while(event)
         {
@@ -170,44 +170,44 @@ int main(int argc, char **argv)
                 break;
 #if 0 /* FIXME */
             case 'b':
-                i = 1 + cucul_get_feature(c, CUCUL_BACKGROUND);
+                i = 1 + cucul_get_feature(cv, CUCUL_BACKGROUND);
                 if(i > CUCUL_BACKGROUND_MAX) i = CUCUL_BACKGROUND_MIN;
-                cucul_set_feature(c, i);
+                cucul_set_feature(cv, i);
                 new_status = STATUS_BACKGROUND;
                 update = 1;
                 break;
             case 'B':
-                i = -1 + cucul_get_feature(c, CUCUL_BACKGROUND);
+                i = -1 + cucul_get_feature(cv, CUCUL_BACKGROUND);
                 if(i < CUCUL_BACKGROUND_MIN) i = CUCUL_BACKGROUND_MAX;
-                cucul_set_feature(c, i);
+                cucul_set_feature(cv, i);
                 new_status = STATUS_BACKGROUND;
                 update = 1;
                 break;
             case 'a':
-                i = 1 + cucul_get_feature(c, CUCUL_ANTIALIASING);
+                i = 1 + cucul_get_feature(cv, CUCUL_ANTIALIASING);
                 if(i > CUCUL_ANTIALIASING_MAX) i = CUCUL_ANTIALIASING_MIN;
-                cucul_set_feature(c, i);
+                cucul_set_feature(cv, i);
                 new_status = STATUS_ANTIALIASING;
                 update = 1;
                 break;
             case 'A':
-                i = -1 + cucul_get_feature(c, CUCUL_ANTIALIASING);
+                i = -1 + cucul_get_feature(cv, CUCUL_ANTIALIASING);
                 if(i < CUCUL_ANTIALIASING_MIN) i = CUCUL_ANTIALIASING_MAX;
-                cucul_set_feature(c, i);
+                cucul_set_feature(cv, i);
                 new_status = STATUS_ANTIALIASING;
                 update = 1;
                 break;
             case 'd':
-                i = 1 + cucul_get_feature(c, CUCUL_DITHERING);
+                i = 1 + cucul_get_feature(cv, CUCUL_DITHERING);
                 if(i > CUCUL_DITHERING_MAX) i = CUCUL_DITHERING_MIN;
-                cucul_set_feature(c, i);
+                cucul_set_feature(cv, i);
                 new_status = STATUS_DITHERING;
                 update = 1;
                 break;
             case 'D':
-                i = -1 + cucul_get_feature(c, CUCUL_DITHERING);
+                i = -1 + cucul_get_feature(cv, CUCUL_DITHERING);
                 if(i < CUCUL_DITHERING_MIN) i = CUCUL_DITHERING_MAX;
-                cucul_set_feature(c, i);
+                cucul_set_feature(cv, i);
                 new_status = STATUS_DITHERING;
                 update = 1;
                 break;
@@ -273,7 +273,7 @@ int main(int argc, char **argv)
             }
             else if(ev.type == CACA_EVENT_RESIZE)
             {
-                caca_display(kk);
+                caca_display(dp);
                 ww = ev.data.resize.w;
                 wh = ev.data.resize.h;
                 update = 1;
@@ -286,7 +286,7 @@ int main(int argc, char **argv)
             if(help || new_help)
                 help = new_help;
 
-            event = caca_get_event(kk, CACA_EVENT_KEY_PRESS, &ev, 0);
+            event = caca_get_event(dp, CACA_EVENT_KEY_PRESS, &ev, 0);
         }
 
         if(items && reload)
@@ -301,11 +301,11 @@ int main(int argc, char **argv)
 
             sprintf(buffer, " Loading `%s'... ", list[current]);
             buffer[ww] = '\0';
-            cucul_set_color(c, CUCUL_COLOR_WHITE, CUCUL_COLOR_BLUE);
-            cucul_putstr(c, (ww - strlen(buffer)) / 2, wh / 2, buffer);
-            caca_display(kk);
-            ww = cucul_get_width(c);
-            wh = cucul_get_height(c);
+            cucul_set_color(cv, CUCUL_COLOR_WHITE, CUCUL_COLOR_BLUE);
+            cucul_putstr(cv, (ww - strlen(buffer)) / 2, wh / 2, buffer);
+            caca_display(dp);
+            ww = cucul_get_width(cv);
+            wh = cucul_get_height(cv);
 
             if(im)
                 unload_image(im);
@@ -321,12 +321,12 @@ int main(int argc, char **argv)
             free(buffer);
         }
 
-        cucul_clear(c);
+        cucul_clear(cv);
 
         if(!items)
         {
-            cucul_set_color(c, CUCUL_COLOR_WHITE, CUCUL_COLOR_BLUE);
-            cucul_printf(c, ww / 2 - 5, wh / 2, " No image. ");
+            cucul_set_color(cv, CUCUL_COLOR_WHITE, CUCUL_COLOR_BLUE);
+            cucul_printf(cv, ww / 2 - 5, wh / 2, " No image. ");
         }
         else if(!im)
         {
@@ -345,8 +345,8 @@ int main(int argc, char **argv)
 
             sprintf(buffer, ERROR_STRING, list[current]);
             buffer[ww] = '\0';
-            cucul_set_color(c, CUCUL_COLOR_WHITE, CUCUL_COLOR_BLUE);
-            cucul_putstr(c, (ww - strlen(buffer)) / 2, wh / 2, buffer);
+            cucul_set_color(cv, CUCUL_COLOR_WHITE, CUCUL_COLOR_BLUE);
+            cucul_putstr(cv, (ww - strlen(buffer)) / 2, wh / 2, buffer);
             free(buffer);
         }
         else
@@ -365,7 +365,7 @@ int main(int argc, char **argv)
                           ww * (1.0 + xfactor) / 2,
                           y + height * (1.0 + yfactor) / 2);
 
-            cucul_dither_bitmap(c, ww * (1.0 - xfactor) * xdelta,
+            cucul_dither_bitmap(cv, ww * (1.0 - xfactor) * xdelta,
                               y + height * (1.0 - yfactor) * ydelta,
                               ww * (xdelta + (1.0 - xdelta) * xfactor),
                               y + height * (ydelta + (1.0 - ydelta) * yfactor),
@@ -377,20 +377,20 @@ int main(int argc, char **argv)
             print_status();
 
 #if 0 /* FIXME */
-            cucul_set_color(c, CUCUL_COLOR_LIGHTGRAY, CUCUL_COLOR_BLACK);
+            cucul_set_color(cv, CUCUL_COLOR_LIGHTGRAY, CUCUL_COLOR_BLACK);
             switch(status)
             {
                 case STATUS_ANTIALIASING:
-                    cucul_printf(c, 0, wh - 1, "Antialiasing: %s",
-                  cucul_get_feature_name(cucul_get_feature(c, CUCUL_ANTIALIASING)));
+                    cucul_printf(cv, 0, wh - 1, "Antialiasing: %s",
+                  cucul_get_feature_name(cucul_get_feature(cv, CUCUL_ANTIALIASING)));
                     break;
                 case STATUS_DITHERING:
-                    cucul_printf(c, 0, wh - 1, "Dithering: %s",
-                  cucul_get_feature_name(cucul_get_feature(c, CUCUL_DITHERING)));
+                    cucul_printf(cv, 0, wh - 1, "Dithering: %s",
+                  cucul_get_feature_name(cucul_get_feature(cv, CUCUL_DITHERING)));
                     break;
                 case STATUS_BACKGROUND:
-                    cucul_printf(c, 0, wh - 1, "Background: %s",
-                  cucul_get_feature_name(cucul_get_feature(c, CUCUL_BACKGROUND)));
+                    cucul_printf(cv, 0, wh - 1, "Background: %s",
+                  cucul_get_feature_name(cucul_get_feature(cv, CUCUL_BACKGROUND)));
                     break;
             }
 #endif
@@ -401,33 +401,33 @@ int main(int argc, char **argv)
             print_help(ww - 26, 2);
         }
 
-        caca_display(kk);
+        caca_display(dp);
         update = 0;
     }
 
     /* Clean up */
     if(im)
         unload_image(im);
-    caca_detach(kk);
-    cucul_free(c);
+    caca_detach(dp);
+    cucul_free(cv);
 
     return 0;
 }
 
 static void print_status(void)
 {
-    cucul_set_color(c, CUCUL_COLOR_WHITE, CUCUL_COLOR_BLUE);
-    cucul_draw_line(c, 0, 0, ww - 1, 0, " ");
-    cucul_draw_line(c, 0, wh - 2, ww - 1, wh - 2, "-");
-    cucul_putstr(c, 0, 0, "q:Quit  np:Next/Prev  +-x:Zoom  gG:Gamma  "
+    cucul_set_color(cv, CUCUL_COLOR_WHITE, CUCUL_COLOR_BLUE);
+    cucul_draw_line(cv, 0, 0, ww - 1, 0, " ");
+    cucul_draw_line(cv, 0, wh - 2, ww - 1, wh - 2, "-");
+    cucul_putstr(cv, 0, 0, "q:Quit  np:Next/Prev  +-x:Zoom  gG:Gamma  "
                            "hjkl:Move  d:Dither  a:Antialias");
-    cucul_putstr(c, ww - strlen("?:Help"), 0, "?:Help");
-    cucul_printf(c, 3, wh - 2, "cacaview %s", VERSION);
-    cucul_printf(c, ww - 30, wh - 2, "(gamma: %#.3g)", GAMMA(g));
-    cucul_printf(c, ww - 14, wh - 2, "(zoom: %s%i)", zoom > 0 ? "+" : "", zoom);
+    cucul_putstr(cv, ww - strlen("?:Help"), 0, "?:Help");
+    cucul_printf(cv, 3, wh - 2, "cacaview %s", VERSION);
+    cucul_printf(cv, ww - 30, wh - 2, "(gamma: %#.3g)", GAMMA(g));
+    cucul_printf(cv, ww - 14, wh - 2, "(zoom: %s%i)", zoom > 0 ? "+" : "", zoom);
 
-    cucul_set_color(c, CUCUL_COLOR_LIGHTGRAY, CUCUL_COLOR_BLACK);
-    cucul_draw_line(c, 0, wh - 1, ww - 1, wh - 1, " ");
+    cucul_set_color(cv, CUCUL_COLOR_LIGHTGRAY, CUCUL_COLOR_BLACK);
+    cucul_draw_line(cv, 0, wh - 1, ww - 1, wh - 1, " ");
 }
 
 static void print_help(int x, int y)
@@ -454,10 +454,10 @@ static void print_help(int x, int y)
 
     int i;
 
-    cucul_set_color(c, CUCUL_COLOR_WHITE, CUCUL_COLOR_BLUE);
+    cucul_set_color(cv, CUCUL_COLOR_WHITE, CUCUL_COLOR_BLUE);
 
     for(i = 0; help[i]; i++)
-        cucul_putstr(c, x, y + i, help[i]);
+        cucul_putstr(cv, x, y + i, help[i]);
 }
 
 static void set_zoom(int new_zoom)
@@ -472,13 +472,13 @@ static void set_zoom(int new_zoom)
     if(zoom > ZOOM_MAX) zoom = ZOOM_MAX;
     if(zoom < -ZOOM_MAX) zoom = -ZOOM_MAX;
 
-    ww = cucul_get_width(c);
+    ww = cucul_get_width(cv);
     height = fullscreen ? wh : wh - 3;
 
     xfactor = (zoom < 0) ? 1.0 / zoomtab[-zoom] : zoomtab[zoom];
     yfactor = xfactor * ww / height * im->h / im->w
-               * cucul_get_height(c) / cucul_get_width(c)
-               * caca_get_window_width(kk) / caca_get_window_height(kk);
+               * cucul_get_height(cv) / cucul_get_width(cv)
+               * caca_get_window_width(dp) / caca_get_window_height(dp);
 
     if(yfactor > xfactor)
     {
@@ -506,17 +506,17 @@ static void draw_checkers(int x1, int y1, int x2, int y2)
 {
     int xn, yn;
 
-    if(x2 + 1 > (int)cucul_get_width(c)) x2 = cucul_get_width(c) - 1;
-    if(y2 + 1 > (int)cucul_get_height(c)) y2 = cucul_get_height(c) - 1;
+    if(x2 + 1 > (int)cucul_get_width(cv)) x2 = cucul_get_width(cv) - 1;
+    if(y2 + 1 > (int)cucul_get_height(cv)) y2 = cucul_get_height(cv) - 1;
 
     for(yn = y1 > 0 ? y1 : 0; yn <= y2; yn++)
         for(xn = x1 > 0 ? x1 : 0; xn <= x2; xn++)
     {
         if((((xn - x1) / 5) ^ ((yn - y1) / 3)) & 1)
-            cucul_set_color(c, CUCUL_COLOR_LIGHTGRAY, CUCUL_COLOR_DARKGRAY);
+            cucul_set_color(cv, CUCUL_COLOR_LIGHTGRAY, CUCUL_COLOR_DARKGRAY);
         else
-            cucul_set_color(c, CUCUL_COLOR_DARKGRAY, CUCUL_COLOR_LIGHTGRAY);
-        cucul_putchar(c, xn, yn, ' ');
+            cucul_set_color(cv, CUCUL_COLOR_DARKGRAY, CUCUL_COLOR_LIGHTGRAY);
+        cucul_putchar(cv, xn, yn, ' ');
     }
 }
 

src/img2irc.c

@@ -23,7 +23,7 @@
 int main(int argc, char **argv)
 {
     /* libcucul context */
-    cucul_canvas_t *c;
+    cucul_canvas_t *cv;
     cucul_buffer_t *export;
     struct image *i;
     int cols = 56, lines;
@@ -34,8 +34,8 @@ int main(int argc, char **argv)
         return 1;
     }
 
-    c = cucul_create(0, 0);
-    if(!c)
+    cv = cucul_create(0, 0);
+    if(!cv)
     {
         fprintf(stderr, "%s: unable to initialise libcucul\n", argv[0]);
         return 1;
@@ -45,25 +45,25 @@ int main(int argc, char **argv)
     if(!i)
     {
         fprintf(stderr, "%s: unable to load %s\n", argv[0], argv[1]);
-        cucul_free(c);
+        cucul_free(cv);
         return 1;
     }
 
     /* Assume a 6×10 font */
     lines = cols * i->h * 6 / i->w / 10;
 
-    cucul_set_size(c, cols, lines);
-    cucul_clear(c);
-    cucul_dither_bitmap(c, 0, 0, cols - 1, lines - 1, i->dither, i->pixels);
+    cucul_set_size(cv, cols, lines);
+    cucul_clear(cv);
+    cucul_dither_bitmap(cv, 0, 0, cols - 1, lines - 1, i->dither, i->pixels);
 
     unload_image(i);
 
-    export = cucul_create_export(c, "irc");
+    export = cucul_create_export(cv, "irc");
     fwrite(cucul_get_buffer_data(export),
            cucul_get_buffer_size(export), 1, stdout);
     cucul_free_buffer(export);
 
-    cucul_free(c);
+    cucul_free(cv);
 
     return 0;
 }

test/colors.c

@@ -22,38 +22,38 @@
 
 int main(int argc, char **argv)
 {
-    cucul_canvas_t *c;
-    caca_t *kk;
+    cucul_canvas_t *cv;
+    caca_display_t *dp;
     caca_event_t ev;
     int i, j;
 
-    c = cucul_create(0, 0);
-    if(!c)
+    cv = cucul_create(0, 0);
+    if(!cv)
         return 1;
 
-    kk = caca_attach(c);
-    if(!kk)
+    dp = caca_attach(cv);
+    if(!dp)
         return 1;
 
-    cucul_clear(c);
+    cucul_clear(cv);
     for(i = 0; i < 16; i++)
     {
-        cucul_set_color(c, CUCUL_COLOR_LIGHTGRAY, CUCUL_COLOR_BLACK);
-        cucul_printf(c, 4, i + (i >= 8 ? 4 : 3), "'%c': %i (%s)",
+        cucul_set_color(cv, CUCUL_COLOR_LIGHTGRAY, CUCUL_COLOR_BLACK);
+        cucul_printf(cv, 4, i + (i >= 8 ? 4 : 3), "'%cv': %i (%s)",
                      'a' + i, i, cucul_get_color_name(i));
         for(j = 0; j < 16; j++)
         {
-            cucul_set_color(c, i, j);
-            cucul_putstr(c, (j >= 8 ? 41 : 40) + j * 2, i + (i >= 8 ? 4 : 3),
+            cucul_set_color(cv, i, j);
+            cucul_putstr(cv, (j >= 8 ? 41 : 40) + j * 2, i + (i >= 8 ? 4 : 3),
                          "# ");
         }
     }
 
-    caca_display(kk);
-    caca_get_event(kk, CACA_EVENT_KEY_PRESS, &ev, -1);
+    caca_display(dp);
+    caca_get_event(dp, CACA_EVENT_KEY_PRESS, &ev, -1);
 
-    caca_detach(kk);
-    cucul_free(c);
+    caca_detach(dp);
+    cucul_free(cv);
 
     return 0;
 }

test/demo.c

@@ -37,22 +37,22 @@ int outline = 0;
 int dithering = 0;
 cucul_sprite_t *sprite = NULL;
 
-cucul_canvas_t *c;
-caca_t *kk;
+cucul_canvas_t *cv;
+caca_display_t *dp;
 
 int main(int argc, char **argv)
 {
     void (*demo)(void) = NULL;
     int quit = 0;
 
-    c = cucul_create(0, 0);
-    if(!c)
+    cv = cucul_create(0, 0);
+    if(!cv)
         return 1;
-    kk = caca_attach(c);
-    if(!kk)
+    dp = caca_attach(cv);
+    if(!dp)
         return 1;
 
-    caca_set_delay(kk, 40000);
+    caca_set_delay(dp, 40000);
 
     /* Initialize data */
     sprite = cucul_load_sprite(DATADIR "/caca.txt");
@@ -62,11 +62,11 @@ int main(int argc, char **argv)
         sprite = cucul_load_sprite("examples/caca.txt");
 
     /* Disable cursor */
-    caca_set_mouse(kk, 0);
+    caca_set_mouse(dp, 0);
 
     /* Main menu */
     display_menu();
-    caca_display(kk);
+    caca_display(dp);
 
     /* Go ! */
     while(!quit)
@@ -74,7 +74,7 @@ int main(int argc, char **argv)
         caca_event_t ev;
         int menu = 0, mouse = 0, xmouse = 0, ymouse = 0;
 
-        while(caca_get_event(kk, CACA_EVENT_ANY, &ev, 0))
+        while(caca_get_event(dp, CACA_EVENT_ANY, &ev, 0))
         {
             if(demo && (ev.type & CACA_EVENT_KEY_PRESS))
             {
@@ -104,7 +104,7 @@ int main(int argc, char **argv)
                 case 'd':
                 case 'D':
                     dithering = (dithering + 1) % 5;
-                    cucul_set_feature(c, dithering);
+                    cucul_set_feature(cv, dithering);
                     display_menu();
                     break;
 #endif
@@ -142,7 +142,7 @@ int main(int argc, char **argv)
                 }
 
                 if(demo)
-                    cucul_clear(c);
+                    cucul_clear(cv);
             }
             else if(ev.type & CACA_EVENT_MOUSE_MOTION)
             {
@@ -161,11 +161,11 @@ int main(int argc, char **argv)
             display_menu();
             if(mouse && !demo)
             {
-                cucul_set_color(c, CUCUL_COLOR_RED, CUCUL_COLOR_BLACK);
-                cucul_putstr(c, xmouse, ymouse,     ".");
-                cucul_putstr(c, xmouse, ymouse + 1, "|\\");
+                cucul_set_color(cv, CUCUL_COLOR_RED, CUCUL_COLOR_BLACK);
+                cucul_putstr(cv, xmouse, ymouse,     ".");
+                cucul_putstr(cv, xmouse, ymouse + 1, "|\\");
             }
-            caca_display(kk);
+            caca_display(dp);
             mouse = menu = 0;
         }
 
@@ -173,58 +173,58 @@ int main(int argc, char **argv)
         {
             demo();
 
-            cucul_set_color(c, CUCUL_COLOR_LIGHTGRAY, CUCUL_COLOR_BLACK);
-            cucul_draw_thin_box(c, 1, 1, cucul_get_width(c) - 2, cucul_get_height(c) - 2);
-            cucul_printf(c, 4, 1, "[%i.%i fps]----",
-                         1000000 / caca_get_rendertime(kk),
-                         (10000000 / caca_get_rendertime(kk)) % 10);
-            caca_display(kk);
+            cucul_set_color(cv, CUCUL_COLOR_LIGHTGRAY, CUCUL_COLOR_BLACK);
+            cucul_draw_thin_box(cv, 1, 1, cucul_get_width(cv) - 2, cucul_get_height(cv) - 2);
+            cucul_printf(cv, 4, 1, "[%i.%i fps]----",
+                         1000000 / caca_get_rendertime(dp),
+                         (10000000 / caca_get_rendertime(dp)) % 10);
+            caca_display(dp);
         }
     }
 
     /* Clean up */
     cucul_free_sprite(sprite);
-    caca_detach(kk);
-    cucul_free(c);
+    caca_detach(dp);
+    cucul_free(cv);
 
     return 0;
 }
 
 static void display_menu(void)
 {
-    int xo = cucul_get_width(c) - 2;
-    int yo = cucul_get_height(c) - 2;
-
-    cucul_clear(c);
-    cucul_set_color(c, CUCUL_COLOR_LIGHTGRAY, CUCUL_COLOR_BLACK);
-    cucul_draw_thin_box(c, 1, 1, xo, yo);
-
-    cucul_putstr(c, (xo - strlen("libcaca demo")) / 2, 3, "libcaca demo");
-    cucul_putstr(c, (xo - strlen("==============")) / 2, 4, "==============");
-
-    cucul_putstr(c, 4, 6, "demos:");
-    cucul_putstr(c, 4, 7, "'f': full");
-    cucul_putstr(c, 4, 8, "'1': dots");
-    cucul_putstr(c, 4, 9, "'2': lines");
-    cucul_putstr(c, 4, 10, "'3': boxes");
-    cucul_putstr(c, 4, 11, "'4': triangles");
-    cucul_putstr(c, 4, 12, "'5': ellipses");
-    cucul_putstr(c, 4, 13, "'c': colour");
-    cucul_putstr(c, 4, 14, "'r': render");
+    int xo = cucul_get_width(cv) - 2;
+    int yo = cucul_get_height(cv) - 2;
+
+    cucul_clear(cv);
+    cucul_set_color(cv, CUCUL_COLOR_LIGHTGRAY, CUCUL_COLOR_BLACK);
+    cucul_draw_thin_box(cv, 1, 1, xo, yo);
+
+    cucul_putstr(cv, (xo - strlen("libcaca demo")) / 2, 3, "libcaca demo");
+    cucul_putstr(cv, (xo - strlen("==============")) / 2, 4, "==============");
+
+    cucul_putstr(cv, 4, 6, "demos:");
+    cucul_putstr(cv, 4, 7, "'f': full");
+    cucul_putstr(cv, 4, 8, "'1': dots");
+    cucul_putstr(cv, 4, 9, "'2': lines");
+    cucul_putstr(cv, 4, 10, "'3': boxes");
+    cucul_putstr(cv, 4, 11, "'4': triangles");
+    cucul_putstr(cv, 4, 12, "'5': ellipses");
+    cucul_putstr(cv, 4, 13, "'c': colour");
+    cucul_putstr(cv, 4, 14, "'r': render");
     if(sprite)
-        cucul_putstr(c, 4, 15, "'s': sprites");
+        cucul_putstr(cv, 4, 15, "'s': sprites");
 
-    cucul_putstr(c, 4, 16, "settings:");
-    cucul_printf(c, 4, 17, "'o': outline: %s",
+    cucul_putstr(cv, 4, 16, "settings:");
+    cucul_printf(cv, 4, 17, "'o': outline: %s",
                  outline == 0 ? "none" : outline == 1 ? "solid" : "thin");
-    cucul_printf(c, 4, 18, "'b': drawing boundaries: %s",
+    cucul_printf(cv, 4, 18, "'b': drawing boundaries: %s",
                  bounds == 0 ? "screen" : "infinite");
-    //cucul_printf(c, 4, 19, "'d': dithering (%s)",
+    //cucul_printf(cv, 4, 19, "'d': dithering (%s)",
     //             cucul_get_feature_name(dithering));
 
-    cucul_putstr(c, 4, yo - 2, "'q': quit");
+    cucul_putstr(cv, 4, yo - 2, "'q': quit");
 
-    caca_display(kk);
+    caca_display(dp);
 }
 
 static void demo_all(void)
@@ -235,99 +235,99 @@ static void demo_all(void)
 
     i++;
 
-    cucul_clear(c);
+    cucul_clear(cv);
 
     /* Draw the sun */
-    cucul_set_color(c, CUCUL_COLOR_YELLOW, CUCUL_COLOR_BLACK);
-    xo = cucul_get_width(c) / 4;
-    yo = cucul_get_height(c) / 4 + 5 * sin(0.03*i);
+    cucul_set_color(cv, CUCUL_COLOR_YELLOW, CUCUL_COLOR_BLACK);
+    xo = cucul_get_width(cv) / 4;
+    yo = cucul_get_height(cv) / 4 + 5 * sin(0.03*i);
 
     for(j = 0; j < 16; j++)
     {
         xa = xo - (30 + sin(0.03*i) * 8) * sin(0.03*i + M_PI*j/8);
         ya = yo + (15 + sin(0.03*i) * 4) * cos(0.03*i + M_PI*j/8);
-        cucul_draw_thin_line(c, xo, yo, xa, ya);
+        cucul_draw_thin_line(cv, xo, yo, xa, ya);
     }
 
     j = 15 + sin(0.03*i) * 8;
-    cucul_set_color(c, CUCUL_COLOR_WHITE, CUCUL_COLOR_BLACK);
-    cucul_fill_ellipse(c, xo, yo, j, j / 2, "#");
-    cucul_set_color(c, CUCUL_COLOR_YELLOW, CUCUL_COLOR_BLACK);
-    cucul_draw_ellipse(c, xo, yo, j, j / 2, "#");
+    cucul_set_color(cv, CUCUL_COLOR_WHITE, CUCUL_COLOR_BLACK);
+    cucul_fill_ellipse(cv, xo, yo, j, j / 2, "#");
+    cucul_set_color(cv, CUCUL_COLOR_YELLOW, CUCUL_COLOR_BLACK);
+    cucul_draw_ellipse(cv, xo, yo, j, j / 2, "#");
 
     /* Draw the pyramid */
-    xo = cucul_get_width(c) * 5 / 8;
+    xo = cucul_get_width(cv) * 5 / 8;
     yo = 2;
 
-    xa = cucul_get_width(c) / 8 + sin(0.03*i) * 5;
-    ya = cucul_get_height(c) / 2 + cos(0.03*i) * 5;
+    xa = cucul_get_width(cv) / 8 + sin(0.03*i) * 5;
+    ya = cucul_get_height(cv) / 2 + cos(0.03*i) * 5;
 
-    xb = cucul_get_width(c) - 10 - cos(0.02*i) * 10;
-    yb = cucul_get_height(c) * 3 / 4 - 5 + sin(0.02*i) * 5;
+    xb = cucul_get_width(cv) - 10 - cos(0.02*i) * 10;
+    yb = cucul_get_height(cv) * 3 / 4 - 5 + sin(0.02*i) * 5;
 
-    xc = cucul_get_width(c) / 4 - sin(0.02*i) * 5;
-    yc = cucul_get_height(c) * 3 / 4 + cos(0.02*i) * 5;
+    xc = cucul_get_width(cv) / 4 - sin(0.02*i) * 5;
+    yc = cucul_get_height(cv) * 3 / 4 + cos(0.02*i) * 5;
 
-    cucul_set_color(c, CUCUL_COLOR_GREEN, CUCUL_COLOR_BLACK);
-    cucul_fill_triangle(c, xo, yo, xb, yb, xa, ya, "%");
-    cucul_set_color(c, CUCUL_COLOR_YELLOW, CUCUL_COLOR_BLACK);
-    cucul_draw_thin_triangle(c, xo, yo, xb, yb, xa, ya);
+    cucul_set_color(cv, CUCUL_COLOR_GREEN, CUCUL_COLOR_BLACK);
+    cucul_fill_triangle(cv, xo, yo, xb, yb, xa, ya, "%");
+    cucul_set_color(cv, CUCUL_COLOR_YELLOW, CUCUL_COLOR_BLACK);
+    cucul_draw_thin_triangle(cv, xo, yo, xb, yb, xa, ya);
 
-    cucul_set_color(c, CUCUL_COLOR_RED, CUCUL_COLOR_BLACK);
-    cucul_fill_triangle(c, xa, ya, xb, yb, xc, yc, "#");
-    cucul_set_color(c, CUCUL_COLOR_YELLOW, CUCUL_COLOR_BLACK);
-    cucul_draw_thin_triangle(c, xa, ya, xb, yb, xc, yc);
+    cucul_set_color(cv, CUCUL_COLOR_RED, CUCUL_COLOR_BLACK);
+    cucul_fill_triangle(cv, xa, ya, xb, yb, xc, yc, "#");
+    cucul_set_color(cv, CUCUL_COLOR_YELLOW, CUCUL_COLOR_BLACK);
+    cucul_draw_thin_triangle(cv, xa, ya, xb, yb, xc, yc);
 
-    cucul_set_color(c, CUCUL_COLOR_BLUE, CUCUL_COLOR_BLACK);
-    cucul_fill_triangle(c, xo, yo, xb, yb, xc, yc, "%");
-    cucul_set_color(c, CUCUL_COLOR_YELLOW, CUCUL_COLOR_BLACK);
-    cucul_draw_thin_triangle(c, xo, yo, xb, yb, xc, yc);
+    cucul_set_color(cv, CUCUL_COLOR_BLUE, CUCUL_COLOR_BLACK);
+    cucul_fill_triangle(cv, xo, yo, xb, yb, xc, yc, "%");
+    cucul_set_color(cv, CUCUL_COLOR_YELLOW, CUCUL_COLOR_BLACK);
+    cucul_draw_thin_triangle(cv, xo, yo, xb, yb, xc, yc);
 
     /* Draw a background triangle */
     xa = 2;
     ya = 2;
 
-    xb = cucul_get_width(c) - 3;
-    yb = cucul_get_height(c) / 2;
+    xb = cucul_get_width(cv) - 3;
+    yb = cucul_get_height(cv) / 2;
 
-    xc = cucul_get_width(c) / 3;
-    yc = cucul_get_height(c) - 3;
+    xc = cucul_get_width(cv) / 3;
+    yc = cucul_get_height(cv) - 3;
 
-    cucul_set_color(c, CUCUL_COLOR_CYAN, CUCUL_COLOR_BLACK);
-    cucul_draw_thin_triangle(c, xa, ya, xb, yb, xc, yc);
+    cucul_set_color(cv, CUCUL_COLOR_CYAN, CUCUL_COLOR_BLACK);
+    cucul_draw_thin_triangle(cv, xa, ya, xb, yb, xc, yc);
 
-    xo = cucul_get_width(c) / 2 + cos(0.027*i) * cucul_get_width(c) / 3;
-    yo = cucul_get_height(c) / 2 - sin(0.027*i) * cucul_get_height(c) / 2;
+    xo = cucul_get_width(cv) / 2 + cos(0.027*i) * cucul_get_width(cv) / 3;
+    yo = cucul_get_height(cv) / 2 - sin(0.027*i) * cucul_get_height(cv) / 2;
 
-    cucul_draw_thin_line(c, xa, ya, xo, yo);
-    cucul_draw_thin_line(c, xb, yb, xo, yo);
-    cucul_draw_thin_line(c, xc, yc, xo, yo);
+    cucul_draw_thin_line(cv, xa, ya, xo, yo);
+    cucul_draw_thin_line(cv, xb, yb, xo, yo);
+    cucul_draw_thin_line(cv, xc, yc, xo, yo);
 
     /* Draw a sprite on the pyramid */
-    cucul_draw_sprite(c, xo, yo, sprite, 0);
+    cucul_draw_sprite(cv, xo, yo, sprite, 0);
 
     /* Draw a trail behind the foreground sprite */
     for(j = i - 60; j < i; j++)
     {
         int delta = cucul_rand(-5, 5);
-        cucul_set_color(c, cucul_rand(0, 15), cucul_rand(0, 15));
-        cucul_putchar(c, cucul_get_width(c) / 2
-                    + cos(0.02*j) * (delta + cucul_get_width(c) / 4),
-                   cucul_get_height(c) / 2
-                    + sin(0.02*j) * (delta + cucul_get_height(c) / 3),
+        cucul_set_color(cv, cucul_rand(0, 15), cucul_rand(0, 15));
+        cucul_putchar(cv, cucul_get_width(cv) / 2
+                    + cos(0.02*j) * (delta + cucul_get_width(cv) / 4),
+                   cucul_get_height(cv) / 2
+                    + sin(0.02*j) * (delta + cucul_get_height(cv) / 3),
                    '#');
     }
 
     /* Draw foreground sprite */
-    cucul_draw_sprite(c, cucul_get_width(c) / 2 + cos(0.02*i) * cucul_get_width(c) / 4,
-                   cucul_get_height(c) / 2 + sin(0.02*i) * cucul_get_height(c) / 3,
+    cucul_draw_sprite(cv, cucul_get_width(cv) / 2 + cos(0.02*i) * cucul_get_width(cv) / 4,
+                   cucul_get_height(cv) / 2 + sin(0.02*i) * cucul_get_height(cv) / 3,
                    sprite, 0);
 }
 
 static void demo_dots(void)
 {
-    int xmax = cucul_get_width(c) - 1;
-    int ymax = cucul_get_height(c) - 1;
+    int xmax = cucul_get_width(cv) - 1;
+    int ymax = cucul_get_height(cv) - 1;
     int i;
     static char chars[10] =
     {
@@ -337,8 +337,8 @@ static void demo_dots(void)
     for(i = 1000; i--;)
     {
         /* Putpixel */
-        cucul_set_color(c, cucul_rand(0, 15), cucul_rand(0, 15));
-        cucul_putchar(c, cucul_rand(0, xmax), cucul_rand(0, ymax),
+        cucul_set_color(cv, cucul_rand(0, 15), cucul_rand(0, 15));
+        cucul_putchar(cv, cucul_rand(0, xmax), cucul_rand(0, ymax),
                       chars[cucul_rand(0, 9)]);
     }
 }
@@ -348,24 +348,24 @@ static void demo_color(void)
     int i, j;
     char buf[BUFSIZ];
 
-    cucul_clear(c);
+    cucul_clear(cv);
     for(i = 0; i < 16; i++)
     {
         sprintf(buf, "'%c': %i (%s)", 'a' + i, i, cucul_get_color_name(i));
-        cucul_set_color(c, CUCUL_COLOR_LIGHTGRAY, CUCUL_COLOR_BLACK);
-        cucul_putstr(c, 4, i + (i >= 8 ? 4 : 3), buf);
+        cucul_set_color(cv, CUCUL_COLOR_LIGHTGRAY, CUCUL_COLOR_BLACK);
+        cucul_putstr(cv, 4, i + (i >= 8 ? 4 : 3), buf);
         for(j = 0; j < 16; j++)
         {
-            cucul_set_color(c, i, j);
-            cucul_putstr(c, (j >= 8 ? 41 : 40) + j * 2, i + (i >= 8 ? 4 : 3), "# ");
+            cucul_set_color(cv, i, j);
+            cucul_putstr(cv, (j >= 8 ? 41 : 40) + j * 2, i + (i >= 8 ? 4 : 3), "# ");
         }
     }
 }
 
 static void demo_lines(void)
 {
-    int w = cucul_get_width(c);
-    int h = cucul_get_height(c);
+    int w = cucul_get_width(cv);
+    int h = cucul_get_height(cv);
     int xa, ya, xb, yb;
 
     if(bounds)
@@ -379,17 +379,17 @@ static void demo_lines(void)
         xb = cucul_rand(0, w - 1); yb = cucul_rand(0, h - 1);
     }
 
-    cucul_set_color(c, cucul_rand(0, 15), CUCUL_COLOR_BLACK);
+    cucul_set_color(cv, cucul_rand(0, 15), CUCUL_COLOR_BLACK);
     if(outline > 1)
-        cucul_draw_thin_line(c, xa, ya, xb, yb);
+        cucul_draw_thin_line(cv, xa, ya, xb, yb);
     else
-        cucul_draw_line(c, xa, ya, xb, yb, "#");
+        cucul_draw_line(cv, xa, ya, xb, yb, "#");
 }
 
 static void demo_boxes(void)
 {
-    int w = cucul_get_width(c);
-    int h = cucul_get_height(c);
+    int w = cucul_get_width(cv);
+    int h = cucul_get_height(cv);
     int xa, ya, xb, yb;
 
     if(bounds)
@@ -403,20 +403,20 @@ static void demo_boxes(void)
         xb = cucul_rand(0, w - 1); yb = cucul_rand(0, h - 1);
     }
 
-    cucul_set_color(c, cucul_rand(0, 15), cucul_rand(0, 15));
-    cucul_fill_box(c, xa, ya, xb, yb, "#");
+    cucul_set_color(cv, cucul_rand(0, 15), cucul_rand(0, 15));
+    cucul_fill_box(cv, xa, ya, xb, yb, "#");
 
-    cucul_set_color(c, cucul_rand(0, 15), CUCUL_COLOR_BLACK);
+    cucul_set_color(cv, cucul_rand(0, 15), CUCUL_COLOR_BLACK);
     if(outline == 2)
-        cucul_draw_thin_box(c, xa, ya, xb, yb);
+        cucul_draw_thin_box(cv, xa, ya, xb, yb);
     else if(outline == 1)
-        cucul_draw_box(c, xa, ya, xb, yb, "#");
+        cucul_draw_box(cv, xa, ya, xb, yb, "#");
 }
 
 static void demo_ellipses(void)
 {
-    int w = cucul_get_width(c);
-    int h = cucul_get_height(c);
+    int w = cucul_get_width(cv);
+    int h = cucul_get_height(cv);
     int x, y, a, b;
 
     if(bounds)
@@ -434,20 +434,20 @@ static void demo_ellipses(void)
         } while(x - a < 0 || x + a >= w || y - b < 0 || y + b >= h);
     }
 
-    cucul_set_color(c, cucul_rand(0, 15), cucul_rand(0, 15));
-    cucul_fill_ellipse(c, x, y, a, b, "#");
+    cucul_set_color(cv, cucul_rand(0, 15), cucul_rand(0, 15));
+    cucul_fill_ellipse(cv, x, y, a, b, "#");
 
-    cucul_set_color(c, cucul_rand(0, 15), CUCUL_COLOR_BLACK);
+    cucul_set_color(cv, cucul_rand(0, 15), CUCUL_COLOR_BLACK);
     if(outline == 2)
-        cucul_draw_thin_ellipse(c, x, y, a, b);
+        cucul_draw_thin_ellipse(cv, x, y, a, b);
     else if(outline == 1)
-        cucul_draw_ellipse(c, x, y, a, b, "#");
+        cucul_draw_ellipse(cv, x, y, a, b, "#");
 }
 
 static void demo_triangles(void)
 {
-    int w = cucul_get_width(c);
-    int h = cucul_get_height(c);
+    int w = cucul_get_width(cv);
+    int h = cucul_get_height(cv);
     int xa, ya, xb, yb, xc, yc;
 
     if(bounds)
@@ -464,20 +464,20 @@ static void demo_triangles(void)
         xc = cucul_rand(0, w - 1); yc = cucul_rand(0, h - 1);
     }
 
-    cucul_set_color(c, cucul_rand(0, 15), cucul_rand(0, 15));
-    cucul_fill_triangle(c, xa, ya, xb, yb, xc, yc, "#");
+    cucul_set_color(cv, cucul_rand(0, 15), cucul_rand(0, 15));
+    cucul_fill_triangle(cv, xa, ya, xb, yb, xc, yc, "#");
 
-    cucul_set_color(c, cucul_rand(0, 15), CUCUL_COLOR_BLACK);
+    cucul_set_color(cv, cucul_rand(0, 15), CUCUL_COLOR_BLACK);
     if(outline == 2)
-        cucul_draw_thin_triangle(c, xa, ya, xb, yb, xc, yc);
+        cucul_draw_thin_triangle(cv, xa, ya, xb, yb, xc, yc);
     else if(outline == 1)
-        cucul_draw_triangle(c, xa, ya, xb, yb, xc, yc, "#");
+        cucul_draw_triangle(cv, xa, ya, xb, yb, xc, yc, "#");
 }
 
 static void demo_sprites(void)
 {
-    cucul_draw_sprite(c, cucul_rand(0, cucul_get_width(c) - 1),
-                   cucul_rand(0, cucul_get_height(c) - 1), sprite, 0);
+    cucul_draw_sprite(cv, cucul_rand(0, cucul_get_width(cv) - 1),
+                   cucul_rand(0, cucul_get_height(cv) - 1), sprite, 0);
 }
 
 #if 0
@@ -503,7 +503,7 @@ static void demo_render(void)
     cucul_set_dither_invert(dither, 1);
     //dither = cucul_create_dither(16, 256, 256, 2 * 256, 0xf800, 0x07e0, 0x001f, 0x0000);
     dither = cucul_create_dither(32, 256, 256, 4 * 256, 0x00ff0000, 0x0000ff00, 0x000000ff, 0xff000000);
-    cucul_dither_bitmap(c, 0, 0, cucul_get_width(c) - 1, cucul_get_height(c) - 1,
+    cucul_dither_bitmap(cv, 0, 0, cucul_get_width(cv) - 1, cucul_get_height(cv) - 1,
                      dither, buffer);
     cucul_free_dither(dither);
 }
@@ -548,7 +548,7 @@ static void demo_render(void)
 
     dither = cucul_create_dither(32, 256, 256, 4 * 256, 0x00ff0000, 0x0000ff00, 0x000000ff, 0xff000000);
  cucul_set_dither_invert(dither, 1);
-    cucul_dither_bitmap(c, 0, 0, cucul_get_width(c) - 1, cucul_get_height(c) - 1, dither, (char *)buffer);
+    cucul_dither_bitmap(cv, 0, 0, cucul_get_width(cv) - 1, cucul_get_height(cv) - 1, dither, (char *)buffer);
     cucul_free_dither(dither);
 }
 

test/dithering.c

@@ -35,13 +35,13 @@ char density[] = " ',+:;o&%w$W@#";
 int main(void)
 {
     caca_event_t ev;
-    cucul_canvas_t *c;
-    caca_t *kk;
+    cucul_canvas_t *cv;
+    caca_display_t *dp;
     int neara, dista, nearb, distb, dist;
     int x, y;
 
-    c = cucul_create(0, 0);
-    kk = caca_attach(c);
+    cv = cucul_create(0, 0);
+    dp = caca_attach(cv);
 
     for(x = 0; x < 100; x++)
         for(y = 0; y < 100; y++)
@@ -116,18 +116,18 @@ int main(void)
             ch = density[distb * 2 * 13 / (dista + distb)];
         else
             ch = density[dista * 2 * 13 / (dista + distb)];
-        cucul_set_color(c, points[nearb], points[neara]);
+        cucul_set_color(cv, points[nearb], points[neara]);
 
-        cucul_putchar(c, x * cucul_get_width(c) / 100,
-                          (100 - y) * cucul_get_height(c) / 100, ch);
+        cucul_putchar(cv, x * cucul_get_width(cv) / 100,
+                          (100 - y) * cucul_get_height(cv) / 100, ch);
     }
 
-    caca_display(kk);
+    caca_display(dp);
 
-    caca_get_event(kk, CACA_EVENT_KEY_PRESS, &ev, -1);
+    caca_get_event(dp, CACA_EVENT_KEY_PRESS, &ev, -1);
 
-    caca_detach(kk);
-    cucul_free(c);
+    caca_detach(dp);
+    cucul_free(cv);
 
     return 0;
 }

test/event.c

@@ -20,8 +20,8 @@
 #include "cucul.h"
 #include "caca.h"
 
-static cucul_canvas_t *c;
-static caca_t *kk;
+static cucul_canvas_t *cv;
+static caca_display_t *dp;
 
 static void print_event(int, int, caca_event_t *);
 
@@ -30,22 +30,22 @@ int main(int argc, char **argv)
     caca_event_t *events;
     int i, h, quit;
 
-    c = cucul_create(0, 0);
-    if(!c)
+    cv = cucul_create(0, 0);
+    if(!cv)
         return 1;
-    kk = caca_attach(c);
-    if(!kk)
+    dp = caca_attach(cv);
+    if(!dp)
         return 1;
 
-    h = cucul_get_height(c) - 1;
+    h = cucul_get_height(cv) - 1;
 
-    cucul_set_color(c, CUCUL_COLOR_WHITE, CUCUL_COLOR_BLUE);
-    cucul_draw_line(c, 0, 0, cucul_get_width(c) - 1, 0, " ");
+    cucul_set_color(cv, CUCUL_COLOR_WHITE, CUCUL_COLOR_BLUE);
+    cucul_draw_line(cv, 0, 0, cucul_get_width(cv) - 1, 0, " ");
 
-    cucul_draw_line(c, 0, h, cucul_get_width(c) - 1, h, " ");
-    cucul_putstr(c, 0, h, "type \"quit\" to exit");
+    cucul_draw_line(cv, 0, h, cucul_get_width(cv) - 1, h, " ");
+    cucul_putstr(cv, 0, h, "type \"quit\" to exit");
 
-    caca_display(kk);
+    caca_display(dp);
 
     events = malloc(h * sizeof(caca_event_t));
     memset(events, 0, h * sizeof(caca_event_t));
@@ -54,7 +54,7 @@ int main(int argc, char **argv)
     {
         caca_event_t ev;
         static char const * quit_string[] = { "", "q", "qu", "qui", "quit" };
-        int ret = caca_get_event(kk, CACA_EVENT_ANY, &ev, -1);
+        int ret = caca_get_event(dp, CACA_EVENT_ANY, &ev, -1);
 
         if(!ret)
             continue;
@@ -77,31 +77,31 @@ int main(int argc, char **argv)
             memmove(events + 1, events, (h - 1) * sizeof(caca_event_t));
             events[0] = ev;
 
-            ret = caca_get_event(kk, CACA_EVENT_ANY, &ev, 0);
+            ret = caca_get_event(dp, CACA_EVENT_ANY, &ev, 0);
         }
         while(ret);
 
-        cucul_clear(c);
+        cucul_clear(cv);
 
         /* Print current event */
-        cucul_set_color(c, CUCUL_COLOR_WHITE, CUCUL_COLOR_BLUE);
-        cucul_draw_line(c, 0, 0, cucul_get_width(c) - 1, 0, " ");
+        cucul_set_color(cv, CUCUL_COLOR_WHITE, CUCUL_COLOR_BLUE);
+        cucul_draw_line(cv, 0, 0, cucul_get_width(cv) - 1, 0, " ");
         print_event(0, 0, events);
 
-        cucul_draw_line(c, 0, h, cucul_get_width(c) - 1, h, " ");
-        cucul_printf(c, 0, h, "type \"quit\" to exit: %s", quit_string[quit]);
+        cucul_draw_line(cv, 0, h, cucul_get_width(cv) - 1, h, " ");
+        cucul_printf(cv, 0, h, "type \"quit\" to exit: %s", quit_string[quit]);
 
         /* Print previous events */
-        cucul_set_color(c, CUCUL_COLOR_WHITE, CUCUL_COLOR_BLACK);
+        cucul_set_color(cv, CUCUL_COLOR_WHITE, CUCUL_COLOR_BLACK);
         for(i = 1; i < h && events[i].type; i++)
             print_event(0, i, events + i);
 
-        caca_display(kk);
+        caca_display(dp);
     }
 
     /* Clean up */
-    caca_detach(kk);
-    cucul_free(c);
+    caca_detach(dp);
+    cucul_free(cv);
 
     return 0;
 }
@@ -113,39 +113,39 @@ static void print_event(int x, int y, caca_event_t *ev)
     switch(ev->type)
     {
     case CACA_EVENT_NONE:
-        cucul_printf(c, x, y, "CACA_EVENT_NONE");
+        cucul_printf(cv, x, y, "CACA_EVENT_NONE");
         break;
     case CACA_EVENT_KEY_PRESS:
         character = ev->data.key.ch;
-        cucul_printf(c, x, y, "CACA_EVENT_KEY_PRESS 0x%02x (%c)", character,
+        cucul_printf(cv, x, y, "CACA_EVENT_KEY_PRESS 0x%02x (%cv)", character,
                      (character > 0x1f && character < 0x80) ? character : '?');
         break;
     case CACA_EVENT_KEY_RELEASE:
         character = ev->data.key.ch;
-        cucul_printf(c, x, y, "CACA_EVENT_KEY_RELEASE 0x%02x (%c)", character,
+        cucul_printf(cv, x, y, "CACA_EVENT_KEY_RELEASE 0x%02x (%cv)", character,
                      (character > 0x1f && character < 0x80) ? character : '?');
         break;
     case CACA_EVENT_MOUSE_MOTION:
-        cucul_printf(c, x, y, "CACA_EVENT_MOUSE_MOTION %u %u",
+        cucul_printf(cv, x, y, "CACA_EVENT_MOUSE_MOTION %u %u",
                      ev->data.mouse.x, ev->data.mouse.y);
         break;
     case CACA_EVENT_MOUSE_PRESS:
-        cucul_printf(c, x, y, "CACA_EVENT_MOUSE_PRESS %u",
+        cucul_printf(cv, x, y, "CACA_EVENT_MOUSE_PRESS %u",
                      ev->data.mouse.button);
         break;
     case CACA_EVENT_MOUSE_RELEASE:
-        cucul_printf(c, x, y, "CACA_EVENT_MOUSE_RELEASE %u",
+        cucul_printf(cv, x, y, "CACA_EVENT_MOUSE_RELEASE %u",
                      ev->data.mouse.button);
         break;
     case CACA_EVENT_RESIZE:
-        cucul_printf(c, x, y, "CACA_EVENT_RESIZE %u %u",
+        cucul_printf(cv, x, y, "CACA_EVENT_RESIZE %u %u",
                      ev->data.resize.w, ev->data.resize.h);
         break;
     case CACA_EVENT_QUIT:
-        cucul_printf(c, x, y, "CACA_EVENT_QUIT");
+        cucul_printf(cv, x, y, "CACA_EVENT_QUIT");
         break;
     default:
-        cucul_printf(c, x, y, "CACA_EVENT_UNKNOWN");
+        cucul_printf(cv, x, y, "CACA_EVENT_UNKNOWN");
     }
 }
 

test/export.c

@@ -34,7 +34,7 @@ uint32_t pixels[256*256];
 
 int main(int argc, char *argv[])
 {
-    cucul_canvas_t *c;
+    cucul_canvas_t *cv;
     cucul_dither_t *dither;
     cucul_buffer_t *buffer;
     char const * const * exports, * const * p;
@@ -65,7 +65,7 @@ int main(int argc, char *argv[])
         exit(-1);
     }
 
-    c = cucul_create(WIDTH, HEIGHT);
+    cv = cucul_create(WIDTH, HEIGHT);
 
     for(y = 0; y < 256; y++)
     {
@@ -80,34 +80,34 @@ int main(int argc, char *argv[])
 
     dither = cucul_create_dither(32, 256, 256, 4 * 256,
                                  0x00ff0000, 0x0000ff00, 0x000000ff, 0x0);
-    cucul_dither_bitmap(c, 0, 0,
-                        cucul_get_width(c) - 1, cucul_get_height(c) - 1,
+    cucul_dither_bitmap(cv, 0, 0,
+                        cucul_get_width(cv) - 1, cucul_get_height(cv) - 1,
                         dither, pixels);
     cucul_free_dither(dither);
 
-    cucul_set_color(c, CUCUL_COLOR_WHITE, CUCUL_COLOR_BLACK);
-    cucul_draw_thin_box(c, 0, 0, WIDTH - 1, HEIGHT - 1);
+    cucul_set_color(cv, CUCUL_COLOR_WHITE, CUCUL_COLOR_BLACK);
+    cucul_draw_thin_box(cv, 0, 0, WIDTH - 1, HEIGHT - 1);
 
-    cucul_set_color(c, CUCUL_COLOR_BLACK, CUCUL_COLOR_WHITE);
-    cucul_fill_ellipse(c, WIDTH / 2, HEIGHT / 2, WIDTH / 4, HEIGHT / 4, " ");
-    cucul_putstr(c, WIDTH / 2 - 5, HEIGHT / 2 - 2, "(\") \\o/ <&>");
-    cucul_putstr(c, WIDTH / 2 - 7, HEIGHT / 2 + 2, "äβç ░▒▓█▓▒░ ΔЗҒ");
+    cucul_set_color(cv, CUCUL_COLOR_BLACK, CUCUL_COLOR_WHITE);
+    cucul_fill_ellipse(cv, WIDTH / 2, HEIGHT / 2, WIDTH / 4, HEIGHT / 4, " ");
+    cucul_putstr(cv, WIDTH / 2 - 5, HEIGHT / 2 - 2, "(\") \\o/ <&>");
+    cucul_putstr(cv, WIDTH / 2 - 7, HEIGHT / 2 + 2, "äβç ░▒▓█▓▒░ ΔЗҒ");
 
-    cucul_set_color(c, CUCUL_COLOR_WHITE, CUCUL_COLOR_LIGHTBLUE);
-    cucul_putstr(c, WIDTH / 2 - 7, HEIGHT / 2, "    LIBCACA    ");
+    cucul_set_color(cv, CUCUL_COLOR_WHITE, CUCUL_COLOR_LIGHTBLUE);
+    cucul_putstr(cv, WIDTH / 2 - 7, HEIGHT / 2, "    LIBCACA    ");
 
     for(x = 0; x < 16; x++)
     {
-        cucul_set_truecolor(c, 0xff00 | x, 0xf00f | (x << 4));
-        cucul_putstr(c, WIDTH / 2 - 7 + x, HEIGHT / 2 + 5, "#");
+        cucul_set_truecolor(cv, 0xff00 | x, 0xf00f | (x << 4));
+        cucul_putstr(cv, WIDTH / 2 - 7 + x, HEIGHT / 2 + 5, "#");
     }
 
-    buffer = cucul_create_export(c, argv[1]);
+    buffer = cucul_create_export(cv, argv[1]);
     fwrite(cucul_get_buffer_data(buffer),
            cucul_get_buffer_size(buffer), 1, stdout);
     cucul_free_buffer(buffer);
 
-    cucul_free(c);
+    cucul_free(cv);
 
     return 0;
 }

test/font.c

@@ -34,8 +34,8 @@ typedef unsigned int uint32_t;
 
 int main(int argc, char *argv[])
 {
-    cucul_canvas_t *c;
-    caca_t *kk;
+    cucul_canvas_t *cv;
+    caca_display_t *dp;
     cucul_font_t *f;
     cucul_dither_t *d;
     caca_event_t ev;
@@ -44,15 +44,15 @@ int main(int argc, char *argv[])
     char const * const * fonts;
 
     /* Create a canvas */
-    c = cucul_create(8, 2);
+    cv = cucul_create(8, 2);
 
     /* Draw stuff on our canvas */
-    cucul_set_color(c, CUCUL_COLOR_WHITE, CUCUL_COLOR_BLACK);
-    cucul_putstr(c, 0, 0, "ABcde");
-    cucul_set_color(c, CUCUL_COLOR_LIGHTRED, CUCUL_COLOR_BLACK);
-    cucul_putstr(c, 5, 0, "\\o/");
-    cucul_set_color(c, CUCUL_COLOR_WHITE, CUCUL_COLOR_BLUE);
-    cucul_putstr(c, 0, 1, "&$âøÿØ?!");
+    cucul_set_color(cv, CUCUL_COLOR_WHITE, CUCUL_COLOR_BLACK);
+    cucul_putstr(cv, 0, 0, "ABcde");
+    cucul_set_color(cv, CUCUL_COLOR_LIGHTRED, CUCUL_COLOR_BLACK);
+    cucul_putstr(cv, 5, 0, "\\o/");
+    cucul_set_color(cv, CUCUL_COLOR_WHITE, CUCUL_COLOR_BLUE);
+    cucul_putstr(cv, 0, 1, "&$âøÿØ?!");
 
     /* Load a libcucul internal font */
     fonts = cucul_get_font_list();
@@ -69,16 +69,16 @@ int main(int argc, char *argv[])
     }
 
     /* Create our bitmap buffer (32-bit ARGB) */
-    w = cucul_get_width(c) * cucul_get_font_width(f);
-    h = cucul_get_height(c) * cucul_get_font_height(f);
+    w = cucul_get_width(cv) * cucul_get_font_width(f);
+    h = cucul_get_height(cv) * cucul_get_font_height(f);
     buf = malloc(4 * w * h);
 
     /* Render the canvas onto our image buffer */
-    cucul_render_canvas(c, f, buf, w, h, 4 * w);
+    cucul_render_canvas(cv, f, buf, w, h, 4 * w);
 
     /* Just for fun, render the image using libcaca */
-    cucul_set_size(c, 80, 32);
-    kk = caca_attach(c);
+    cucul_set_size(cv, 80, 32);
+    dp = caca_attach(cv);
 
 #if defined(HAVE_ENDIAN_H)
     if(__BYTE_ORDER == __BIG_ENDIAN)
@@ -93,18 +93,18 @@ int main(int argc, char *argv[])
         d = cucul_create_dither(32, w, h, 4 * w,
                                 0x0000ff00, 0x00ff0000, 0xff000000, 0x000000ff);
 
-    cucul_dither_bitmap(c, 0, 0, cucul_get_width(c) - 1,
-                                  cucul_get_height(c) - 1, d, buf);
-    caca_display(kk);
+    cucul_dither_bitmap(cv, 0, 0, cucul_get_width(cv) - 1,
+                                  cucul_get_height(cv) - 1, d, buf);
+    caca_display(dp);
 
-    caca_get_event(kk, CACA_EVENT_KEY_PRESS, &ev, -1);
+    caca_get_event(dp, CACA_EVENT_KEY_PRESS, &ev, -1);
 
     /* Free everything */
-    caca_detach(kk);
+    caca_detach(dp);
     free(buf);
     cucul_free_dither(d);
     cucul_free_font(f);
-    cucul_free(c);
+    cucul_free(cv);
 
     return 0;
 }

test/gamma.c

@@ -34,17 +34,17 @@ uint32_t buffer[256 * 4];
 int main(void)
 {
     caca_event_t ev;
-    cucul_canvas_t *c, *gg, *mask;
-    caca_t *kk;
+    cucul_canvas_t *cv, *cw, *mask;
+    caca_display_t *dp;
     cucul_dither_t *left, *right;
     float gam = 1.0;
     int x;
 
-    c = cucul_create(0, 0);
-    kk = caca_attach(c);
+    cv = cucul_create(0, 0);
+    dp = caca_attach(cv);
 
-    gg = cucul_create(cucul_get_width(c), cucul_get_height(c));
-    mask = cucul_create(cucul_get_width(c), cucul_get_height(c));
+    cw = cucul_create(cucul_get_width(cv), cucul_get_height(cv));
+    mask = cucul_create(cucul_get_width(cv), cucul_get_height(cv));
 
     for(x = 0; x < 256; x++)
     {
@@ -58,11 +58,11 @@ int main(void)
                                0x00ff0000, 0x0000ff00, 0x000000ff, 0x0);
     right = cucul_create_dither(32, 256, 4, 4 * 256,
                                 0x00ff0000, 0x0000ff00, 0x000000ff, 0x0);
-    caca_set_delay(kk, 20000);
+    caca_set_delay(dp, 20000);
 
     for(x = 0; ; x++)
     {
-        int ret = caca_get_event(kk, CACA_EVENT_KEY_PRESS, &ev, 0);
+        int ret = caca_get_event(dp, CACA_EVENT_KEY_PRESS, &ev, 0);
 
         if(ret)
         {
@@ -77,18 +77,18 @@ int main(void)
         }
 
         /* Resize the spare canvas, just in case the main one changed */
-        cucul_set_size(gg, cucul_get_width(c), cucul_get_height(c));
-        cucul_set_size(mask, cucul_get_width(c), cucul_get_height(c));
+        cucul_set_size(cw, cucul_get_width(cv), cucul_get_height(cv));
+        cucul_set_size(mask, cucul_get_width(cv), cucul_get_height(cv));
 
         /* Draw the regular dither on the main canvas */
-        cucul_dither_bitmap(c, 0, 0,
-                            cucul_get_width(c) - 1, cucul_get_height(c) - 1,
+        cucul_dither_bitmap(cv, 0, 0,
+                            cucul_get_width(cv) - 1, cucul_get_height(cv) - 1,
                             left, buffer);
 
         /* Draw the gamma-modified dither on the spare canvas */
         cucul_set_dither_gamma(right, gam);
-        cucul_dither_bitmap(gg, 0, 0,
-                            cucul_get_width(gg) - 1, cucul_get_height(gg) - 1,
+        cucul_dither_bitmap(cw, 0, 0,
+                            cucul_get_width(cw) - 1, cucul_get_height(cw) - 1,
                             right, buffer);
 
         /* Draw something on the mask */
@@ -102,20 +102,20 @@ int main(void)
                                  cucul_get_height(mask) / 2, "#");
 
         /* Blit the spare canvas onto the first one */
-        cucul_blit(c, 0, 0, gg, mask);
+        cucul_blit(cv, 0, 0, cw, mask);
 
-        cucul_set_color(c, CUCUL_COLOR_WHITE, CUCUL_COLOR_BLUE);
-        cucul_printf(c, 2, 1,
+        cucul_set_color(cv, CUCUL_COLOR_WHITE, CUCUL_COLOR_BLUE);
+        cucul_printf(cv, 2, 1,
                      "gamma=%g - use arrows to change, Esc to quit", gam);
 
-        caca_display(kk);
+        caca_display(dp);
     }
 
     cucul_free_dither(left);
     cucul_free_dither(right);
 
-    caca_detach(kk);
-    cucul_free(c);
+    caca_detach(dp);
+    cucul_free(cv);
 
     return 0;
 }

test/hsv.c

@@ -29,14 +29,14 @@ uint32_t buffer[256*256];
 int main(void)
 {
     caca_event_t ev;
-    cucul_canvas_t *c;
-    caca_t *kk;
+    cucul_canvas_t *cv;
+    caca_display_t *dp;
 
     cucul_dither_t *dither;
     int x, y;
 
-    c = cucul_create(0, 0);
-    kk = caca_attach(c);
+    cv = cucul_create(0, 0);
+    dp = caca_attach(cv);
 
     for(y = 0; y < 256; y++)
         for(x = 0; x < 256; x++)
@@ -46,17 +46,17 @@ int main(void)
 
     dither = cucul_create_dither(32, 256, 256, 4 * 256,
                                  0x00ff0000, 0x0000ff00, 0x000000ff, 0x0);
-    cucul_dither_bitmap(c, 0, 0,
-                        cucul_get_width(c) - 1, cucul_get_height(c) - 1,
+    cucul_dither_bitmap(cv, 0, 0,
+                        cucul_get_width(cv) - 1, cucul_get_height(cv) - 1,
                         dither, buffer);
     cucul_free_dither(dither);
 
-    caca_display(kk);
+    caca_display(dp);
 
-    caca_get_event(kk, CACA_EVENT_KEY_PRESS, &ev, -1);
+    caca_get_event(dp, CACA_EVENT_KEY_PRESS, &ev, -1);
 
-    caca_detach(kk);
-    cucul_free(c);
+    caca_detach(dp);
+    cucul_free(cv);
 
     return 0;
 }

test/spritedit.c

@@ -22,8 +22,8 @@
 
 int main(int argc, char **argv)
 {
-    cucul_canvas_t *c;
-    caca_t *kk;
+    cucul_canvas_t *cv;
+    caca_display_t *dp;
 
     int quit = 0;
     cucul_sprite_t *sprite;
@@ -37,19 +37,19 @@ int main(int argc, char **argv)
         return 1;
     }
 
-    c = cucul_create(0, 0);
-    if(!c)
+    cv = cucul_create(0, 0);
+    if(!cv)
         return 1;
-    kk = caca_attach(c);
-    if(!kk)
+    dp = caca_attach(cv);
+    if(!dp)
         return 1;
 
     sprite = cucul_load_sprite(argv[1]);
 
     if(!sprite)
     {
-        caca_detach(kk);
-        cucul_free(c);
+        caca_detach(dp);
+        cucul_free(cv);
         fprintf(stderr, "%s: could not open `%s'.\n", argv[0], argv[1]);
         return 1;
     }
@@ -61,7 +61,7 @@ int main(int argc, char **argv)
         int xa, ya, xb, yb;
         char buf[BUFSIZ];
 
-        while(caca_get_event(kk, CACA_EVENT_KEY_PRESS, &ev, 0))
+        while(caca_get_event(dp, CACA_EVENT_KEY_PRESS, &ev, 0))
         {
             switch(ev.data.key.ch)
             {
@@ -100,43 +100,43 @@ int main(int argc, char **argv)
 	}
 
 
-        cucul_clear(c);
+        cucul_clear(cv);
 
-        cucul_set_color(c, CUCUL_COLOR_LIGHTGRAY, CUCUL_COLOR_BLACK);
-        cucul_draw_thin_box(c, 0, 0, cucul_get_width(c) - 1, cucul_get_height(c) - 1);
+        cucul_set_color(cv, CUCUL_COLOR_LIGHTGRAY, CUCUL_COLOR_BLACK);
+        cucul_draw_thin_box(cv, 0, 0, cucul_get_width(cv) - 1, cucul_get_height(cv) - 1);
 
-        cucul_putstr(c, 3, 0, "[ Sprite editor for libcaca ]");
+        cucul_putstr(cv, 3, 0, "[ Sprite editor for libcaca ]");
 
         sprintf(buf, "sprite `%s'", argv[1]);
-        cucul_putstr(c, 3, 2, buf);
+        cucul_putstr(cv, 3, 2, buf);
         sprintf(buf, "frame %i/%i", frame, cucul_get_sprite_frames(sprite) - 1);
-        cucul_putstr(c, 3, 3, buf);
+        cucul_putstr(cv, 3, 3, buf);
 
         /* Crosshair */
-        cucul_draw_thin_line(c, 57, 2, 57, 18);
-        cucul_draw_thin_line(c, 37, 10, 77, 10);
-        cucul_putchar(c, 57, 10, '+');
+        cucul_draw_thin_line(cv, 57, 2, 57, 18);
+        cucul_draw_thin_line(cv, 37, 10, 77, 10);
+        cucul_putchar(cv, 57, 10, '+');
 
         /* Boxed sprite */
         xa = -1 - cucul_get_sprite_dx(sprite, frame);
         ya = -1 - cucul_get_sprite_dy(sprite, frame);
         xb = xa + 1 + cucul_get_sprite_width(sprite, frame);
         yb = ya + 1 + cucul_get_sprite_height(sprite, frame);
-        cucul_set_color(c, CUCUL_COLOR_BLACK, CUCUL_COLOR_BLACK);
-        cucul_fill_box(c, 57 + xa, 10 + ya, 57 + xb, 10 + yb, " ");
-        cucul_set_color(c, CUCUL_COLOR_LIGHTGRAY, CUCUL_COLOR_BLACK);
-        cucul_draw_thin_box(c, 57 + xa, 10 + ya, 57 + xb, 10 + yb);
-        cucul_draw_sprite(c, 57, 10, sprite, frame);
+        cucul_set_color(cv, CUCUL_COLOR_BLACK, CUCUL_COLOR_BLACK);
+        cucul_fill_box(cv, 57 + xa, 10 + ya, 57 + xb, 10 + yb, " ");
+        cucul_set_color(cv, CUCUL_COLOR_LIGHTGRAY, CUCUL_COLOR_BLACK);
+        cucul_draw_thin_box(cv, 57 + xa, 10 + ya, 57 + xb, 10 + yb);
+        cucul_draw_sprite(cv, 57, 10, sprite, frame);
 
         /* Free sprite */
-        cucul_draw_sprite(c, 20, 10, sprite, frame);
+        cucul_draw_sprite(cv, 20, 10, sprite, frame);
 
-        caca_display(kk);
+        caca_display(dp);
     }
 
     /* Clean up */
-    caca_detach(kk);
-    cucul_free(c);
+    caca_detach(dp);
+    cucul_free(cv);
 
     return 0;
 }

test/transform.c

@@ -50,12 +50,12 @@ static char const *duck[] =
 int main(void)
 {
     caca_event_t ev;
-    cucul_canvas_t *c, *normal, *flip, *flop, *rotate;
-    caca_t *kk;
+    cucul_canvas_t *cv, *normal, *flip, *flop, *rotate;
+    caca_display_t *dp;
     int i;
 
-    c = cucul_create(0, 0);
-    kk = caca_attach(c);
+    cv = cucul_create(0, 0);
+    dp = caca_attach(cv);
 
     normal = cucul_create(70, 6);
     flip = cucul_create(70, 6);
@@ -96,26 +96,26 @@ int main(void)
     cucul_rotate(rotate);
 
     /* Blit the transformed canvas onto the main canvas */
-    cucul_set_color(c, CUCUL_COLOR_WHITE, CUCUL_COLOR_BLUE);
-    cucul_putstr(c, 0, 0, "normal");
-    cucul_blit(c, 10, 0, normal, NULL);
-    cucul_putstr(c, 0, 6, "flip");
-    cucul_blit(c, 10, 6, flip, NULL);
-    cucul_putstr(c, 0, 12, "flop");
-    cucul_blit(c, 10, 12, flop, NULL);
-    cucul_putstr(c, 0, 18, "rotate");
-    cucul_blit(c, 10, 18, rotate, NULL);
+    cucul_set_color(cv, CUCUL_COLOR_WHITE, CUCUL_COLOR_BLUE);
+    cucul_putstr(cv, 0, 0, "normal");
+    cucul_blit(cv, 10, 0, normal, NULL);
+    cucul_putstr(cv, 0, 6, "flip");
+    cucul_blit(cv, 10, 6, flip, NULL);
+    cucul_putstr(cv, 0, 12, "flop");
+    cucul_blit(cv, 10, 12, flop, NULL);
+    cucul_putstr(cv, 0, 18, "rotate");
+    cucul_blit(cv, 10, 18, rotate, NULL);
 
-    caca_display(kk);
+    caca_display(dp);
 
-    caca_get_event(kk, CACA_EVENT_KEY_PRESS, &ev, -1);
+    caca_get_event(dp, CACA_EVENT_KEY_PRESS, &ev, -1);
 
-    caca_detach(kk);
+    caca_detach(dp);
     cucul_free(rotate);
     cucul_free(flop);
     cucul_free(flip);
     cucul_free(normal);
-    cucul_free(c);
+    cucul_free(cv);
 
     return 0;
 }

test/truecolor.c

@@ -27,13 +27,13 @@ typedef unsigned int uint32_t;
 int main(void)
 {
     caca_event_t ev;
-    cucul_canvas_t *c;
-    caca_t *kk;
+    cucul_canvas_t *cv;
+    caca_display_t *dp;
 
     int x, y;
 
-    c = cucul_create(32, 16);
-    kk = caca_attach(c);
+    cv = cucul_create(32, 16);
+    dp = caca_attach(cv);
 
     for(y = 0; y < 16; y++)
         for(x = 0; x < 16; x++)
@@ -41,19 +41,19 @@ int main(void)
         uint16_t bgcolor = 0xff00 | (y << 4) | x;
         uint16_t fgcolor = 0xf000 | ((15 - y) << 4) | ((15 - x) << 8);
 
-        cucul_set_truecolor(c, fgcolor, bgcolor);
-        cucul_putstr(c, x * 2, y, "CA");
+        cucul_set_truecolor(cv, fgcolor, bgcolor);
+        cucul_putstr(cv, x * 2, y, "CA");
     }
 
-    cucul_set_color(c, CUCUL_COLOR_WHITE, CUCUL_COLOR_LIGHTBLUE);
-    cucul_putstr(c, 2, 1, " truecolor libcaca ");
+    cucul_set_color(cv, CUCUL_COLOR_WHITE, CUCUL_COLOR_LIGHTBLUE);
+    cucul_putstr(cv, 2, 1, " truecolor libcaca ");
 
-    caca_display(kk);
+    caca_display(dp);
 
-    caca_get_event(kk, CACA_EVENT_KEY_PRESS, &ev, -1);
+    caca_get_event(dp, CACA_EVENT_KEY_PRESS, &ev, -1);
 
-    caca_detach(kk);
-    cucul_free(c);
+    caca_detach(dp);
+    cucul_free(cv);
 
     return 0;
 }

test/unicode.c

@@ -27,70 +27,70 @@ typedef unsigned int uint32_t;
 int main(void)
 {
     caca_event_t ev;
-    cucul_canvas_t *c;
-    caca_t *kk;
-
-    c = cucul_create(0, 0);
-    kk = caca_attach(c);
-
-    cucul_set_color(c, CUCUL_COLOR_WHITE, CUCUL_COLOR_BLUE);
-    cucul_putstr(c, 1, 1, "Basic Unicode support");
-
-    cucul_set_color(c, CUCUL_COLOR_LIGHTGRAY, CUCUL_COLOR_BLACK);
-    cucul_putstr(c, 1, 2, "This is ASCII:    | abc DEF 123 !@# |");
-    cucul_putstr(c, 1, 3, "This is Unicode:  | äßç δεφ ☺♥♀ ╞╬╗ |");
-    cucul_putstr(c, 1, 4, "And this is, too: | ἀβϛ ΔЗҒ ᚴᛒᛯ ♩♔✈ |");
-
-    cucul_putstr(c, 1, 5, "If the three lines do not have the same length, there is a bug somewhere.");
-
-    cucul_set_color(c, CUCUL_COLOR_WHITE, CUCUL_COLOR_BLUE);
-    cucul_putstr(c, 1, 7, "Gradient glyphs");
-
-    cucul_set_color(c, CUCUL_COLOR_LIGHTGRAY, CUCUL_COLOR_BLACK);
-    cucul_putstr(c, 31,  8, "  0%");
-    cucul_putstr(c, 31,  9, " 25%");
-    cucul_putstr(c, 31, 10, " 50%");
-    cucul_putstr(c, 31, 11, " 75%");
-    cucul_putstr(c, 31, 12, "100%");
-
-    cucul_set_color(c, CUCUL_COLOR_LIGHTRED, CUCUL_COLOR_LIGHTGREEN);
-    cucul_putstr(c, 1,  8, "                             ");
-    cucul_putstr(c, 1,  9, "░░░░░░░░░░░░░░░░░░░░░░░░░░░░░");
-    cucul_putstr(c, 1, 10, "▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒");
-    cucul_putstr(c, 1, 11, "▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓");
-    cucul_putstr(c, 1, 12, "█████████████████████████████");
-
-    cucul_set_color(c, CUCUL_COLOR_LIGHTGREEN, CUCUL_COLOR_LIGHTRED);
-    cucul_putstr(c, 36,  8, "█████████████████████████████");
-    cucul_putstr(c, 36,  9, "▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓");
-    cucul_putstr(c, 36, 10, "▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒");
-    cucul_putstr(c, 36, 11, "░░░░░░░░░░░░░░░░░░░░░░░░░░░░░");
-    cucul_putstr(c, 36, 12, "                             ");
-
-    cucul_set_color(c, CUCUL_COLOR_WHITE, CUCUL_COLOR_BLUE);
-    cucul_putstr(c, 1, 14, "Double width characters");
-
-    cucul_set_color(c, CUCUL_COLOR_LIGHTRED, CUCUL_COLOR_BLACK);
-    cucul_putstr(c, 1, 15, "| ドラゴン ボーレ |");
-    cucul_set_color(c, CUCUL_COLOR_LIGHTGRAY, CUCUL_COLOR_BLACK);
-    cucul_putstr(c, 1, 16, "| ()()()() ()()() |");
-    cucul_set_color(c, CUCUL_COLOR_YELLOW, CUCUL_COLOR_BLACK);
-    cucul_putstr(c, 1, 17, "| ドラゴン");
-    cucul_putstr(c, 10, 17, "ボーレ |");
-
-    cucul_set_color(c, CUCUL_COLOR_LIGHTGRAY, CUCUL_COLOR_BLACK);
-    cucul_putstr(c, 1, 18, "If the three lines do not have the same length, there is a bug somewhere.");
-
-    cucul_putstr(c, 1, 20, "CP437 glyphs: ☺ ☻ ♥ ♦ ♣ ♠ • ◘ ○ ◙ ♂ ♀ ♪ ♫ ☼ ► ◄ ↕ ‼ ¶ § ▬ ↨ ↑ ↓ → ← ∟ ↔ ▲ ▼");
-    cucul_putstr(c, 1, 21, "more CP437: α ß Γ π Σ σ µ τ Φ Θ Ω δ ∞ φ ε ∩ ≡ ± ≥ ≤ ⌠ ⌡ ÷ ≈ ° ∙ · √ ⁿ ² ■");
-    cucul_putstr(c, 1, 22, "drawing blocks: ███ ▓▓▓ ▒▒▒ ░░░ ▀ ▄ ▌ ▐ █ ▖ ▗ ▘ ▝ ▚ ▞ ▙ ▛ ▜ ▟");
-
-    caca_display(kk);
-
-    caca_get_event(kk, CACA_EVENT_KEY_PRESS, &ev, -1);
-
-    caca_detach(kk);
-    cucul_free(c);
+    cucul_canvas_t *cv;
+    caca_display_t *dp;
+
+    cv = cucul_create(0, 0);
+    dp = caca_attach(cv);
+
+    cucul_set_color(cv, CUCUL_COLOR_WHITE, CUCUL_COLOR_BLUE);
+    cucul_putstr(cv, 1, 1, "Basic Unicode support");
+
+    cucul_set_color(cv, CUCUL_COLOR_LIGHTGRAY, CUCUL_COLOR_BLACK);
+    cucul_putstr(cv, 1, 2, "This is ASCII:    | abc DEF 123 !@# |");
+    cucul_putstr(cv, 1, 3, "This is Unicode:  | äßç δεφ ☺♥♀ ╞╬╗ |");
+    cucul_putstr(cv, 1, 4, "And this is, too: | ἀβϛ ΔЗҒ ᚴᛒᛯ ♩♔✈ |");
+
+    cucul_putstr(cv, 1, 5, "If the three lines do not have the same length, there is a bug somewhere.");
+
+    cucul_set_color(cv, CUCUL_COLOR_WHITE, CUCUL_COLOR_BLUE);
+    cucul_putstr(cv, 1, 7, "Gradient glyphs");
+
+    cucul_set_color(cv, CUCUL_COLOR_LIGHTGRAY, CUCUL_COLOR_BLACK);
+    cucul_putstr(cv, 31,  8, "  0%");
+    cucul_putstr(cv, 31,  9, " 25%");
+    cucul_putstr(cv, 31, 10, " 50%");
+    cucul_putstr(cv, 31, 11, " 75%");
+    cucul_putstr(cv, 31, 12, "100%");
+
+    cucul_set_color(cv, CUCUL_COLOR_LIGHTRED, CUCUL_COLOR_LIGHTGREEN);
+    cucul_putstr(cv, 1,  8, "                             ");
+    cucul_putstr(cv, 1,  9, "░░░░░░░░░░░░░░░░░░░░░░░░░░░░░");
+    cucul_putstr(cv, 1, 10, "▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒");
+    cucul_putstr(cv, 1, 11, "▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓");
+    cucul_putstr(cv, 1, 12, "█████████████████████████████");
+
+    cucul_set_color(cv, CUCUL_COLOR_LIGHTGREEN, CUCUL_COLOR_LIGHTRED);
+    cucul_putstr(cv, 36,  8, "█████████████████████████████");
+    cucul_putstr(cv, 36,  9, "▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓");
+    cucul_putstr(cv, 36, 10, "▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒");
+    cucul_putstr(cv, 36, 11, "░░░░░░░░░░░░░░░░░░░░░░░░░░░░░");
+    cucul_putstr(cv, 36, 12, "                             ");
+
+    cucul_set_color(cv, CUCUL_COLOR_WHITE, CUCUL_COLOR_BLUE);
+    cucul_putstr(cv, 1, 14, "Double width characters");
+
+    cucul_set_color(cv, CUCUL_COLOR_LIGHTRED, CUCUL_COLOR_BLACK);
+    cucul_putstr(cv, 1, 15, "| ドラゴン ボーレ |");
+    cucul_set_color(cv, CUCUL_COLOR_LIGHTGRAY, CUCUL_COLOR_BLACK);
+    cucul_putstr(cv, 1, 16, "| ()()()() ()()() |");
+    cucul_set_color(cv, CUCUL_COLOR_YELLOW, CUCUL_COLOR_BLACK);
+    cucul_putstr(cv, 1, 17, "| ドラゴン");
+    cucul_putstr(cv, 10, 17, "ボーレ |");
+
+    cucul_set_color(cv, CUCUL_COLOR_LIGHTGRAY, CUCUL_COLOR_BLACK);
+    cucul_putstr(cv, 1, 18, "If the three lines do not have the same length, there is a bug somewhere.");
+
+    cucul_putstr(cv, 1, 20, "CP437 glyphs: ☺ ☻ ♥ ♦ ♣ ♠ • ◘ ○ ◙ ♂ ♀ ♪ ♫ ☼ ► ◄ ↕ ‼ ¶ § ▬ ↨ ↑ ↓ → ← ∟ ↔ ▲ ▼");
+    cucul_putstr(cv, 1, 21, "more CP437: α ß Γ π Σ σ µ τ Φ Θ Ω δ ∞ φ ε ∩ ≡ ± ≥ ≤ ⌠ ⌡ ÷ ≈ ° ∙ · √ ⁿ ² ■");
+    cucul_putstr(cv, 1, 22, "drawing blocks: ███ ▓▓▓ ▒▒▒ ░░░ ▀ ▄ ▌ ▐ █ ▖ ▗ ▘ ▝ ▚ ▞ ▙ ▛ ▜ ▟");
+
+    caca_display(dp);
+
+    caca_get_event(dp, CACA_EVENT_KEY_PRESS, &ev, -1);
+
+    caca_detach(dp);
+    cucul_free(cv);
 
     return 0;
 }