path: root/board/MAI/bios_emulator/scitech/src/pm/linux/event.svga

/****************************************************************************
*
*           The SuperVGA Kit - UniVBE Software Development Kit
*
*  ========================================================================
*
*    The contents of this file are subject to the SciTech MGL Public
*    License Version 1.0 (the "License"); you may not use this file
*    except in compliance with the License. You may obtain a copy of
*    the License at http://www.scitechsoft.com/mgl-license.txt
*
*    Software distributed under the License is distributed on an
*    "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
*    implied. See the License for the specific language governing
*    rights and limitations under the License.
*
*    The Original Code is Copyright (C) 1991-1998 SciTech Software, Inc.
*
*    The Initial Developer of the Original Code is SciTech Software, Inc.
*    All Rights Reserved.
*
*  ========================================================================
*
* Language:     ANSI C
* Environment:  IBM PC (MS DOS)
*
* Description:  Routines to provide a Linux event queue, which automatically
*               handles keyboard and mouse events for the Linux compatability
*               libraries. Based on the event handling code in the MGL.
*
****************************************************************************/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <ctype.h>
#include <termios.h>
#include <signal.h>
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>
#include <sys/time.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <linux/keyboard.h>
#include <linux/kd.h>
#include <linux/vt.h>
#include <gpm.h>
#include "pm.h"
#include "vesavbe.h"
#include "wdirect.h"

/*--------------------------- Global variables ----------------------------*/

#define EVENTQSIZE  100             /* Number of events in event queue  */

static int      head = -1;          /* Head of event queue              */
static int      tail = -1;          /* Tail of event queue              */
static int      freeHead = -1;      /* Head of free list                */
static int      count = 0;          /* No. of items currently in queue  */
static WD_event evtq[EVENTQSIZE];   /* The queue structure itself      */
static int      oldMove = -1;       /* Previous movement event          */
static int      oldKey = -1;        /* Previous key repeat event        */
static int      mx,my;              /* Current mouse position           */
static int      xRes,yRes;          /* Screen resolution coordinates    */
static void     *stateBuf;          /* Pointer to console state buffer  */
static int      conn;               /* GPM file descriptor for mouse handling */
static int      tty_fd;             /* File descriptor for /dev/console */
extern int      tty_vc;             /* Virtual console ID, from the PM/Pro library */
static ibool    key_down[128];      /* State of all keyboard keys       */
static struct termios old_conf;     /* Saved terminal configuration     */
static int      oldkbmode;          /* and previous keyboard mode       */
struct vt_mode  oldvtmode;          /* Old virtual terminal mode        */
static int      old_flags;          /* Old flags for fcntl              */
static ulong    key_modifiers;      /* Keyboard modifiers               */
static int      forbid_vt_release=0;/* Flag to forbid release of VT     */
static int      forbid_vt_acquire=0;/* Flag to forbid cature of VT      */
static int      oldmode;            /* Old SVGA mode saved for VT switch*/
static int      initmode;           /* Initial text mode                */
static ibool    installed = false;  /* True if we are installed         */
static void     (_ASMAPI *moveCursor)(int x,int y) = NULL;
static int      (_ASMAPI *suspendAppCallback)(int flags) = NULL;

#if 0
/* Keyboard Translation table from scancodes to ASCII */

static uchar keyTable[128] =
"\0\0331234567890-=\010"
"\011qwertyuiop[]\015"
"\0asdfghjkl;'`\0\\"
"zxcvbnm,./\0*\0 \0"
"\0\0\0\0\0\0\0\0\0\0\0\0"      /* Function keys */
"789-456+1230.\0\0\0\0\0"       /* Keypad keys */
"\0\0\0\0\0\0\0\015\0/";

static uchar keyTableShifted[128] =
"\0\033!@#$%^&*()_+\010"
"\011QWERTYUIOP{}\015"
"\0ASDFGHJKL:\"~\0|"
"ZXCVBNM<>?\0*\0 \0"
"\0\0\0\0\0\0\0\0\0\0\0\0"      /* Function keys */
"789-456+1230.\0\0\0\0\0"       /* Keypad keys */
"\0\0\0\0\0\0\0\015\0/";
#endif

