int main(int argc, char *argv[])
{
caca_canvas_t *cv, *pig;
void *buffer;
size_t len;
int i, j;
pig = caca_create_canvas(0, 0);
caca_import_canvas_from_memory(pig, STRING, strlen(STRING), "text");
cv = caca_create_canvas(caca_get_canvas_width(pig) * 2,
caca_get_canvas_height(pig) * 2);
if(cv == NULL || pig == NULL)
{
printf("Can't created canvas\n");
return -1;
}
caca_blit(cv, 0, 0, pig, NULL);
caca_flip(pig);
caca_blit(cv, caca_get_canvas_width(pig), 0, pig, NULL);
caca_flip(pig);
caca_flop(pig);
caca_blit(cv, 0, caca_get_canvas_height(pig), pig, NULL);
caca_flop(pig);
caca_rotate_180(pig);
caca_blit(cv, caca_get_canvas_width(pig),
caca_get_canvas_height(pig), pig, NULL);
for(j = 0; j < caca_get_canvas_height(cv); j++)
{
for(i = 0; i < caca_get_canvas_width(cv); i += 2)
{
unsigned long int a;
caca_set_color_ansi(cv, CACA_LIGHTBLUE + (i + j) % 6,
CACA_DEFAULT);
a = caca_get_attr(cv, -1, -1);
caca_put_attr(cv, i, j, a);
caca_put_attr(cv, i + 1, j, a);
}
}
buffer = caca_export_canvas_to_memory(cv, "utf8", &len);
fwrite(buffer, len, 1, stdout);
free(buffer);
caca_rotate_left(cv);
buffer = caca_export_canvas_to_memory(cv, "utf8", &len);
fwrite(buffer, len, 1, stdout);
free(buffer);
caca_free_canvas(pig);
caca_free_canvas(cv);
return 0;
}
int init() {
initMillis () ;
initKeyboard();
pthread_t k_t;
pthread_create(&k_t, NULL, &keyboard_thread, NULL);
printf("init ");
sprintf(pt.density, " .',-+:;=o&%%/$*W@#");
pt.C_stroke_r = 255;
pt.C_stroke_g = 255;
pt.C_stroke_b = 255;
pt.C_color = 0;
pt.C_pixel = '.';
pt.running = 1;
pt.PT_paused = 0;
pt.PT_keyblocked = 0;
pt.PT_bitmap_width = 120;
pt.PT_bitmap_height = 80;
ellipseMode(CENTER);
pt.cv = caca_create_canvas(0, 0);
if (!pt.cv) {
fprintf(stderr, "unable to initialise libcaca\n");
return 1;
}
pt.dp = caca_create_display_with_driver(pt.cv, "ncurses"); // x11, raw..
if (pt.dp == NULL ) {
printf("Failed to create display\n");
return 1;
}
if (!pt.PT_USE_DITHERING) {
width = caca_get_canvas_width(pt.cv) / X_SCALE;
height = caca_get_canvas_height(pt.cv);
} else {
width = pt.PT_bitmap_width;
height = pt.PT_bitmap_height;
}
// caca_set_display_time(pt.dp,40000);
useDithering();
stroke(255);
setDitherResolution(caca_get_canvas_width(pt.cv), caca_get_canvas_height(pt.cv));
background(0);
printf("done ");
return 0;
}
static void filter_metal(context_t *cx)
{
static unsigned char const palette[] =
{
CACA_LIGHTBLUE, CACA_BLUE, CACA_LIGHTGRAY, CACA_DARKGRAY,
};
unsigned int x, y, w, h;
w = caca_get_canvas_width(cx->torender);
h = caca_get_canvas_height(cx->torender);
for(y = 0; y < h; y++)
for(x = 0; x < w; x++)
{
unsigned long int ch = caca_get_char(cx->torender, x, y);
int i;
if(ch == (unsigned char)' ')
continue;
i = ((cx->lines + y + x / 8) / 2) % 4;
caca_set_color_ansi(cx->torender, palette[i], CACA_TRANSPARENT);
caca_put_char(cx->torender, x, y, ch);
}
}
static void filter_america(context_t *cx)
{
unsigned int x, y, w, h, flag_w, flag_h;
unsigned char color;
w = caca_get_canvas_width(cx->torender);
h = caca_get_canvas_height(cx->torender);
flag_w = w * 3 / 7;
flag_h = h * 1 / 3;
/* flag_w = w; flag_h = h; */
for(y = 0; y < h; y++)
for(x = 0; x < w; x++)
{
unsigned long int ch = caca_get_char(cx->torender, x, y);
if(ch == (unsigned char)' ')
continue;
if((x < flag_w) && (y < flag_h))
// @todo this really needs to be better.
color = ((x + y) % 2 && y % 2) ? CACA_WHITE : CACA_BLUE;
else
color = (y % 2) ? CACA_WHITE : CACA_RED;
caca_set_color_ansi(cx->torender, color, CACA_TRANSPARENT);
caca_put_char(cx->torender, x, y, ch);
}
}
static void filter_rainbow(context_t *cx)
{
static unsigned char const rainbow[] =
{
CACA_LIGHTMAGENTA, CACA_LIGHTRED, CACA_YELLOW,
CACA_LIGHTGREEN, CACA_LIGHTCYAN, CACA_LIGHTBLUE,
};
unsigned int x, y, w, h;
w = caca_get_canvas_width(cx->torender);
h = caca_get_canvas_height(cx->torender);
for(y = 0; y < h; y++)
for(x = 0; x < w; x++)
{
unsigned long int ch = caca_get_char(cx->torender, x, y);
if(ch != (unsigned char)' ')
{
caca_set_color_ansi(cx->torender,
rainbow[(x / 2 + y + cx->lines) % 6],
CACA_TRANSPARENT);
caca_put_char(cx->torender, x, y, ch);
}
}
}
static void filter_crop(context_t *cx)
{
unsigned int x, y, w, h;
unsigned int xmin, xmax, ymin, ymax;
xmin = w = caca_get_canvas_width(cx->torender);
xmax = 0;
ymin = h = caca_get_canvas_height(cx->torender);
ymax = 0;
for(y = 0; y < h; y++)
for(x = 0; x < w; x++)
{
unsigned long int ch = caca_get_char(cx->torender, x, y);
if(ch != (unsigned char)' ')
{
if(x < xmin)
xmin = x;
if(x > xmax)
xmax = x;
if(y < ymin)
ymin = y;
if(y > ymax)
ymax = y;
}
}
if(xmax < xmin || ymax < ymin)
return;
caca_set_canvas_boundaries(cx->torender, xmin, ymin,
xmax - xmin + 1, ymax - ymin + 1);
}
static int win32_get_display_height(caca_display_t const *dp)
{
/* FIXME */
/* Fallback to a 6x10 font */
return caca_get_canvas_height(dp->cv) * 10;
}
static void conio_display(caca_display_t *dp)
{
char *screen = dp->drv.p->screen;
uint32_t const *chars = caca_get_canvas_chars(dp->cv);
uint32_t const *attrs = caca_get_canvas_attrs(dp->cv);
int width = caca_get_canvas_width(dp->cv);
int height = caca_get_canvas_height(dp->cv);
int n;
for(n = height * width; n--; )
{
char ch = caca_utf32_to_cp437(*chars++);
if(n && *chars == CACA_MAGIC_FULLWIDTH)
{
*screen++ = '[';
*screen++ = caca_attr_to_ansi(*attrs++);
ch = ']';
chars++;
n--;
}
*screen++ = ch;
*screen++ = caca_attr_to_ansi(*attrs++);
}
# if defined(SCREENUPDATE_IN_PC_H)
ScreenUpdate(dp->drv.p->screen);
# else
/* FIXME */
# endif
}
/** \brief flush the figlet context */
int caca_flush_figlet(caca_canvas_t *cv)
{
caca_charfont_t *ff = cv->ff;
int x, y;
if (!ff)
return -1;
//ff->torender = cv;
//caca_set_canvas_size(ff->torender, ff->w, ff->h);
caca_set_canvas_size(cv, ff->w, ff->h);
/* FIXME: do this somewhere else, or record hardblank positions */
for(y = 0; y < ff->h; y++)
for(x = 0; x < ff->w; x++)
if(caca_get_char(cv, x, y) == 0xa0)
{
uint32_t attr = caca_get_attr(cv, x, y);
caca_put_char(cv, x, y, ' ');
caca_put_attr(cv, x, y, attr);
}
ff->x = ff->y = 0;
ff->w = ff->h = 0;
//cv = caca_create_canvas(1, 1); /* XXX */
/* from render.c */
ff->lines += caca_get_canvas_height(cv);
return 0;
}
static void
_increment_frame (lw6sys_context_t * sys_context, _mod_caca_context_t * caca_context, caca_font_t * fo, caca_dither_t * di, uint8_t * buff)
{
int wc, hc;
static caca_font_t *f = NULL;
static caca_dither_t *d = NULL;
static uint8_t *buf = NULL;
if (fo != NULL)
f = fo;
if (di != NULL)
d = di;
if (buff != NULL)
buf = buff;
hc = caca_get_canvas_height (caca_context->canvas);
wc = caca_get_canvas_width (caca_context->canvas);
_plasma (sys_context, UPDATE, caca_context->canvas);
_plasma (sys_context, RENDER, caca_context->canvas);
caca_set_color_ansi (caca_context->canvas, CACA_WHITE, CACA_BLACK);
caca_dither_bitmap (caca_context->canvas, (wc - (10 * caca_get_font_width (f))) / 2, (hc - caca_get_font_height (f)) / 2, wc, hc, d, buf);
caca_put_str (caca_context->canvas, wc - 8, 0, "mod-caca");
caca_put_str (caca_context->canvas, 0, 0, "PFA Epitech 2012-2013");
caca_put_str (caca_context->canvas, (wc - 41) / 2, hc - 1, "by france_a, clavel_r, lemonn_k, vougie_c");
caca_refresh_display (caca_context->display);
frame++;
}
static int resize(void)
{
screen_w = caca_get_canvas_width(canvas);
screen_h = caca_get_canvas_height(canvas);
caca_free_dither(dither);
talloc_free(dither_buffer);
dither = caca_create_dither(bpp, image_width, image_height,
depth * image_width,
rmask, gmask, bmask, amask);
if (dither == NULL) {
mp_msg(MSGT_VO, MSGL_FATAL, "vo_caca: caca_create_dither failed!\n");
return ENOSYS;
}
dither_buffer =
talloc_array(NULL, uint8_t, depth * image_width * image_height);
/* Default libcaca features */
caca_set_dither_antialias(dither, dither_antialias);
caca_set_dither_charset(dither, dither_charset);
caca_set_dither_color(dither, dither_color);
caca_set_dither_algorithm(dither, dither_algo);
return 0;
}
static int caca_install_driver(caca_display_t *dp, char const *driver)
{
#if defined(USE_PLUGINS)
dp->plugin = NULL;
#endif
if(caca_select_driver(dp, driver))
{
#if defined(USE_PLUGINS)
if(dp->plugin)
dlclose(dp->plugin);
#endif
return -1;
}
if(dp->drv.init_graphics(dp))
{
#if defined(USE_PLUGINS)
if(dp->plugin)
dlclose(dp->plugin);
#endif
return -1;
}
/* Graphics stuff */
dp->delay = 0;
dp->rendertime = 0;
/* Events stuff */
#if defined(USE_SLANG) || defined(USE_NCURSES)
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)
dp->events.queue = 0;
#endif
dp->timer.last_sec = 0;
dp->timer.last_usec = 0;
#if defined PROF
_caca_init_stat(&dp->display_stat, "dp[%p] disp_sys time", dp);
_caca_init_stat(&dp->wait_stat, "dp[%p] disp_wait time", dp);
_caca_init_stat(&dp->ev_sys_stat, "dp[%p] ev_sys time", dp);
_caca_init_stat(&dp->ev_wait_stat, "dp[%p] ev_wait time", dp);
#endif
dp->lastticks = 0;
/* Mouse position */
dp->mouse.x = caca_get_canvas_width(dp->cv) / 2;
dp->mouse.y = caca_get_canvas_height(dp->cv) / 2;
/* Resize events */
dp->resize.resized = 0;
dp->resize.allow = 0;
return 0;
}
static void caca_render_msg(video_frame_info_t *video_info,
void *data, const char *msg,
const void *userdata)
{
float x, y, scale;
unsigned width, height;
unsigned newX, newY;
unsigned align;
caca_raster_t *font = (caca_raster_t*)data;
const struct font_params *params = (const struct font_params*)userdata;
if (!font || string_is_empty(msg))
return;
if (params)
{
x = params->x;
y = params->y;
scale = params->scale;
align = params->text_align;
}
else
{
x = video_info->font_msg_pos_x;
y = video_info->font_msg_pos_y;
scale = 1.0f;
align = TEXT_ALIGN_LEFT;
}
if (!font->caca || !font->caca->caca_cv || !font->caca->caca_display ||
!*font->caca->caca_cv || !*font->caca->caca_display)
return;
width = caca_get_canvas_width(*font->caca->caca_cv);
height = caca_get_canvas_height(*font->caca->caca_cv);
newY = height - (y * height * scale);
switch (align)
{
case TEXT_ALIGN_RIGHT:
newX = (x * width * scale) - strlen(msg);
break;
case TEXT_ALIGN_CENTER:
newX = (x * width * scale) - (strlen(msg) / 2);
break;
case TEXT_ALIGN_LEFT:
default:
newX = x * width * scale;
break;
}
caca_put_str(*font->caca->caca_cv, newX, newY, msg);
caca_refresh_display(*font->caca->caca_display);
}
static void filter_border(context_t *cx)
{
int w, h;
w = caca_get_canvas_width(cx->torender);
h = caca_get_canvas_height(cx->torender);
caca_set_canvas_boundaries(cx->torender, -1, -1, w + 2, h + 2);
caca_draw_cp437_box(cx->torender, 0, 0, w + 2, h + 2);
}
int main(int argc, char *argv[])
{
caca_canvas_t *cv, *sprite;
caca_display_t *dp;
cv = caca_create_canvas(80, 24);
if(cv == NULL)
{
printf("Failed to create canvas\n");
return 1;
}
dp = caca_create_display(cv);
if(dp == NULL)
{
printf("Failed to create display\n");
return 1;
}
sprite = caca_create_canvas(0, 0);
caca_set_color_ansi(sprite, CACA_LIGHTRED, CACA_BLACK);
caca_import_canvas_from_memory(sprite, pig, strlen(pig), "text");
caca_set_canvas_handle(sprite, caca_get_canvas_width(sprite) / 2,
caca_get_canvas_height(sprite) / 2);
caca_set_color_ansi(cv, CACA_WHITE, CACA_BLUE);
caca_put_str(cv, 0, 0, "Centered sprite");
caca_blit(cv, caca_get_canvas_width(cv) / 2,
caca_get_canvas_height(cv) / 2, sprite, NULL);
caca_refresh_display(dp);
caca_get_event(dp, CACA_EVENT_KEY_PRESS, NULL, -1);
caca_free_display(dp);
caca_free_canvas(sprite);
caca_free_canvas(cv);
return 0;
}
void processing_terminal() {
setup();
while (pt.running) {
//width = caca_get_canvas_width(pt.cv);
// height = caca_get_canvas_height(pt.cv);
if (!pt.PT_USE_DITHERING) {
width = caca_get_canvas_width(pt.cv) / X_SCALE;
height = caca_get_canvas_height(pt.cv);
} else {
width = pt.PT_bitmap_width;
height = pt.PT_bitmap_height;
}
pt.DITHERED_DRAW = 0;
pt.textrenderjoblist_items = 0;
if (!pt.PT_paused) {
draw();
}
if (pt.PT_USE_DITHERING && pt.DITHERED_DRAW) {
caca_dither_bitmap(caca_get_canvas(pt.dp), 0, 0, caca_get_canvas_width(pt.cv),
caca_get_canvas_height(pt.cv), pt.PT_dither, pt.PT_buffer);
}
render_text_items();
int duration = caca_get_display_time(pt.dp);
if (duration > 0) {
frameRate = (frameRate * 0.9) + ((1000000 / duration) * 0.1); //(1000 / duration);
}
caca_printf(pt.cv, 0, caca_get_canvas_height(pt.cv) - 1, "%d/%d key=%c (%d) fps=%f (%d)", width, height, key, key, frameRate,duration);
caca_refresh_display(pt.dp);
}
if (pt.PT_USE_DITHERING) caca_free_dither(pt.PT_dither);
caca_free_display(pt.dp);
caca_free_canvas(pt.cv);
closeKeyboard();
}
static void win32_display(caca_display_t *dp)
{
COORD size, pos;
SMALL_RECT rect;
CHAR_INFO *buffer = dp->drv.p->buffer;
uint32_t const *cvchars = caca_get_canvas_chars(dp->cv);
uint32_t const *cvattrs = caca_get_canvas_attrs(dp->cv);
int width = caca_get_canvas_width(dp->cv);
int height = caca_get_canvas_height(dp->cv);
int n;
/* Render everything to our screen buffer */
for(n = height * width; n--; )
{
uint32_t ch = *cvchars++;
uint16_t bgfg = caca_attr_to_ansi(*cvattrs);
uint8_t fg = bgfg & 0xf;
uint8_t bg = bgfg >> 4;
#if 0
if(ch > 0x00000020 && ch < 0x00000080)
dp->drv.p->buffer[i].Char.AsciiChar = (uint8_t)ch;
else
dp->drv.p->buffer[i].Char.AsciiChar = ' ';
#else
if(n && *cvchars == CACA_MAGIC_FULLWIDTH)
;
else if(ch > 0x00000020 && ch < 0x00010000)
buffer->Char.UnicodeChar = (uint16_t)ch;
else
buffer->Char.UnicodeChar = (uint16_t)' ';
#endif
buffer->Attributes = win32_fg_palette[fg < 0x10 ? fg : CACA_LIGHTGRAY]
| win32_bg_palette[bg < 0x10 ? bg : CACA_BLACK];
cvattrs++;
buffer++;
}
/* Blit the screen buffer */
size.X = width;
size.Y = height;
pos.X = pos.Y = 0;
rect.Left = rect.Top = 0;
rect.Right = width - 1;
rect.Bottom = height - 1;
#if 0
WriteConsoleOutput(dp->drv.p->screen, dp->drv.p->buffer, size, pos, &rect);
#else
/* FIXME: would this benefit from dirty rectangles? */
WriteConsoleOutputW(dp->drv.p->screen, dp->drv.p->buffer, size, pos, &rect);
#endif
}
static void slang_handle_resize(caca_display_t *dp)
{
SLtt_get_screen_size();
dp->resize.w = SLtt_Screen_Cols;
dp->resize.h = SLtt_Screen_Rows;
SLsig_block_signals();
if(dp->resize.w != caca_get_canvas_width(dp->cv)
|| dp->resize.h != caca_get_canvas_height(dp->cv))
SLsmg_reinit_smg();
SLsig_unblock_signals();
}
struct geo_facts
geo_facts_of(struct vnc *vnc, caca_display_t * disp, caca_canvas_t * view)
{
struct geo_facts ret;
ret.px_width = caca_get_display_width(disp);
ret.px_height = caca_get_display_height(disp);
ret.ch_width = caca_get_canvas_width(view);
ret.ch_height = caca_get_canvas_height(view);
ret.vnc_width = vnc->conn->width;
ret.vnc_height = vnc->conn->height;
return ret;
}
int main(void)
{
// R G B A
uint32_t pattern = 0xFFFF00FF;
#ifdef __APPLE__
memset_pattern4(gfx, &pattern, sizeof(gfx));
#else
wmemset(gfx, pattern, (64*32) * sizeof(char));
#endif
gfx[0] = 0xFF0000FF; // R
gfx[1] = 0x00FF00FF; // G
gfx[2] = 0x0000FFFF; // B
gfx[63] = 0xFF0000FF; // R
gfx[64*31] =0x00FF00FF; // G
int x = 64, y = 32;
gfx[(y-1)*64+(x-1)] = 0x0000FFFF; // B
caca_canvas_t *cv; caca_display_t *dp; caca_event_t ev;
dp = caca_create_display(NULL);
if(!dp)
return 1;
/*
printf("Current driver: %s\n", caca_get_display_driver(dp));
char **drivers = caca_get_display_driver_list();
caca_free_display(dp);
while(*drivers != NULL) {
printf("%s\n", *drivers);
drivers++;
}
exit(0);*/
cv = caca_get_canvas(dp);
caca_dither_t *dither = caca_create_dither(32, 64, 32, 4*64,
0xFF000000,
0x00FF0000,
0x0000FF00,
0x000000FF);
int cw = caca_get_canvas_width(cv);
int ch = caca_get_canvas_height(cv);
caca_set_display_title(dp, "Hello!");
//caca_set_color_ansi(cv, CACA_BLUE, CACA_WHITE);
//caca_put_str(cv, 0, 0, "This is a message");
caca_dither_bitmap(cv, 0,0,cw,ch, dither, gfx);
caca_refresh_display(dp);
caca_free_dither(dither);
//caca_get_event(dp, CACA_EVENT_KEY_PRESS, &ev, -1);
caca_get_event(dp, CACA_EVENT_KEY_PRESS, NULL, -1);
caca_free_display(dp);
return 0;
}
void _caca_handle_resize(caca_display_t *dp)
{
dp->drv.handle_resize(dp);
/* Tell libcaca we changed size */
if(dp->resize.w != caca_get_canvas_width(dp->cv)
|| dp->resize.h != caca_get_canvas_height(dp->cv))
{
dp->resize.allow = 1;
caca_set_canvas_size(dp->cv, dp->resize.w, dp->resize.h);
dp->resize.allow = 0;
}
}
static int conio_end_graphics(caca_display_t *dp)
{
_wscroll = 1;
textcolor((enum COLORS)WHITE);
textbackground((enum COLORS)BLACK);
gotoxy(caca_get_canvas_width(dp->cv), caca_get_canvas_height(dp->cv));
cputs("\r\n");
_setcursortype(_NORMALCURSOR);
free(dp->drv.p->screen);
free(dp->drv.p);
return 0;
}
void gui_console_init(int argc, char *argv[], int w, int h, int bpp)
{
c_ui.dp = caca_create_display(NULL);
c_ui.cv = caca_get_canvas(c_ui.dp);
c_ui.ww = caca_get_canvas_width(c_ui.cv);
c_ui.wh = caca_get_canvas_height(c_ui.cv);
caca_set_display_title(c_ui.dp, PACKAGE_NAME);
c_ui.im = caca_create_dither(
bpp,
w, h,
3 * w /*stride*/,
0xff0000, 0x00ff00, 0x0000ff, 0);
}
void
_mod_caca_plasma_anim (lw6sys_context_t * sys_context, _mod_caca_context_t * caca_context)
{
if (frame != 0)
{
_increment_frame (sys_context, caca_context, NULL, NULL, NULL);
return;
}
int wc, hc;
caca_canvas_t *cv = NULL;
caca_font_t *f = NULL;
caca_dither_t *d = NULL;
uint8_t *buf = NULL;
char const *const *fonts;
cv = caca_create_canvas (10, 1);
if (cv == NULL)
{
lw6sys_log (sys_context, LW6SYS_LOG_ERROR, _x_ ("Can't create tmp canvas"));
return;
}
hc = caca_get_canvas_height (caca_context->canvas);
wc = caca_get_canvas_width (caca_context->canvas);
_plasma (sys_context, PREPARE, caca_context->canvas);
_plasma (sys_context, INIT, caca_context->canvas);
caca_set_color_ansi (cv, CACA_BLACK, CACA_TRANSPARENT);
caca_put_str (cv, 0, 0, "LiquidWar6");
fonts = caca_get_font_list ();
if (fonts[0] == NULL || fonts[1] == NULL)
{
lw6sys_log (sys_context, LW6SYS_LOG_ERROR, _x_ ("libcaca was compiled without any fonts"));
return;
}
f = caca_load_font (fonts[1], 0);
if (f == NULL)
{
lw6sys_log (sys_context, LW6SYS_LOG_ERROR, _x_ ("could not load font : '%s'"), fonts[0]);
return;
}
buf = malloc (4 * wc * hc);
if (buf == NULL)
return;
caca_render_canvas (cv, f, buf, wc, hc, 4 * wc);
d = caca_create_dither (32, wc, hc, 4 * wc, 0xff00, 0xff0000, 0xff000000, 0xff);
_increment_frame (sys_context, caca_context, f, d, buf);
_mod_caca_splash_free (sys_context, caca_context, f, d, buf, 1);
caca_free_canvas (cv);
}
static void caca_gfx_create()
{
caca_display = caca_create_display(NULL);
caca_cv = caca_get_canvas(caca_display);
if(!caca_video_width || !caca_video_height)
{
caca_video_width = caca_get_canvas_width(caca_cv);
caca_video_height = caca_get_canvas_height(caca_cv);
}
if (caca_rgb32)
caca_dither = caca_create_dither(32, caca_video_width, caca_video_height, caca_video_pitch,
0x00ff0000, 0xff00, 0xff, 0x0);
else
caca_dither = caca_create_dither(16, caca_video_width, caca_video_height, caca_video_pitch,
0xf800, 0x7e0, 0x1f, 0x0);
video_driver_set_size(&caca_video_width, &caca_video_height);
}
static void ncurses_handle_resize(caca_display_t *dp)
{
struct winsize size;
#if defined HAVE_SYS_IOCTL_H
if(ioctl(fileno(stdout), TIOCGWINSZ, &size) == 0)
{
dp->resize.w = size.ws_col;
dp->resize.h = size.ws_row;
#if defined HAVE_RESIZE_TERM
resize_term(dp->resize.h, dp->resize.w);
#else
resizeterm(dp->resize.h, dp->resize.w);
#endif
wrefresh(curscr);
return;
}
#endif
/* Fallback */
dp->resize.w = caca_get_canvas_width(dp->cv);
dp->resize.h = caca_get_canvas_height(dp->cv);
}
int main(int argc, char *argv[])
{
caca_display_t *dp;
caca_canvas_t *cv;
caca_dither_t *dither;
int x, y;
dp = caca_create_display(NULL);
if(dp == NULL)
{
printf("Can't create display\n");
return -1;
}
cv = caca_get_canvas(dp);
for(y = 0; y < 256; y++)
for(x = 0; x < 256; x++)
{
buffer[y * 256 + x] = ((y * x / 256) << 16) | ((y * x / 256) << 8) | (x<< 0);
}
dither = caca_create_dither(32, 256, 256, 4 * 256,
0x00ff0000, 0x0000ff00, 0x000000ff, 0x0);
caca_dither_bitmap(caca_get_canvas(dp), 0, 0, caca_get_canvas_width(cv),
caca_get_canvas_height(cv), dither, buffer);
caca_free_dither(dither);
caca_refresh_display(dp);
caca_get_event(dp, CACA_EVENT_KEY_PRESS, NULL, -1);
caca_free_display(dp);
return 0;
}
static void conio_handle_resize(caca_display_t *dp)
{
/* We know nothing about our window */
dp->resize.w = caca_get_canvas_width(dp->cv);
dp->resize.h = caca_get_canvas_height(dp->cv);
}
int main(int argc, char *argv[]) {
caca_canvas_t *cv;
caca_canvas_t *figcv;
caca_display_t *dp;
uint32_t w, h, fw, fh;
char *format = "%R:%S";
char *font = "/usr/share/figlet/mono12.tlf";
for(;;)
{
int option_index = 0;
static struct caca_option long_options[] =
{
{ "font", 1, NULL, 'f' },
{ "dateformat", 1, NULL, 'd' },
{ "help", 0, NULL, 'h' },
{ "version", 0, NULL, 'v' },
};
int c = caca_getopt(argc, argv, "f:d:hv",
long_options, &option_index);
if(c == -1)
break;
switch(c)
{
case 'h': /* --help */
usage(argc, argv);
return 0;
break;
case 'v': /* --version */
version();
return 0;
break;
case 'f': /* --font */
font = caca_optarg;
break;
case 'd': /* --dateformat */
format = caca_optarg;
break;
default:
return 1;
break;
}
}
cv = caca_create_canvas(0, 0);
figcv = caca_create_canvas(0, 0);
if(!cv || !figcv)
{
fprintf(stderr, "%s: unable to initialise libcaca\n", argv[0]);
return 1;
}
if(caca_canvas_set_figfont(figcv, font))
{
fprintf(stderr, "Could not open font\n");
return -1;
}
dp = caca_create_display(cv);
if(!dp) {
printf("Can't open window. CACA_DRIVER problem ?\n");
return -1;
}
caca_set_color_ansi(figcv, CACA_DEFAULT, CACA_DEFAULT);
caca_clear_canvas(cv);
for(;;) {
caca_event_t ev;
while(caca_get_event(dp, CACA_EVENT_KEY_PRESS
| CACA_EVENT_QUIT, &ev, 1))
{
if(caca_get_event_type(&ev))
goto end;
}
char *d = get_date(format);
uint32_t o = 0;
// figfont API is not complete, and does not allow us to put a string
// at another position than 0,0
// So, we have to create a canvas which will hold the figfont string,
// then blit this canvas to the main one at the desired position.
caca_clear_canvas(cv);
caca_clear_canvas(figcv);
while(d[o])
{
caca_put_figchar(figcv, d[o++]);
}
caca_flush_figlet (figcv);
free(d);
w = caca_get_canvas_width (cv);
h = caca_get_canvas_height(cv);
fw = caca_get_canvas_width (figcv);
fh = caca_get_canvas_height(figcv);
uint32_t x = (w/2) - (fw/2);
uint32_t y = (h/2) - (fh/2);
caca_blit(cv, x, y, figcv, NULL);
caca_refresh_display(dp);
usleep(250000);
}
end:
caca_free_canvas(figcv);
caca_free_canvas(cv);
caca_free_display(dp);
return 0;
}
int main(int argc, char **argv)
{
caca_event_t *events;
int i, h, quit;
cv = caca_create_canvas(80, 24);
if(cv == NULL)
{
printf("Failed to create canvas\n");
return 1;
}
dp = caca_create_display(cv);
if(dp == NULL)
{
printf("Failed to create display\n");
return 1;
}
h = caca_get_canvas_height(cv) - 1;
caca_set_color_ansi(cv, CACA_WHITE, CACA_BLUE);
caca_draw_line(cv, 0, 0, caca_get_canvas_width(cv) - 1, 0, ' ');
caca_draw_line(cv, 0, h, caca_get_canvas_width(cv) - 1, h, ' ');
caca_put_str(cv, 0, h, "type \"quit\" to exit");
caca_refresh_display(dp);
events = malloc(h * sizeof(caca_event_t));
memset(events, 0, h * sizeof(caca_event_t));
for(quit = 0; quit < 4; )
{
caca_event_t ev;
static char const * quit_string[] = { "", "q", "qu", "qui", "quit" };
int ret = caca_get_event(dp, CACA_EVENT_ANY, &ev, -1);
if(!ret)
continue;
do
{
/* "quit" quits */
if(caca_get_event_type(&ev) & CACA_EVENT_KEY_PRESS)
{
int key = caca_get_event_key_ch(&ev);
if((key == 'q' && quit == 0) || (key == 'u' && quit == 1)
|| (key == 'i' && quit == 2) || (key == 't' && quit == 3))
quit++;
else if(key == 'q')
quit = 1;
else
quit = 0;
}
memmove(events + 1, events, (h - 1) * sizeof(caca_event_t));
events[0] = ev;
ret = caca_get_event(dp, CACA_EVENT_ANY, &ev, 0);
}
while(ret);
caca_set_color_ansi(cv, CACA_LIGHTGRAY, CACA_BLACK);
caca_clear_canvas(cv);
/* Print current event */
caca_set_color_ansi(cv, CACA_WHITE, CACA_BLUE);
caca_draw_line(cv, 0, 0, caca_get_canvas_width(cv) - 1, 0, ' ');
print_event(0, 0, events);
caca_draw_line(cv, 0, h, caca_get_canvas_width(cv) - 1, h, ' ');
caca_printf(cv, 0, h, "type \"quit\" to exit: %s", quit_string[quit]);
/* Print previous events */
caca_set_color_ansi(cv, CACA_WHITE, CACA_BLACK);
for(i = 1; i < h && caca_get_event_type(&events[i]); i++)
print_event(0, i, events + i);
caca_refresh_display(dp);
}
/* Clean up */
free(events);
caca_free_display(dp);
caca_free_canvas(cv);
return 0;
}