Changeset 336


Ignore:
Timestamp:
Jan 11, 2004, 6:09:02 AM (16 years ago)
Author:
Sam Hocevar
Message:
  • src/caca.c src/graphics.c src/io.c src/time.c: + Native win32 port.
Location:
libcaca/trunk
Files:
7 edited

Legend:

Unmodified
Added
Removed
  • libcaca/trunk/NOTES

    r331 r336  
    194194      work using <conio.h>. No need to kludge anything.
    195195
    196    o  Win32: we use GetConsoleScreenBufferInfo etc.
     196   o  Win32: we use GetConsoleScreenBufferInfo etc. There is an interesting
     197      tutorial here: http://www.adrianxw.dk/SoftwareSite/index.html
    197198
  • libcaca/trunk/examples/cacaview.c

    r316 r336  
    3535#endif
    3636
     37#if defined(HAVE_SLEEP)
     38#   include <windows.h>
     39#endif
     40
    3741#include "caca.h"
    3842
     
    257261        if(!update)
    258262        {
     263#if defined(HAVE_USLEEP)
    259264            usleep(10000);
     265#elif defined(HAVE_SLEEP)
     266            Sleep(10);
     267#endif
    260268            continue;
    261269        }
  • libcaca/trunk/src/caca.c

    r335 r336  
    6969#if defined(USE_NCURSES)
    7070static mmask_t oldmask;
     71#endif
     72
     73#if defined(USE_WIN32)
     74static CONSOLE_CURSOR_INFO cci;
    7175#endif
    7276
     
    169173    if(_caca_driver == CACA_DRIVER_WIN32)
    170174    {
    171         /* Nothing to do */
    172         printf("initialising win32 driver\n");
     175        win32_hin = GetStdHandle(STD_INPUT_HANDLE);
     176        win32_hout = CreateFile("CONOUT$", GENERIC_READ | GENERIC_WRITE,
     177                                FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
     178                                OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
     179
     180        if(win32_hout == INVALID_HANDLE_VALUE)
     181            return -1;
     182
     183        GetConsoleCursorInfo(win32_hout, &cci);
     184        cci.bVisible = FALSE;
     185        SetConsoleCursorInfo(win32_hout, &cci);
     186
     187        SetConsoleMode(win32_hout, ENABLE_MOUSE_INPUT);
    173188    }
    174189    else
     
    392407    if(_caca_driver == CACA_DRIVER_WIN32)
    393408    {
    394         /* Nothing to do */
     409        SetConsoleTextAttribute(win32_hout, FOREGROUND_INTENSITY
     410                                             | FOREGROUND_RED
     411                                             | FOREGROUND_GREEN
     412                                             | FOREGROUND_BLUE);
     413        cci.bVisible = TRUE;
     414        SetConsoleCursorInfo(win32_hout, &cci);
     415        CloseHandle(win32_hout);
    395416    }
    396417    else
  • libcaca/trunk/src/caca_internals.h

    r335 r336  
    8787#endif
    8888
     89#if defined(USE_WIN32)
     90#include <windows.h>
     91extern HANDLE win32_hin, win32_hout;
     92#endif
     93
    8994#endif /* __CACA_INTERNALS_H__ */
  • libcaca/trunk/src/graphics.c

    r335 r336  
    5252#   endif
    5353#endif
     54#if defined(USE_WIN32)
     55#   include <windows.h>
     56#endif
    5457
    5558#if defined(HAVE_INTTYPES_H) || defined(_DOXYGEN_SKIP_ME)
     
    6265#include <string.h>
    6366#include <stdlib.h>
     67#include <unistd.h>
    6468#include <stdarg.h>
    6569
     
    162166#endif
    163167
     168#if defined(USE_WIN32)
     169static uint8_t *win32_char, *win32_attr;
     170HANDLE win32_hin, win32_hout;
     171static HANDLE win32_front, win32_back;
     172static CHAR_INFO *win32_buffer;
     173
     174static int const win32_fg_palette[] =
     175{
     176    0,
     177    FOREGROUND_BLUE,
     178    FOREGROUND_GREEN,
     179    FOREGROUND_GREEN | FOREGROUND_BLUE,
     180    FOREGROUND_RED,
     181    FOREGROUND_RED | FOREGROUND_BLUE,
     182    FOREGROUND_RED | FOREGROUND_GREEN,
     183    FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE,
     184    FOREGROUND_INTENSITY,
     185    FOREGROUND_INTENSITY | FOREGROUND_BLUE,
     186    FOREGROUND_INTENSITY | FOREGROUND_GREEN,
     187    FOREGROUND_INTENSITY | FOREGROUND_GREEN | FOREGROUND_BLUE,
     188    FOREGROUND_INTENSITY | FOREGROUND_RED,
     189    FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_BLUE,
     190    FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN,
     191    FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE
     192};
     193
     194static int const win32_bg_palette[] =
     195{
     196    0,
     197    BACKGROUND_BLUE,
     198    BACKGROUND_GREEN,
     199    BACKGROUND_GREEN | BACKGROUND_BLUE,
     200    BACKGROUND_RED,
     201    BACKGROUND_RED | BACKGROUND_BLUE,
     202    BACKGROUND_RED | BACKGROUND_GREEN,
     203    BACKGROUND_RED | BACKGROUND_GREEN | BACKGROUND_BLUE,
     204    BACKGROUND_INTENSITY,
     205    BACKGROUND_INTENSITY | BACKGROUND_BLUE,
     206    BACKGROUND_INTENSITY | BACKGROUND_GREEN,
     207    BACKGROUND_INTENSITY | BACKGROUND_GREEN | BACKGROUND_BLUE,
     208    BACKGROUND_INTENSITY | BACKGROUND_RED,
     209    BACKGROUND_INTENSITY | BACKGROUND_RED | BACKGROUND_BLUE,
     210    BACKGROUND_INTENSITY | BACKGROUND_RED | BACKGROUND_GREEN,
     211    BACKGROUND_INTENSITY | BACKGROUND_RED | BACKGROUND_GREEN | BACKGROUND_BLUE
     212};
     213#endif
     214
    164215static char *_caca_empty_line;
    165216static char *_caca_scratch_line;
     
    245296#if defined(USE_X11)
    246297    case CACA_DRIVER_X11:
    247         /* FIXME */
     298        /* Nothing to do */
     299        break;
     300#endif
     301#if defined(USE_WIN32)
     302    case CACA_DRIVER_WIN32:
     303        /* Nothing to do */
    248304        break;
    249305#endif
     
    328384        break;
    329385#endif
     386#if defined(USE_WIN32)
     387    case CACA_DRIVER_WIN32:
     388        win32_char[x + y * _caca_width] = c;
     389        win32_attr[x + y * _caca_width] = (_caca_bgcolor << 4) | _caca_fgcolor;
     390        break;
     391#endif
    330392    default:
    331393        break;
     
    346408void caca_putstr(int x, int y, char const *s)
    347409{
    348 #if defined(USE_CONIO) | defined(USE_X11)
     410#if defined(USE_CONIO) | defined(USE_X11) | defined(USE_WIN32)
    349411    char *charbuf;
    350412#endif
    351 #if defined(USE_X11)
     413#if defined(USE_X11) | defined(USE_WIN32)
    352414    char *attrbuf;
    353415#endif
     
    409471        charbuf = x11_char + x + y * _caca_width;
    410472        attrbuf = x11_attr + x + y * _caca_width;
     473        while(*s)
     474        {
     475            *charbuf++ = *s++;
     476            *attrbuf++ = (_caca_bgcolor << 4) | _caca_fgcolor;
     477        }
     478        break;
     479#endif
     480#if defined(USE_WIN32)
     481    case CACA_DRIVER_WIN32:
     482        charbuf = win32_char + x + y * _caca_width;
     483        attrbuf = win32_attr + x + y * _caca_width;
    411484        while(*s)
    412485        {
     
    736809    else
    737810#endif
     811#if defined(USE_WIN32)
     812    if(_caca_driver == CACA_DRIVER_WIN32)
     813    {
     814        CONSOLE_CURSOR_INFO cci;
     815        CONSOLE_SCREEN_BUFFER_INFO csbi;
     816        COORD size;
     817
     818        win32_front = CreateConsoleScreenBuffer(GENERIC_READ | GENERIC_WRITE,
     819                                                0, NULL,
     820                                                CONSOLE_TEXTMODE_BUFFER, NULL);
     821        if(!win32_front)
     822            return -1;
     823
     824        win32_back = CreateConsoleScreenBuffer(GENERIC_READ | GENERIC_WRITE,
     825                                               0, NULL,
     826                                               CONSOLE_TEXTMODE_BUFFER, NULL);
     827        if(!win32_back)
     828            return -1;
     829
     830        if(!GetConsoleScreenBufferInfo(win32_hout, &csbi))
     831            return -1;
     832
     833        _caca_width = csbi.srWindow.Right - csbi.srWindow.Left + 1;
     834        _caca_height = csbi.srWindow.Bottom - csbi.srWindow.Top + 1;
     835
     836        size.X = _caca_width;
     837        size.Y = _caca_height;
     838        SetConsoleScreenBufferSize(win32_front, size);
     839        SetConsoleScreenBufferSize(win32_back, size);
     840
     841        SetConsoleMode(win32_front, 0);
     842        SetConsoleMode(win32_back, 0);
     843
     844        GetConsoleCursorInfo(win32_front, &cci);
     845        cci.bVisible = FALSE;
     846        SetConsoleCursorInfo(win32_front, &cci);
     847        SetConsoleCursorInfo(win32_back, &cci);
     848
     849        SetConsoleActiveScreenBuffer(win32_front);
     850
     851        win32_char = malloc(_caca_width * _caca_height * sizeof(int));
     852        if(win32_char == NULL)
     853            return -1;
     854
     855        win32_attr = malloc(_caca_width * _caca_height * sizeof(int));
     856        if(win32_attr == NULL)
     857        {
     858            free(win32_char);
     859            return -1;
     860        }
     861
     862win32_buffer = malloc(sizeof(CHAR_INFO) * _caca_width * _caca_height);
     863
     864        memset(win32_char, 0, _caca_width * _caca_height * sizeof(int));
     865        memset(win32_attr, 0, _caca_width * _caca_height * sizeof(int));
     866    }
     867    else
     868#endif
    738869    {
    739870        /* Dummy */
     
    786917    else
    787918#endif
     919#if defined(USE_WIN32)
     920    if(_caca_driver == CACA_DRIVER_WIN32)
     921    {
     922        SetConsoleActiveScreenBuffer(win32_hout);
     923        CloseHandle(win32_back);
     924        CloseHandle(win32_front);
     925        free(win32_char);
     926        free(win32_attr);
     927    }
     928    else
     929#endif
    788930    {
    789931        /* Dummy */
     
    9271069        XFlush(x11_dpy);
    9281070    }
    929 #endif
     1071    else
     1072#endif
     1073#if defined(USE_WIN32)
     1074    if(_caca_driver == CACA_DRIVER_WIN32)
     1075    {
     1076        COORD size, pos;
     1077        SMALL_RECT rect;
     1078        DWORD dummy;
     1079        unsigned int x, y, len;
     1080
     1081        /* Render everything to our back buffer */
     1082        for(y = 0; y < _caca_height; y++)
     1083        {
     1084            pos.X = 0;
     1085            pos.Y = y;
     1086            SetConsoleCursorPosition(win32_back, pos);
     1087
     1088            for(x = 0; x < _caca_width; x += len)
     1089            {
     1090                unsigned char *attr = win32_attr + x + y * _caca_width;
     1091
     1092                len = 1;
     1093                while(x + len < _caca_width && attr[len] == attr[0])
     1094                    len++;
     1095
     1096                SetConsoleTextAttribute(win32_back,
     1097                                        win32_fg_palette[attr[0] & 0xf]
     1098                                         | win32_bg_palette[attr[0] >> 4]);
     1099
     1100                WriteConsole(win32_back, win32_char + x + y * _caca_width,
     1101                             len, &dummy, NULL);
     1102            }
     1103        }
     1104
     1105        /* Blit the back buffer to the front buffer */
     1106        size.X = _caca_width;
     1107        size.Y = _caca_height;
     1108        pos.X = pos.Y = 0;
     1109        rect.Left = rect.Top = 0;
     1110        rect.Right = _caca_width - 1;
     1111        rect.Bottom = _caca_height - 1;
     1112        ReadConsoleOutput(win32_back, win32_buffer, size, pos, &rect);
     1113        WriteConsoleOutput(win32_front, win32_buffer, size, pos, &rect);
     1114    }
     1115    else
     1116#endif
     1117    {
     1118        /* Dummy */
     1119    }
    9301120
    9311121    /* Wait until _caca_delay + time of last call */
  • libcaca/trunk/src/io.c

    r335 r336  
    5757static unsigned int _get_next_event(void);
    5858static unsigned int _lowlevel_event(void);
     59#if defined(USE_SLANG) || defined(USE_NCURSES) || defined(USE_CONIO)
    5960static void _push_event(unsigned int);
    6061static unsigned int _pop_event(void);
     62#endif
    6163
    6264#if !defined(_DOXYGEN_SKIP_ME)
    6365#define EVENTBUF_LEN 10
    6466#endif
     67#if defined(USE_SLANG) || defined(USE_NCURSES) || defined(USE_CONIO)
    6568static unsigned int eventbuf[EVENTBUF_LEN];
    6669static int events = 0;
     70#endif
    6771
    6872#if !defined(_DOXYGEN_SKIP_ME)
     
    199203static unsigned int _lowlevel_event(void)
    200204{
    201     unsigned int event = _pop_event();
     205    unsigned int event;
     206
     207#if defined(USE_SLANG) || defined(USE_NCURSES) || defined(USE_CONIO)
     208    event = _pop_event();
    202209
    203210    if(event)
    204211        return event;
     212#endif
    205213
    206214#if defined(USE_X11)
     
    541549    if(_caca_driver == CACA_DRIVER_WIN32)
    542550    {
     551        INPUT_RECORD rec;
     552        DWORD num;
     553
     554        GetNumberOfConsoleInputEvents(win32_hin, &num);
     555        if(num == 0)
     556            return CACA_EVENT_NONE;
     557
     558        ReadConsoleInput(win32_hin, &rec, 1, &num);
     559        if(rec.EventType == KEY_EVENT)
     560        {
     561            if(rec.Event.KeyEvent.bKeyDown)
     562                event = CACA_EVENT_KEY_PRESS;
     563            else
     564                event = CACA_EVENT_KEY_RELEASE;
     565
     566            if(rec.Event.KeyEvent.uChar.AsciiChar)
     567                return event | rec.Event.KeyEvent.uChar.AsciiChar;
     568        }
     569        else if(rec.EventType == MOUSE_EVENT)
     570        {
     571            if(rec.Event.MouseEvent.dwEventFlags == 0)
     572            {
     573                if(rec.Event.MouseEvent.dwButtonState & 0x01)
     574                    return CACA_EVENT_MOUSE_PRESS | 0x000001;
     575
     576                if(rec.Event.MouseEvent.dwButtonState & 0x02)
     577                    return CACA_EVENT_MOUSE_PRESS | 0x000002;
     578            }
     579            else if(rec.Event.MouseEvent.dwEventFlags == MOUSE_MOVED)
     580            {
     581                return CACA_EVENT_MOUSE_MOTION
     582                        | (rec.Event.MouseEvent.dwMousePosition.X << 12)
     583                        | (rec.Event.MouseEvent.dwMousePosition.Y);
     584            }
     585#if 0
     586            else if(rec.Event.MouseEvent.dwEventFlags == DOUBLE_CLICK)
     587            {
     588                cout << rec.Event.MouseEvent.dwMousePosition.X << "," <<
     589                        rec.Event.MouseEvent.dwMousePosition.Y << "  " << flush;
     590            }
     591            else if(rec.Event.MouseEvent.dwEventFlags == MOUSE_WHEELED)
     592            {
     593                SetConsoleCursorPosition(hOut,
     594                                         WheelWhere);
     595                if(rec.Event.MouseEvent.dwButtonState & 0xFF000000)
     596                    cout << "Down" << flush;
     597                else
     598                    cout << "Up  " << flush;
     599            }
     600#endif
     601        }
     602
    543603        return CACA_EVENT_NONE;
    544604    }
     
    552612}
    553613
     614#if defined(USE_SLANG) || defined(USE_NCURSES) || defined(USE_CONIO)
    554615static void _push_event(unsigned int event)
    555616{
     
    575636    return event;
    576637}
    577 
     638#endif
     639
  • libcaca/trunk/src/time.c

    r335 r336  
    5959    struct timeval tv;
    6060#elif defined(USE_WIN32)
    61     static long long int freq = -1LL;
    62     long long int usec;
     61    static long long int freq = -1;
     62    unsigned long long int usec;
    6363#endif
    6464    unsigned int ticks = 0;
     
    7070    new_usec = tv.tv_usec;
    7171#elif defined(USE_WIN32)
    72     if(freq == -1LL)
     72    if(freq == -1)
    7373    {
    7474        if(!QueryPerformanceFrequency((LARGE_INTEGER *)&freq))
     
    7777
    7878    QueryPerformanceCounter((LARGE_INTEGER *)&usec);
    79     new_sec = usec / freq;
    80     new_usec = usec % freq;
     79    new_sec = usec * 1000000 / freq / 1000000;
     80    new_usec = (usec * 1000000 / freq) % 1000000;
    8181#endif
    8282
Note: See TracChangeset for help on using the changeset viewer.