/* Macros to keep track of the CAPS and NUM lock states */

#define EVT_CAPSSTATE   0x0100
#define EVT_NUMSTATE    0x0200

/* Helper macros for dealing with timers */

#define TICKS_TO_USEC(t) ((t)*65536.0/1.193180)
#define USEC_TO_TICKS(u) ((u)*1.193180/65536.0)

/* Number of keycodes to read at a time from the console */

#define KBDREADBUFFERSIZE 32

/*---------------------------- Implementation -----------------------------*/

/****************************************************************************
REMARKS:
Returns the current time stamp in units of 18.2 ticks per second.
****************************************************************************/
static ulong getTimeStamp(void)
{
    return (ulong)(clock() / (CLOCKS_PER_SEC / 18.2));
}

/****************************************************************************
PARAMETERS:
evt - Event to place onto event queue

REMARKS:
Adds an event to the event queue by tacking it onto the tail of the event
queue. This routine assumes that at least one spot is available on the
freeList for the event to be inserted.
****************************************************************************/
static void addEvent(
    WD_event *evt)
{
    int         evtID;

    /* Get spot to place the event from the free list */
    evtID = freeHead;
    freeHead = evtq[freeHead].next;

    /* Add to the tail of the event queue   */
    evt->next = -1;
    evt->prev = tail;
    if (tail != -1)
        evtq[tail].next = evtID;
    else
        head = evtID;
    tail = evtID;
    evtq[evtID] = *evt;
    count++;
}

/****************************************************************************
PARAMETERS:
what        - Event code
message     - Event message
modifiers   - keyboard modifiers
x           - Mouse X position at time of event
y           - Mouse Y position at time of event
but_stat    - Mouse button status at time of event

REMARKS:
Adds a new mouse event to the event queue. This routine is called from
within the mouse interrupt subroutine, so it must be efficient.
****************************************************************************/
static void addMouseEvent(
    uint what,
    uint message,
    int x,
    int y,
    uint but_stat)
{
    WD_event    evt;

    if (count < EVENTQSIZE) {
        evt.what = what;
        evt.when = getTimeStamp();
        evt.message = message;
        evt.modifiers = but_stat | key_modifiers;
        evt.where_x = x;
        evt.where_y = y;
        fprintf(stderr, "(%d,%d), buttons %ld\n", x,y, evt.modifiers);
        addEvent(&evt);                 /* Add to tail of event queue   */
        }
}

/****************************************************************************
PARAMETERS:
scancode    - Raw keyboard scan code
modifiers   - Keyboard modifiers flags

REMARKS:
Converts the raw scan code into the appropriate ASCII code using the scan
code and the keyboard modifier flags.
****************************************************************************/
static ulong getKeyMessage(
    uint scancode,
    ulong modifiers)
{
    ushort  code = scancode << 8;
    ushort  ascii;
    struct kbentry ke;

    ke.kb_index = scancode;

    /* Find the basic ASCII code for the scan code */
    if (modifiers & EVT_CAPSSTATE) {
        if (modifiers & EVT_SHIFTKEY)
          ke.kb_table = K_NORMTAB;
        //          ascii = tolower(keyTableShifted[scancode]);
        else
          ke.kb_table = K_SHIFTTAB;
        //          ascii = toupper(keyTable[scancode]);
        }
    else {
        if (modifiers & EVT_SHIFTKEY)
          ke.kb_table = K_SHIFTTAB;
          // ascii = keyTableShifted[scancode];
        else
          ke.kb_table = K_NORMTAB;
          // ascii = keyTable[scancode];
        }
    if(modifiers & EVT_ALTSTATE)
      ke.kb_table |= K_ALTTAB;

    if (ioctl(tty_fd, KDGKBENT, (unsigned long)&ke)) {
        fprintf(stderr, "KDGKBENT at index %d in table %d: ",
            scancode, ke.kb_table);
        return 0;
    }
    ascii = ke.kb_value;

    /* Add ASCII code if key is not alt'ed or ctrl'ed */
    if (!(modifiers & (EVT_ALTSTATE | EVT_CTRLSTATE)))
        code |= ascii;

    return code;
}

