Changeset 527


Ignore:
Timestamp:
Mar 6, 2006, 9:32:40 AM (15 years ago)
Author:
Sam Hocevar
Message:
  • All output plugins should now work again.
  • Renamed caca_refresh() into caca_display() which makes more sense.
  • Optimised gl_bgpal by directly storing floats instead of doing the conversion at runtime.
  • Handle resizing in cucul_set_size() and try to keep as much information as possible from the previous canvas.
  • Moved most global variables into cucul_t or caca_t contexts.
  • Moved time.c into libcaca.
Location:
libcaca/trunk
Files:
31 edited

Legend:

Unmodified
Added
Removed
  • libcaca/trunk/caca-config.in

    r245 r527  
    6464      echo_ldflags=yes
    6565      ;;
    66 @NEED_PIC_TRUE@    --libs)
    67 @NEED_PIC_FALSE@    --libs | --plugin-libs)
     66    --libs | --plugin-libs)
    6867      echo_libs=yes
    6968      ;;
    70 @NEED_PIC_TRUE@    --plugin-libs)
    71 @NEED_PIC_TRUE@      echo_plugin_libs=yes
    72 @NEED_PIC_TRUE@      ;;
    7369    *)
    7470      usage 1 1>&2
     
    110106if test "$echo_libs" = "yes"
    111107then
    112   echo -L@libdir@ -lcaca @CACA_LIBS@
     108  echo -L@libdir@ -lcucul -lcaca @CUCUL_LIBS@ @CACA_LIBS@
    113109fi
    114110
    115 @NEED_PIC_TRUE@if test "$echo_plugin_libs" = "yes"
    116 @NEED_PIC_TRUE@then
    117 @NEED_PIC_TRUE@  echo -L@libdir@ -lcaca_pic @CACA_LIBS@
    118 @NEED_PIC_TRUE@fi
    119 
  • libcaca/trunk/configure.ac

    r524 r527  
    77AC_CANONICAL_SYSTEM
    88
    9 AM_INIT_AUTOMAKE(libcaca, 0.9)
     9AM_INIT_AUTOMAKE(libcaca, 0.10)
    1010AM_CONFIG_HEADER(config.h)
    1111
  • libcaca/trunk/examples/aafire.c

    r524 r527  
    237237                    cucul_get_width(qq) - 1, cucul_get_height(qq) - 1,
    238238                    cucul_bitmap, bitmap);
    239   caca_refresh(kk);
     239  caca_display(kk);
    240240  /*XSIZ = caca_get_width() * 2;
    241241  YSIZ = caca_get_height() * 2 - 4;*/
  • libcaca/trunk/examples/cacaball.c

    r524 r527  
    145145                          cucul_get_width(qq) - 1, cucul_get_height(qq) - 1,
    146146                          cucul_bitmap, pixels + (METASIZE / 2) * (1 + XSIZ));
    147         caca_refresh(kk);
     147        caca_display(kk);
    148148    }
    149149
  • libcaca/trunk/examples/cacamoir.c

    r524 r527  
    104104                          cucul_get_width(qq) - 1, cucul_get_height(qq) - 1,
    105105                          bitmap, screen);
    106         caca_refresh(kk);
     106        caca_display(kk);
    107107    }
    108108
  • libcaca/trunk/examples/cacaplas.c

    r524 r527  
    114114                          cucul_get_width(qq) - 1, cucul_get_height(qq) - 1,
    115115                          bitmap, screen);
    116         caca_refresh(kk);
     116        caca_display(kk);
    117117    }
    118118
  • libcaca/trunk/examples/cacaview.c

    r524 r527  
    271271            else if(event == CACA_EVENT_RESIZE)
    272272            {
    273                 caca_refresh(kk);
     273                caca_display(kk);
    274274                ww = cucul_get_width(qq);
    275275                wh = cucul_get_height(qq);
     
    301301            cucul_set_color(qq, CUCUL_COLOR_WHITE, CUCUL_COLOR_BLUE);
    302302            cucul_putstr(qq, (ww - strlen(buffer)) / 2, wh / 2, buffer);
    303             caca_refresh(kk);
     303            caca_display(kk);
    304304            ww = cucul_get_width(qq);
    305305            wh = cucul_get_height(qq);
     
    395395        }
    396396
    397         caca_refresh(kk);
     397        caca_display(kk);
    398398        update = 0;
    399399    }
  • libcaca/trunk/src/Makefile.am

    r524 r527  
    1818        bitmap.c \
    1919        export.c \
    20         time.c \
    2120        $(NULL)
    2221libcucul_la_LDFLAGS = -no-undefined
     
    2928        graphics.c \
    3029        event.c \
     30        time.c \
    3131        $(NULL)
    3232libcaca_la_LDFLAGS = -no-undefined
  • libcaca/trunk/src/bitmap.c

    r524 r527  
    11/*
    2  *  libcaca       ASCII-Art library
    3  *  Copyright (c) 2002, 2003 Sam Hocevar <sam@zoy.org>
     2 *  libcucul      Unicode canvas library
     3 *  Copyright (c) 2002-2006 Sam Hocevar <sam@zoy.org>
    44 *                All Rights Reserved
    55 *
     
    833833 * Ordered 2 dithering
    834834 */
    835 static unsigned int *ordered2_table;
     835static unsigned int const *ordered2_table;
    836836static unsigned int ordered2_index;
    837837
    838838static void init_ordered2_dither(int line)
    839839{
    840     static unsigned int dither2x2[] =
     840    static unsigned int const dither2x2[] =
    841841    {
    842842        0x00, 0x80,
     
    865865                          -2, -7, -8,  3,
    866866                           4, -3, -4, -7};*/
    867 static unsigned int *ordered4_table;
     867static unsigned int const *ordered4_table;
    868868static unsigned int ordered4_index;
    869869
    870870static void init_ordered4_dither(int line)
    871871{
    872     static unsigned int dither4x4[] =
     872    static unsigned int const dither4x4[] =
    873873    {
    874874        0x00, 0x80, 0x20, 0xa0,
     
    895895 * Ordered 8 dithering
    896896 */
    897 static unsigned int *ordered8_table;
     897static unsigned int const *ordered8_table;
    898898static unsigned int ordered8_index;
    899899
    900900static void init_ordered8_dither(int line)
    901901{
    902     static unsigned int dither8x8[] =
     902    static unsigned int const dither8x8[] =
    903903    {
    904904        0x00, 0x80, 0x20, 0xa0, 0x08, 0x88, 0x28, 0xa8,
  • libcaca/trunk/src/box.c

    r524 r527  
    11/*
    2  *  libcaca       ASCII-Art library
    3  *  Copyright (c) 2002, 2003 Sam Hocevar <sam@zoy.org>
     2 *  libcucul      Unicode canvas library
     3 *  Copyright (c) 2002-2006 Sam Hocevar <sam@zoy.org>
    44 *                All Rights Reserved
    55 *
  • libcaca/trunk/src/caca.c

    r524 r527  
    11/*
    22 *  libcaca       ASCII-Art library
    3  *  Copyright (c) 2002, 2003 Sam Hocevar <sam@zoy.org>
     3 *  Copyright (c) 2002-2006 Sam Hocevar <sam@zoy.org>
    44 *                All Rights Reserved
    55 *
     
    167167    if(kk->driver == CACA_DRIVER_WIN32)
    168168    {
    169         /* This call is allowed to fail in cas we already have a console */
     169        /* This call is allowed to fail in case we already have a console */
    170170        AllocConsole();
    171171
    172         win32_hin = GetStdHandle(STD_INPUT_HANDLE);
    173         win32_hout = CreateFile("CONOUT$", GENERIC_READ | GENERIC_WRITE,
    174                                 FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
    175                                 OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
    176 
    177         if(win32_hout == INVALID_HANDLE_VALUE)
     172        kk->win32.hin = GetStdHandle(STD_INPUT_HANDLE);
     173        kk->win32.hout = CreateFile("CONOUT$", GENERIC_READ | GENERIC_WRITE,
     174                                    FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
     175                                    OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
     176
     177        if(kk->win32.hout == INVALID_HANDLE_VALUE)
    178178            return NULL;
    179179
    180         GetConsoleCursorInfo(win32_hout, &cci);
     180        GetConsoleCursorInfo(kk->win32.hout, &cci);
    181181        cci.bVisible = FALSE;
    182         SetConsoleCursorInfo(win32_hout, &cci);
    183 
    184         SetConsoleMode(win32_hout, ENABLE_MOUSE_INPUT);
     182        SetConsoleCursorInfo(kk->win32.hout, &cci);
     183
     184        SetConsoleMode(kk->win32.hout, ENABLE_MOUSE_INPUT);
    185185    }
    186186    else
     
    197197    }
    198198
     199    /* Initialise events stuff */
     200    kk->events.key_timer.last_sec = 0;
     201    kk->events.key_timer.last_usec = 0;
     202    kk->events.last_key_ticks = 0;
     203    kk->events.autorepeat_ticks = 0;
     204    kk->events.last_key = 0;
     205
    199206    qq->refcount++;
    200207    kk->qq = qq;
     208
     209    kk->timer.last_sec = 0;
     210    kk->timer.last_usec = 0;
     211    kk->lastticks = 0;
    201212
    202213    kk->resize = 0;
     
    255266    if(kk->driver == CACA_DRIVER_WIN32)
    256267    {
    257         SetConsoleTextAttribute(win32_hout, FOREGROUND_INTENSITY
    258                                              | FOREGROUND_RED
    259                                              | FOREGROUND_GREEN
    260                                              | FOREGROUND_BLUE);
     268        SetConsoleTextAttribute(kk->win32.hout, FOREGROUND_INTENSITY
     269                                                 | FOREGROUND_RED
     270                                                 | FOREGROUND_GREEN
     271                                                 | FOREGROUND_BLUE);
    261272        cci.bVisible = TRUE;
    262         SetConsoleCursorInfo(win32_hout, &cci);
    263         CloseHandle(win32_hout);
     273        SetConsoleCursorInfo(kk->win32.hout, &cci);
     274        CloseHandle(kk->win32.hout);
    264275    }
    265276    else
  • libcaca/trunk/src/caca.h

    r524 r527  
    178178void caca_detach(caca_t *kk);
    179179void caca_set_delay(caca_t *kk, unsigned int);
    180 void caca_refresh(caca_t *kk);
     180void caca_display(caca_t *kk);
    181181unsigned int caca_get_rendertime(caca_t *kk);
    182182unsigned int caca_get_window_width(caca_t *kk);
  • libcaca/trunk/src/caca_internals.h

    r524 r527  
    11/*
    22 *  libcaca       ASCII-Art library
    3  *  Copyright (c) 2002, 2003 Sam Hocevar <sam@zoy.org>
     3 *  Copyright (c) 2002-2006 Sam Hocevar <sam@zoy.org>
    44 *                All Rights Reserved
    55 *
     
    5050
    5151/* Timer structure */
    52 #define CACA_TIMER_INITIALIZER { 0, 0 }
    5352struct caca_timer
    5453{
     
    6867
    6968    unsigned int delay, rendertime;
     69    struct caca_timer timer;
     70    int lastticks;
     71
     72    struct events
     73    {
     74#if defined(USE_SLANG) || defined(USE_NCURSES)
     75        struct caca_timer key_timer;
     76        unsigned int last_key_ticks;
     77        unsigned int autorepeat_ticks;
     78        unsigned int last_key;
     79#endif
     80    } events;
    7081
    7182#if defined(USE_X11) && !defined(_DOXYGEN_SKIP_ME)
     
    8495        int font_offset;
    8596#if defined(HAVE_X11_XKBLIB_H)
    86         Bool detect_autorepeat;
     97        Bool autorepeat;
    8798#endif
    8899    } x11;
     100#endif
     101#if defined(USE_NCURSES)
     102    struct ncurses
     103    {
     104        int attr[16*16];
     105    } ncurses;
     106#endif
     107#if defined(USE_CONIO)
     108    struct conio
     109    {
     110        struct text_info ti;
     111        char *screen;
     112    } conio;
     113#endif
     114#if defined(USE_WIN32)
     115    struct win32
     116    {
     117        HANDLE hin, hout;
     118        HANDLE front, back;
     119        CHAR_INFO *buffer;
     120    } win32;
     121#endif
     122#if defined(USE_GL)
     123    struct gl
     124    {
     125        int window;
     126        unsigned int width, height;
     127        float font_width, font_height;
     128        float incx, incy;
     129        int id[94];
     130        unsigned char resized, bit;
     131        unsigned char mouse_changed, mouse_clicked;
     132        unsigned int mouse_x, mouse_y;
     133        unsigned int mouse_button, mouse_state;
     134
     135        unsigned char key;
     136        int special_key;
     137        int new_width;
     138        int new_height;
     139
     140        float sw, sh;
     141    } gl;
    89142#endif
    90143};
  • libcaca/trunk/src/char.c

    r524 r527  
    11/*
    2  *  libcaca       ASCII-Art library
    3  *  Copyright (c) 2002, 2003 Sam Hocevar <sam@zoy.org>
     2 *  libcucul      Unicode canvas library
     3 *  Copyright (c) 2002-2006 Sam Hocevar <sam@zoy.org>
    44 *                All Rights Reserved
    55 *
     
    6060    qq->fgcolor = fgcolor;
    6161    qq->bgcolor = bgcolor;
    62 
    63 #if 0
    64     switch(kk->driver)
    65     {
    66 #if defined(USE_SLANG)
    67     case CACA_DRIVER_SLANG:
    68 
    69 #if defined(OPTIMISE_SLANG_PALETTE)
    70         /* If foreground == background, discard this colour pair. Functions
    71          * such as cucul_putchar will print spaces instead of characters */
    72         if(fgcolor != bgcolor)
    73             qq->fgisbg = 0;
    74         else
    75         {
    76             qq->fgisbg = 1;
    77             if(fgcolor == CUCUL_COLOR_BLACK)
    78                 fgcolor = CUCUL_COLOR_WHITE;
    79             else if(fgcolor == CUCUL_COLOR_WHITE
    80                      || fgcolor <= CUCUL_COLOR_LIGHTGRAY)
    81                 fgcolor = CUCUL_COLOR_BLACK;
    82             else
    83                 fgcolor = CUCUL_COLOR_WHITE;
    84         }
    85 #endif
    86 
    87 #if defined(OPTIMISE_SLANG_PALETTE)
    88         SLsmg_set_color(slang_assoc[fgcolor + 16 * bgcolor]);
    89 #else
    90         SLsmg_set_color(fgcolor + 16 * bgcolor);
    91 #endif
    92         break;
    93 #endif
    94 #if defined(USE_NCURSES)
    95     case CACA_DRIVER_NCURSES:
    96         attrset(ncurses_attr[fgcolor + 16 * bgcolor]);
    97         break;
    98 #endif
    99 #if defined(USE_CONIO)
    100     case CACA_DRIVER_CONIO:
    101         textbackground(bgcolor);
    102         textcolor(fgcolor);
    103         break;
    104 #endif
    105 #if defined(USE_X11)
    106     case CACA_DRIVER_X11:
    107         /* Nothing to do */
    108         break;
    109 #endif
    110 #if defined(USE_WIN32)
    111     case CACA_DRIVER_WIN32:
    112         /* Nothing to do */
    113         break;
    114 #endif
    115 #if defined(USE_GL)
    116     case CACA_DRIVER_GL:
    117         /* Nothing to do */
    118         break;
    119 #endif
    120     default:
    121         break;
    122     }
    123 #endif
    12462}
    12563
     
    16098void cucul_putchar(cucul_t *qq, int x, int y, char c)
    16199{
    162 #if defined(USE_CONIO)
    163     char *data;
    164 #endif
    165100    if(x < 0 || x >= (int)qq->width ||
    166101       y < 0 || y >= (int)qq->height)
     
    169104    qq->chars[x + y * qq->width] = c;
    170105    qq->attr[x + y * qq->width] = (qq->bgcolor << 4) | qq->fgcolor;
    171 
    172 #if 0
    173     switch(kk->driver)
    174     {
    175 #if defined(USE_SLANG)
    176     case CACA_DRIVER_SLANG:
    177         SLsmg_gotorc(y, x);
    178 #if defined(OPTIMISE_SLANG_PALETTE)
    179         if(qq->fgisbg)
    180             SLsmg_write_char(' ');
    181         else
    182 #endif
    183             SLsmg_write_char(c);
    184         break;
    185 #endif
    186 #if defined(USE_NCURSES)
    187     case CACA_DRIVER_NCURSES:
    188         move(y, x);
    189         addch(c);
    190         break;
    191 #endif
    192 #if defined(USE_CONIO)
    193     case CACA_DRIVER_CONIO:
    194         data = conio_screen + 2 * (x + y * qq->width);
    195         data[0] = c;
    196         data[1] = (qq->bgcolor << 4) | qq->fgcolor;
    197         break;
    198 #endif
    199 #if defined(USE_X11)
    200     case CACA_DRIVER_X11:
    201         break;
    202 #endif
    203 #if defined(USE_WIN32)
    204     case CACA_DRIVER_WIN32:
    205         break;
    206 #endif
    207 #if defined(USE_GL)
    208     case CACA_DRIVER_GL:
    209         break;
    210 #endif
    211     default:
    212         break;
    213     }
    214 #endif
    215106}
    216107
     
    263154        *attrbuf++ = (qq->bgcolor << 4) | qq->fgcolor;
    264155    }
    265 
    266 #if 0
    267     switch(kk->driver)
    268     {
    269 #if defined(USE_SLANG)
    270     case CACA_DRIVER_SLANG:
    271         SLsmg_gotorc(y, x);
    272 #if defined(OPTIMISE_SLANG_PALETTE)
    273         if(qq->fgisbg)
    274             SLsmg_write_string(qq->empty_line + qq->width - len);
    275         else
    276 #endif
    277         {
    278             union { char *ch; const char *constch; } u;
    279             u.constch = s;
    280             SLsmg_write_string(u.ch);
    281         }
    282         break;
    283 #endif
    284 #if defined(USE_NCURSES)
    285     case CACA_DRIVER_NCURSES:
    286         move(y, x);
    287         addstr(s);
    288         break;
    289 #endif
    290 #if defined(USE_CONIO)
    291     case CACA_DRIVER_CONIO:
    292         charbuf = conio_screen + 2 * (x + y * qq->width);
    293         while(*s)
    294         {
    295             *charbuf++ = *s++;
    296             *charbuf++ = (qq->bgcolor << 4) | qq->fgcolor;
    297         }
    298         break;
    299 #endif
    300 #if defined(USE_X11)
    301     case CACA_DRIVER_X11:
    302         break;
    303 #endif
    304 #if defined(USE_WIN32)
    305     case CACA_DRIVER_WIN32:
    306         break;
    307 #endif
    308 #if defined(USE_GL)
    309     case CACA_DRIVER_GL:
    310         break;
    311 #endif
    312     default:
    313         break;
    314     }
    315 #endif
    316156}
    317157
  • libcaca/trunk/src/conic.c

    r524 r527  
    11/*
    2  *  libcaca       ASCII-Art library
    3  *  Copyright (c) 2002, 2003 Sam Hocevar <sam@zoy.org>
     2 *  libcucul      Unicode canvas library
     3 *  Copyright (c) 2002-2006 Sam Hocevar <sam@zoy.org>
    44 *                All Rights Reserved
    55 *
  • libcaca/trunk/src/cucul.c

    r525 r527  
    3333#include "cucul_internals.h"
    3434
    35 static void cucul_init_features(cucul_t *qq);
     35static void cucul_read_environment(cucul_t *qq);
    3636
    3737/** \brief Initialise \e libcucul.
     
    4848    cucul_t *qq = malloc(sizeof(cucul_t));
    4949
    50     cucul_init_features(qq);
     50    cucul_read_environment(qq);
    5151
    5252    qq->fgcolor = CUCUL_COLOR_LIGHTGRAY;
    5353    qq->bgcolor = CUCUL_COLOR_BLACK;
    54 #if defined(OPTIMISE_SLANG_PALETTE)
    55     qq->fgisbg = 0;
    56 #endif
    57 
    58     /* Initialise to a default size. If a graphic driver attaches to
    59      * us before cucul_set_size is called, we'll adapt. */
     54
     55    /* Initialise to a default size. When a graphic driver attaches to
     56     * us, we'll adapt to its size. */
    6057    qq->width = 80;
    6158    qq->height = 32;
    62     qq->size_set = 0;
    6359
    6460    qq->chars = malloc(qq->width * qq->height * sizeof(uint8_t));
    6561    qq->attr = malloc(qq->width * qq->height * sizeof(uint8_t));
    6662
    67     memset(qq->chars, 0, qq->width * qq->height * sizeof(uint8_t));
     63    memset(qq->chars, ' ', qq->width * qq->height * sizeof(uint8_t));
    6864    memset(qq->attr, 0, qq->width * qq->height * sizeof(uint8_t));
    6965
     
    9288void cucul_set_size(cucul_t *qq, unsigned int width, unsigned int height)
    9389{
     90    unsigned int x, y, old_width, old_height, new_size, old_size;
     91
     92    old_width = qq->width;
     93    old_height = qq->height;
     94    old_size = old_width * old_height;
     95
    9496    qq->width = width;
    9597    qq->height = height;
    96     qq->size_set = 1;
     98    new_size = width * height;
     99
     100    /* Step 1: if new area is bigger, resize the memory area now. */
     101    if(new_size > old_size)
     102    {
     103        qq->chars = realloc(qq->chars, new_size * sizeof(uint8_t));
     104        qq->attr = realloc(qq->attr, new_size * sizeof(uint8_t));
     105    }
     106
     107    /* Step 2: move line data if necessary. */
     108    if(width == old_width)
     109    {
     110        /* Width did not change, which means we do not need to move data. */
     111        ;
     112    }
     113    else if(width > old_width)
     114    {
     115        /* New width is bigger than old width, which means we need to
     116         * copy lines starting from the bottom of the screen otherwise
     117         * we will overwrite information. */
     118        for(y = height < old_height ? height : old_height; y--; )
     119        {
     120            for(x = old_width; x--; )
     121            {
     122                qq->chars[y * width + x] = qq->chars[y * old_width + x];
     123                qq->attr[y * width + x] = qq->attr[y * old_width + x];
     124            }
     125
     126            /* Zero the end of the line */
     127            memset(qq->chars + y * width + old_width, ' ',
     128                   width - old_width);
     129            memset(qq->attr + y * width + old_width, 0,
     130                   width - old_width);
     131        }
     132    }
     133    else
     134    {
     135        /* New width is smaller. Copy as many lines as possible. Ignore
     136         * the first line, it is already in place. */
     137        unsigned int lines = height < old_height ? height : old_height;
     138
     139        for(y = 1; y < lines; y++)
     140        {
     141            for(x = 0; x < width; x++)
     142            {
     143                qq->chars[y * width + x] = qq->chars[y * old_width + x];
     144                qq->attr[y * width + x] = qq->attr[y * old_width + x];
     145            }
     146        }
     147    }
     148
     149    /* Step 3: fill the bottom of the new screen if necessary. */
     150    if(height > old_height)
     151    {
     152        /* Zero the bottom of the screen */
     153        memset(qq->chars + old_height * width, ' ',
     154               (height - old_height) * width);
     155    }
     156
     157    /* Step 4: if new area is smaller, resize memory area now. */
     158    if(new_size <= old_size)
     159    {
     160        qq->chars = realloc(qq->chars, new_size * sizeof(uint8_t));
     161        qq->attr = realloc(qq->attr, new_size * sizeof(uint8_t));
     162    }
     163
     164    /* Recompute the scratch line and the empty line */
     165    if(width != old_width)
     166    {
     167        qq->empty_line = realloc(qq->empty_line, width + 1);
     168        memset(qq->empty_line, ' ', width);
     169        qq->empty_line[width] = '\0';
     170
     171        qq->scratch_line = realloc(qq->scratch_line, width + 1);
     172    }
    97173}
    98174
     
    121197/** \brief Translate a colour index into the colour's name.
    122198 *
    123  *  This function translates a caca_color enum into a human-readable
     199 *  This function translates a cucul_color enum into a human-readable
    124200 *  description string of the associated colour.
    125201 *
     
    157233/** \brief Get the current value of a feature.
    158234 *
    159  *  This function retrieves the value of an internal \e libcaca feature. A
     235 *  This function retrieves the value of an internal \e libcucul feature. A
    160236 *  generic feature value is expected, such as CUCUL_ANTIALIASING.
    161237 *
     
    182258/** \brief Set a feature.
    183259 *
    184  *  This function sets an internal \e libcaca feature such as the antialiasing
     260 *  This function sets an internal \e libcucul feature such as the antialiasing
    185261 *  or dithering modes. If a specific feature such as CUCUL_DITHERING_RANDOM,
    186262 *  cucul_set_feature() will set it immediately. If a generic feature is given
     
    275351 */
    276352
    277 static void cucul_init_features(cucul_t * qq)
     353static void cucul_read_environment(cucul_t * qq)
    278354{
    279355    /* FIXME: if strcasecmp isn't available, use strcmp */
  • libcaca/trunk/src/cucul_internals.h

    r524 r527  
    2525    /* Context size */
    2626    unsigned int width, height;
    27     int size_set;
    2827
    2928    uint8_t *chars, *attr;
     
    3231    enum cucul_color fgcolor;
    3332    enum cucul_color bgcolor;
    34 #if defined(OPTIMISE_SLANG_PALETTE)
    35     int fgisbg;
    36 #endif
    3733
    3834    /* Internal libcucul features */
  • libcaca/trunk/src/event.c

    r524 r527  
    11/*
    22 *  libcaca       ASCII-Art library
    3  *  Copyright (c) 2002, 2003 Sam Hocevar <sam@zoy.org>
     3 *  Copyright (c) 2002-2006 Sam Hocevar <sam@zoy.org>
    44 *                All Rights Reserved
    55 *
     
    5555#include <GL/glut.h>
    5656#include <GL/freeglut_ext.h>
    57 extern int gl_special_key;
    58 extern unsigned char gl_key;
    59 extern unsigned char gl_resized;
    60 extern float gl_font_width;
    61 extern float gl_font_height;
    62 extern int gl_new_width;
    63 extern int gl_new_height;
    64 extern unsigned char gl_mouse_changed, gl_mouse_clicked;
    65 extern unsigned int gl_mouse_x, gl_mouse_y;
    66 extern unsigned int gl_mouse_button, gl_mouse_state;
    67 #endif
     57#endif
     58
    6859#include "cucul.h"
    6960#include "cucul_internals.h"
     
    190181{
    191182#if defined(USE_SLANG) || defined(USE_NCURSES)
    192     static struct caca_timer key_timer = CACA_TIMER_INITIALIZER;
    193     static unsigned int last_key_ticks = 0;
    194     static unsigned int autorepeat_ticks = 0;
    195     static unsigned int last_key = 0;
    196183    unsigned int ticks;
    197184#endif
     
    210197#if defined(USE_SLANG) || defined(USE_NCURSES)
    211198    /* Simulate long keypresses using autorepeat features */
    212     ticks = _caca_getticks(&key_timer);
    213     last_key_ticks += ticks;
    214     autorepeat_ticks += ticks;
     199    ticks = _caca_getticks(&kk->events.key_timer);
     200    kk->events.last_key_ticks += ticks;
     201    kk->events.autorepeat_ticks += ticks;
    215202
    216203    /* Handle autorepeat */
    217     if(last_key && autorepeat_ticks > AUTOREPEAT_TRIGGER
    218                 && autorepeat_ticks > AUTOREPEAT_THRESHOLD
    219                 && autorepeat_ticks > AUTOREPEAT_RATE)
     204    if(kk->events.last_key
     205           && kk->events.autorepeat_ticks > AUTOREPEAT_TRIGGER
     206           && kk->events.autorepeat_ticks > AUTOREPEAT_THRESHOLD
     207           && kk->events.autorepeat_ticks > AUTOREPEAT_RATE)
    220208    {
    221209        _push_event(event);
    222         autorepeat_ticks -= AUTOREPEAT_RATE;
    223         return CACA_EVENT_KEY_PRESS | last_key;
     210        kk->events.autorepeat_ticks -= AUTOREPEAT_RATE;
     211        return CACA_EVENT_KEY_PRESS | kk->events.last_key;
    224212    }
    225213
    226214    /* We are in autorepeat mode and the same key was just pressed, ignore
    227215     * this event and return the next one by calling ourselves. */
    228     if(event == (CACA_EVENT_KEY_PRESS | last_key))
    229     {
    230         last_key_ticks = 0;
     216    if(event == (CACA_EVENT_KEY_PRESS | kk->events.last_key))
     217    {
     218        kk->events.last_key_ticks = 0;
    231219        return _get_next_event(kk);
    232220    }
     
    234222    /* We are in autorepeat mode, but key has expired or a new key was
    235223     * pressed - store our event and return a key release event first */
    236     if(last_key && (last_key_ticks > AUTOREPEAT_THRESHOLD
    237                      || (event & CACA_EVENT_KEY_PRESS)))
     224    if(kk->events.last_key
     225          && (kk->events.last_key_ticks > AUTOREPEAT_THRESHOLD
     226               || (event & CACA_EVENT_KEY_PRESS)))
    238227    {
    239228        _push_event(event);
    240         event = CACA_EVENT_KEY_RELEASE | last_key;
    241         last_key = 0;
     229        event = CACA_EVENT_KEY_RELEASE | kk->events.last_key;
     230        kk->events.last_key = 0;
    242231        return event;
    243232    }
     
    246235    if(event & CACA_EVENT_KEY_PRESS)
    247236    {
    248         last_key_ticks = 0;
    249         autorepeat_ticks = 0;
    250         last_key = event & 0x00ffffff;
     237        kk->events.last_key_ticks = 0;
     238        kk->events.autorepeat_ticks = 0;
     239        kk->events.last_key = event & 0x00ffffff;
    251240    }
    252241
     
    281270            if(xevent.type == Expose)
    282271            {
    283                 XCopyArea(kk->x11.dpy, kk->x11.pixmap, kk->x11.window, kk->x11.gc, 0, 0,
     272                XCopyArea(kk->x11.dpy, kk->x11.pixmap,
     273                          kk->x11.window, kk->x11.gc, 0, 0,
    284274                          kk->qq->width * kk->x11.font_width,
    285275                          kk->qq->height * kk->x11.font_height, 0, 0);
     
    303293                kk->x11.new_height = h;
    304294
     295                /* If we are already resizing, ignore the new signal */
    305296                if(kk->resize)
    306297                    continue;
     
    739730        glutMainLoopEvent();
    740731
    741         if(gl_resized && !kk->resize)
     732        if(kk->gl.resized && !kk->resize)
    742733        {
    743734            kk->resize = 1;
    744             gl_resized = 0;
     735            kk->gl.resized = 0;
    745736            return CACA_EVENT_RESIZE;
    746737        }
    747738
    748         if(gl_mouse_changed)
    749         {
    750             if(gl_mouse_clicked)
     739        if(kk->gl.mouse_changed)
     740        {
     741            if(kk->gl.mouse_clicked)
    751742            {
    752                 event|= CACA_EVENT_MOUSE_PRESS | gl_mouse_button;
    753                 gl_mouse_clicked=0;
     743                event|= CACA_EVENT_MOUSE_PRESS | kk->gl.mouse_button;
     744                kk->gl.mouse_clicked=0;
    754745            }
    755             mouse_x = gl_mouse_x;
    756             mouse_y = gl_mouse_y;
     746            mouse_x = kk->gl.mouse_x;
     747            mouse_y = kk->gl.mouse_y;
    757748            event |= CACA_EVENT_MOUSE_MOTION | (mouse_x << 12) | mouse_y;
    758             gl_mouse_changed = 0;
    759         }
    760 
    761         if(gl_key != 0)
     749            kk->gl.mouse_changed = 0;
     750        }
     751
     752        if(kk->gl.key != 0)
    762753        {
    763754            event |= CACA_EVENT_KEY_PRESS;
    764             event |= gl_key;
    765             gl_key = 0;
     755            event |= kk->gl.key;
     756            kk->gl.key = 0;
    766757            return event;
    767758        }
    768759
    769         if(gl_special_key != 0)
     760        if(kk->gl.special_key != 0)
    770761        {
    771762            event |= CACA_EVENT_KEY_PRESS;
    772763     
    773             switch(gl_special_key)
     764            switch(kk->gl.special_key)
    774765            {
    775                 case GLUT_KEY_F1 : gl_special_key = 0; return event | CACA_KEY_F1;
    776                 case GLUT_KEY_F2 : gl_special_key = 0; return event | CACA_KEY_F2;
    777                 case GLUT_KEY_F3 : gl_special_key = 0; return event | CACA_KEY_F3;
    778                 case GLUT_KEY_F4 : gl_special_key = 0; return event | CACA_KEY_F4;
    779                 case GLUT_KEY_F5 : gl_special_key = 0; return event | CACA_KEY_F5;
    780                 case GLUT_KEY_F6 : gl_special_key = 0; return event | CACA_KEY_F6;
    781                 case GLUT_KEY_F7 : gl_special_key = 0; return event | CACA_KEY_F7;
    782                 case GLUT_KEY_F8 : gl_special_key = 0; return event | CACA_KEY_F8;
    783                 case GLUT_KEY_F9 : gl_special_key = 0; return event | CACA_KEY_F9;
    784                 case GLUT_KEY_F10: gl_special_key = 0; return event | CACA_KEY_F10;
    785                 case GLUT_KEY_F11: gl_special_key = 0; return event | CACA_KEY_F11;
    786                 case GLUT_KEY_F12: gl_special_key = 0; return event | CACA_KEY_F12;
    787                 case GLUT_KEY_LEFT : gl_special_key = 0; return event | CACA_KEY_LEFT;
    788                 case GLUT_KEY_RIGHT: gl_special_key = 0; return event | CACA_KEY_RIGHT;
    789                 case GLUT_KEY_UP   : gl_special_key = 0; return event | CACA_KEY_UP;
    790                 case GLUT_KEY_DOWN : gl_special_key = 0; return event | CACA_KEY_DOWN;
     766                case GLUT_KEY_F1 : kk->gl.special_key = 0; return event | CACA_KEY_F1;
     767                case GLUT_KEY_F2 : kk->gl.special_key = 0; return event | CACA_KEY_F2;
     768                case GLUT_KEY_F3 : kk->gl.special_key = 0; return event | CACA_KEY_F3;
     769                case GLUT_KEY_F4 : kk->gl.special_key = 0; return event | CACA_KEY_F4;
     770                case GLUT_KEY_F5 : kk->gl.special_key = 0; return event | CACA_KEY_F5;
     771                case GLUT_KEY_F6 : kk->gl.special_key = 0; return event | CACA_KEY_F6;
     772                case GLUT_KEY_F7 : kk->gl.special_key = 0; return event | CACA_KEY_F7;
     773                case GLUT_KEY_F8 : kk->gl.special_key = 0; return event | CACA_KEY_F8;
     774                case GLUT_KEY_F9 : kk->gl.special_key = 0; return event | CACA_KEY_F9;
     775                case GLUT_KEY_F10: kk->gl.special_key = 0; return event | CACA_KEY_F10;
     776                case GLUT_KEY_F11: kk->gl.special_key = 0; return event | CACA_KEY_F11;
     777                case GLUT_KEY_F12: kk->gl.special_key = 0; return event | CACA_KEY_F12;
     778                case GLUT_KEY_LEFT : kk->gl.special_key = 0; return event | CACA_KEY_LEFT;
     779                case GLUT_KEY_RIGHT: kk->gl.special_key = 0; return event | CACA_KEY_RIGHT;
     780                case GLUT_KEY_UP   : kk->gl.special_key = 0; return event | CACA_KEY_UP;
     781                case GLUT_KEY_DOWN : kk->gl.special_key = 0; return event | CACA_KEY_DOWN;
    791782                default: return CACA_EVENT_NONE;
    792783            }
  • libcaca/trunk/src/export.c

    r524 r527  
    11/*
    2  *  libcaca       ASCII-Art library
    3  *  Copyright (c) 2002, 2003 Sam Hocevar <sam@zoy.org>
     2 *  libcucul      Unicode canvas library
     3 *  Copyright (c) 2002-2006 Sam Hocevar <sam@zoy.org>
    44 *                All Rights Reserved
    55 *
  • libcaca/trunk/src/graphics.c

    r524 r527  
    11/*
    22 *  libcaca       ASCII-Art library
    3  *  Copyright (c) 2002, 2003 Sam Hocevar <sam@zoy.org>
     3 *  Copyright (c) 2002-2006 Sam Hocevar <sam@zoy.org>
    44 *                All Rights Reserved
    55 *
     
    143143#endif
    144144
    145 #if defined(USE_CONIO)
    146 static struct text_info conio_ti;
    147 static char *conio_screen;
    148 #endif
    149 
    150145#if defined(USE_WIN32)
    151 HANDLE win32_hin, win32_hout;
    152 static HANDLE win32_front, win32_back;
    153 static CHAR_INFO *win32_buffer;
    154 
    155146static int const win32_fg_palette[] =
    156147{
     
    193184};
    194185#endif
     186
    195187#if defined(USE_GL)
    196 
    197 static unsigned int const gl_bgpal[] =
    198 {
    199     0,
    200     0x0000007F,
    201     0x00007F00,
    202     0x00007F7F,
    203     0x007F0000,
    204     0x007F007F,
    205     0x007F7F00,
    206     0x007F7F7F,
     188static float const gl_bgpal[][3] =
     189{
     190    { 0.0f, 0.0f, 0.0f },
     191    { 0.0f, 0.0f, 0.5f },
     192    { 0.0f, 0.5f, 0.0f },
     193    { 0.0f, 0.5f, 0.5f },
     194    { 0.5f, 0.0f, 0.0f },
     195    { 0.5f, 0.0f, 0.5f },
     196    { 0.5f, 0.5f, 0.0f },
     197    { 0.5f, 0.5f, 0.5f },
    207198    // + intensity
    208     0x00000000,
    209     0x000000FF,
    210     0x0000FF00,
    211     0x0000FFFF,
    212     0x00FF0000,
    213     0x00FF00FF,
    214     0x00FFFF00,
    215     0x00FFFFFF,
    216 
     199    { 0.0f, 0.0f, 0.0f },
     200    { 0.0f, 0.0f, 1.0f },
     201    { 0.0f, 1.0f, 0.0f },
     202    { 0.0f, 1.0f, 1.0f },
     203    { 1.0f, 0.0f, 0.0f },
     204    { 1.0f, 0.0f, 1.0f },
     205    { 1.0f, 1.0f, 0.0f },
     206    { 1.0f, 1.0f, 1.0f },
    217207};
    218208
    219 int gl_window;
    220 unsigned int gl_width, gl_height;
    221 float gl_font_width, gl_font_height;
    222 float gl_incx, gl_incy;
    223 int id[94];
    224 unsigned char gl_resized = 0, gl_bit = 0;
    225 unsigned char gl_mouse_changed = 0, gl_mouse_clicked = 0;
    226 unsigned int gl_mouse_x, gl_mouse_y;
    227 unsigned int gl_mouse_button = 0, gl_mouse_state = 0;
    228 
    229 unsigned char gl_key = 0;
    230 int gl_special_key = 0;
    231 int gl_new_width;
    232 int gl_new_height;
    233 
    234 float gl_sw = 9.0f/16.0f;
    235 float gl_sh = 15.0f/16.0f;
    236 
    237 #endif
    238 
    239 #if defined(USE_NCURSES)
    240 static int ncurses_attr[16*16];
     209static caca_t *gl_kk; /* FIXME: we ought to get rid of this */
    241210#endif
    242211
     
    251220
    252221#if defined(HAVE_SIGNAL) && (defined(USE_NCURSES) || defined(USE_SLANG))
    253 static caca_t *sigwinch_kk;
    254222static RETSIGTYPE sigwinch_handler(int);
     223static caca_t *sigwinch_kk; /* FIXME: we ought to get rid of this */
    255224#endif
    256225
     
    284253        SLtt_Has_Alt_Charset = 0;
    285254
    286         if(!kk->qq->size_set)
    287             cucul_set_size(kk->qq, SLtt_Screen_Cols, SLtt_Screen_Rows);
     255        cucul_set_size(kk->qq, SLtt_Screen_Cols, SLtt_Screen_Rows);
    288256    }
    289257    else
     
    335303                int col = ((max + 7 - fg) % max) + max * bg;
    336304                init_pair(col, curses_colors[fg], curses_colors[bg]);
    337                 ncurses_attr[fg + 16 * bg] = COLOR_PAIR(col);
     305                kk->ncurses.attr[fg + 16 * bg] = COLOR_PAIR(col);
    338306
    339307                if(max == 8)
    340308                {
    341309                    /* Bright fg on simple bg */
    342                     ncurses_attr[fg + 8 + 16 * bg] = A_BOLD | COLOR_PAIR(col);
     310                    kk->ncurses.attr[fg + 8 + 16 * bg] = A_BOLD | COLOR_PAIR(col);
    343311                    /* Simple fg on bright bg */
    344                     ncurses_attr[fg + 16 * (bg + 8)] = A_BLINK
     312                    kk->ncurses.attr[fg + 16 * (bg + 8)] = A_BLINK
    345313                                                        | COLOR_PAIR(col);
    346314                    /* Bright fg on bright bg */
    347                     ncurses_attr[fg + 8 + 16 * (bg + 8)] = A_BLINK | A_BOLD
     315                    kk->ncurses.attr[fg + 8 + 16 * (bg + 8)] = A_BLINK | A_BOLD
    348316                                                            | COLOR_PAIR(col);
    349317                }
    350318            }
    351319
    352         if(!kk->qq->size_set)
    353             cucul_set_size(kk->qq, COLS, LINES);
     320        cucul_set_size(kk->qq, COLS, LINES);
    354321    }
    355322    else
     
    358325    if(kk->driver == CACA_DRIVER_CONIO)
    359326    {
    360         gettextinfo(&conio_ti);
    361         conio_screen = malloc(2 * conio_ti.screenwidth
    362                                 * conio_ti.screenheight * sizeof(char));
    363         if(conio_screen == NULL)
     327        gettextinfo(&kk->conio.ti);
     328        kk->conio.screen = malloc(2 * kk->conio.ti.screenwidth
     329                                * kk->conio.ti.screenheight * sizeof(char));
     330        if(kk->conio.screen == NULL)
    364331            return -1;
    365332#   if defined(SCREENUPDATE_IN_PC_H)
    366         ScreenRetrieve(conio_screen);
     333        ScreenRetrieve(kk->conio.screen);
    367334#   else
    368335        /* FIXME */
    369336#   endif
    370         if(!kk->qq->size_set)
    371             cucul_set_size(kk->qq, conio_ti.screenwidth, conio_ti.screenheight);
     337        cucul_set_size(kk->qq, kk->conio.ti.screenwidth,
     338                               kk->conio.ti.screenheight);
    372339    }
    373340    else
     
    376343    if(kk->driver == CACA_DRIVER_X11)
    377344    {
    378         static int x11_palette[] =
     345        static int const x11_palette[] =
    379346        {
    380347            /* Standard curses colours */
     
    401368        XSetWindowAttributes x11_winattr;
    402369        int (*old_error_handler)(Display *, XErrorEvent *);
    403         char const *font_name = "8x13bold";
     370        char const *fonts[] = { NULL, "8x13bold", "fixed" }, **parser;
     371        char const *geometry;
     372        unsigned int width = 0, height = 0;
    404373        int i;
    405374
    406         if(!kk->qq->size_set)
    407         {
    408             unsigned int width = 0, height = 0;
    409 
    410             if(getenv("CACA_GEOMETRY") && *(getenv("CACA_GEOMETRY")))
    411                 sscanf(getenv("CACA_GEOMETRY"), "%ux%u", &width, &height);
    412 
    413             if(width && height)
    414                 cucul_set_size(kk->qq, width, height);
    415         }
     375        geometry = getenv("CACA_GEOMETRY");
     376        if(geometry && *(geometry))
     377            sscanf(geometry, "%ux%u", &width, &height);
     378
     379        if(width && height)
     380            cucul_set_size(kk->qq, width, height);
    416381
    417382        kk->x11.dpy = XOpenDisplay(NULL);
     
    419384            return -1;
    420385
    421         if(getenv("CACA_FONT") && *(getenv("CACA_FONT")))
    422             font_name = getenv("CACA_FONT");
     386        fonts[0] = getenv("CACA_FONT");
     387        if(fonts[0] && *fonts[0])
     388            parser = fonts;
     389        else
     390            parser = fonts + 1;
    423391
    424392        /* Ignore font errors */
    425393        old_error_handler = XSetErrorHandler(x11_error_handler);
    426394
    427         kk->x11.font = XLoadFont(kk->x11.dpy, font_name);
    428         if(!kk->x11.font)
    429         {
    430             XCloseDisplay(kk->x11.dpy);
    431             return -1;
    432         }
    433 
    434         kk->x11.font_struct = XQueryFont(kk->x11.dpy, kk->x11.font);
    435         if(!kk->x11.font_struct)
    436         {
    437             XUnloadFont(kk->x11.dpy, kk->x11.font);
    438             XCloseDisplay(kk->x11.dpy);
    439             return -1;
     395        /* Parse our font list */
     396        for( ; ; parser++)
     397        {
     398            if(!*parser)
     399            {
     400                XSetErrorHandler(old_error_handler);
     401                XCloseDisplay(kk->x11.dpy);
     402                return -1;
     403            }
     404
     405            kk->x11.font = XLoadFont(kk->x11.dpy, *parser);
     406            if(!kk->x11.font)
     407                continue;
     408
     409            kk->x11.font_struct = XQueryFont(kk->x11.dpy, kk->x11.font);
     410            if(!kk->x11.font_struct)
     411            {
     412                XUnloadFont(kk->x11.dpy, kk->x11.font);
     413                continue;
     414            }
     415
     416            break;
    440417        }
    441418
     
    463440        x11_winattr.event_mask = ExposureMask | StructureNotifyMask;
    464441
    465         kk->x11.window = XCreateWindow(kk->x11.dpy, DefaultRootWindow(kk->x11.dpy), 0, 0,
    466                                    kk->qq->width * kk->x11.font_width,
    467                                    kk->qq->height * kk->x11.font_height,
    468                                    0, 0, InputOutput, 0,
    469                                    CWBackingStore | CWBackPixel | CWEventMask,
    470                                    &x11_winattr);
     442        kk->x11.window =
     443            XCreateWindow(kk->x11.dpy, DefaultRootWindow(kk->x11.dpy), 0, 0,
     444                          kk->qq->width * kk->x11.font_width,
     445                          kk->qq->height * kk->x11.font_height,
     446                          0, 0, InputOutput, 0,
     447                          CWBackingStore | CWBackPixel | CWEventMask,
     448                          &x11_winattr);
    471449
    472450        XStoreName(kk->x11.dpy, kk->x11.window, "caca for X");
     
    487465        }
    488466
     467#if defined(HAVE_X11_XKBLIB_H)
    489468        /* Disable autorepeat */
    490 #if defined(HAVE_X11_XKBLIB_H)
    491         XkbSetDetectableAutoRepeat(kk->x11.dpy, True, &kk->x11.detect_autorepeat);
    492         if(!kk->x11.detect_autorepeat)
     469        XkbSetDetectableAutoRepeat(kk->x11.dpy, True, &kk->x11.autorepeat);
     470        if(!kk->x11.autorepeat)
    493471            XAutoRepeatOff(kk->x11.dpy);
    494472#endif
     
    499477
    500478        kk->x11.pixmap = XCreatePixmap(kk->x11.dpy, kk->x11.window,
    501                                    kk->qq->width * kk->x11.font_width,
    502                                    kk->qq->height * kk->x11.font_height,
    503                                    DefaultDepth(kk->x11.dpy,
     479                                       kk->qq->width * kk->x11.font_width,
     480                                       kk->qq->height * kk->x11.font_height,
     481                                       DefaultDepth(kk->x11.dpy,
    504482                                                DefaultScreen(kk->x11.dpy)));
    505483
     
    515493        COORD size;
    516494
    517         win32_front = CreateConsoleScreenBuffer(GENERIC_READ | GENERIC_WRITE,
    518                                                 0, NULL,
    519                                                 CONSOLE_TEXTMODE_BUFFER, NULL);
    520         if(!win32_front || win32_front == INVALID_HANDLE_VALUE)
     495        kk->win32.front =
     496            CreateConsoleScreenBuffer(GENERIC_READ | GENERIC_WRITE,
     497                                      0, NULL, CONSOLE_TEXTMODE_BUFFER, NULL);
     498        if(!kk->win32.front || kk->win32.front == INVALID_HANDLE_VALUE)
    521499            return -1;
    522500
    523         win32_back = CreateConsoleScreenBuffer(GENERIC_READ | GENERIC_WRITE,
    524                                                0, NULL,
    525                                               CONSOLE_TEXTMODE_BUFFER, NULL);
    526         if(!win32_back || win32_back == INVALID_HANDLE_VALUE)
     501        kk->win32.back =
     502            CreateConsoleScreenBuffer(GENERIC_READ | GENERIC_WRITE,
     503                                      0, NULL, CONSOLE_TEXTMODE_BUFFER, NULL);
     504        if(!kk->win32.back || kk->win32.back == INVALID_HANDLE_VALUE)
    527505            return -1;
    528506
    529         if(!GetConsoleScreenBufferInfo(win32_hout, &csbi))
     507        if(!GetConsoleScreenBufferInfo(kk->win32.hout, &csbi))
    530508            return -1;
    531509
    532510        /* Sample code to get the biggest possible window */
    533         //size = GetLargestConsoleWindowSize(win32_hout);
    534         if(!kk->qq->size_set)
    535         {
    536             cucul_set_size(kk->qq,
    537                            csbi.srWindow.Right - csbi.srWindow.Left + 1,
    538                            csbi.srWindow.Bottom - csbi.srWindow.Top + 1);
    539         }
     511        //size = GetLargestConsoleWindowSize(kk->win32.hout);
     512        cucul_set_size(kk->qq, csbi.srWindow.Right - csbi.srWindow.Left + 1,
     513                               csbi.srWindow.Bottom - csbi.srWindow.Top + 1);
    540514        size.X = kk->qq->width;
    541515        size.Y = kk->qq->height;
    542         SetConsoleScreenBufferSize(win32_front, size);
    543         SetConsoleScreenBufferSize(win32_back, size);
    544 
    545         SetConsoleMode(win32_front, 0);
    546         SetConsoleMode(win32_back, 0);
    547 
    548         GetConsoleCursorInfo(win32_front, &cci);
     516        SetConsoleScreenBufferSize(kk->win32.front, size);
     517        SetConsoleScreenBufferSize(kk->win32.back, size);
     518
     519        SetConsoleMode(kk->win32.front, 0);
     520        SetConsoleMode(kk->win32.back, 0);
     521
     522        GetConsoleCursorInfo(kk->win32.front, &cci);
    549523        cci.dwSize = 0;
    550524        cci.bVisible = FALSE;
    551         SetConsoleCursorInfo(win32_front, &cci);
    552         SetConsoleCursorInfo(win32_back, &cci);
    553 
    554         SetConsoleActiveScreenBuffer(win32_front);
    555 
    556         win32_buffer = malloc(kk->qq->width * kk->qq->height * sizeof(CHAR_INFO));
    557         if(win32_buffer == NULL)
     525        SetConsoleCursorInfo(kk->win32.front, &cci);
     526        SetConsoleCursorInfo(kk->win32.back, &cci);
     527
     528        SetConsoleActiveScreenBuffer(kk->win32.front);
     529
     530        kk->win32.buffer = malloc(kk->qq->width * kk->qq->height
     531                                   * sizeof(CHAR_INFO));
     532        if(kk->win32.buffer == NULL)
    558533            return -1;
    559534    }
     
    563538    if(kk->driver == CACA_DRIVER_GL)
    564539    {
    565         int argc;
    566         char *argv[2];
     540        char *empty_texture;
     541        char const *geometry;
     542        char *argv[2] = { "", NULL };
     543        unsigned int width = 0, height = 0;
     544        int argc = 1;
    567545        int i;
    568         char *empty;
    569        
    570         if(!kk->qq->size_set)
    571         {
    572             unsigned int width = 0, height = 0;
    573 
    574             if(getenv("CACA_GEOMETRY") && *(getenv("CACA_GEOMETRY")))
    575                 sscanf(getenv("CACA_GEOMETRY"), "%ux%u", &width, &height);
    576 
    577             if(width && height)
    578                 cucul_set_size(kk->qq, width, height);
    579         }
    580 
    581         gl_font_width = 9;
    582         gl_font_height = 15;
    583 
    584         gl_width = kk->qq->width * gl_font_width;
    585         gl_height = kk->qq->height * gl_font_height;
    586 
    587         argc = 1;
    588         argv[0] = "";
    589         argv[1] = NULL;
     546
     547        gl_kk = kk;
     548
     549        geometry = getenv("CACA_GEOMETRY");
     550        if(geometry && *(geometry))
     551            sscanf(geometry, "%ux%u", &width, &height);
     552
     553        if(width && height)
     554            cucul_set_size(kk->qq, width, height);
     555
     556        kk->gl.font_width = 9;
     557        kk->gl.font_height = 15;
     558
     559        kk->gl.width = kk->qq->width * kk->gl.font_width;
     560        kk->gl.height = kk->qq->height * kk->gl.font_height;
     561
     562        kk->gl.resized = 0;
     563        kk->gl.bit = 0;
     564
     565        kk->gl.mouse_changed = kk->gl.mouse_clicked = 0;
     566        kk->gl.mouse_button = kk->gl.mouse_state = 0;
     567
     568        kk->gl.key = 0;
     569        kk->gl.special_key = 0;
     570
     571        kk->gl.sw = 9.0f / 16.0f;
     572        kk->gl.sh = 15.0f / 16.0f;
     573
    590574        glutInit(&argc, argv);
    591575
    592576        glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE);
    593         glutInitWindowSize(gl_width, gl_height);
    594         gl_window = glutCreateWindow("caca for GL");
    595 
    596         gluOrtho2D(0, gl_width, gl_height, 0);
     577        glutInitWindowSize(kk->gl.width, kk->gl.height);
     578        kk->gl.window = glutCreateWindow("caca for GL");
     579
     580        gluOrtho2D(0, kk->gl.width, kk->gl.height, 0);
    597581
    598582        glDisable(GL_CULL_FACE);
     
    612596        glPushMatrix();
    613597        glLoadIdentity();
    614         gluOrtho2D(0, gl_width, gl_height, 0);
     598        gluOrtho2D(0, kk->gl.width, kk->gl.height, 0);
    615599
    616600        glMatrixMode(GL_MODELVIEW);
     
    618602        glClear(GL_COLOR_BUFFER_BIT);
    619603
    620         empty = malloc(16 * 16 * 4);
    621         if(empty == NULL)
     604        empty_texture = malloc(16 * 16 * 4);
     605        if(empty_texture == NULL)
    622606            return -1;
    623607
    624         memset(empty, 0xff, 16 * 16 * 4);
     608        memset(empty_texture, 0xff, 16 * 16 * 4);
    625609        glEnable(GL_TEXTURE_2D);
    626610
    627611        for(i = 0; i < 94; i++)
    628612        {
    629             glGenTextures(1, (GLuint*)&id[i]);
    630             glBindTexture(GL_TEXTURE_2D, id[i]);
     613            glGenTextures(1, (GLuint*)&kk->gl.id[i]);
     614            glBindTexture(GL_TEXTURE_2D, kk->gl.id[i]);
    631615            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    632616            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    633617            glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB8,
    634                          16, 16, 0, GL_RGB, GL_UNSIGNED_BYTE, empty);
     618                         16, 16, 0, GL_RGB, GL_UNSIGNED_BYTE, empty_texture);
    635619        }
    636620
     
    645629
    646630            glEnable(GL_TEXTURE_2D);
    647             glBindTexture(GL_TEXTURE_2D, id[i]);
     631            glBindTexture(GL_TEXTURE_2D, kk->gl.id[i]);
    648632            glCopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGB,
    649                              0, gl_height - 16, 16, 16, 0);
     633                             0, kk->gl.height - 16, 16, 16, 0);
    650634
    651635            glutMainLoopEvent();
     
    676660    if(kk->driver == CACA_DRIVER_CONIO)
    677661    {
    678         free(conio_screen);
     662        free(kk->conio.screen);
    679663    }
    680664    else
     
    685669        XSync(kk->x11.dpy, False);
    686670#if defined(HAVE_X11_XKBLIB_H)
    687         if(!kk->x11.detect_autorepeat)
     671        if(!kk->x11.autorepeat)
    688672            XAutoRepeatOn(kk->x11.dpy);
    689673#endif
     
    700684    if(kk->driver == CACA_DRIVER_WIN32)
    701685    {
    702         SetConsoleActiveScreenBuffer(win32_hout);
    703         CloseHandle(win32_back);
    704         CloseHandle(win32_front);
     686        SetConsoleActiveScreenBuffer(kk->win32.hout);
     687        CloseHandle(kk->win32.back);
     688        CloseHandle(kk->win32.front);
    705689    }
    706690    else
     
    709693    if(kk->driver == CACA_DRIVER_GL)
    710694    {
    711         glutDestroyWindow(gl_window);
     695        glutDestroyWindow(kk->gl.window);
    712696    }
    713697    else
     
    788772    if(kk->driver == CACA_DRIVER_GL)
    789773    {
    790         return gl_width;
     774        return kk->gl.width;
    791775    }
    792776    else
     
    828812    if(kk->driver == CACA_DRIVER_GL)
    829813    {
    830         return gl_height;
     814        return kk->gl.height;
    831815    }
    832816    else
     
    851835void caca_set_size(caca_t *kk, unsigned int width, unsigned int height)
    852836{
    853   kk->qq->width = width;
    854   kk->qq->height = height;
     837    kk->qq->width = width;
     838    kk->qq->height = height;
    855839}
    856840
     
    864848void caca_set_width(caca_t *kk, unsigned int width)
    865849{
    866    kk->qq->width = width;
     850    kk->qq->width = width;
    867851}
    868852/** \brief Set the height of the window, in characters, if device permits it.
     
    873857void caca_set_height(caca_t *kk, unsigned int height)
    874858{
    875    kk->qq->height = height;
     859    kk->qq->height = height;
    876860}
    877861
     
    881865 *
    882866 *  This function sets the refresh delay in microseconds. The refresh delay
    883  *  is used by caca_refresh() to achieve constant framerate. See the
    884  *  caca_refresh() documentation for more details.
     867 *  is used by caca_display() to achieve constant framerate. See the
     868 *  caca_display() documentation for more details.
    885869 *
    886870 *  If the argument is zero, constant framerate is disabled. This is the
     
    897881 *
    898882 *  This function returns the average rendering time, which is the average
    899  *  measured time between two caca_refresh() calls, in microseconds. If
     883 *  measured time between two caca_display() calls, in microseconds. If
    900884 *  constant framerate was activated by calling caca_set_delay(), the average
    901885 *  rendering time will not be considerably shorter than the requested delay
     
    912896 *
    913897 *  This function flushes all graphical operations and prints them to the
    914  *  screen. Nothing will show on the screen until caca_refresh() is
     898 *  screen. Nothing will show on the screen until caca_display() is
    915899 *  called.
    916900 *
    917  *  If caca_set_delay() was called with a non-zero value, caca_refresh()
     901 *  If caca_set_delay() was called with a non-zero value, caca_display()
    918902 *  will use that value to achieve constant framerate: if two consecutive
    919  *  calls to caca_refresh() are within a time range shorter than the value
     903 *  calls to caca_display() are within a time range shorter than the value
    920904 *  set with caca_set_delay(), the second call will wait a bit before
    921905 *  performing the screen refresh.
    922906 */
    923 void caca_refresh(caca_t *kk)
     907void caca_display(caca_t *kk)
    924908{
    925909#if !defined(_DOXYGEN_SKIP_ME)
    926910#define IDLE_USEC 10000
    927911#endif
    928     static struct caca_timer timer = CACA_TIMER_INITIALIZER;
    929     static int lastticks = 0;
    930     int ticks = lastticks + _caca_getticks(&timer);
     912    int ticks = kk->lastticks + _caca_getticks(&kk->timer);
    931913
    932914#if defined(USE_SLANG)
    933915    if(kk->driver == CACA_DRIVER_SLANG)
    934916    {
     917        int x, y;
     918        uint8_t *attr = kk->qq->attr;
     919        uint8_t *chars = kk->qq->chars;
     920        for(y = 0; y < kk->qq->height; y++)
     921        {
     922            SLsmg_gotorc(y, 0);
     923            for(x = kk->qq->width; x--; )
     924            {
     925#if defined(OPTIMISE_SLANG_PALETTE)
     926                /* If foreground == background, just don't use this colour
     927                 * pair, and print a space instead of the real character. */
     928                uint8_t fgcolor = *attr & 0xf;
     929                uint8_t bgcolor = *attr >> 4;
     930                if(fgcolor != bgcolor)
     931                {
     932                    SLsmg_set_color(slang_assoc[*attr++]);
     933                    SLsmg_write_char(*chars++);
     934                }
     935                else
     936                {
     937                    if(fgcolor == CUCUL_COLOR_BLACK)
     938                        fgcolor = CUCUL_COLOR_WHITE;
     939                    else if(fgcolor == CUCUL_COLOR_WHITE
     940                             || fgcolor <= CUCUL_COLOR_LIGHTGRAY)
     941                        fgcolor = CUCUL_COLOR_BLACK;
     942                    else
     943                        fgcolor = CUCUL_COLOR_WHITE;
     944                    SLsmg_set_color(slang_assoc[fgcolor + 16 * bgcolor]);
     945                    SLsmg_write_char(' ');
     946                    chars++;
     947                    attr++;
     948                }
     949#else
     950                SLsmg_set_color(*attr++);
     951                SLsmg_write_char(*chars++);
     952#endif
     953            }
     954        }
    935955        SLsmg_refresh();
    936956    }
     
    940960    if(kk->driver == CACA_DRIVER_NCURSES)
    941961    {
     962        int x, y;
     963        uint8_t *attr = kk->qq->attr;
     964        uint8_t *chars = kk->qq->chars;
     965        for(y = 0; y < kk->qq->height; y++)
     966        {
     967            move(y, 0);
     968            for(x = kk->qq->width; x--; )
     969            {
     970                attrset(kk->ncurses.attr[*attr++]);
     971                addch(*chars++);
     972            }
     973        }
    942974        refresh();
    943975    }
     
    947979    if(kk->driver == CACA_DRIVER_CONIO)
    948980    {
     981        int n;
     982        char *screen = kk->conio.screen;
     983        uint8_t *attr = kk->qq->attr;
     984        uint8_t *chars = kk->qq->chars;
     985        for(n = kk->qq->height * kk->qq->width; n--; )
     986        {
     987            *screen++ = *chars++;
     988            *screen++ = *attr++;
     989        }
    949990#   if defined(SCREENUPDATE_IN_PC_H)
    950         ScreenUpdate(conio_screen);
     991        ScreenUpdate(kk->conio.screen);
    951992#   else
    952993        /* FIXME */
     
    9731014                    len++;
    9741015
    975                 XSetForeground(kk->x11.dpy, kk->x11.gc, kk->x11.colors[attr[0] >> 4]);
     1016                XSetForeground(kk->x11.dpy, kk->x11.gc,
     1017                               kk->x11.colors[attr[0] >> 4]);
    9761018                XFillRectangle(kk->x11.dpy, kk->x11.pixmap, kk->x11.gc,
    9771019                               x * kk->x11.font_width, y * kk->x11.font_height,
     
    10211063        for(i = 0; i < kk->qq->width * kk->qq->height; i++)
    10221064        {
    1023             win32_buffer[i].Char.AsciiChar = kk->qq->chars[i];
    1024             win32_buffer[i].Attributes = win32_fg_palette[kk->qq->attr[i] & 0xf]
    1025                                        | win32_bg_palette[kk->qq->attr[i] >> 4];
     1065            kk->win32.buffer[i].Char.AsciiChar = kk->qq->chars[i];
     1066            kk->win32.buffer[i].Attributes =
     1067                    win32_fg_palette[kk->qq->attr[i] & 0xf]
     1068                     | win32_bg_palette[kk->qq->attr[i] >> 4];
    10261069        }
    10271070
     
    10331076        rect.Right = kk->qq->width - 1;
    10341077        rect.Bottom = kk->qq->height - 1;
    1035         WriteConsoleOutput(win32_front, win32_buffer, size, pos, &rect);
     1078        WriteConsoleOutput(kk->win32.front, kk->win32.buffer, size, pos, &rect);
    10361079    }
    10371080    else
     
    10451088
    10461089        offsety = 0;
    1047         for(y = 0; y < gl_height; y += gl_font_height)
     1090        for(y = 0; y < kk->gl.height; y += kk->gl.font_height)
    10481091        {
    10491092            offsetx = 0;
    1050             for(x = 0; x < gl_width; x += gl_font_width)
     1093            for(x = 0; x < kk->gl.width; x += kk->gl.font_width)
    10511094            {
    10521095                uint8_t *attr = kk->qq->attr + offsetx + offsety * kk->qq->width;
     
    10551098                offset = attr[0] >> 4;
    10561099
    1057                 br = ((gl_bgpal[offset] & 0x00FF0000) >> 16) / 255.0f;
    1058                 bg = ((gl_bgpal[offset] & 0x0000FF00) >> 8) / 255.0f;
    1059                 bb = ((gl_bgpal[offset] & 0x000000FF)) / 255.0f;
     1100                br = gl_bgpal[offset][0];
     1101                bg = gl_bgpal[offset][1];
     1102                bb = gl_bgpal[offset][2];
    10601103
    10611104                glDisable(GL_TEXTURE_2D);
     
    10631106                glBegin(GL_QUADS);
    10641107                    glVertex2f(x, y);
    1065                     glVertex2f(x + gl_font_width, y);
    1066                     glVertex2f(x + gl_font_width, y + gl_font_height);
    1067                     glVertex2f(x, y + gl_font_height);
     1108                    glVertex2f(x + kk->gl.font_width, y);
     1109                    glVertex2f(x + kk->gl.font_width, y + kk->gl.font_height);
     1110                    glVertex2f(x, y + kk->gl.font_height);
    10681111                glEnd();
    10691112
     
    10801123
    10811124        offsety = 0;
    1082         for(y = 0; y < gl_height; y += gl_font_height)
     1125        for(y = 0; y < kk->gl.height; y += kk->gl.font_height)
    10831126        {
    10841127            offsetx = 0;
    1085             for(x = 0; x < gl_width; x += gl_font_width)
     1128            for(x = 0; x < kk->gl.width; x += kk->gl.font_width)
    10861129            {
    10871130                uint8_t *attr = kk->qq->attr + offsetx + offsety * kk->qq->width;
     
    10891132                float fr, fg, fb;
    10901133
    1091                 fr = ((gl_bgpal[attr[0] & 0xf] & 0x00FF0000) >> 16) / 255.0f;
    1092                 fg = ((gl_bgpal[attr[0] & 0xf] & 0x0000FF00) >> 8) / 255.0f;
    1093                 fb = ((gl_bgpal[attr[0] & 0xf] & 0x000000FF)) / 255.0f;
     1134                fr = gl_bgpal[attr[0] & 0xf][0];
     1135                fg = gl_bgpal[attr[0] & 0xf][1];
     1136                fb = gl_bgpal[attr[0] & 0xf][2];
    10941137
    10951138                if(chr[0] != ' ')
    10961139                {
    1097                     glBindTexture(GL_TEXTURE_2D, id[chr[0]-32]);
     1140                    glBindTexture(GL_TEXTURE_2D, kk->gl.id[chr[0]-32]);
    10981141
    10991142                    glColor3f(fr, fg, fb);
    11001143                    glBegin(GL_QUADS);
    1101                         glTexCoord2f(0, gl_sh);
     1144                        glTexCoord2f(0, kk->gl.sh);
    11021145                        glVertex2f(x, y);
    1103                         glTexCoord2f(gl_sw, gl_sh);
    1104                         glVertex2f(x + gl_font_width, y);
    1105                         glTexCoord2f(gl_sw, 0);
    1106                         glVertex2f(x + gl_font_width, y + gl_font_height);
     1146                        glTexCoord2f(kk->gl.sw, kk->gl.sh);
     1147                        glVertex2f(x + kk->gl.font_width, y);
     1148                        glTexCoord2f(kk->gl.sw, 0);
     1149                        glVertex2f(x + kk->gl.font_width, y + kk->gl.font_height);
    11071150                        glTexCoord2f(0, 0);
    1108                         glVertex2f(x, y + gl_font_height);
     1151                        glVertex2f(x, y + kk->gl.font_height);
    11091152                    glEnd();
    11101153                }
     
    11261169    }
    11271170
     1171    /* FIXME handle this somewhere else */
    11281172    if(kk->resize)
    11291173    {
     
    11331177
    11341178    /* Wait until kk->delay + time of last call */
    1135     ticks += _caca_getticks(&timer);
    1136     for(ticks += _caca_getticks(&timer);
     1179    ticks += _caca_getticks(&kk->timer);
     1180    for(ticks += _caca_getticks(&kk->timer);
    11371181        ticks + IDLE_USEC < (int)kk->delay;
    1138         ticks += _caca_getticks(&timer))
     1182        ticks += _caca_getticks(&kk->timer))
    11391183    {
    11401184        _caca_sleep(IDLE_USEC);
     
    11441188    kk->rendertime = (7 * kk->rendertime + ticks) / 8;
    11451189
    1146     lastticks = ticks - kk->delay;
     1190    kk->lastticks = ticks - kk->delay;
    11471191
    11481192    /* If we drifted too much, it's bad, bad, bad. */
    1149     if(lastticks > (int)kk->delay)
    1150         lastticks = 0;
     1193    if(kk->lastticks > (int)kk->delay)
     1194        kk->lastticks = 0;
    11511195}
    11521196
     
    11571201static void caca_handle_resize(caca_t *kk)
    11581202{
    1159     unsigned int old_width = kk->qq->width;
    1160     unsigned int old_height = kk->qq->height;
     1203    unsigned int new_width, new_height;
     1204
     1205    new_width = kk->qq->width;
     1206    new_height = kk->qq->height;
    11611207
    11621208#if defined(USE_SLANG)
     
    11641210    {
    11651211        SLtt_get_screen_size();
    1166         kk->qq->width = SLtt_Screen_Cols;
    1167         kk->qq->height = SLtt_Screen_Rows;
    1168 
    1169         if(kk->qq->width != old_width || kk->qq->height != old_height)
     1212        new_width = SLtt_Screen_Cols;
     1213        new_height = SLtt_Screen_Rows;
     1214
     1215        if(new_width != kk->qq->width || new_height != kk->qq->height)
    11701216            SLsmg_reinit_smg();
    11711217    }
     
    11791225        if(ioctl(fileno(stdout), TIOCGWINSZ, &size) == 0)
    11801226        {
    1181             kk->qq->width = size.ws_col;
    1182             kk->qq->height = size.ws_row;
     1227            new_width = size.ws_col;
     1228            new_height = size.ws_row;
    11831229#if defined(HAVE_RESIZE_TERM)
    1184             resize_term(kk->qq->height, kk->qq->width);
     1230            resize_term(new_height, new_width);
    11851231#else
    1186             resizeterm(kk->qq->height, kk->qq->width);
     1232            resizeterm(new_height, new_width);
    11871233#endif
    11881234            wrefresh(curscr);
     
    12031249        Pixmap new_pixmap;
    12041250
    1205         kk->qq->width = kk->x11.new_width;
    1206         kk->qq->height = kk->x11.new_height;
     1251        new_width = kk->x11.new_width;
     1252        new_height = kk->x11.new_height;
    12071253
    12081254        new_pixmap = XCreatePixmap(kk->x11.dpy, kk->x11.window,
     
    12121258                                                DefaultScreen(kk->x11.dpy)));
    12131259        XCopyArea(kk->x11.dpy, kk->x11.pixmap, new_pixmap, kk->x11.gc, 0, 0,
    1214                   old_width * kk->x11.font_width, old_height * kk->x11.font_height,
    1215                   0, 0);
     1260                  kk->qq->width * kk->x11.font_width,
     1261                  kk->qq->height * kk->x11.font_height, 0, 0);
    12161262        XFreePixmap(kk->x11.dpy, kk->x11.pixmap);
    12171263        kk->x11.pixmap = new_pixmap;
     
    12291275    if(kk->driver == CACA_DRIVER_GL)
    12301276    {
    1231       gl_width = gl_new_width;
    1232       gl_height = gl_new_height;
    1233 
    1234       kk->qq->width = gl_width/gl_font_width;
    1235       kk->qq->height = (gl_height/gl_font_height)+1;
    1236 
    1237       glMatrixMode(GL_PROJECTION);
    1238       glPushMatrix();
    1239       glLoadIdentity();
    1240 
    1241       glViewport(0,0,gl_width, gl_height);
    1242       gluOrtho2D(0, gl_width, gl_height, 0);
    1243       glMatrixMode(GL_MODELVIEW);
    1244 
     1277        kk->gl.width = kk->gl.new_width;
     1278        kk->gl.height = kk->gl.new_height;
     1279
     1280        new_width = kk->gl.width / kk->gl.font_width;
     1281        new_height = (kk->gl.height / kk->gl.font_height) + 1;
     1282
     1283        glMatrixMode(GL_PROJECTION);
     1284        glPushMatrix();
     1285        glLoadIdentity();
     1286
     1287        glViewport(0, 0, kk->gl.width, kk->gl.height);
     1288        gluOrtho2D(0, kk->gl.width, kk->gl.height, 0);
     1289        glMatrixMode(GL_MODELVIEW);
    12451290    }
    12461291    else
     
    12501295    }
    12511296
    1252     if(kk->qq->width != old_width || kk->qq->height != old_height)
    1253     {
    1254         free(kk->qq->chars);
    1255         free(kk->qq->attr);
    1256 
    1257         kk->qq->chars = malloc(kk->qq->width * kk->qq->height * sizeof(uint8_t));
    1258         memset(kk->qq->chars, 0, kk->qq->width * kk->qq->height * sizeof(uint8_t));
    1259         kk->qq->attr = malloc(kk->qq->width * kk->qq->height * sizeof(uint8_t));
    1260         memset(kk->qq->attr, 0, kk->qq->width * kk->qq->height * sizeof(uint8_t));
    1261     }
    1262 
    1263     if(kk->qq->width != old_width)
    1264     {
    1265         free(kk->qq->empty_line);
    1266         kk->qq->empty_line = malloc(kk->qq->width + 1);
    1267         memset(kk->qq->empty_line, ' ', kk->qq->width);
    1268         kk->qq->empty_line[kk->qq->width] = '\0';
    1269 
    1270         free(kk->qq->scratch_line);
    1271         kk->qq->scratch_line = malloc(kk->qq->width + 1);
    1272     }
     1297    /* Tell libcucul we changed size */
     1298    if(new_width != kk->qq->width || new_height != kk->qq->height)
     1299        cucul_set_size(kk->qq, new_width, new_height);
    12731300}
    12741301
     
    13381365static void gl_handle_keyboard(unsigned char key, int x, int y)
    13391366{
    1340     gl_key = key;
     1367    caca_t *kk = gl_kk;
     1368
     1369    kk->gl.key = key;
    13411370}
    13421371
    13431372static void gl_handle_special_key(int key, int x, int y)
    13441373{
    1345     gl_special_key = key;
     1374    caca_t *kk = gl_kk;
     1375
     1376    kk->gl.special_key = key;
    13461377}
    13471378
    13481379static void gl_handle_reshape(int w, int h)
    13491380{
    1350     if(gl_bit) /* Do not handle reshaping at the first time*/
    1351     {
    1352         gl_new_width = w;
    1353         gl_new_height = h;
    1354 
    1355         gl_resized = 1;
    1356     }
    1357     else
    1358         gl_bit = 1;
     1381    caca_t *kk = gl_kk;
     1382
     1383    if(kk->gl.bit) /* Do not handle reshaping at the first time */
     1384    {
     1385        kk->gl.new_width = w;
     1386        kk->gl.new_height = h;
     1387
     1388        kk->gl.resized = 1;
     1389    }
     1390    else
     1391        kk->gl.bit = 1;
    13591392}
    13601393
    13611394static void gl_handle_mouse(int button, int state, int x, int y)
    13621395{
    1363     gl_mouse_clicked = 1;
    1364     gl_mouse_button = button;
    1365     gl_mouse_state = state;
    1366     gl_mouse_x = x / gl_font_width;
    1367     gl_mouse_y = y / gl_font_height;
    1368     gl_mouse_changed = 1;
     1396    caca_t *kk = gl_kk;
     1397
     1398    kk->gl.mouse_clicked = 1;
     1399    kk->gl.mouse_button = button;
     1400    kk->gl.mouse_state = state;
     1401    kk->gl.mouse_x = x / kk->gl.font_width;
     1402    kk->gl.mouse_y = y / kk->gl.font_height;
     1403    kk->gl.mouse_changed = 1;
    13691404}
    13701405
    13711406static void gl_handle_mouse_motion(int x, int y)
    13721407{
    1373     gl_mouse_x = x / gl_font_width;
    1374     gl_mouse_y = y / gl_font_height;
    1375     gl_mouse_changed = 1;
    1376 }
    1377 #endif
    1378 
     1408    caca_t *kk = gl_kk;
     1409
     1410    kk->gl.mouse_x = x / kk->gl.font_width;
     1411    kk->gl.mouse_y = y / kk->gl.font_height;
     1412    kk->gl.mouse_changed = 1;
     1413}
     1414#endif
     1415
  • libcaca/trunk/src/line.c

    r524 r527  
    11/*
    2  *  libcaca       ASCII-Art library
    3  *  Copyright (c) 2002, 2003 Sam Hocevar <sam@zoy.org>
     2 *  libcucul      Unicode canvas library
     3 *  Copyright (c) 2002-2006 Sam Hocevar <sam@zoy.org>
    44 *                All Rights Reserved
    55 *
  • libcaca/trunk/src/math.c

    r524 r527  
    11/*
    2  *  libcaca       ASCII-Art library
    3  *  Copyright (c) 2002, 2003 Sam Hocevar <sam@zoy.org>
     2 *  libcucul      Unicode canvas library
     3 *  Copyright (c) 2002-2006 Sam Hocevar <sam@zoy.org>
    44 *                All Rights Reserved
    55 *
  • libcaca/trunk/src/sprite.c

    r524 r527  
    11/*
    2  *  libcaca       ASCII-Art library
    3  *  Copyright (c) 2002, 2003 Sam Hocevar <sam@zoy.org>
     2 *  libcucul      Unicode canvas library
     3 *  Copyright (c) 2002-2006 Sam Hocevar <sam@zoy.org>
    44 *                All Rights Reserved
    55 *
  • libcaca/trunk/src/time.c

    r522 r527  
    11/*
    22 *  libcaca       ASCII-Art library
    3  *  Copyright (c) 2002, 2003, 2004 Sam Hocevar <sam@zoy.org>
     3 *  Copyright (c) 2002-2006 Sam Hocevar <sam@zoy.org>
    44 *                All Rights Reserved
    55 *
     
    5353    struct timeval tv;
    5454#elif defined(USE_WIN32)
    55     static __int64 freq = -1;
     55    static __int64 freq = -1; /* FIXME: can this move to caca_context? */
    5656    unsigned __int64 usec;
    5757#endif
  • libcaca/trunk/src/triangle.c

    r524 r527  
    11/*
    2  *  libcaca       ASCII-Art library
    3  *  Copyright (c) 2002, 2003 Sam Hocevar <sam@zoy.org>
     2 *  libcucul      Unicode canvas library
     3 *  Copyright (c) 2002-2006 Sam Hocevar <sam@zoy.org>
    44 *                All Rights Reserved
    55 *
  • libcaca/trunk/test/colors.c

    r524 r527  
    4747    }
    4848
    49     caca_refresh(kk);
     49    caca_display(kk);
    5050    caca_wait_event(kk, CACA_EVENT_KEY_PRESS);
    5151
  • libcaca/trunk/test/demo.c

    r524 r527  
    6464    /* Main menu */
    6565    display_menu();
    66     caca_refresh(kk);
     66    caca_display(kk);
    6767
    6868    /* Go ! */
     
    156156                cucul_putstr(qq, xmouse, ymouse, "|\\");
    157157            }
    158             caca_refresh(kk);
     158            caca_display(kk);
    159159            mouse = menu = 0;
    160160        }
     
    169169                         1000000 / caca_get_rendertime(kk),
    170170                         (10000000 / caca_get_rendertime(kk)) % 10);
    171             caca_refresh(kk);
     171            caca_display(kk);
    172172        }
    173173    }
  • libcaca/trunk/test/dithering.c

    r524 r527  
    122122    }
    123123
    124     caca_refresh(kk);
     124    caca_display(kk);
    125125
    126126    while(!caca_get_event(kk, CACA_EVENT_KEY_PRESS));
  • libcaca/trunk/test/event.c

    r524 r527  
    4646    cucul_putstr(qq, 0, h, "type \"quit\" to exit");
    4747
    48     caca_refresh(kk);
     48    caca_display(kk);
    4949
    5050    events = malloc(h * sizeof(int));
     
    9696            print_event(0, i, events[i]);
    9797
    98         caca_refresh(kk);
     98        caca_display(kk);
    9999    }
    100100
  • libcaca/trunk/test/hsv.c

    r524 r527  
    5151    cucul_free_bitmap(qq, bitmap);
    5252
    53     caca_refresh(kk);
     53    caca_display(kk);
    5454
    5555    while(!caca_get_event(kk, CACA_EVENT_KEY_PRESS));
  • libcaca/trunk/test/spritedit.c

    r524 r527  
    109109        cucul_draw_sprite(qq, 20, 10, sprite, frame);
    110110
    111         caca_refresh(kk);
     111        caca_display(kk);
    112112    }
    113113
Note: See TracChangeset for help on using the changeset viewer.