cacalabs
/
libcaca
огледало от https://github.com/cacalabs/libcaca.git
1
0
Разклонения 0
Код Задачи 0 Версии 7 Уики Activity
Преглед на файлове

* Finished moving everything driver-specific to the apropriate driver_*.c 

files. Phew. Now they just need a few comments.
tags/v0.99.beta14
Sam Hocevar sam преди 19 години
родител
cf02908f38
ревизия
8f286f6432
променени са 10 файла, в които са добавени 477 реда и са изтрити 458 реда
Разделен изглед
Diff Options
Показване на статистика Download Patch File Download Diff File
  1. +2
    -66
      caca/caca.c
  2. +3
    -87
      caca/caca_internals.h
  3. +31
    -20
      caca/driver_conio.c
  4. +123
    -99
      caca/driver_gl.c
  5. +75
    -17
      caca/driver_ncurses.c
  6. +48
    -10
      caca/driver_slang.c
  7. +63
    -49
      caca/driver_win32.c
  8. +124
    -102
      caca/driver_x11.c
  9. +3
    -3
      caca/event.c
  10. +5
    -5
      caca/graphics.c

+ 2
- 66
caca/caca.c Целия файл

@@ -30,7 +30,6 @@
#include "caca_internals.h"

static int caca_init_driver(caca_t *kk);
static void caca_check_terminal(caca_t *kk);

/** \brief Attach a caca graphical context to a cucul backend context.
*
@@ -54,10 +53,7 @@ caca_t * caca_attach(cucul_t * qq)
return NULL;
}

/* Only needed for slang and ncurses */
caca_check_terminal(kk);

if(kk->driver.init_graphics(kk))
if(kk->drv.init_graphics(kk))
{
free(kk);
return NULL;
@@ -102,7 +98,7 @@ caca_t * caca_attach(cucul_t * qq)
*/
void caca_detach(caca_t *kk)
{
kk->driver.end_graphics(kk);
kk->drv.end_graphics(kk);
kk->qq->refcount--;
free(kk);
}
@@ -193,63 +189,3 @@ static int caca_init_driver(caca_t *kk)
return -1;
}

static void caca_check_terminal(caca_t *kk)
{
#if defined(HAVE_GETENV) && defined(HAVE_PUTENV) && \
(defined(USE_SLANG) || defined(USE_NCURSES))
char *term, *colorterm, *other;
#endif

#if defined(USE_SLANG)
if(kk->driver.driver != CACA_DRIVER_SLANG)
#endif
#if defined(USE_NCURSES)
if(kk->driver.driver != CACA_DRIVER_NCURSES)
#endif
return;

#if defined(HAVE_GETENV) && defined(HAVE_PUTENV) && \
(defined(USE_SLANG) || defined(USE_NCURSES))
term = getenv("TERM");
colorterm = getenv("COLORTERM");

if(term && !strcmp(term, "xterm"))
{
/* If we are using gnome-terminal, it's really a 16 colour terminal */
if(colorterm && !strcmp(colorterm, "gnome-terminal"))
{
#if defined(USE_NCURSES)
if(kk->driver.driver == CACA_DRIVER_NCURSES)
{
SCREEN *screen;
screen = newterm("xterm-16color", stdout, stdin);
if(screen == NULL)
return;
endwin();
}
#endif
(void)putenv("TERM=xterm-16color");
return;
}

/* Ditto if we are using Konsole */
other = getenv("KONSOLE_DCOP_SESSION");
if(other)
{
#if defined(USE_NCURSES)
if(kk->driver.driver == CACA_DRIVER_NCURSES)
{
SCREEN *screen;
screen = newterm("xterm-16color", stdout, stdin);
if(screen == NULL)
return;
endwin();
}
#endif
(void)putenv("TERM=xterm-16color");
return;
}
}
#endif
}


+ 3
- 87
caca/caca_internals.h Целия файл

@@ -29,26 +29,6 @@ typedef unsigned short uint16_t;
typedef unsigned int uint32_t;
#endif

#if defined(USE_CONIO)
# include <conio.h>
#endif
#if defined(USE_GL)
# include <GL/glut.h>
#endif
#if defined(USE_NCURSES)
# if defined(HAVE_NCURSES_H)
# include <ncurses.h>
# else
# include <curses.h>
# endif
#endif
#if defined(USE_WIN32)
# include <windows.h>
#endif
#if defined(USE_X11)
# include <X11/Xlib.h>
#endif

#if !defined(_DOXYGEN_SKIP_ME)
# define EVENTBUF_LEN 10
#endif
@@ -108,9 +88,10 @@ struct caca_context
{
cucul_t *qq;

struct driver
struct drv
{
enum caca_driver driver;
struct driver_private *p;

int (* init_graphics) (caca_t *);
int (* end_graphics) (caca_t *);
@@ -120,7 +101,7 @@ struct caca_context
void (* display) (caca_t *);
void (* handle_resize) (caca_t *, unsigned int *, unsigned int *);
unsigned int (* get_event) (caca_t *);
} driver;
} drv;

//unsigned int width, height;
unsigned int mouse_x, mouse_y;
@@ -145,71 +126,6 @@ struct caca_context
unsigned int last_key;
#endif
} events;

/* FIXME: maybe this should go away */
#if defined(USE_X11) && !defined(_DOXYGEN_SKIP_ME)
struct x11
{
Display *dpy;
Window window;
Pixmap pixmap;
GC gc;
long int event_mask;
int font_width, font_height;
unsigned int new_width, new_height;
int colors[16];
Font font;
XFontStruct *font_struct;
int font_offset;
#if defined(HAVE_X11_XKBLIB_H)
Bool autorepeat;
#endif
} x11;
#endif
#if defined(USE_NCURSES)
struct ncurses
{
int attr[16*16];
mmask_t oldmask;
} ncurses;
#endif
#if defined(USE_CONIO)
struct conio
{
struct text_info ti;
char *screen;
} conio;
#endif
#if defined(USE_WIN32)
struct win32
{
HANDLE hin, hout;
HANDLE front, back;
CHAR_INFO *buffer;
CONSOLE_CURSOR_INFO cci;
} win32;
#endif
#if defined(USE_GL)
struct gl
{
int window;
unsigned int width, height;
float font_width, font_height;
float incx, incy;
int id[94];
unsigned char resized, bit;
unsigned char mouse_changed, mouse_clicked;
unsigned int mouse_x, mouse_y;
unsigned int mouse_button, mouse_state;

unsigned char key;
int special_key;
int new_width;
int new_height;

float sw, sh;
} gl;
#endif
};

/* Timer functions */


+ 31
- 20
caca/driver_conio.c Целия файл

@@ -27,29 +27,39 @@
# include <pc.h>
#endif

#include <stdlib.h>

#include "caca.h"
#include "caca_internals.h"
#include "cucul.h"
#include "cucul_internals.h"

struct driver_private
{
struct text_info ti;
char *screen;
};