/****************************************************************************
PARAMETERS:
what        - Event code
scancode    - Raw scancode of keyboard event to add

REMARKS:
Adds a new keyboard event to the event queue. We only take KEYUP and
KEYDOWN event codes, however if a key is already down we convert the KEYDOWN
to a KEYREPEAT.
****************************************************************************/
static void addKeyEvent(
    uint what,
    uint scancode)
{
    WD_event    evt;

    if (count < EVENTQSIZE) {
        evt.what = what;
        evt.when = getTimeStamp();
        evt.message = getKeyMessage(scancode,key_modifiers) | 0x10000UL;
        evt.where_x = evt.where_y = 0;
        evt.modifiers = key_modifiers;
        if (evt.what == EVT_KEYUP)
            key_down[scancode] = false;
        else if (evt.what == EVT_KEYDOWN) {
            if (key_down[scancode]) {
                if (oldKey != -1) {
                    evtq[oldKey].message += 0x10000UL;
                    }
                else {
                    evt.what = EVT_KEYREPEAT;
                    oldKey = freeHead;
                    addEvent(&evt);
                    oldMove = -1;
                    }
                return;
                }
            key_down[scancode] = true;
            }

        addEvent(&evt);
        oldMove = -1;
        }
}

/****************************************************************************
PARAMETERS:
sig - Signal being sent to this signal handler

REMARKS:
Signal handler for the timer. This routine takes care of periodically
posting timer events to the event queue.
****************************************************************************/
void timerHandler(
    int sig)
{
    WD_event    evt;

    if (sig == SIGALRM) {
        if (count < EVENTQSIZE) {
            evt.when = getTimeStamp();
            evt.what = EVT_TIMERTICK;
            evt.message = 0;
            evt.where_x = evt.where_y = 0;
            evt.modifiers = 0;
            addEvent(&evt);
            oldMove = -1;
            oldKey = -1;
            }
        signal(SIGALRM, timerHandler);
        }
}

/****************************************************************************
REMARKS:
Restore the terminal to normal operation on exit
****************************************************************************/
static void restore_term(void)
{
    RMREGS  regs;

    if (installed) {
        /* Restore text mode and the state of the console */
        regs.x.ax = 0x3;
        PM_int86(0x10,&regs,&regs);
        PM_restoreConsoleState(stateBuf,tty_fd);

        /* Restore console to normal operation */
        ioctl(tty_fd, VT_SETMODE, &oldvtmode);
        ioctl(tty_fd, KDSKBMODE, oldkbmode);
        tcsetattr(tty_fd, TCSAFLUSH, &old_conf);
        fcntl(tty_fd,F_SETFL,old_flags &= ~O_NONBLOCK);
        PM_closeConsole(tty_fd);

        /* Close the mouse driver */
        close(conn);

        /* Flag that we are not no longer installed */
        installed = false;
        }
}

/****************************************************************************
REMARKS:
Signal handler to capture forced program termination conditions so that
we can clean up properly.
****************************************************************************/
static void exitHandler(int sig)
{
    exit(-1);
}

/****************************************************************************
REMARKS:
Sleep until the virtual terminal is active
****************************************************************************/
void wait_vt_active(void)
{
    while (ioctl(tty_fd, VT_WAITACTIVE, tty_vc) < 0) {
        if ((errno != EAGAIN) && (errno != EINTR)) {
            perror("ioctl(VT_WAITACTIVE)");
            exit(1);
            }
        usleep(150000);
        }
}

/****************************************************************************
REMARKS:
Signal handler called when our virtual terminal has been released and we are
losing the active focus.
****************************************************************************/
static void release_vt_signal(int n)
{
    forbid_vt_acquire = 1;
    if (forbid_vt_release) {
        forbid_vt_acquire = 0;
        ioctl(tty_fd, VT_RELDISP, 0);
        return;
        }

    // TODO: Call the user supplied suspendAppCallback and restore text
    //       mode (saving the existing mode so we can restore it).
    //
    //       Also if the suspendAppCallback is NULL then we have to
    //       ignore the switch request!
    if(suspendAppCallback){
      oldmode = VBE_getVideoMode();
      suspendAppCallback(true);
      VBE_setVideoMode(initmode);
    }

    ioctl(tty_fd, VT_RELDISP, 1);
    forbid_vt_acquire = 0;
    wait_vt_active();
}

