#ifdef HAVE_XWIN_CONFIG_H
#include <xwin-config.h>
#endif
#include "win.h"
#include "winkeybd.h"
#include "winconfig.h"
#include "winmsg.h"
#ifdef XKB
#ifndef XKB_IN_SERVER
#define XKB_IN_SERVER
#endif
#include <X11/extensions/XKBsrv.h>
#endif
static Bool g_winKeyState[NUM_KEYCODES];
static unsigned short const *g_winInternalModeKeyStatesPtr = NULL;
static void
winGetKeyMappings (KeySymsPtr pKeySyms, CARD8 *pModMap);
static void
winKeybdBell (int iPercent, DeviceIntPtr pDeviceInt,
pointer pCtrl, int iClass);
static void
winKeybdCtrl (DeviceIntPtr pDevice, KeybdCtrl *pCtrl);
void
winTranslateKey (WPARAM wParam, LPARAM lParam, int *piScanCode)
{
int iKeyFixup = g_iKeyMap[wParam * WIN_KEYMAP_COLS + 1];
int iKeyFixupEx = g_iKeyMap[wParam * WIN_KEYMAP_COLS + 2];
int iParamScanCode = LOBYTE (HIWORD (lParam));
if ((HIWORD (lParam) & KF_EXTENDED) && iKeyFixupEx)
*piScanCode = iKeyFixupEx;
else if (iKeyFixup)
*piScanCode = iKeyFixup;
else if (wParam == 0 && iParamScanCode == 0x70)
*piScanCode = KEY_HKTG;
else
switch (iParamScanCode)
{
case 0x70:
*piScanCode = KEY_HKTG;
break;
case 0x73:
*piScanCode = KEY_BSlash2;
break;
default:
*piScanCode = iParamScanCode;
break;
}
}
static void
winGetKeyMappings (KeySymsPtr pKeySyms, CARD8 *pModMap)
{
int i;
KeySym *pMap = map;
KeySym *pKeySym;
ZeroMemory (g_winKeyState, sizeof (g_winKeyState[0]) * NUM_KEYCODES);
for (i = 0; i < MAP_LENGTH; i++)
pModMap[i] = NoSymbol;
for (pKeySym = pMap, i = MIN_KEYCODE;
i < (MIN_KEYCODE + NUM_KEYCODES);
i++, pKeySym += GLYPHS_PER_KEY)
{
switch (*pKeySym)
{
case XK_Shift_L:
case XK_Shift_R:
pModMap[i] = ShiftMask;
break;
case XK_Control_L:
case XK_Control_R:
pModMap[i] = ControlMask;
break;
case XK_Caps_Lock:
pModMap[i] = LockMask;
break;
case XK_Alt_L:
case XK_Alt_R:
pModMap[i] = AltMask;
break;
case XK_Num_Lock:
pModMap[i] = NumLockMask;
break;
case XK_Scroll_Lock:
pModMap[i] = ScrollLockMask;
break;
#if 0
case XK_Super_L:
case XK_Super_R:
pModMap[i] = Mod4Mask;
break;
#else
case XK_Kana_Lock:
case XK_Kana_Shift:
pModMap[i] = KanaMask;
break;
#endif
case XK_Mode_switch:
pModMap[i] = AltLangMask;
break;
}
}
pKeySyms->map = (KeySym *) pMap;
pKeySyms->mapWidth = GLYPHS_PER_KEY;
pKeySyms->minKeyCode = MIN_KEYCODE;
pKeySyms->maxKeyCode = MAX_KEYCODE;
}
static void
winKeybdBell (int iPercent, DeviceIntPtr pDeviceInt,
pointer pCtrl, int iClass)
{
MessageBeep (MB_OK);
}
static void
winKeybdCtrl (DeviceIntPtr pDevice, KeybdCtrl *pCtrl)
{
g_winInternalModeKeyStatesPtr = &(pDevice->key->state);
}
int
winKeybdProc (DeviceIntPtr pDeviceInt, int iState)
{
KeySymsRec keySyms;
CARD8 modMap[MAP_LENGTH];
DevicePtr pDevice = (DevicePtr) pDeviceInt;
#ifdef XKB
XkbComponentNamesRec names;
XkbSrvInfoPtr xkbi;
XkbControlsPtr ctrl;
#endif
switch (iState)
{
case DEVICE_INIT:
winConfigKeyboard (pDeviceInt);
winGetKeyMappings (&keySyms, modMap);
#ifdef XKB
defaultKeyboardControl.leds = g_winInfo.keyboard.leds;
#else
defaultKeyboardControl.leds = g_winInfo.keyboard.leds;
#endif
#ifdef XKB
if (g_winInfo.xkb.disable)
{
#endif
InitKeyboardDeviceStruct (pDevice,
&keySyms,
modMap,
winKeybdBell,
winKeybdCtrl);
#ifdef XKB
}
else
{
names.keymap = g_winInfo.xkb.keymap;
names.keycodes = g_winInfo.xkb.keycodes;
names.types = g_winInfo.xkb.types;
names.compat = g_winInfo.xkb.compat;
names.symbols = g_winInfo.xkb.symbols;
names.geometry = g_winInfo.xkb.geometry;
winErrorFVerb(2, "Rules = \"%s\" Model = \"%s\" Layout = \"%s\""
" Variant = \"%s\" Options = \"%s\"\n",
g_winInfo.xkb.rules, g_winInfo.xkb.model,
g_winInfo.xkb.layout, g_winInfo.xkb.variant,
g_winInfo.xkb.options);
XkbSetRulesDflts (g_winInfo.xkb.rules, g_winInfo.xkb.model,
g_winInfo.xkb.layout, g_winInfo.xkb.variant,
g_winInfo.xkb.options);
XkbInitKeyboardDeviceStruct (pDeviceInt, &names, &keySyms,
modMap, winKeybdBell, winKeybdCtrl);
}
#endif
#ifdef XKB
if (!g_winInfo.xkb.disable)
{
xkbi = pDeviceInt->key->xkbInfo;
if (xkbi != NULL)
{
ctrl = xkbi->desc->ctrls;
ctrl->repeat_delay = g_winInfo.keyboard.delay;
ctrl->repeat_interval = 1000/g_winInfo.keyboard.rate;
}
else
{
winErrorFVerb (1, "winKeybdProc - Error initializing keyboard AutoRepeat (No XKB)\n");
}
}
#endif
g_winInternalModeKeyStatesPtr = &(pDeviceInt->key->state);
break;
case DEVICE_ON:
pDevice->on = TRUE;
g_winInternalModeKeyStatesPtr = &(pDeviceInt->key->state);
break;
case DEVICE_CLOSE:
case DEVICE_OFF:
pDevice->on = FALSE;
g_winInternalModeKeyStatesPtr = NULL;
break;
}
return Success;
}
void
winInitializeModeKeyStates (void)
{
if (GetKeyState (VK_NUMLOCK) & 0x0001)
{
winSendKeyEvent (KEY_NumLock, TRUE);
winSendKeyEvent (KEY_NumLock, FALSE);
}
if (GetKeyState (VK_CAPITAL) & 0x0001)
{
winSendKeyEvent (KEY_CapsLock, TRUE);
winSendKeyEvent (KEY_CapsLock, FALSE);
}
if (GetKeyState (VK_SCROLL) & 0x0001)
{
winSendKeyEvent (KEY_ScrollLock, TRUE);
winSendKeyEvent (KEY_ScrollLock, FALSE);
}
if (GetKeyState (VK_KANA) & 0x0001)
{
winSendKeyEvent (KEY_HKTG, TRUE);
winSendKeyEvent (KEY_HKTG, FALSE);
}
}
void
winRestoreModeKeyStates ()
{
DWORD dwKeyState;
BOOL processEvents = TRUE;
unsigned short internalKeyStates;
if (!g_winInternalModeKeyStatesPtr)
return;
if (WindowTable && WindowTable[0] && WindowTable[0]->mapped == FALSE)
processEvents = FALSE;
if (processEvents)
mieqProcessInputEvents ();
internalKeyStates = *g_winInternalModeKeyStatesPtr;
dwKeyState = GetKeyState (VK_NUMLOCK) & 0x0001;
if (WIN_XOR (internalKeyStates & NumLockMask, dwKeyState))
{
winSendKeyEvent (KEY_NumLock, TRUE);
winSendKeyEvent (KEY_NumLock, FALSE);
}
dwKeyState = GetKeyState (VK_CAPITAL) & 0x0001;
if (WIN_XOR (internalKeyStates & LockMask, dwKeyState))
{
winSendKeyEvent (KEY_CapsLock, TRUE);
winSendKeyEvent (KEY_CapsLock, FALSE);
}
dwKeyState = GetKeyState (VK_SCROLL) & 0x0001;
if (WIN_XOR (internalKeyStates & ScrollLockMask, dwKeyState))
{
winSendKeyEvent (KEY_ScrollLock, TRUE);
winSendKeyEvent (KEY_ScrollLock, FALSE);
}
dwKeyState = GetKeyState (VK_KANA) & 0x0001;
if (WIN_XOR (internalKeyStates & KanaMask, dwKeyState))
{
winSendKeyEvent (KEY_HKTG, TRUE);
winSendKeyEvent (KEY_HKTG, FALSE);
}
}
Bool
winIsFakeCtrl_L (UINT message, WPARAM wParam, LPARAM lParam)
{
MSG msgNext;
LONG lTime;
Bool fReturn;
if ((message == WM_KEYDOWN || message == WM_SYSKEYDOWN)
&& wParam == VK_CONTROL
&& (HIWORD (lParam) & KF_EXTENDED) == 0)
{
lTime = GetMessageTime ();
fReturn = PeekMessage (&msgNext, NULL,
WM_KEYDOWN, WM_SYSKEYDOWN,
PM_NOREMOVE);
if (!fReturn)
{
Sleep (0);
fReturn = PeekMessage (&msgNext, NULL,
WM_KEYDOWN, WM_SYSKEYDOWN,
PM_NOREMOVE);
}
if (msgNext.message != WM_KEYDOWN && msgNext.message != WM_SYSKEYDOWN)
fReturn = 0;
if (fReturn && msgNext.wParam == VK_MENU
&& msgNext.time == lTime
&& (HIWORD (msgNext.lParam) & KF_EXTENDED))
{
return TRUE;
}
}
if ((message == WM_KEYUP || message == WM_SYSKEYUP)
&& wParam == VK_CONTROL
&& (HIWORD (lParam) & KF_EXTENDED) == 0)
{
lTime = GetMessageTime ();
fReturn = PeekMessage (&msgNext, NULL,
WM_KEYUP, WM_SYSKEYUP,
PM_NOREMOVE);
if (!fReturn)
{
Sleep (0);
fReturn = PeekMessage (&msgNext, NULL,
WM_KEYUP, WM_SYSKEYUP,
PM_NOREMOVE);
}
if (msgNext.message != WM_KEYUP && msgNext.message != WM_SYSKEYUP)
fReturn = 0;
if (fReturn
&& (msgNext.message == WM_KEYUP
|| msgNext.message == WM_SYSKEYUP)
&& msgNext.wParam == VK_MENU
&& msgNext.time == lTime
&& (HIWORD (msgNext.lParam) & KF_EXTENDED))
{
return TRUE;
}
}
return FALSE;
}
void
winKeybdReleaseKeys ()
{
int i;
#ifdef HAS_DEVWINDOWS
if (g_fdMessageQueue == WIN_FD_INVALID)
return;
#endif
for (i = 0; i < NUM_KEYCODES; ++i)
{
if (g_winKeyState[i])
winSendKeyEvent (i, FALSE);
g_winKeyState[i] = FALSE;
}
}
void
winSendKeyEvent (DWORD dwKey, Bool fDown)
{
xEvent xCurrentEvent;
if (g_winKeyState[dwKey] == FALSE && fDown == FALSE) return;
g_winKeyState[dwKey] = fDown;
ZeroMemory (&xCurrentEvent, sizeof (xCurrentEvent));
xCurrentEvent.u.u.type = fDown ? KeyPress : KeyRelease;
xCurrentEvent.u.keyButtonPointer.time =
g_c32LastInputEventTime = GetTickCount ();
xCurrentEvent.u.u.detail = dwKey + MIN_KEYCODE;
mieqEnqueue (&xCurrentEvent);
}
BOOL winCheckKeyPressed(WPARAM wParam, LPARAM lParam)
{
switch (wParam)
{
case VK_CONTROL:
if ((lParam & 0x1ff0000) == 0x11d0000 && g_winKeyState[KEY_RCtrl])
return TRUE;
if ((lParam & 0x1ff0000) == 0x01d0000 && g_winKeyState[KEY_LCtrl])
return TRUE;
break;
case VK_SHIFT:
if ((lParam & 0x1ff0000) == 0x0360000 && g_winKeyState[KEY_ShiftR])
return TRUE;
if ((lParam & 0x1ff0000) == 0x02a0000 && g_winKeyState[KEY_ShiftL])
return TRUE;
break;
default:
return TRUE;
}
return FALSE;
}
void winFixShiftKeys (int iScanCode)
{
if (GetKeyState (VK_SHIFT) & 0x8000)
return;
if (iScanCode == KEY_ShiftL && g_winKeyState[KEY_ShiftR])
winSendKeyEvent (KEY_ShiftR, FALSE);
if (iScanCode == KEY_ShiftR && g_winKeyState[KEY_ShiftL])
winSendKeyEvent (KEY_ShiftL, FALSE);
}