/* OpenDoors Online Software Programming Toolkit * (C) Copyright 1991 - 1999 by Brian Pirie. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA * * * File: ODGetIn.c * * Description: Implements the od_get_input() function, which obtains the * next input event of any type, optionally performing * translation. * * Revisions: Date Ver Who Change * --------------------------------------------------------------- * Jan 04, 1996 6.00 BP Created. * Jan 30, 1996 6.00 BP Tweaked TREAT_ESC_AS_ANSI_TIMEOUT. * Jan 30, 1996 6.00 BP Replaced od_yield() with od_sleep(). * Jan 30, 1996 6.00 BP Add ODInQueueGetNextEvent() timeout. * Jan 31, 1996 6.00 BP Added timeout for od_get_input(). * Feb 13, 1996 6.00 BP Added od_get_input() flags parameter. * Feb 19, 1996 6.00 BP Changed version number to 6.00. * Feb 19, 1996 6.00 BP Switched to table implementation. * Feb 25, 1996 6.00 BP Added new control sequences to table. * Feb 27, 1996 6.00 BP Added od_max_key_latency. * Mar 03, 1996 6.10 BP Begin version 6.10. * Aug 10, 2003 6.23 SH *nix support * Apr 11, 2005 6.23 SH Fix hang forver on ESC press and latency timeout. */ #define BUILDING_OPENDOORS #include #include #include "OpenDoor.h" #include "ODInQue.h" #include "ODCore.h" #include "ODKrnl.h" /* Control sequence table definitions. */ typedef struct { char *pszSequence; char chExtendedKey; BOOL bIsControlKey; } tODKeySequence; tODKeySequence aKeySequences[] = { /* VT-52 control sequences. */ {"\033A", OD_KEY_UP, FALSE}, {"\033B", OD_KEY_DOWN, FALSE}, {"\033C", OD_KEY_RIGHT, FALSE}, {"\033D", OD_KEY_LEFT, FALSE}, {"\033H", OD_KEY_HOME, FALSE}, {"\033K", OD_KEY_END, FALSE}, {"\033P", OD_KEY_F1, FALSE}, {"\033Q", OD_KEY_F2, FALSE}, {"\033?w", OD_KEY_F3, FALSE}, {"\033?x", OD_KEY_F4, FALSE}, {"\033?t", OD_KEY_F5, FALSE}, {"\033?u", OD_KEY_F6, FALSE}, {"\033?q", OD_KEY_F7, FALSE}, {"\033?r", OD_KEY_F8, FALSE}, {"\033?p", OD_KEY_F9, FALSE}, /* Control sequences common to VT-100/VT-102/VT-220/VT-320/ANSI. */ {"\033[A", OD_KEY_UP, FALSE}, {"\033[B", OD_KEY_DOWN, FALSE}, {"\033[C", OD_KEY_RIGHT, FALSE}, {"\033[D", OD_KEY_LEFT, FALSE}, {"\033[M", OD_KEY_PGUP, FALSE}, {"\033[H\x1b[2J", OD_KEY_PGDN, FALSE}, {"\033[H", OD_KEY_HOME, FALSE}, {"\033[K", OD_KEY_END, FALSE}, {"\033OP", OD_KEY_F1, FALSE}, {"\033OQ", OD_KEY_F2, FALSE}, {"\033OR", OD_KEY_F3, FALSE}, {"\033OS", OD_KEY_F4, FALSE}, /* VT-220/VT-320 specific control sequences. */ {"\033[1~", OD_KEY_HOME, FALSE}, /* Windows XP telnet.exe. Is actually FIND */ {"\033[2~", OD_KEY_INSERT, FALSE}, {"\033[3~", OD_KEY_DELETE, FALSE}, {"\033[4~", OD_KEY_END, FALSE}, /* Windows XP telnet.exe. Is actually SELECT */ {"\033[5~", OD_KEY_PGUP, FALSE}, {"\033[6~", OD_KEY_PGDN, FALSE}, {"\033[17~", OD_KEY_F6, FALSE}, {"\033[18~", OD_KEY_F7, FALSE}, {"\033[19~", OD_KEY_F8, FALSE}, {"\033[20~", OD_KEY_F9, FALSE}, {"\033[21~", OD_KEY_F10, FALSE}, {"\033[23~", OD_KEY_F11, FALSE}, {"\033[24~", OD_KEY_F12, FALSE}, /* ANSI-specific control sequences. */ {"\033[L", OD_KEY_HOME, FALSE}, {"\033Ow", OD_KEY_F3, FALSE}, {"\033Ox", OD_KEY_F4, FALSE}, {"\033Ot", OD_KEY_F5, FALSE}, {"\033Ou", OD_KEY_F6, FALSE}, {"\033Oq", OD_KEY_F7, FALSE}, {"\033Or", OD_KEY_F8, FALSE}, {"\033Op", OD_KEY_F9, FALSE}, /* PROCOMM-specific control sequences (non-keypad alternatives). */ {"\033OA", OD_KEY_UP, FALSE}, {"\033OB", OD_KEY_DOWN, FALSE}, {"\033OC", OD_KEY_RIGHT, FALSE}, {"\033OD", OD_KEY_LEFT, FALSE}, {"\033OH", OD_KEY_HOME, FALSE}, {"\033OK", OD_KEY_END, FALSE}, /* Other standard control sequences. */ {"\x16\t", OD_KEY_INSERT, TRUE}, /* OpenDoors-specific alternatives. */ {"\x7f", OD_KEY_DELETE, FALSE}, {"\x5", OD_KEY_UP, TRUE}, {"\x18", OD_KEY_DOWN, TRUE}, {"\x13", OD_KEY_LEFT, TRUE}, {"\x4", OD_KEY_RIGHT, TRUE}, {"\x7", OD_KEY_DELETE, TRUE}, {"\x16", OD_KEY_INSERT, TRUE}, }; /* Constant that indicates no match has been found. */ #define NO_MATCH DIM(aKeySequences) /* Configurable constants. */ /* The time, in milliseconds, to wait for a second character in a control */ /* sequence, before deciding that none is going to come. */ #define MAX_CHARACTER_LATENCY 250 /* Size of inbound sequence buffer. */ #define SEQUENCE_BUFFER_SIZE 10 /* Current control sequence received state. */ static char szCurrentSequence[SEQUENCE_BUFFER_SIZE] = ""; #if 0 // Unused... static tODTimer SequenceFailTimer; static BOOL bSequenceFromRemote; static int nMatchedSequence = NO_MATCH; static BOOL bTimerActive = FALSE; #endif static BOOL bDoorwaySequence = FALSE; static BOOL bDoorwaySequencePending = FALSE; /* Local private function prototypes. */ static int ODGetCodeIfLongest(WORD wFlags); static int ODHaveStartOfSequence(WORD wFlags); static int ODLongestFullCode(WORD wFlags); static void ODShiftSeq(int chars); /* ---------------------------------------------------------------------------- * od_get_input() * * Obtains the next input event of any type, optionally performing * translation on input events. * * Parameters: pInputEvent - Pointer to a tODInputEvent structure, which * will be filled by information on the next input * event, if any is obtained. * * TimeToWait - Number of milliseconds to wait for input to be * available. A value of 0 causes od_get_input() * to return immediately if no input is waiting, * while a value of OD_NO_TIMEOUT causes the * function to never return unless input has been * obtained. * * wFlags - Flags which customize od_get_input()'s behaviour. * * Return: TRUE if an input event was obtained, FALSE if not. */ ODAPIDEF BOOL ODCALL od_get_input(tODInputEvent *pInputEvent, tODMilliSec TimeToWait, WORD wFlags) { tODInputEvent LastInputEvent; int nSequence; int nSequenceLen; /* Log function entry if running in trace mode. */ TRACE(TRACE_API, "od_get_input()"); /* Initialize OpenDoors if it hasn't already been done. */ if(!bODInitialized) od_init(); OD_API_ENTRY(); /* Check for parameter validity. */ if(pInputEvent == NULL) { od_control.od_error = ERR_PARAMETER; OD_API_EXIT(); return(FALSE); } /* Call the OpenDoors kernel, if applicable */ CALL_KERNEL_IF_NEEDED(); /* If you don't know better, it's a remote char */ /* Local chars are always correctly received (no ANSI sequences) */ LastInputEvent.bFromRemote = TRUE; if((!bDoorwaySequence) && bDoorwaySequencePending && (!szCurrentSequence[0])) { bDoorwaySequencePending=FALSE; bDoorwaySequence=TRUE; } /* If no pending input string, wait for the first keystroke */ if((!szCurrentSequence[0]) && (!bDoorwaySequence)) { if(ODInQueueGetNextEvent(hODInputQueue, &LastInputEvent, TimeToWait) != kODRCSuccess) { OD_API_EXIT(); return(FALSE); } /* If you have a *local* char, send it immediately */ if((!LastInputEvent.bFromRemote) && (LastInputEvent.chKeyPress != 0) #if 0 && (LastInputEvent.EventType == EVENT_EXTENDED_KEY)) { #else ) { #endif memcpy(pInputEvent, &LastInputEvent, sizeof(tODInputEvent)); OD_API_EXIT(); return(TRUE); } /* IF the received char is a NULL, this is the start of a doorway char */ if(!LastInputEvent.chKeyPress) bDoorwaySequence = TRUE; else { szCurrentSequence[0]=LastInputEvent.chKeyPress; szCurrentSequence[1]=0; } } nSequenceLen=strlen(szCurrentSequence); CALL_KERNEL_IF_NEEDED(); /* If you don't have the start of a sequence, and it's not doorway mode, you have * a char. It's that simple. */ if((!bDoorwaySequence) && (!ODHaveStartOfSequence(wFlags))) { pInputEvent->chKeyPress = szCurrentSequence[0]; pInputEvent->EventType = EVENT_CHARACTER; pInputEvent->bFromRemote = LastInputEvent.bFromRemote; /* Shift the sequence buffer over one */ ODShiftSeq(1); OD_API_EXIT(); return(TRUE); } /* Now... if the current sequence IS the longest valid one, return it * immediately. If it's sequence leftovers, it HAS to be a remote key * since local chars are #1 always doorway mode and #2 have no delay * betwixt them. */ if((nSequence = ODGetCodeIfLongest(wFlags)) != NO_MATCH) { pInputEvent->chKeyPress = aKeySequences[nSequence].chExtendedKey; pInputEvent->EventType = EVENT_EXTENDED_KEY; pInputEvent->bFromRemote = LastInputEvent.bFromRemote; /* Shift the sequence buffer... being sure to copy the terminator */ ODShiftSeq(strlen(aKeySequences[nSequence].pszSequence)); OD_API_EXIT(); return(TRUE); } /* Now, continue adding chars, waiting at MOST MAX_CHARACTER_LATENCY between them */ CALL_KERNEL_IF_NEEDED(); while((!bDoorwaySequencePending) && (ODInQueueGetNextEvent(hODInputQueue, &LastInputEvent, MAX_CHARACTER_LATENCY) == kODRCSuccess)) { /* If you are looking for a doorway sequence, any char completes it (honest!) */ /* Further, thanks to some lack of planning, it's EXACTLY THE SAME as the char, * only it's extended. */ if(bDoorwaySequence) { memcpy(pInputEvent, &LastInputEvent, sizeof(tODInputEvent)); pInputEvent->EventType = EVENT_EXTENDED_KEY; bDoorwaySequence=FALSE; OD_API_EXIT(); return(TRUE); } /* If we get a 0, we *WILL BE* looking for a doorway sequence. But NOT * until the current sequence buffer is drained! */ if(LastInputEvent.chKeyPress == 0) { bDoorwaySequencePending=TRUE; break; } /* If you have a *local* char, send it immediately */ if((!LastInputEvent.bFromRemote) && (LastInputEvent.chKeyPress != 0) #if 0 && (LastInputEvent.EventType == EVENT_EXTENDED_KEY)) { #else ) { #endif memcpy(pInputEvent, &LastInputEvent, sizeof(tODInputEvent)); OD_API_EXIT(); return(TRUE); } /* Put this char into the sequence buffer */ szCurrentSequence[nSequenceLen++]=LastInputEvent.chKeyPress; szCurrentSequence[nSequenceLen]=0; /* When you have the longest possible sequence, you ARE done */ if((nSequence = ODGetCodeIfLongest(wFlags)) != NO_MATCH) { pInputEvent->chKeyPress = aKeySequences[nSequence].chExtendedKey; pInputEvent->EventType = EVENT_EXTENDED_KEY; pInputEvent->bFromRemote = LastInputEvent.bFromRemote; /* Shift the sequence buffer... being sure to copy the terminator */ ODShiftSeq(strlen(aKeySequences[nSequence].pszSequence)); OD_API_EXIT(); return(TRUE); } CALL_KERNEL_IF_NEEDED(); } /* If we were looking for a doorway sequence, tough, we didn't get it. */ if(bDoorwaySequence) { pInputEvent->chKeyPress = 0; pInputEvent->EventType = EVENT_CHARACTER; pInputEvent->bFromRemote = LastInputEvent.bFromRemote; bDoorwaySequence=FALSE; OD_API_EXIT(); return(TRUE); } /* Now, if we have any kind of sequence, we'll settle for it. */ if((nSequence = ODLongestFullCode(wFlags)) != NO_MATCH) { pInputEvent->chKeyPress = aKeySequences[nSequence].chExtendedKey; pInputEvent->EventType = EVENT_EXTENDED_KEY; pInputEvent->bFromRemote = LastInputEvent.bFromRemote; /* Shift the sequence buffer... being sure to copy the terminator */ ODShiftSeq(strlen(aKeySequences[nSequence].pszSequence)); OD_API_EXIT(); return(TRUE); } /* If we don't have a complete sequence, send a single char */ pInputEvent->chKeyPress = szCurrentSequence[0]; if(szCurrentSequence[0]) { pInputEvent->EventType = EVENT_CHARACTER; pInputEvent->bFromRemote = LastInputEvent.bFromRemote; /* Shift the sequence buffer over one */ ODShiftSeq(1); } OD_API_EXIT(); /* Return false if something broke */ return(pInputEvent->chKeyPress); } /* ---------------------------------------------------------------------------- * ODLongestFullCode() *** PRIVATE FUNCTION *** * * Return the index of the longest full code that matches the start of the * sequence buffer * * Parameters: wFlags from od_get_input() * * Return: void */ static int ODLongestFullCode(WORD wFlags) { int CurrLen=0; int seqlen; int i; int retval=NO_MATCH;; if(wFlags & GETIN_RAW) return(NO_MATCH); for(i = 0; i < DIM(aKeySequences); ++i) { if((wFlags & GETIN_RAWCTRL) && aKeySequences[i].bIsControlKey) { continue; } seqlen=strlen(aKeySequences[i].pszSequence); if(seqlen>CurrLen) { if(strncmp(aKeySequences[i].pszSequence, szCurrentSequence, seqlen)==0) { retval=i; CurrLen=seqlen; } } } return(retval); } /* ---------------------------------------------------------------------------- * ODHaveStartOfSequence() *** PRIVATE FUNCTION *** * * If the current sequence buffer is the start of a valid sequence, return TRUE * * Parameters: wFlags from od_get_input() * * Return: void */ static int ODHaveStartOfSequence(WORD wFlags) { int seqlen1; int seqlen2; int i; if(wFlags & GETIN_RAW) return(FALSE); seqlen1=strlen(szCurrentSequence); for(i = 0; i < DIM(aKeySequences); ++i) { if((wFlags & GETIN_RAWCTRL) && aKeySequences[i].bIsControlKey) { continue; } seqlen2=strlen(aKeySequences[i].pszSequence); if(seqlen1CurrLen) { if(seqlen2<=seqlen1) { /* The sequence would be completed in buffer */ if(strncmp(aKeySequences[i].pszSequence, szCurrentSequence, seqlen2)==0) { retval=i; CurrLen=seqlen2; } } else { /* Possible partial sequence */ if(strncmp(aKeySequences[i].pszSequence, szCurrentSequence, seqlen1)==0) { return(NO_MATCH); } } } } return(retval); } /* ---------------------------------------------------------------------------- * ODShiftSeq() *** PRIVATE FUNCTION *** * * Shifts szCurrentSequence left the specified number of chars * * Parameters: int chars to shift * * Return: void */ static void ODShiftSeq(int chars) { char *in; char *out; if(!chars) return; out=szCurrentSequence; in=out+chars; if(in>strchr(szCurrentSequence,0)) return; while(*in) { *(out++)=*(in++); } *out=*in; }