/****************************************************************************
REMARKS:
Signal handler called when our virtual terminal has been re-aquired and we
are now regaiing the active focus.
****************************************************************************/
static void acquire_vt_signal(int n)
{
    forbid_vt_release = 1;
    if (forbid_vt_acquire) {
        forbid_vt_release = 0;
        return;
        }

    // TODO: Restore the old display mode, call the user suspendAppCallback
    //       and and we will be back in graphics mode.

    if(suspendAppCallback){
      VBE_setVideoMode(oldmode);
      suspendAppCallback(false);
    }

    ioctl(tty_fd, VT_RELDISP, VT_ACKACQ);
    forbid_vt_release = 0;
}

/****************************************************************************
REMARKS:
Function to set the action for a specific signal to call our signal handler.
****************************************************************************/
static void set_sigaction(int sig,void (*handler)(int))
{
    struct sigaction    siga;

    siga.sa_handler = handler;
    siga.sa_flags = SA_RESTART;
    memset(&(siga.sa_mask), 0, sizeof(sigset_t));
    sigaction(sig, &siga, NULL);
}

/****************************************************************************
REMARKS:
Function to take over control of VT switching so that we can capture
virtual terminal release and aquire signals, allowing us to properly
support VT switching while in graphics modes.
****************************************************************************/
static void take_vt_control(void)
{
    struct vt_mode      vtmode;

    ioctl(tty_fd, VT_GETMODE, &vtmode);
    oldvtmode = vtmode;
    vtmode.mode = VT_PROCESS;
    vtmode.relsig = SIGUSR1;
    vtmode.acqsig = SIGUSR2;
    set_sigaction(SIGUSR1, release_vt_signal);
    set_sigaction(SIGUSR2, acquire_vt_signal);
    ioctl(tty_fd, VT_SETMODE, &oldvtmode);
}

/****************************************************************************
REMARKS:
Set the shift keyboard LED's based on the current keyboard modifiers flags.
****************************************************************************/
static void updateLEDStatus(void)
{
    int state = 0;
    if (key_modifiers & EVT_CAPSSTATE)
        state |= LED_CAP;
    if (key_modifiers & EVT_NUMSTATE)
        state |= LED_NUM;
    ioctl(tty_fd,KDSETLED,state);
}

/****************************************************************************
PARAMETERS:
scancode    - Raw scan code to handle

REMARKS:
Handles the shift key modifiers and keeps track of the shift key states
so that we can return the correct ASCII codes for the keyboard.
****************************************************************************/
static void toggleModifiers(
    int scancode)
{
    static int caps_down = 0,num_down = 0;

    if (scancode & 0x80) {
        /* Handle key-release function */
        scancode &= 0x7F;
        if (scancode == 0x2A || scancode == 0x36)
            key_modifiers &= ~EVT_SHIFTKEY;
        else if (scancode == 0x1D || scancode == 0x61)
            key_modifiers &= ~EVT_CTRLSTATE;
        else if (scancode == 0x38 || scancode == 0x64)
            key_modifiers &= ~EVT_ALTSTATE;
        else if (scancode == 0x3A)
            caps_down = false;
        else if (scancode == 0x45)
            num_down = false;
        }
    else {
        /* Handle key-down function */
        scancode &= 0x7F;
        if (scancode == 0x2A || scancode == 0x36)
            key_modifiers |= EVT_SHIFTKEY;
        else if (scancode == 0x1D || scancode == 0x61)
            key_modifiers |= EVT_CTRLSTATE;
        else if (scancode == 0x38 || scancode == 0x64)
            key_modifiers |= EVT_ALTSTATE;
        else if (scancode == 0x3A) {
            if (!caps_down) {
                key_modifiers ^= EVT_CAPSSTATE;
                updateLEDStatus();
                }
            caps_down = true;
            }
        else if (scancode == 0x45) {
            if (!num_down) {
                key_modifiers ^= EVT_NUMSTATE;
                updateLEDStatus();
                }
            num_down = true;
            }
        }
}