static int conio_init_graphics(caca_t *kk)
{
kk->drv.p = malloc(sizeof(struct driver_private));

_wscroll = 0;
_setcursortype(_NOCURSOR);
clrscr();

gettextinfo(&kk->conio.ti);
kk->conio.screen = malloc(2 * kk->conio.ti.screenwidth
* kk->conio.ti.screenheight * sizeof(char));
if(kk->conio.screen == NULL)
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)
return -1;
# if defined(SCREENUPDATE_IN_PC_H)
ScreenRetrieve(kk->conio.screen);
ScreenRetrieve(kk->drv.p->screen);
# else
/* FIXME */
# endif
cucul_set_size(kk->qq, kk->conio.ti.screenwidth,
kk->conio.ti.screenheight);
cucul_set_size(kk->qq, kk->drv.p->ti.screenwidth,
kk->drv.p->ti.screenheight);
return 0;
}

@@ -62,7 +72,8 @@ static int conio_end_graphics(caca_t *kk)
cputs("\r\n");
_setcursortype(_NORMALCURSOR);

free(kk->conio.screen);
free(kk->drv.p->screen);
free(kk->drv.p);

return 0;
}
@@ -87,7 +98,7 @@ static unsigned int conio_get_window_height(caca_t *kk)
static void conio_display(caca_t *kk)
{
int n;
char *screen = kk->conio.screen;
char *screen = kk->drv.p->screen;
uint8_t *attr = kk->qq->attr;
uint32_t *chars = kk->qq->chars;
for(n = kk->qq->height * kk->qq->width; n--; )
@@ -96,7 +107,7 @@ static void conio_display(caca_t *kk)
*screen++ = *attr++;
}
# if defined(SCREENUPDATE_IN_PC_H)
ScreenUpdate(kk->conio.screen);
ScreenUpdate(kk->drv.p->screen);
# else
/* FIXME */
# endif
@@ -127,16 +138,16 @@ static unsigned int conio_get_event(caca_t *kk)

void conio_init_driver(caca_t *kk)
{
kk->driver.driver = CACA_DRIVER_CONIO;
kk->driver.init_graphics = conio_init_graphics;
kk->driver.end_graphics = conio_end_graphics;
kk->driver.set_window_title = conio_set_window_title;
kk->driver.get_window_width = conio_get_window_width;
kk->driver.get_window_height = conio_get_window_height;
kk->driver.display = conio_display;
kk->driver.handle_resize = conio_handle_resize;
kk->driver.get_event = conio_get_event;
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;
}

#endif /* USE_CONIO */


+ 123
- 99
caca/driver_gl.c Целия файл

@@ -27,6 +27,7 @@

#include <string.h>
#include <stdlib.h>
#include <stdio.h>

#include "caca.h"
#include "caca_internals.h"
@@ -70,6 +71,26 @@ static void gl_handle_reshape(int, int);
static void gl_handle_mouse(int, int, int, int);
static void gl_handle_mouse_motion(int, int);

struct driver_private
{
int window;
unsigned int width, height;
float font_width, font_height;
float incx, incy;
int id[94];
unsigned char resized, bit;
unsigned char mouse_changed, mouse_clicked;
unsigned int mouse_x, mouse_y;
unsigned int mouse_button, mouse_state;

unsigned char key;
int special_key;
int new_width;
int new_height;

float sw, sh;
};

static int gl_init_graphics(caca_t *kk)
{
char *empty_texture;
@@ -79,6 +100,8 @@ static int gl_init_graphics(caca_t *kk)
int argc = 1;
int i;

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

gl_kk = kk;

geometry = getenv("CACA_GEOMETRY");
@@ -88,31 +111,31 @@ static int gl_init_graphics(caca_t *kk)
if(width && height)
cucul_set_size(kk->qq, width, height);

kk->gl.font_width = 9;
kk->gl.font_height = 15;
kk->drv.p->font_width = 9;
kk->drv.p->font_height = 15;

kk->gl.width = kk->qq->width * kk->gl.font_width;
kk->gl.height = kk->qq->height * kk->gl.font_height;
kk->drv.p->width = kk->qq->width * kk->drv.p->font_width;
kk->drv.p->height = kk->qq->height * kk->drv.p->font_height;

kk->gl.resized = 0;
kk->gl.bit = 0;
kk->drv.p->resized = 0;
kk->drv.p->bit = 0;

kk->gl.mouse_changed = kk->gl.mouse_clicked = 0;
kk->gl.mouse_button = kk->gl.mouse_state = 0;
kk->drv.p->mouse_changed = kk->drv.p->mouse_clicked = 0;
kk->drv.p->mouse_button = kk->drv.p->mouse_state = 0;

kk->gl.key = 0;
kk->gl.special_key = 0;
kk->drv.p->key = 0;
kk->drv.p->special_key = 0;

kk->gl.sw = 9.0f / 16.0f;
kk->gl.sh = 15.0f / 16.0f;
kk->drv.p->sw = 9.0f / 16.0f;
kk->drv.p->sh = 15.0f / 16.0f;

glutInit(&argc, argv);

glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE);
glutInitWindowSize(kk->gl.width, kk->gl.height);
kk->gl.window = glutCreateWindow("caca for GL");
glutInitWindowSize(kk->drv.p->width, kk->drv.p->height);
kk->drv.p->window = glutCreateWindow("caca for GL");

gluOrtho2D(0, kk->gl.width, kk->gl.height, 0);
gluOrtho2D(0, kk->drv.p->width, kk->drv.p->height, 0);

glDisable(GL_CULL_FACE);
glDisable(GL_DEPTH_TEST);
@@ -130,7 +153,7 @@ static int gl_init_graphics(caca_t *kk)
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
gluOrtho2D(0, kk->gl.width, kk->gl.height, 0);
gluOrtho2D(0, kk->drv.p->width, kk->drv.p->height, 0);

glMatrixMode(GL_MODELVIEW);

@@ -145,8 +168,8 @@ static int gl_init_graphics(caca_t *kk)

for(i = 0; i < 94; i++)
{
glGenTextures(1, (GLuint*)&kk->gl.id[i]);
glBindTexture(GL_TEXTURE_2D, kk->gl.id[i]);
glGenTextures(1, (GLuint*)&kk->drv.p->id[i]);
glBindTexture(GL_TEXTURE_2D, kk->drv.p->id[i]);
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,
@@ -163,9 +186,9 @@ static int gl_init_graphics(caca_t *kk)
glutBitmapCharacter(GLUT_BITMAP_9_BY_15, i + 32);

glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, kk->gl.id[i]);
glBindTexture(GL_TEXTURE_2D, kk->drv.p->id[i]);
glCopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGB,
0, kk->gl.height - 16, 16, 16, 0);
0, kk->drv.p->height - 16, 16, 16, 0);

glutMainLoopEvent();
glutPostRedisplay();
@@ -176,7 +199,8 @@ static int gl_init_graphics(caca_t *kk)

static int gl_end_graphics(caca_t *kk)
{
glutDestroyWindow(kk->gl.window);
glutDestroyWindow(kk->drv.p->window);
free(kk->drv.p);
return 0;
}

@@ -188,12 +212,12 @@ static int gl_set_window_title(caca_t *kk, char const *title)

static unsigned int gl_get_window_width(caca_t *kk)
{
return kk->gl.width;
return kk->drv.p->width;
}

static unsigned int gl_get_window_height(caca_t *kk)
{
return kk->gl.height;
return kk->drv.p->height;
}

static void gl_display(caca_t *kk)
@@ -203,19 +227,19 @@ static void gl_display(caca_t *kk)
glClear(GL_COLOR_BUFFER_BIT);

