/**************************************************************************** * * 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 #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #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,®s,®s); 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; }