/***************************************************************************
REMARKS:
Returns the number of bits that have changed from 0 to 1
(a negative value means the number of bits that have changed from 1 to 0) 
 **************************************************************************/
static int compareBits(short a, short b)
{
    int ret = 0;
    if( (a&1) != (b&1) ) ret += (b&1) ? 1 : -1;
    if( (a&2) != (b&2) ) ret += (b&2) ? 1 : -1;
    if( (a&4) != (b&4) ) ret += (b&4) ? 1 : -1;
    return ret;
}

/***************************************************************************
REMARKS:
Turns off all keyboard state because we can't rely on them anymore as soon
as we switch VT's
***************************************************************************/
static void keyboard_clearstate(void)
{
  key_modifiers = 0;
  memset(key_down, 0, sizeof(key_down));
}

/****************************************************************************
REMARKS:
Pumps all events from the console event queue into the WinDirect event queue.
****************************************************************************/
static void pumpEvents(void)
{
    static uchar    buf[KBDREADBUFFERSIZE];
    static char     data[5];
    static int      old_buts, old_mx, old_my;
    static struct timeval t;
    fd_set fds;
    int             numkeys,i;
    int             dx, dy, buts;

    /* Read all pending keypresses from keyboard buffer and process */
    while ((numkeys = read(tty_fd, buf, KBDREADBUFFERSIZE)) > 0) {
        for (i = 0; i < numkeys; i++) {
            toggleModifiers(buf[i]);
            if (key_modifiers & EVT_ALTSTATE){
              int fkey = 0;

              // Do VT switching here for Alt+Fx keypresses
              switch(buf[i] & 0x7F){
              case 59 ... 68: /* F1 to F10 */
                fkey = (buf[i] & 0x7F) - 58;
                break;
              case 87: /* F11 */
              case 88: /* F12 */
                fkey = (buf[i] & 0x7F) - 76;
                break;
              }
              if(fkey){
                struct vt_stat vts;
                ioctl(tty_fd, VT_GETSTATE, &vts);
                
                if(fkey != vts.v_active){
                  keyboard_clearstate();
                  ioctl(tty_fd, VT_ACTIVATE, fkey);
                }
              }
            }

            if (buf[i] & 0x80)
                addKeyEvent(EVT_KEYUP,buf[i] & 0x7F);
            else
                addKeyEvent(EVT_KEYDOWN,buf[i] & 0x7F);
            }

        // TODO: If we want to handle VC switching we will need to do it
        //       in here so that we can switch away from the VC and then
        //       switch back to it later. Right now VC switching is disabled
        //       and in order to enable it we need to save/restore the state
        //       of the graphics screen (using the suspendAppCallback and
        //       saving/restoring the state of the current display mode).

        }

    /* Read all pending mouse events and process them */
    if(conn > 0){
        FD_ZERO(&fds);
        FD_SET(conn, &fds);
        t.tv_sec = t.tv_usec = 0L;
        while (select(conn+1, &fds, NULL, NULL, &t) > 0) {
            if(read(conn, data, 5) == 5){
                buts = (~data[0]) & 0x07;
                dx = (char)(data[1]) + (char)(data[3]);
                dy = -((char)(data[2]) + (char)(data[4]));
                
                mx += dx; my += dy;
                
                if (dx || dy)
                    addMouseEvent(EVT_MOUSEMOVE, 0, mx, my, buts);
                
                if (buts != old_buts){
                    int c = compareBits(buts,old_buts);
                    if(c>0)
                        addMouseEvent(EVT_MOUSEDOWN, 0, mx, my, buts);
                    else if(c<0)
                        addMouseEvent(EVT_MOUSEUP, 0, mx, my, buts);
                }
                old_mx = mx; old_my = my;
                old_buts = buts;
                FD_SET(conn, &fds);
                t.tv_sec = t.tv_usec = 0L;
            }
        }
    }
}