line = 0;
for(y = 0; y < kk->gl.height; y += kk->gl.font_height)
for(y = 0; y < kk->drv.p->height; y += kk->drv.p->font_height)
{
uint8_t *attr = kk->qq->attr + line * kk->qq->width;

for(x = 0; x < kk->gl.width; x += kk->gl.font_width)
for(x = 0; x < kk->drv.p->width; x += kk->drv.p->font_width)
{
glDisable(GL_TEXTURE_2D);
glColor4bv(gl_bgpal[attr[0] >> 4]);
glBegin(GL_QUADS);
glVertex2f(x, y);
glVertex2f(x + kk->gl.font_width, y);
glVertex2f(x + kk->gl.font_width, y + kk->gl.font_height);
glVertex2f(x, y + kk->gl.font_height);
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);
glEnd();

attr++;
@@ -230,29 +254,29 @@ static void gl_display(caca_t *kk)
glBlendFunc(GL_ONE, GL_ONE);

line = 0;
for(y = 0; y < kk->gl.height; y += kk->gl.font_height)
for(y = 0; y < kk->drv.p->height; y += kk->drv.p->font_height)
{
uint8_t *attr = kk->qq->attr + line * kk->qq->width;
uint32_t *chars = kk->qq->chars + line * kk->qq->width;

for(x = 0; x < kk->gl.width; x += kk->gl.font_width)
for(x = 0; x < kk->drv.p->width; x += kk->drv.p->font_width)
{
if(*chars != (uint32_t)' ')
{
char ch = *chars & 0x7f;

/* FIXME: check ch bounds */
glBindTexture(GL_TEXTURE_2D, kk->gl.id[ch - 32]);
glBindTexture(GL_TEXTURE_2D, kk->drv.p->id[ch - 32]);
glColor4bv(gl_bgpal[attr[0] & 0xf]);
glBegin(GL_QUADS);
glTexCoord2f(0, kk->gl.sh);
glTexCoord2f(0, kk->drv.p->sh);
glVertex2f(x, y);
glTexCoord2f(kk->gl.sw, kk->gl.sh);
glVertex2f(x + kk->gl.font_width, y);
glTexCoord2f(kk->gl.sw, 0);
glVertex2f(x + kk->gl.font_width, y + kk->gl.font_height);
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(0, 0);
glVertex2f(x, y + kk->gl.font_height);
glVertex2f(x, y + kk->drv.p->font_height);
glEnd();
}

@@ -272,18 +296,18 @@ static void gl_display(caca_t *kk)
static void gl_handle_resize(caca_t *kk, unsigned int *new_width,
unsigned int *new_height)
{
kk->gl.width = kk->gl.new_width;
kk->gl.height = kk->gl.new_height;
kk->drv.p->width = kk->drv.p->new_width;
kk->drv.p->height = kk->drv.p->new_height;

*new_width = kk->gl.width / kk->gl.font_width;
*new_height = (kk->gl.height / kk->gl.font_height) + 1;
*new_width = kk->drv.p->width / kk->drv.p->font_width;
*new_height = (kk->drv.p->height / kk->drv.p->font_height) + 1;

glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();

glViewport(0, 0, kk->gl.width, kk->gl.height);
gluOrtho2D(0, kk->gl.width, kk->gl.height, 0);
glViewport(0, 0, kk->drv.p->width, kk->drv.p->height);
gluOrtho2D(0, kk->drv.p->width, kk->drv.p->height, 0);
glMatrixMode(GL_MODELVIEW);
}

@@ -293,56 +317,56 @@ static unsigned int gl_get_event(caca_t *kk)

glutMainLoopEvent();

if(kk->gl.resized && !kk->resize)
if(kk->drv.p->resized && !kk->resize)
{
kk->resize = 1;
kk->gl.resized = 0;
kk->drv.p->resized = 0;
return CACA_EVENT_RESIZE;
}

if(kk->gl.mouse_changed)
if(kk->drv.p->mouse_changed)
{
if(kk->gl.mouse_clicked)
if(kk->drv.p->mouse_clicked)
{
event |= CACA_EVENT_MOUSE_PRESS | kk->gl.mouse_button;
kk->gl.mouse_clicked = 0;
event |= CACA_EVENT_MOUSE_PRESS | kk->drv.p->mouse_button;
kk->drv.p->mouse_clicked = 0;
}
kk->mouse_x = kk->gl.mouse_x;
kk->mouse_y = kk->gl.mouse_y;
kk->mouse_x = kk->drv.p->mouse_x;
kk->mouse_y = kk->drv.p->mouse_y;
event |= CACA_EVENT_MOUSE_MOTION | (kk->mouse_x << 12) | kk->mouse_y;
kk->gl.mouse_changed = 0;
kk->drv.p->mouse_changed = 0;
}

if(kk->gl.key != 0)
if(kk->drv.p->key != 0)
{
event |= CACA_EVENT_KEY_PRESS;
event |= kk->gl.key;
kk->gl.key = 0;
event |= kk->drv.p->key;
kk->drv.p->key = 0;
return event;
}

if(kk->gl.special_key != 0)
if(kk->drv.p->special_key != 0)
{
event |= CACA_EVENT_KEY_PRESS;

switch(kk->gl.special_key)
switch(kk->drv.p->special_key)
{
case GLUT_KEY_F1 : kk->gl.special_key = 0; return event | CACA_KEY_F1;
case GLUT_KEY_F2 : kk->gl.special_key = 0; return event | CACA_KEY_F2;
case GLUT_KEY_F3 : kk->gl.special_key = 0; return event | CACA_KEY_F3;
case GLUT_KEY_F4 : kk->gl.special_key = 0; return event | CACA_KEY_F4;
case GLUT_KEY_F5 : kk->gl.special_key = 0; return event | CACA_KEY_F5;
case GLUT_KEY_F6 : kk->gl.special_key = 0; return event | CACA_KEY_F6;
case GLUT_KEY_F7 : kk->gl.special_key = 0; return event | CACA_KEY_F7;
case GLUT_KEY_F8 : kk->gl.special_key = 0; return event | CACA_KEY_F8;
case GLUT_KEY_F9 : kk->gl.special_key = 0; return event | CACA_KEY_F9;
case GLUT_KEY_F10: kk->gl.special_key = 0; return event | CACA_KEY_F10;
case GLUT_KEY_F11: kk->gl.special_key = 0; return event | CACA_KEY_F11;
case GLUT_KEY_F12: kk->gl.special_key = 0; return event | CACA_KEY_F12;
case GLUT_KEY_LEFT : kk->gl.special_key = 0; return event | CACA_KEY_LEFT;
case GLUT_KEY_RIGHT: kk->gl.special_key = 0; return event | CACA_KEY_RIGHT;
case GLUT_KEY_UP : kk->gl.special_key = 0; return event | CACA_KEY_UP;
case GLUT_KEY_DOWN : kk->gl.special_key = 0; return event | CACA_KEY_DOWN;
case GLUT_KEY_F1 : kk->drv.p->special_key = 0; return event | CACA_KEY_F1;
case GLUT_KEY_F2 : kk->drv.p->special_key = 0; return event | CACA_KEY_F2;
case GLUT_KEY_F3 : kk->drv.p->special_key = 0; return event | CACA_KEY_F3;
case GLUT_KEY_F4 : kk->drv.p->special_key = 0; return event | CACA_KEY_F4;
case GLUT_KEY_F5 : kk->drv.p->special_key = 0; return event | CACA_KEY_F5;
case GLUT_KEY_F6 : kk->drv.p->special_key = 0; return event | CACA_KEY_F6;
case GLUT_KEY_F7 : kk->drv.p->special_key = 0; return event | CACA_KEY_F7;
case GLUT_KEY_F8 : kk->drv.p->special_key = 0; return event | CACA_KEY_F8;
case GLUT_KEY_F9 : kk->drv.p->special_key = 0; return event | CACA_KEY_F9;
case GLUT_KEY_F10: kk->drv.p->special_key = 0; return event | CACA_KEY_F10;
case GLUT_KEY_F11: kk->drv.p->special_key = 0; return event | CACA_KEY_F11;
case GLUT_KEY_F12: kk->drv.p->special_key = 0; return event | CACA_KEY_F12;
case GLUT_KEY_LEFT : kk->drv.p->special_key = 0; return event | CACA_KEY_LEFT;
case GLUT_KEY_RIGHT: kk->drv.p->special_key = 0; return event | CACA_KEY_RIGHT;
case GLUT_KEY_UP : kk->drv.p->special_key = 0; return event | CACA_KEY_UP;
case GLUT_KEY_DOWN : kk->drv.p->special_key = 0; return event | CACA_KEY_DOWN;
default: return CACA_EVENT_NONE;
}
}
@@ -357,50 +381,50 @@ static void gl_handle_keyboard(unsigned char key, int x, int y)
{
caca_t *kk = gl_kk;

kk->gl.key = key;
kk->drv.p->key = key;
}

static void gl_handle_special_key(int key, int x, int y)
{
caca_t *kk = gl_kk;

kk->gl.special_key = key;
kk->drv.p->special_key = key;
}

static void gl_handle_reshape(int w, int h)
{
caca_t *kk = gl_kk;

if(kk->gl.bit) /* Do not handle reshaping at the first time */
if(kk->drv.p->bit) /* Do not handle reshaping at the first time */
{
kk->gl.new_width = w;
kk->gl.new_height = h;
kk->drv.p->new_width = w;
kk->drv.p->new_height = h;

kk->gl.resized = 1;
kk->drv.p->resized = 1;
}
else
kk->gl.bit = 1;
kk->drv.p->bit = 1;
}

static void gl_handle_mouse(int button, int state, int x, int y)
{
caca_t *kk = gl_kk;

kk->gl.mouse_clicked = 1;
kk->gl.mouse_button = button;
kk->gl.mouse_state = state;
kk->gl.mouse_x = x / kk->gl.font_width;
kk->gl.mouse_y = y / kk->gl.font_height;
kk->gl.mouse_changed = 1;
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->drv.p->mouse_changed = 1;
}

static void gl_handle_mouse_motion(int x, int y)
{
caca_t *kk = gl_kk;

kk->gl.mouse_x = x / kk->gl.font_width;
kk->gl.mouse_y = y / kk->gl.font_height;
kk->gl.mouse_changed = 1;
kk->drv.p->mouse_x = x / kk->drv.p->font_width;
kk->drv.p->mouse_y = y / kk->drv.p->font_height;
kk->drv.p->mouse_changed = 1;
}

/*
@@ -409,16 +433,16 @@ static void gl_handle_mouse_motion(int x, int y)

void gl_init_driver(caca_t *kk)
{
kk->driver.driver = CACA_DRIVER_GL;
kk->driver.init_graphics = gl_init_graphics;
kk->driver.end_graphics = gl_end_graphics;
kk->driver.set_window_title = gl_set_window_title;
kk->driver.get_window_width = gl_get_window_width;
kk->driver.get_window_height = gl_get_window_height;
kk->driver.display = gl_display;
kk->driver.handle_resize = gl_handle_resize;
kk->driver.get_event = gl_get_event;
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;
}

#endif /* USE_GL */


+ 75
- 17
caca/driver_ncurses.c Целия файл

@@ -27,6 +27,9 @@
# include <curses.h>
#endif

#include <stdlib.h>
#include <string.h>

#if defined(HAVE_SIGNAL_H)
# include <signal.h>
#endif
@@ -47,6 +50,15 @@
static RETSIGTYPE sigwinch_handler(int);
static caca_t *sigwinch_kk; /* FIXME: we ought to get rid of this */
#endif
#if defined(HAVE_GETENV) && defined(HAVE_PUTENV)
static void ncurses_check_terminal(void);
#endif

struct driver_private
{
int attr[16*16];
mmask_t oldmask;
};

static int ncurses_init_graphics(caca_t *kk)
{
@@ -75,6 +87,12 @@ static int ncurses_init_graphics(caca_t *kk)
mmask_t newmask;
int fg, bg, max;

kk->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;
signal(SIGWINCH, sigwinch_handler);
@@ -90,7 +108,7 @@ static int ncurses_init_graphics(caca_t *kk)

/* Activate mouse */
newmask = REPORT_MOUSE_POSITION | ALL_MOUSE_EVENTS;
mousemask(newmask, &kk->ncurses.oldmask);
mousemask(newmask, &kk->drv.p->oldmask);
mouseinterval(-1); /* No click emulation */

/* Set the escape delay to a ridiculously low value */
@@ -115,17 +133,17 @@ 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->ncurses.attr[fg + 16 * bg] = COLOR_PAIR(col);
kk->drv.p->attr[fg + 16 * bg] = COLOR_PAIR(col);

if(max == 8)
{
/* Bright fg on simple bg */
kk->ncurses.attr[fg + 8 + 16 * bg] = A_BOLD | COLOR_PAIR(col);
kk->drv.p->attr[fg + 8 + 16 * bg] = A_BOLD | COLOR_PAIR(col);
/* Simple fg on bright bg */
kk->ncurses.attr[fg + 16 * (bg + 8)] = A_BLINK
kk->drv.p->attr[fg + 16 * (bg + 8)] = A_BLINK
| COLOR_PAIR(col);
/* Bright fg on bright bg */
kk->ncurses.attr[fg + 8 + 16 * (bg + 8)] = A_BLINK | A_BOLD
kk->drv.p->attr[fg + 8 + 16 * (bg + 8)] = A_BLINK | A_BOLD
| COLOR_PAIR(col);
}
}
@@ -137,11 +155,13 @@ static int ncurses_init_graphics(caca_t *kk)

static int ncurses_end_graphics(caca_t *kk)
{
mousemask(kk->ncurses.oldmask, NULL);
mousemask(kk->drv.p->oldmask, NULL);
curs_set(1);
noraw();
endwin();

free(kk->drv.p);

return 0;
}

@@ -172,7 +192,7 @@ static void ncurses_display(caca_t *kk)
move(y, 0);
for(x = kk->qq->width; x--; )
{
attrset(kk->ncurses.attr[*attr++]);
attrset(kk->drv.p->attr[*attr++]);
addch(*chars++ & 0x7f);
}
}
@@ -396,22 +416,60 @@ static RETSIGTYPE sigwinch_handler(int sig)
}
#endif

#if defined(HAVE_GETENV) && defined(HAVE_PUTENV)
static void ncurses_check_terminal(void)
{
char *term, *colorterm, *other;

term = getenv("TERM");
colorterm = getenv("COLORTERM");

if(term && !strcmp(term, "xterm"))
{
/* If we are using gnome-terminal, it's really a 16 colour terminal */
if(colorterm && !strcmp(colorterm, "gnome-terminal"))
{
SCREEN *screen;
screen = newterm("xterm-16color", stdout, stdin);
if(screen == NULL)
return;
endwin();
(void)putenv("TERM=xterm-16color");
return;
}

/* Ditto if we are using Konsole */
other = getenv("KONSOLE_DCOP_SESSION");
if(other)
{
SCREEN *screen;
screen = newterm("xterm-16color", stdout, stdin);
if(screen == NULL)
return;
endwin();
(void)putenv("TERM=xterm-16color");
return;
}
}
}
#endif

/*
* Driver initialisation
*/

void ncurses_init_driver(caca_t *kk)
{
kk->driver.driver = CACA_DRIVER_NCURSES;

kk->driver.init_graphics = ncurses_init_graphics;
kk->driver.end_graphics = ncurses_end_graphics;
kk->driver.set_window_title = ncurses_set_window_title;
kk->driver.get_window_width = ncurses_get_window_width;
kk->driver.get_window_height = ncurses_get_window_height;
kk->driver.display = ncurses_display;
kk->driver.handle_resize = ncurses_handle_resize;
kk->driver.get_event = ncurses_get_event;
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;
}

#endif /* USE_NCURSES */


+ 48
- 10
caca/driver_slang.c Целия файл

@@ -27,6 +27,9 @@
# include <slang.h>
#endif

#include <stdlib.h>
#include <string.h>

#if defined(HAVE_SIGNAL_H)
# include <signal.h>
#endif
@@ -106,9 +109,16 @@ static void slang_init_palette(void);
static RETSIGTYPE sigwinch_handler(int);
static caca_t *sigwinch_kk; /* 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)
{
#if defined(HAVE_GETENV) && defined(HAVE_PUTENV)
slang_check_terminal();
#endif

#if defined(HAVE_SIGNAL)
sigwinch_kk = kk;
signal(SIGWINCH, sigwinch_handler);
@@ -375,22 +385,50 @@ static RETSIGTYPE sigwinch_handler(int sig)
}
#endif

#if defined(HAVE_GETENV) && defined(HAVE_PUTENV)
static void slang_check_terminal(void)
{
char *term, *colorterm, *other;

term = getenv("TERM");
colorterm = getenv("COLORTERM");

if(term && !strcmp(term, "xterm"))
{
/* If we are using gnome-terminal, it's really a 16 colour terminal */
if(colorterm && !strcmp(colorterm, "gnome-terminal"))
{
(void)putenv("TERM=xterm-16color");
return;
}

/* Ditto if we are using Konsole */
other = getenv("KONSOLE_DCOP_SESSION");
if(other)
{
(void)putenv("TERM=xterm-16color");
return;
}
}
}
#endif

