/* Turn on keyboard echo. Does not check error returns. */
static void
EchoOn( void )
{
KBDINFO KbdInfo;
KbdGetStatus (&KbdInfo, 0);
KbdInfo.fsMask = (KbdInfo.fsMask & ~KEYBOARD_ECHO_OFF) | KEYBOARD_ECHO_ON;
KbdSetStatus (&KbdInfo, 0);
}
/*
* ShiftDown - test if shift key is down
*/
bool ShiftDown( void )
{
KBDINFO ki;
ki.cb = sizeof( KBDINFO );
KbdGetStatus( &ki, 0 );
if( ki.fsState & KEY_SHIFT ) {
return( TRUE );
}
return( FALSE );
} /* ShiftDown */
void TEventQueue::suspend()
{
#ifdef __OS2__
{
KBDINFO ki;
ki.cb = sizeof(ki);
assert(!KbdGetStatus(&ki,0));
ki.fsMask |= KEYBOARD_ASCII_MODE;
ki.fsMask &= ~KEYBOARD_BINARY_MODE;
assert(!KbdSetStatus(&ki,0));
}
#endif
mouse.suspend();
}
KBDINFO setkbmode(void)
{
USHORT rc;
KBDINFO kb_state;
kb_state.cb = sizeof(kb_state);
KbdGetStatus(&kb_state, 0);
kb_state.fsMask &= ~KEYBOARD_ASCII_MODE;
kb_state.fsMask |= KEYBOARD_BINARY_MODE;
rc = KbdSetStatus(&kb_state, 0);
/* if(rc) printf("KbdSetStatus rc = %04x\n", rc); */
return kb_state;
}
/*
* EMX initialization
*/
static void Term_init_emx(term *t)
{
struct _KBDINFO kbdinfo; /* see structure description ?somewhere? */
v_init();
v_getctype(&curs_start, &curs_end);
/* hide cursor (?) XXX XXX XXX */
v_clear();
/* the documentation I (SWD) have implies, in passing, that setting */
/* "binary mode" on the keyboard device will prevent the O/S from */
/* acting on keys such as ^S (pause) and ^P (printer echo). */
/* note also that "KbdSetStatus is ignored for a Vio-windowed application." */
/* so there may well be problems with running this in a window. Damnit. */
/* this is kind of a nasty structure, as you can't just flip a bit */
/* to change binary/ASCII mode, or echo on/off mode... nor can you */
/* clear the whole thing -- certain bits need to be preserved. */
KbdGetStatus(&kbdinfo, (HKBD)0);
kbdinfo.fsMask &= ~ (KEYBOARD_ECHO_ON| /* clear lowest four bits */
KEYBOARD_ECHO_OFF|KEYBOARD_BINARY_MODE|KEYBOARD_ASCII_MODE);
kbdinfo.fsMask |= (KEYBOARD_BINARY_MODE); /* set bit two */
KbdSetStatus(&kbdinfo, (HKBD)0);
#if 1 /* turn off for debug */
signal(SIGHUP, SIG_IGN);
signal(SIGINT, SIG_IGN);
signal(SIGQUIT, SIG_IGN);
/* signal(SIGILL,SIG_IGN); */
/* signal(SIGTRAP,SIG_IGN); */
/* signal(SIGABRT,SIG_IGN); */
/* signal(SIGEMT,SIG_IGN); */
/* signal(SIGFPE,SIG_IGN); */
/* signal(SIGBUS,SIG_IGN); */
/* signal(SIGSEGV,SIG_IGN); */
/* signal(SIGSYS,SIG_IGN); */
signal(SIGPIPE, SIG_IGN);
signal(SIGALRM, SIG_IGN);
/* signal(SIGTERM,SIG_IGN); */
signal(SIGUSR1, SIG_IGN);
signal(SIGUSR2, SIG_IGN);
signal(SIGCHLD, SIG_IGN);
signal(SIGBREAK, SIG_IGN);
#endif
}
/*
* TurnOffCapsLock - switch off caps lock
*/
void TurnOffCapsLock( void )
{
KBDINFO ki;
ki.cb = sizeof( KBDINFO );
KbdGetStatus( &ki, 0 );
if( ki.fsState & KEY_CAPS_LOCK ) {
hadCapsLock = TRUE;
ki.fsMask |= 0x10;
ki.fsState &= ~KEY_CAPS_LOCK;
KbdSetStatus( &ki, 0 ); /* OS/2 2.0 F***S UP IF YOU DO THIS */
} else {
hadCapsLock = FALSE;
}
} /* TurnOffCapsLock */
int SLang_init_tty(int abort_char, int dum2, int dum3)
{
VIOCURSORINFO cursorInfo, OldcursorInfo;
(void) dum2; (void) dum3;
if (abort_char == -1) abort_char = 3; /* ^C */
SLang_Abort_Char = abort_char;
SLKeyBoard_Quit = 0;
/* set ^C off */
signal (SIGINT, SIG_IGN);
signal (SIGBREAK, SIG_IGN);
/* set up the keyboard */
initialKbdInfo.cb = sizeof(initialKbdInfo);
KbdGetStatus(&initialKbdInfo, 0);
set_kbd();
/* open a semaphore */
CreateSem();
/* start a separate thread to read the keyboard */
#if defined(__BORLANDC__)
SLos2_threadID = _beginthread (thread_code, 8096, NULL);
#else
SLos2_threadID = _beginthread (thread_code, NULL, 8096, NULL);
#endif
if ((int)SLos2_threadID == -1)
{
SLang_exit_error ("init_tty: Error starting keyboard thread.");
}
VioGetCurType (&OldcursorInfo, 0);
cursorInfo.yStart = 1;
cursorInfo.cEnd = 15;
cursorInfo.cx = 1;
cursorInfo.attr = 1;
if (VioSetCurType (&cursorInfo, 0))
VioSetCurType (&OldcursorInfo, 0); /* reset to previous value */
return 0;
}
int ConInit(int XSize, int YSize) {
USHORT MevMask = 127;
if (Initialized) return 0;
EventBuf.What = evNone;
MousePresent = (MouOpen(NULL, &MouseHandle) == 0) ? 1 : 0;
if (MousePresent) MouSetEventMask(&MevMask, MouseHandle);
memset(&SaveKbdState, 0, sizeof(SaveKbdState));
SaveKbdState.cb = sizeof(SaveKbdState);
APIRET16 s = KbdGetStatus(&SaveKbdState, 0);
assert(s == 0);
ConContinue();
Initialized = 1;
return 0;
}
void TEventQueue::resume()
{
#ifdef __OS2__
{
KBDINFO ki;
ki.cb = sizeof(ki);
assert(!KbdGetStatus(&ki,0));
ki.fsMask &= ~KEYBOARD_ASCII_MODE;
ki.fsMask |= KEYBOARD_BINARY_MODE;
assert(!KbdSetStatus(&ki,0));
}
#endif
if( mouse.present() == False )
mouse.resume();
if( mouse.present() == False )
return;
mouse.getEvent( curMouse );
lastMouse = curMouse;
mouse.registerHandler( 0xFFFF, (void (*)(void))mouseInt );
mouseEvents = True;
mouse.show();
TMouse::setRange( TScreen::screenWidth-1, TScreen::screenHeight-1 );
}
static int hb_gt_os2_getKbdState( void )
{
int iKbdState = 0;
memset( s_kbd, 0, sizeof( KBDINFO ) );
if( KbdGetStatus( s_kbd, 0 ) == NO_ERROR )
{
if( s_kbd->fsState & KBDSTF_SHIFT ) iKbdState |= HB_GTI_KBD_SHIFT;
if( s_kbd->fsState & KBDSTF_CONTROL ) iKbdState |= HB_GTI_KBD_CTRL;
if( s_kbd->fsState & KBDSTF_ALT ) iKbdState |= HB_GTI_KBD_ALT;
if( s_kbd->fsState & KBDSTF_SCROLLLOCK_ON ) iKbdState |= HB_GTI_KBD_SCROLOCK;
if( s_kbd->fsState & KBDSTF_NUMLOCK_ON ) iKbdState |= HB_GTI_KBD_NUMLOCK;
if( s_kbd->fsState & KBDSTF_CAPSLOCK_ON ) iKbdState |= HB_GTI_KBD_CAPSLOCK;
if( s_kbd->fsState & KBDSTF_INSERT_ON ) iKbdState |= HB_GTI_KBD_INSERT;
if( s_kbd->fsState & KBDSTF_LEFTSHIFT ) iKbdState |= HB_GTI_KBD_LSHIFT;
if( s_kbd->fsState & KBDSTF_RIGHTSHIFT ) iKbdState |= HB_GTI_KBD_RSHIFT;
if( s_kbd->fsState & KBDSTF_LEFTCONTROL ) iKbdState |= HB_GTI_KBD_LCTRL;
if( s_kbd->fsState & KBDSTF_RIGHTCONTROL ) iKbdState |= HB_GTI_KBD_RCTRL;
if( s_kbd->fsState & KBDSTF_LEFTALT ) iKbdState |= HB_GTI_KBD_LALT;
if( s_kbd->fsState & KBDSTF_RIGHTALT ) iKbdState |= HB_GTI_KBD_RALT;
}
return iKbdState;
}
int ReadMouseEvent(TEvent *Event, ULONG EventMask) {
static unsigned short PrevState = 0;
static unsigned short PrevButtons = 0;
static TEvent LastMouseEvent = { evNone };
static ULONG LastEventTime = 0;
static ULONG LastClick = 0;
static ULONG LastClickTime = 0;
static ULONG LastClickCount = 0;
MOUEVENTINFO mi;
unsigned short Buttons, State, Btn;
USHORT fWait = MOU_NOWAIT;
MOUQUEINFO mq;
ULONG CurTime;
DosQuerySysInfo(QSV_MS_COUNT, QSV_MS_COUNT, &CurTime, 4);
Event->What = evNone;
MouGetNumQueEl(&mq, MouseHandle);
if (mq.cEvents == 0) {
if ((LastMouseEvent.What == evMouseAuto) && (EventMask & evMouseAuto)) {
if (TM_DIFF(CurTime, LastEventTime) >= MouseAutoRepeat) {
*Event = LastMouseEvent;
DosQuerySysInfo(QSV_MS_COUNT, QSV_MS_COUNT, &LastEventTime, 4);
return 1;
}
}
if (((LastMouseEvent.What == evMouseDown) ||
(LastMouseEvent.What == evMouseMove))
&&
(LastMouseEvent.Mouse.Buttons)
&& (EventMask & evMouseAuto)) {
if (TM_DIFF(CurTime, LastEventTime) >= MouseAutoDelay) {
LastMouseEvent.What = evMouseAuto;
*Event = LastMouseEvent;
DosQuerySysInfo(QSV_MS_COUNT, QSV_MS_COUNT, &LastEventTime, 4);
return 1;
}
}
return 0;
}
if (MouReadEventQue(&mi, &fWait, MouseHandle) != 0) return 0;
Event->Mouse.X = mi.col;
Event->Mouse.Y = mi.row;
State = mi.fs;
Btn = Buttons = ((State & (2 | 4)) ? 1 : 0) |
((State & (8 | 16)) ? 2 : 0) |
((State & (32 | 64)) ? 4 : 0);
if (Buttons != PrevButtons) {
Buttons ^= PrevButtons;
if (PrevButtons & Buttons) Event->What = evMouseUp;
else Event->What = evMouseDown;
} else {
Event->What = evMouseMove;
if ((Event->Mouse.X == LastMouseEvent.Mouse.X) &&
(Event->Mouse.Y == LastMouseEvent.Mouse.Y)) return 0;
}
Event->Mouse.Buttons = Buttons;
Event->Mouse.Count = 1;
PrevState = State;
PrevButtons = Btn;
if (Event->What == evMouseDown) {
if (LastClickCount) {
if (LastClick == Event->Mouse.Buttons) {
if (TM_DIFF(CurTime, LastClickTime) <= MouseMultiClick) {
Event->Mouse.Count = ++LastClickCount;
} else {
LastClickCount = 0;
}
} else {
LastClick = 0;
LastClickCount = 0;
LastClickTime = 0;
}
}
LastClick = Event->Mouse.Buttons;
if (LastClickCount == 0) LastClickCount = 1;
DosQuerySysInfo(QSV_MS_COUNT, QSV_MS_COUNT, &LastClickTime, 4);
}
/* if (Event->What == evMouseMove) {
LastClick = 0;
LastClickCount = 0;
LastClickTime = 0;
}*/
{
KBDINFO ki;
USHORT Flags;
TKeyCode KeyFlags = 0;
ki.cb = sizeof(ki);
KbdGetStatus(&ki, 0);
Flags = ki.fsState;
if ((Flags & (LEFTSHIFT | RIGHTSHIFT)) != 0) KeyFlags |= kfShift;
if ((Flags & (LEFTCONTROL | RIGHTCONTROL)) != 0) KeyFlags |= kfCtrl;
if ((Flags & (LEFTALT | RIGHTALT)) != 0) KeyFlags |= kfAlt;
Event->Mouse.KeyMask = KeyFlags;
}
LastMouseEvent = *Event;
DosQuerySysInfo(QSV_MS_COUNT, QSV_MS_COUNT, &LastEventTime, 4);
return 1;
}
USHORT __pascal KBDGETSTATUS(KBDINFO * pkbdinfo, const HKBD hdbd)
{
return KbdGetStatus(pkbdinfo, hdbd);
}
unsigned char getShiftState() {
// returns a value that can be used as a substitute for the shift state at [0040:0017]
TThreads::tiled->keyboardShiftInfo.cb = 10;
KbdGetStatus(&TThreads::tiled->keyboardShiftInfo, 0);
return TThreads::tiled->keyboardShiftInfo.fsState & 0xFF;
}