/*------------------------ Public interface routines ----------------------*/

/****************************************************************************
PARAMETERS:
which       - Which code for event to post
what        - Event code for event to post
message     - Event message
modifiers   - Shift key/mouse button modifiers

RETURNS:
True if the event was posted, false if queue is full.

REMARKS:
Posts an event to the event queue. This routine can be used to post any type
of event into the queue.
****************************************************************************/
ibool _WDAPI WD_postEvent(
    ulong which,
    uint what,
    ulong message,
    ulong modifiers)
{
    WD_event    evt;

    if (count < EVENTQSIZE) {
        /* Save information in event record */
        evt.which = which;
        evt.what = what;
        evt.when = getTimeStamp();
        evt.message = message;
        evt.modifiers = modifiers;
        addEvent(&evt);             /* Add to tail of event queue   */
        return true;
        }
    else
        return false;
}

/****************************************************************************
PARAMETERS:
mask    - Event mask to use

REMARKS:
Flushes all the event specified in 'mask' from the event queue.
****************************************************************************/
void _WDAPI WD_flushEvent(
    uint mask)
{
    WD_event    evt;

    do {                            /* Flush all events */
        WD_getEvent(&evt,mask);
        } while (evt.what != EVT_NULLEVT);
}

/****************************************************************************
PARAMETERS:
evt     - Place to store event
mask    - Event mask to use

REMARKS:
Halts program execution until a specified event occurs. The event is
returned. All pending events not in the specified mask will be ignored and
removed from the queue.
****************************************************************************/
void _WDAPI WD_haltEvent(
    WD_event *evt,
    uint mask)
{
    do {                            /* Wait for an event    */
        WD_getEvent(evt,EVT_EVERYEVT);
        } while (!(evt->what & mask));
}

/****************************************************************************
PARAMETERS:
evt     - Place to store event
mask    - Event mask to use

RETURNS:
True if an event was pending.

REMARKS:
Retrieves the next pending event defined in 'mask' from the event queue.
The event queue is adjusted to reflect the new state after the event has
been removed.
****************************************************************************/
ibool _WDAPI WD_getEvent(
    WD_event *evt,
    uint mask)
{
    int     evtID,next,prev;

    pumpEvents();
    if (moveCursor)
        moveCursor(mx,my);                  /* Move the mouse cursor    */
    evt->what = EVT_NULLEVT;                /* Default to null event    */

    if (count) {
        for (evtID = head; evtID != -1; evtID = evtq[evtID].next) {
            if (evtq[evtID].what & mask)
                break;                      /* Found an event           */
            }
        if (evtID == -1)
            return false;                   /* Event was not found      */
        next = evtq[evtID].next;
        prev = evtq[evtID].prev;
        if (prev != -1)
            evtq[prev].next = next;
        else
            head = next;
        if (next != -1)
            evtq[next].prev = prev;
        else
            tail = prev;
        *evt = evtq[evtID];                 /* Return the event         */
        evtq[evtID].next = freeHead;        /* and return to free list  */
        freeHead = evtID;
        count--;
        if (evt->what == EVT_MOUSEMOVE)
            oldMove = -1;
        if (evt->what == EVT_KEYREPEAT)
            oldKey = -1;
        }
    return evt->what != EVT_NULLEVT;
}

/****************************************************************************
PARAMETERS:
evt     - Place to store event
mask    - Event mask to use

RETURNS:
True if an event is pending.

REMARKS:
Peeks at the next pending event defined in 'mask' in the event queue. The
event is not removed from the event queue.
****************************************************************************/
ibool _WDAPI WD_peekEvent(
    WD_event *evt,
    uint mask)
{
    int     evtID;

    pumpEvents();
    if (moveCursor)
        moveCursor(mx,my);                  /* Move the mouse cursor    */
    evt->what = EVT_NULLEVT;                /* Default to null event    */

    if (count) {
        for (evtID = head; evtID != -1; evtID = evtq[evtID].next) {
            if (evtq[evtID].what & mask)
                break;                      /* Found an event           */
            }
        if (evtID == -1)
            return false;                   /* Event was not found      */

        *evt = evtq[evtID];                 /* Return the event         */
        }
    return evt->what != EVT_NULLEVT;
}