/*
* Driver initialisation
*/

void slang_init_driver(caca_t *kk)
{
kk->driver.driver = CACA_DRIVER_SLANG;

kk->driver.init_graphics = slang_init_graphics;
kk->driver.end_graphics = slang_end_graphics;
kk->driver.set_window_title = slang_set_window_title;
kk->driver.get_window_width = slang_get_window_width;
kk->driver.get_window_height = slang_get_window_height;
kk->driver.display = slang_display;
kk->driver.handle_resize = slang_handle_resize;
kk->driver.get_event = slang_get_event;
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;
}

#endif /* USE_SLANG */


+ 63
- 49
caca/driver_win32.c Целия файл

@@ -23,6 +23,8 @@

#include <windows.h>

#include <stdlib.h>

#include "caca.h"
#include "caca_internals.h"
#include "cucul.h"
@@ -72,65 +74,75 @@ static int const win32_bg_palette[] =
BACKGROUND_INTENSITY | BACKGROUND_RED | BACKGROUND_GREEN | BACKGROUND_BLUE
};

struct driver_private
{
HANDLE hin, hout;
HANDLE front, back;
CHAR_INFO *buffer;
CONSOLE_CURSOR_INFO cci;
};

static int win32_init_graphics(caca_t *kk)
{
CONSOLE_SCREEN_BUFFER_INFO csbi;
COORD size;

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

/* This call is allowed to fail in case we already have a console */
AllocConsole();

kk->win32.hin = GetStdHandle(STD_INPUT_HANDLE);
kk->win32.hout = CreateFile("CONOUT$", GENERIC_READ | GENERIC_WRITE,
FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
if(kk->win32.hout == INVALID_HANDLE_VALUE)
kk->drv.p->hin = GetStdHandle(STD_INPUT_HANDLE);
kk->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)
return -1;

GetConsoleCursorInfo(kk->win32.hout, &kk->win32.cci);
kk->win32.cci.bVisible = FALSE;
SetConsoleCursorInfo(kk->win32.hout, &kk->win32.cci);
GetConsoleCursorInfo(kk->drv.p->hout, &kk->drv.p->cci);
kk->drv.p->cci.bVisible = FALSE;
SetConsoleCursorInfo(kk->drv.p->hout, &kk->drv.p->cci);

SetConsoleMode(kk->win32.hout, ENABLE_MOUSE_INPUT);
SetConsoleMode(kk->drv.p->hout, ENABLE_MOUSE_INPUT);

kk->win32.front =
kk->drv.p->front =
CreateConsoleScreenBuffer(GENERIC_READ | GENERIC_WRITE,
0, NULL, CONSOLE_TEXTMODE_BUFFER, NULL);
if(!kk->win32.front || kk->win32.front == INVALID_HANDLE_VALUE)
if(!kk->drv.p->front || kk->drv.p->front == INVALID_HANDLE_VALUE)
return -1;

kk->win32.back =
kk->drv.p->back =
CreateConsoleScreenBuffer(GENERIC_READ | GENERIC_WRITE,
0, NULL, CONSOLE_TEXTMODE_BUFFER, NULL);
if(!kk->win32.back || kk->win32.back == INVALID_HANDLE_VALUE)
if(!kk->drv.p->back || kk->drv.p->back == INVALID_HANDLE_VALUE)
return -1;

if(!GetConsoleScreenBufferInfo(kk->win32.hout, &csbi))
if(!GetConsoleScreenBufferInfo(kk->drv.p->hout, &csbi))
return -1;

/* Sample code to get the biggest possible window */
//size = GetLargestConsoleWindowSize(kk->win32.hout);
//size = GetLargestConsoleWindowSize(kk->drv.p->hout);
cucul_set_size(kk->qq, csbi.srWindow.Right - csbi.srWindow.Left + 1,
csbi.srWindow.Bottom - csbi.srWindow.Top + 1);
size.X = kk->qq->width;
size.Y = kk->qq->height;
SetConsoleScreenBufferSize(kk->win32.front, size);
SetConsoleScreenBufferSize(kk->win32.back, size);
SetConsoleScreenBufferSize(kk->drv.p->front, size);
SetConsoleScreenBufferSize(kk->drv.p->back, size);

SetConsoleMode(kk->win32.front, 0);
SetConsoleMode(kk->win32.back, 0);
SetConsoleMode(kk->drv.p->front, 0);
SetConsoleMode(kk->drv.p->back, 0);

GetConsoleCursorInfo(kk->win32.front, &kk->win32.cci);
kk->win32.cci.dwSize = 0;
kk->win32.cci.bVisible = FALSE;
SetConsoleCursorInfo(kk->win32.front, &kk->win32.cci);
SetConsoleCursorInfo(kk->win32.back, &kk->win32.cci);
GetConsoleCursorInfo(kk->drv.p->front, &kk->drv.p->cci);
kk->drv.p->cci.dwSize = 0;
kk->drv.p->cci.bVisible = FALSE;
SetConsoleCursorInfo(kk->drv.p->front, &kk->drv.p->cci);
SetConsoleCursorInfo(kk->drv.p->back, &kk->drv.p->cci);

SetConsoleActiveScreenBuffer(kk->win32.front);
SetConsoleActiveScreenBuffer(kk->drv.p->front);

kk->win32.buffer = malloc(kk->qq->width * kk->qq->height
kk->drv.p->buffer = malloc(kk->qq->width * kk->qq->height
* sizeof(CHAR_INFO));
if(kk->win32.buffer == NULL)
if(kk->drv.p->buffer == NULL)
return -1;

return 0;
@@ -138,17 +150,19 @@ static int win32_init_graphics(caca_t *kk)

static int win32_end_graphics(caca_t *kk)
{
SetConsoleActiveScreenBuffer(kk->win32.hout);
CloseHandle(kk->win32.back);
CloseHandle(kk->win32.front);
SetConsoleActiveScreenBuffer(kk->drv.p->hout);
CloseHandle(kk->drv.p->back);
CloseHandle(kk->drv.p->front);

SetConsoleTextAttribute(kk->win32.hout, FOREGROUND_INTENSITY
SetConsoleTextAttribute(kk->drv.p->hout, FOREGROUND_INTENSITY
| FOREGROUND_RED
| FOREGROUND_GREEN
| FOREGROUND_BLUE);
kk->win32.cci.bVisible = TRUE;
SetConsoleCursorInfo(kk->win32.hout, &kk->win32.cci);
CloseHandle(kk->win32.hout);
kk->drv.p->cci.bVisible = TRUE;
SetConsoleCursorInfo(kk->drv.p->hout, &kk->drv.p->cci);
CloseHandle(kk->drv.p->hout);

free(kk->drv.p);

return 0;
}
@@ -184,8 +198,8 @@ static void win32_display(caca_t *kk)
/* Render everything to our back buffer */
for(i = 0; i < kk->qq->width * kk->qq->height; i++)
{
kk->win32.buffer[i].Char.AsciiChar = kk->qq->chars[i] & 0x7f;
kk->win32.buffer[i].Attributes =
kk->drv.p->buffer[i].Char.AsciiChar = kk->qq->chars[i] & 0x7f;
kk->drv.p->buffer[i].Attributes =
win32_fg_palette[kk->qq->attr[i] & 0xf]
| win32_bg_palette[kk->qq->attr[i] >> 4];
}
@@ -197,7 +211,7 @@ static void win32_display(caca_t *kk)
rect.Left = rect.Top = 0;
rect.Right = kk->qq->width - 1;
rect.Bottom = kk->qq->height - 1;
WriteConsoleOutput(kk->win32.front, kk->win32.buffer, size, pos, &rect);
WriteConsoleOutput(kk->drv.p->front, kk->drv.p->buffer, size, pos, &rect);
}

static void win32_handle_resize(caca_t *kk, unsigned int *new_width,
@@ -215,11 +229,11 @@ static unsigned int win32_get_event(caca_t *kk)

for( ; ; )
{
GetNumberOfConsoleInputEvents(kk->win32.hin, &num);
GetNumberOfConsoleInputEvents(kk->drv.p->hin, &num);
if(num == 0)
break;

ReadConsoleInput(kk->win32.hin, &rec, 1, &num);
ReadConsoleInput(kk->drv.p->hin, &rec, 1, &num);
if(rec.EventType == KEY_EVENT)
{
unsigned int event;
@@ -288,16 +302,16 @@ static unsigned int win32_get_event(caca_t *kk)

void win32_init_driver(caca_t *kk)
{
kk->driver.driver = CACA_DRIVER_WIN32;
kk->driver.init_graphics = win32_init_graphics;
kk->driver.end_graphics = win32_end_graphics;
kk->driver.set_window_title = win32_set_window_title;
kk->driver.get_window_width = win32_get_window_width;
kk->driver.get_window_height = win32_get_window_height;
kk->driver.display = win32_display;
kk->driver.handle_resize = win32_handle_resize;
kk->driver.get_event = win32_get_event;
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;
}

#endif /* USE_WIN32 */


+ 124
- 102
caca/driver_x11.c Целия файл

@@ -41,6 +41,24 @@
*/
static int x11_error_handler(Display *, XErrorEvent *);

struct driver_private
{
Display *dpy;
Window window;
Pixmap pixmap;
GC gc;
long int event_mask;
int font_width, font_height;
unsigned int new_width, new_height;
int colors[16];
Font font;
XFontStruct *font_struct;
int font_offset;
#if defined(HAVE_X11_XKBLIB_H)
Bool autorepeat;
#endif
};

static int x11_init_graphics(caca_t *kk)
{
static int const x11_palette[] =
@@ -73,6 +91,8 @@ static int x11_init_graphics(caca_t *kk)
unsigned int width = 0, height = 0;
int i;

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

geometry = getenv("CACA_GEOMETRY");
if(geometry && *(geometry))
sscanf(geometry, "%ux%u", &width, &height);
@@ -80,8 +100,8 @@ static int x11_init_graphics(caca_t *kk)
if(width && height)
cucul_set_size(kk->qq, width, height);

kk->x11.dpy = XOpenDisplay(NULL);
if(kk->x11.dpy == NULL)
kk->drv.p->dpy = XOpenDisplay(NULL);
if(kk->drv.p->dpy == NULL)
return -1;

fonts[0] = getenv("CACA_FONT");
@@ -99,18 +119,18 @@ static int x11_init_graphics(caca_t *kk)
if(!*parser)
{
XSetErrorHandler(old_error_handler);
XCloseDisplay(kk->x11.dpy);
XCloseDisplay(kk->drv.p->dpy);
return -1;
}

kk->x11.font = XLoadFont(kk->x11.dpy, *parser);
if(!kk->x11.font)
kk->drv.p->font = XLoadFont(kk->drv.p->dpy, *parser);
if(!kk->drv.p->font)
continue;

kk->x11.font_struct = XQueryFont(kk->x11.dpy, kk->x11.font);
if(!kk->x11.font_struct)
kk->drv.p->font_struct = XQueryFont(kk->drv.p->dpy, kk->drv.p->font);
if(!kk->drv.p->font_struct)
{
XUnloadFont(kk->x11.dpy, kk->x11.font);
XUnloadFont(kk->drv.p->dpy, kk->drv.p->font);
continue;
}

@@ -120,108 +140,110 @@ static int x11_init_graphics(caca_t *kk)
/* Reset the default X11 error handler */
XSetErrorHandler(old_error_handler);

kk->x11.font_width = kk->x11.font_struct->max_bounds.width;
kk->x11.font_height = kk->x11.font_struct->max_bounds.ascent
+ kk->x11.font_struct->max_bounds.descent;
kk->x11.font_offset = kk->x11.font_struct->max_bounds.descent;
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;

colormap = DefaultColormap(kk->x11.dpy, DefaultScreen(kk->x11.dpy));
colormap = DefaultColormap(kk->drv.p->dpy, DefaultScreen(kk->drv.p->dpy));
for(i = 0; i < 16; i++)
{
XColor color;
color.red = x11_palette[i * 3];
color.green = x11_palette[i * 3 + 1];
color.blue = x11_palette[i * 3 + 2];
XAllocColor(kk->x11.dpy, colormap, &color);
kk->x11.colors[i] = color.pixel;
XAllocColor(kk->drv.p->dpy, colormap, &color);
kk->drv.p->colors[i] = color.pixel;
}

x11_winattr.backing_store = Always;
x11_winattr.background_pixel = kk->x11.colors[0];
x11_winattr.background_pixel = kk->drv.p->colors[0];
x11_winattr.event_mask = ExposureMask | StructureNotifyMask;

kk->x11.window =
XCreateWindow(kk->x11.dpy, DefaultRootWindow(kk->x11.dpy), 0, 0,
kk->qq->width * kk->x11.font_width,
kk->qq->height * kk->x11.font_height,
kk->drv.p->window =
XCreateWindow(kk->drv.p->dpy, DefaultRootWindow(kk->drv.p->dpy), 0, 0,
kk->qq->width * kk->drv.p->font_width,
kk->qq->height * kk->drv.p->font_height,
0, 0, InputOutput, 0,
CWBackingStore | CWBackPixel | CWEventMask,
&x11_winattr);

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

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

kk->x11.gc = XCreateGC(kk->x11.dpy, kk->x11.window, 0, NULL);
XSetForeground(kk->x11.dpy, kk->x11.gc, kk->x11.colors[15]);
XSetFont(kk->x11.dpy, kk->x11.gc, kk->x11.font);
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[15]);
XSetFont(kk->drv.p->dpy, kk->drv.p->gc, kk->drv.p->font);

for(;;)
{
XEvent xevent;
XNextEvent(kk->x11.dpy, &xevent);
XNextEvent(kk->drv.p->dpy, &xevent);
if (xevent.type == MapNotify)
break;
}

#if defined(HAVE_X11_XKBLIB_H)
/* Disable autorepeat */
XkbSetDetectableAutoRepeat(kk->x11.dpy, True, &kk->x11.autorepeat);
if(!kk->x11.autorepeat)
XAutoRepeatOff(kk->x11.dpy);
XkbSetDetectableAutoRepeat(kk->drv.p->dpy, True, &kk->drv.p->autorepeat);
if(!kk->drv.p->autorepeat)
XAutoRepeatOff(kk->drv.p->dpy);
#endif

kk->x11.event_mask = KeyPressMask | KeyReleaseMask | ButtonPressMask
kk->drv.p->event_mask = KeyPressMask | KeyReleaseMask | ButtonPressMask
| ButtonReleaseMask | PointerMotionMask | StructureNotifyMask
| ExposureMask;

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

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

kk->x11.pixmap = XCreatePixmap(kk->x11.dpy, kk->x11.window,
kk->qq->width * kk->x11.font_width,
kk->qq->height * kk->x11.font_height,
DefaultDepth(kk->x11.dpy,
DefaultScreen(kk->x11.dpy)));
kk->drv.p->pixmap = XCreatePixmap(kk->drv.p->dpy, kk->drv.p->window,
kk->qq->width * kk->drv.p->font_width,
kk->qq->height * kk->drv.p->font_height,
DefaultDepth(kk->drv.p->dpy,
DefaultScreen(kk->drv.p->dpy)));

kk->x11.new_width = kk->x11.new_height = 0;
kk->drv.p->new_width = kk->drv.p->new_height = 0;

return 0;
}

static int x11_end_graphics(caca_t *kk)
{
XSync(kk->x11.dpy, False);
XSync(kk->drv.p->dpy, False);
#if defined(HAVE_X11_XKBLIB_H)
if(!kk->x11.autorepeat)
XAutoRepeatOn(kk->x11.dpy);
if(!kk->drv.p->autorepeat)
XAutoRepeatOn(kk->drv.p->dpy);
#endif
XFreePixmap(kk->x11.dpy, kk->x11.pixmap);
XFreeFont(kk->x11.dpy, kk->x11.font_struct);
XFreeGC(kk->x11.dpy, kk->x11.gc);
XUnmapWindow(kk->x11.dpy, kk->x11.window);
XDestroyWindow(kk->x11.dpy, kk->x11.window);
XCloseDisplay(kk->x11.dpy);
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);

free(kk->drv.p);

return 0;
}

static int x11_set_window_title(caca_t *kk, char const *title)
{
XStoreName(kk->x11.dpy, kk->x11.window, title);
XStoreName(kk->drv.p->dpy, kk->drv.p->window, title);
return 0;
}

static unsigned int x11_get_window_width(caca_t *kk)
{
return kk->qq->width * kk->x11.font_width;
return kk->qq->width * kk->drv.p->font_width;
}

static unsigned int x11_get_window_height(caca_t *kk)
{
return kk->qq->height * kk->x11.font_height;
return kk->qq->height * kk->drv.p->font_height;
}

static void x11_display(caca_t *kk)
@@ -241,11 +263,11 @@ static void x11_display(caca_t *kk)
&& (attr[len] >> 4) == (attr[0] >> 4))
len++;

XSetForeground(kk->x11.dpy, kk->x11.gc,
kk->x11.colors[attr[0] >> 4]);
XFillRectangle(kk->x11.dpy, kk->x11.pixmap, kk->x11.gc,
x * kk->x11.font_width, y * kk->x11.font_height,
len * kk->x11.font_width, kk->x11.font_height);
XSetForeground(kk->drv.p->dpy, kk->drv.p->gc,
kk->drv.p->colors[attr[0] >> 4]);
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);
}
}