/****************************************************************************
PARAMETERS:
hwndMain    - Handle to main window
_xRes       - X resolution of graphics mode to be used
_yRes       - Y resolulion of graphics mode to be used

RETURNS:
Handle to the fullscreen event window if (we return hwndMain on Linux)

REMARKS:
Initiliase the event handling module. Here we install our mouse handling
ISR to be called whenever any button's are pressed or released. We also
build the free list of events in the event queue.
****************************************************************************/
WD_HWND _WDAPI WD_startFullScreen(
    WD_HWND hwndMain,
    int _xRes,
    int _yRes)
{
    int             i;
    struct termios  conf;
    if (!installed) {
        Gpm_Connect gpm;

        /* Build free list, and initialise global data structures */
        for (i = 0; i < EVENTQSIZE; i++)
            evtq[i].next = i+1;
        evtq[EVENTQSIZE-1].next = -1;       /* Terminate list           */
        count = freeHead = 0;
        head = tail = -1;
        oldMove = -1;
        oldKey = -1;
        xRes = _xRes;
        yRes = _yRes;

        /* Open the console device and initialise it for raw mode */
        tty_fd = PM_openConsole();

        /* Wait until virtual terminal is active and take over control */
        wait_vt_active();
        take_vt_control();

        /* Initialise keyboard handling to raw mode */
        if (ioctl(tty_fd, KDGKBMODE, &oldkbmode)) {
            printf("WD_startFullScreen: cannot get keyboard mode.\n");
            exit(-1);
            }
        old_flags = fcntl(tty_fd,F_GETFL);
        fcntl(tty_fd,F_SETFL,old_flags |= O_NONBLOCK);
        tcgetattr(tty_fd, &conf);
        old_conf = conf;
        conf.c_lflag &= ~(ICANON | ECHO | ECHOE | ECHOK | ECHONL | NOFLSH | ISIG);
        conf.c_iflag &= ~(ISTRIP | IGNCR | ICRNL | INLCR | BRKINT | PARMRK | INPCK | IUCLC | IXON | IXOFF);
        conf.c_iflag  |= (IGNBRK | IGNPAR);
        conf.c_cc[VMIN] = 1;
        conf.c_cc[VTIME] = 0;
        conf.c_cc[VSUSP] = 0;
        tcsetattr(tty_fd, TCSAFLUSH, &conf);
        ioctl(tty_fd, KDSKBMODE, K_MEDIUMRAW);

        /* Clear the keyboard state information */
        memset(key_down, 0, sizeof(key_down));
        ioctl(tty_fd,KDSETLED,key_modifiers = 0);

        /* Initialize the mouse connection 
           The user *MUST* run gpm with the  option -R for this to work (or have a MouseSystems mouse)
        */
        if(Gpm_Open(&gpm,0) > 0){ /* GPM available */
            if ((conn = open(GPM_NODE_FIFO,O_RDONLY|O_SYNC)) < 0)
                fprintf(stderr,"WD_startFullScreen: Can't open mouse connection.\n");
        }else{
            fprintf(stderr,"Warning: when not using gpm -R, only MouseSystems mice are currently supported.\n");
            if ((conn = open("/dev/mouse",O_RDONLY|O_SYNC)) < 0)
                fprintf(stderr,"WD_startFullScreen: Can't open /dev/mouse.\n");
        }
        Gpm_Close();

        /* TODO: Scale the mouse coordinates to the specific resolution */

        /* Save the state of the console */
        if ((stateBuf = malloc(PM_getConsoleStateSize())) == NULL) {
            printf("Out of memory!\n");
            exit(-1);
            }
        PM_saveConsoleState(stateBuf,tty_fd);
        initmode = VBE_getVideoMode();

        /* Initialize the signal handler for timer events */
        signal(SIGALRM, timerHandler);

        /* Capture termination signals so we can clean up properly */
        signal(SIGTERM, exitHandler);
        signal(SIGINT, exitHandler);
        signal(SIGQUIT, exitHandler);
        atexit(restore_term);

        /* Signal that we are installed */
        installed = true;
        }
    return hwndMain;
}

/****************************************************************************
REMARKS:
Lets the library know when fullscreen graphics mode has been initialized so
that we can properly scale the mouse driver coordinates.
****************************************************************************/
void _WDAPI WD_inFullScreen(void)
{
    /* Nothing to do in here */
}

/****************************************************************************
REMARKS:
Suspends all of our event handling operations. This is also used to
de-install the event handling code.
****************************************************************************/
void _WDAPI WD_restoreGDI(void)
{
    restore_term();
}

/****************************************************************************
PARAMETERS:
ticks   - Number of ticks between timer tick messages

RETURNS:
Previous value for the timer tick event spacing.

REMARKS:
The event module will automatically generate periodic timer tick events for
you, with 'ticks' between each event posting. If you set the value of
'ticks' to 0, the timer tick events are turned off.
****************************************************************************/
int _WDAPI WD_setTimerTick(
    int ticks)
{
    int                 old;
    struct itimerval    tim;
    long                ms = TICKS_TO_USEC(ticks);

    getitimer(ITIMER_REAL, &tim);
    old = USEC_TO_TICKS(tim.it_value.tv_sec*1000000.0 + tim.it_value.tv_usec);
    tim.it_interval.tv_sec  = ms / 1000000;
    tim.it_interval.tv_usec = ms % 1000000;
    setitimer(ITIMER_REAL, &tim, NULL);
    return old;
}

/****************************************************************************
PARAMETERS:
saveState   - Address of suspend app callback to register

REMARKS:
Registers a user application supplied suspend application callback so that
we can properly handle virtual terminal switching.
****************************************************************************/
void _WDAPI WD_setSuspendAppCallback(
    int (_ASMAPI *saveState)(int flags))
{
  suspendAppCallback = saveState;
}

/****************************************************************************
PARAMETERS:
x   - New X coordinate to move the mouse cursor to
y   - New Y coordinate to move the mouse cursor to

REMARKS:
Moves to mouse cursor to the specified coordinate.
****************************************************************************/
void _WDAPI WD_setMousePos(
    int x,
    int y)
{
    mx = x;
    my = y;
}

/****************************************************************************
PARAMETERS:
x   - Place to store X coordinate of mouse cursor
y   - Place to store Y coordinate of mouse cursor

REMARKS:
Reads the current mouse cursor location int *screen* coordinates.
****************************************************************************/
void _WDAPI WD_getMousePos(
    int *x,
    int *y)
{
    *x = mx;
    *y = my;
}

/****************************************************************************
PARAMETERS:
mcb - Address of mouse callback function

REMARKS:
Registers an application supplied mouse callback function that is called
whenever the mouse cursor moves.
****************************************************************************/
void _WDAPI WD_setMouseCallback(
    void (_ASMAPI *mcb)(int x,int y))
{
    moveCursor = mcb;
}

/****************************************************************************
PARAMETERS:
xRes    - New X resolution of graphics mode
yRes    - New Y resolution of graphics mode

REMARKS:
This is called to inform the event handling code that the screen resolution
has changed so that the mouse coordinates can be scaled appropriately.
****************************************************************************/
void _WDAPI WD_changeResolution(
    int xRes,
    int yRes)
{
    //  Gpm_FitValues(xRes, yRes);  // ??
}

/****************************************************************************
PARAMETERS:
scancode    - Scan code to check if a key is down

REMARKS:
Determines if a particular key is down based on the scan code for the key.
****************************************************************************/
ibool _WDAPI WD_isKeyDown(
    uchar scancode)
{   
    return key_down[scancode];
}

/****************************************************************************
REMARKS:
Determines if the application needs to run in safe mode. Not necessary for
anything but broken Windows 95 display drivers so we return false for
Linux.
****************************************************************************/
int _WDAPI WD_isSafeMode(void)
{
    return false;
}