@@ -273,19 +295,19 @@ static void x11_display(caca_t *kk)
len++;
}

XSetForeground(kk->x11.dpy, kk->x11.gc, kk->x11.colors[attr[0] & 0xf]);
XDrawString(kk->x11.dpy, kk->x11.pixmap, kk->x11.gc,
x * kk->x11.font_width,
(y + 1) * kk->x11.font_height - kk->x11.font_offset,
XSetForeground(kk->drv.p->dpy, kk->drv.p->gc, kk->drv.p->colors[attr[0] & 0xf]);
XDrawString(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_offset,
buffer, len);
}
}

XCopyArea(kk->x11.dpy, kk->x11.pixmap, kk->x11.window, kk->x11.gc, 0, 0,
kk->qq->width * kk->x11.font_width,
kk->qq->height * kk->x11.font_height,
XCopyArea(kk->drv.p->dpy, kk->drv.p->pixmap, kk->drv.p->window, kk->drv.p->gc, 0, 0,
kk->qq->width * kk->drv.p->font_width,
kk->qq->height * kk->drv.p->font_height,
0, 0);
XFlush(kk->x11.dpy);
XFlush(kk->drv.p->dpy);
}

static void x11_handle_resize(caca_t *kk, unsigned int *new_width,
@@ -293,19 +315,19 @@ static void x11_handle_resize(caca_t *kk, unsigned int *new_width,
{
Pixmap new_pixmap;

*new_width = kk->x11.new_width;
*new_height = kk->x11.new_height;
new_pixmap = XCreatePixmap(kk->x11.dpy, kk->x11.window,
kk->qq->width * kk->x11.font_width,
kk->qq->height * kk->x11.font_height,
DefaultDepth(kk->x11.dpy,
DefaultScreen(kk->x11.dpy)));
XCopyArea(kk->x11.dpy, kk->x11.pixmap, new_pixmap, kk->x11.gc, 0, 0,
kk->qq->width * kk->x11.font_width,
kk->qq->height * kk->x11.font_height, 0, 0);
XFreePixmap(kk->x11.dpy, kk->x11.pixmap);
kk->x11.pixmap = new_pixmap;
*new_width = kk->drv.p->new_width;
*new_height = kk->drv.p->new_height;
new_pixmap = XCreatePixmap(kk->drv.p->dpy, kk->drv.p->window,
kk->qq->width * kk->drv.p->font_width,
kk->qq->height * 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->qq->width * kk->drv.p->font_width,
kk->qq->height * kk->drv.p->font_height, 0, 0);
XFreePixmap(kk->drv.p->dpy, kk->drv.p->pixmap);
kk->drv.p->pixmap = new_pixmap;
}

static unsigned int x11_get_event(caca_t *kk)
@@ -314,18 +336,18 @@ static unsigned int x11_get_event(caca_t *kk)
XEvent xevent;
char key;

while(XCheckWindowEvent(kk->x11.dpy, kk->x11.window,
kk->x11.event_mask, &xevent) == True)
while(XCheckWindowEvent(kk->drv.p->dpy, kk->drv.p->window,
kk->drv.p->event_mask, &xevent) == True)
{
KeySym keysym;

/* Expose event */
if(xevent.type == Expose)
{
XCopyArea(kk->x11.dpy, kk->x11.pixmap,
kk->x11.window, kk->x11.gc, 0, 0,
kk->qq->width * kk->x11.font_width,
kk->qq->height * kk->x11.font_height, 0, 0);
XCopyArea(kk->drv.p->dpy, kk->drv.p->pixmap,
kk->drv.p->window, kk->drv.p->gc, 0, 0,
kk->qq->width * kk->drv.p->font_width,
kk->qq->height * kk->drv.p->font_height, 0, 0);
continue;
}

@@ -334,16 +356,16 @@ static unsigned int x11_get_event(caca_t *kk)
{
unsigned int w, h;

w = (xevent.xconfigure.width + kk->x11.font_width / 3)
/ kk->x11.font_width;
h = (xevent.xconfigure.height + kk->x11.font_height / 3)
/ kk->x11.font_height;
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;

if(!w || !h || (w == kk->qq->width && h == kk->qq->height))
continue;

kk->x11.new_width = w;
kk->x11.new_height = h;
kk->drv.p->new_width = w;
kk->drv.p->new_height = h;

/* If we are already resizing, ignore the new signal */
if(kk->resize)
@@ -357,8 +379,8 @@ static unsigned int x11_get_event(caca_t *kk)
/* Check for mouse motion events */
if(xevent.type == MotionNotify)
{
unsigned int newx = xevent.xmotion.x / kk->x11.font_width;
unsigned int newy = xevent.xmotion.y / kk->x11.font_height;
unsigned int newx = xevent.xmotion.x / kk->drv.p->font_width;
unsigned int newy = xevent.xmotion.y / kk->drv.p->font_height;

if(newx >= kk->qq->width)
newx = kk->qq->width - 1;
@@ -394,7 +416,7 @@ static unsigned int x11_get_event(caca_t *kk)
if(XLookupString(&xevent.xkey, &key, 1, NULL, NULL))
return event | key;

keysym = XKeycodeToKeysym(kk->x11.dpy, xevent.xkey.keycode, 0);
keysym = XKeycodeToKeysym(kk->drv.p->dpy, xevent.xkey.keycode, 0);
switch(keysym)
{
case XK_F1: return event | CACA_KEY_F1;
@@ -439,16 +461,16 @@ static int x11_error_handler(Display *dpy, XErrorEvent *xevent)

void x11_init_driver(caca_t *kk)
{
kk->driver.driver = CACA_DRIVER_X11;
kk->driver.init_graphics = x11_init_graphics;
kk->driver.end_graphics = x11_end_graphics;
kk->driver.set_window_title = x11_set_window_title;
kk->driver.get_window_width = x11_get_window_width;
kk->driver.get_window_height = x11_get_window_height;
kk->driver.display = x11_display;
kk->driver.handle_resize = x11_handle_resize;
kk->driver.get_event = x11_get_event;
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;
}

#endif /* USE_X11 */


+ 3
- 3
caca/event.c Целия файл

@@ -140,10 +140,10 @@ static unsigned int _get_next_event(caca_t *kk)
event = _lowlevel_event(kk);

#if defined(USE_SLANG)
if(kk->driver.driver != CACA_DRIVER_SLANG)
if(kk->drv.driver != CACA_DRIVER_SLANG)
#endif
#if defined(USE_NCURSES)
if(kk->driver.driver != CACA_DRIVER_NCURSES)
if(kk->drv.driver != CACA_DRIVER_NCURSES)
#endif
return event;

@@ -205,7 +205,7 @@ static unsigned int _lowlevel_event(caca_t *kk)
return event;
#endif

return kk->driver.get_event(kk);
return kk->drv.get_event(kk);
}

#if defined(USE_SLANG) || defined(USE_NCURSES) || defined(USE_CONIO)


+ 5
- 5
caca/graphics.c Целия файл

@@ -47,7 +47,7 @@ static void caca_handle_resize(caca_t *kk);
*/
int caca_set_window_title(caca_t *kk, char const *title)
{
return kk->driver.set_window_title(kk, title);
return kk->drv.set_window_title(kk, title);
}

/** \brief Get the window width.
@@ -61,7 +61,7 @@ int caca_set_window_title(caca_t *kk, char const *title)
*/
unsigned int caca_get_window_width(caca_t *kk)
{
return kk->driver.get_window_width(kk);
return kk->drv.get_window_width(kk);
}

/** \brief Get the window height.
@@ -75,7 +75,7 @@ unsigned int caca_get_window_width(caca_t *kk)
*/
unsigned int caca_get_window_height(caca_t *kk)
{
return kk->driver.get_window_height(kk);
return kk->drv.get_window_height(kk);
}

/** \brief Set the refresh delay.
@@ -128,7 +128,7 @@ void caca_display(caca_t *kk)
#endif
int ticks = kk->lastticks + _caca_getticks(&kk->timer);

kk->driver.display(kk);
kk->drv.display(kk);

/* FIXME handle this somewhere else */
if(kk->resize)
@@ -164,7 +164,7 @@ static void caca_handle_resize(caca_t *kk)
{
unsigned int new_width, new_height;

kk->driver.handle_resize(kk, &new_width, &new_height);
kk->drv.handle_resize(kk, &new_width, &new_height);

/* Tell libcucul we changed size */
if(new_width != kk->qq->width || new_height != kk->qq->height)


Пиши Преглед
Зареждане…
Отказ
Запис