/*
* ProcessInputEvents --
* Retrieve all waiting input events and pass them to DIX in their
* correct chronological order. Only reads from the system pointer
* and keyboard.
*/
void
ProcessInputEvents (void)
{
int x, y;
mieqProcessInputEvents();
/* FIXME: This is a problem if we have multiple pointers */
miPointerGetPosition(inputInfo.pointer, &x, &y);
xf86SetViewport(xf86Info.currentScreen, x, y);
}
/*
* Run through the Windows message queue(s) one more time.
* Tell mi to dequeue the events that we have sent it.
*/
void
ProcessInputEvents (void)
{
#if 0
ErrorF ("ProcessInputEvents\n");
#endif
mieqProcessInputEvents ();
#if 0
ErrorF ("ProcessInputEvents - returning\n");
#endif
}
/*
* ProcessInputEvents
* Read and process events from the event queue until it is empty.
*/
void
ProcessInputEvents(void)
{
char nullbyte;
int x = sizeof(nullbyte);
mieqProcessInputEvents();
// Empty the signaling pipe
while (x == sizeof(nullbyte)) {
x = read(darwinEventReadFD, &nullbyte, sizeof(nullbyte));
}
}
void
PtrAddEvent(int buttonMask, int x, int y, rfbClientPtr cl)
{
int i;
int valuators[2];
ValuatorMask mask;
static int oldButtonMask = 0;
if (!ptrDevice)
FatalError("Pointer device not initialized");
if (cursorPosX != x || cursorPosY != y) {
valuators[0] = x;
valuators[1] = y;
valuator_mask_set_range(&mask, 0, 2, valuators);
QueuePointerEvents(ptrDevice, MotionNotify, 0, POINTER_ABSOLUTE,
&mask);
cursorPosX = x;
cursorPosY = y;
}
for (i = 0; i < 5; i++) {
if ((buttonMask ^ oldButtonMask) & (1 << i)) {
if (buttonMask & (1 << i)) {
valuator_mask_set_range(&mask, 0, 0, NULL);
QueuePointerEvents(ptrDevice, ButtonPress, i + 1,
POINTER_RELATIVE, &mask);
} else {
valuator_mask_set_range(&mask, 0, 0, NULL);
QueuePointerEvents(ptrDevice, ButtonRelease, i + 1,
POINTER_RELATIVE, &mask);
}
}
}
oldButtonMask = buttonMask;
mieqProcessInputEvents();
}
void
ProcessInputEvents(void)
{
mieqProcessInputEvents();
}
void
ProcessInputEvents()
{
mieqProcessInputEvents();
miPointerUpdate();
}
void
winRestoreModeKeyStates (void)
{
DWORD dwKeyState;
BOOL processEvents = TRUE;
unsigned short internalKeyStates;
/* X server is being initialized */
if (!inputInfo.keyboard)
return;
/* Only process events if the rootwindow is mapped. The keyboard events
* will cause segfaults otherwise */
if (screenInfo.screens[0]->root && screenInfo.screens[0]->root->mapped == FALSE)
processEvents = FALSE;
/* Force to process all pending events in the mi event queue */
if (processEvents)
mieqProcessInputEvents ();
/* Read the mode key states of our X server */
/* (stored in the virtual core keyboard) */
internalKeyStates = XkbStateFieldFromRec(&inputInfo.keyboard->key->xkbInfo->state);
winDebug("winRestoreModeKeyStates: state %d\n", internalKeyStates);
/*
* NOTE: The C XOR operator, ^, will not work here because it is
* a bitwise operator, not a logical operator. C does not
* have a logical XOR operator, so we use a macro instead.
*/
/* Has the key state changed? */
dwKeyState = GetKeyState (VK_NUMLOCK) & 0x0001;
if (WIN_XOR (internalKeyStates & NumLockMask, dwKeyState))
{
winSendKeyEvent (KEY_NumLock, TRUE);
winSendKeyEvent (KEY_NumLock, FALSE);
}
/* Has the key state changed? */
dwKeyState = GetKeyState (VK_CAPITAL) & 0x0001;
if (WIN_XOR (internalKeyStates & LockMask, dwKeyState))
{
winSendKeyEvent (KEY_CapsLock, TRUE);
winSendKeyEvent (KEY_CapsLock, FALSE);
}
/* Has the key state changed? */
dwKeyState = GetKeyState (VK_SCROLL) & 0x0001;
if (WIN_XOR (internalKeyStates & ScrollLockMask, dwKeyState))
{
winSendKeyEvent (KEY_ScrollLock, TRUE);
winSendKeyEvent (KEY_ScrollLock, FALSE);
}
/* Has the key state changed? */
dwKeyState = GetKeyState (VK_KANA) & 0x0001;
if (WIN_XOR (internalKeyStates & KanaMask, dwKeyState))
{
winSendKeyEvent (KEY_HKTG, TRUE);
winSendKeyEvent (KEY_HKTG, FALSE);
}
}
void
winRestoreModeKeyStates(void)
{
DWORD dwKeyState;
BOOL processEvents = TRUE;
unsigned short internalKeyStates;
/* X server is being initialized */
if (!inputInfo.keyboard)
return;
/* Only process events if the rootwindow is mapped. The keyboard events
* will cause segfaults otherwise */
if (screenInfo.screens[0]->root &&
screenInfo.screens[0]->root->mapped == FALSE)
processEvents = FALSE;
/* Force to process all pending events in the mi event queue */
if (processEvents)
mieqProcessInputEvents();
/* Read the mode key states of our X server */
/* (stored in the virtual core keyboard) */
internalKeyStates =
XkbStateFieldFromRec(&inputInfo.keyboard->key->xkbInfo->state);
winDebug("winRestoreModeKeyStates: state %d\n", internalKeyStates);
{
/* Make sure the message queue is empty, otherwise the GetKeyState will not always
return the correct state of the numlock key, capslock key, ...
This is mainly because this function is called from the WM_SETFOCUS handler.
From MSDN GetKeyState: The key status returned from this function changes as a thread
reads key messages from its message queue.*/
MSG msg;
/* Process all messages on our queue */
while (PeekMessage (&msg, NULL, 0, 0, PM_REMOVE))
{
DispatchMessage (&msg);
}
}
/* Check if modifier keys are pressed, and if so, fake a press */
{
BOOL ctrl = (GetAsyncKeyState(VK_CONTROL) < 0);
BOOL shift = (GetAsyncKeyState(VK_SHIFT) < 0);
BOOL alt = (GetAsyncKeyState(VK_LMENU) < 0);
BOOL altgr = (GetAsyncKeyState(VK_RMENU) < 0);
if (ctrl && altgr)
ctrl = FALSE;
if (LOGICAL_XOR(internalKeyStates & ControlMask, ctrl))
winSendKeyEvent(KEY_LCtrl, ctrl);
if (LOGICAL_XOR(internalKeyStates & ShiftMask, shift))
winSendKeyEvent(KEY_ShiftL, shift);
if (LOGICAL_XOR(internalKeyStates & Mod1Mask, alt))
winSendKeyEvent(KEY_Alt, alt);
if (LOGICAL_XOR(internalKeyStates & Mod5Mask, altgr))
winSendKeyEvent(KEY_AltLang, altgr);
}
/*
Check if latching modifier key states have changed, and if so,
fake a press and a release to toggle the modifier to the correct
state
*/
dwKeyState = GetKeyState(VK_NUMLOCK) & 0x0001;
if (LOGICAL_XOR(internalKeyStates & NumLockMask, dwKeyState)) {
winSendKeyEvent(KEY_NumLock, TRUE);
winSendKeyEvent(KEY_NumLock, FALSE);
}
dwKeyState = GetKeyState(VK_CAPITAL) & 0x0001;
if (LOGICAL_XOR(internalKeyStates & LockMask, dwKeyState)) {
winSendKeyEvent(KEY_CapsLock, TRUE);
winSendKeyEvent(KEY_CapsLock, FALSE);
}
dwKeyState = GetKeyState(VK_SCROLL) & 0x0001;
if (LOGICAL_XOR(internalKeyStates & ScrollLockMask, dwKeyState)) {
winSendKeyEvent(KEY_ScrollLock, TRUE);
winSendKeyEvent(KEY_ScrollLock, FALSE);
}
dwKeyState = GetKeyState(VK_KANA) & 0x0001;
if (LOGICAL_XOR(internalKeyStates & KanaMask, dwKeyState)) {
winSendKeyEvent(KEY_HKTG, TRUE);
winSendKeyEvent(KEY_HKTG, FALSE);
}
}
void
ProcessInputEvents ()
{
int x, y;
#ifdef INHERIT_LOCK_STATE
static int generation = 0;
#endif
#ifdef AMOEBA
#define MAXEVENTS 32
#define BUTTON_PRESS 0x1000
#define MAP_BUTTON(ev,but) (((ev) == EV_ButtonPress) ? \
((but) | BUTTON_PRESS) : ((but) & ~BUTTON_PRESS))
#define KEY_RELEASE 0x80
#define MAP_KEY(ev, key) (((ev) == EV_KeyReleaseEvent) ? \
((key) | KEY_RELEASE) : ((key) & ~KEY_RELEASE))
register IOPEvent *e, *elast;
IOPEvent events[MAXEVENTS];
int dx, dy, nevents;
#endif
/*
* With INHERIT_LOCK_STATE defined, the initial state of CapsLock, NumLock
* and ScrollLock will be set to match that of the VT the server is
* running on.
*/
#ifdef INHERIT_LOCK_STATE
if (generation != serverGeneration) {
xEvent kevent;
DevicePtr pKeyboard = xf86Info.pKeyboard;
extern unsigned int xf86InitialCaps, xf86InitialNum, xf86InitialScroll;
generation = serverGeneration;
kevent.u.keyButtonPointer.time = GetTimeInMillis();
kevent.u.keyButtonPointer.rootX = 0;
kevent.u.keyButtonPointer.rootY = 0;
kevent.u.u.type = KeyPress;
if (xf86InitialCaps) {
kevent.u.u.detail = xf86InitialCaps;
(* pKeyboard->processInputProc)(&kevent, (DeviceIntPtr)pKeyboard, 1);
xf86InitialCaps = 0;
}
if (xf86InitialNum) {
kevent.u.u.detail = xf86InitialNum;
(* pKeyboard->processInputProc)(&kevent, (DeviceIntPtr)pKeyboard, 1);
xf86InitialNum = 0;
}
if (xf86InitialScroll) {
kevent.u.u.detail = xf86InitialScroll;
(* pKeyboard->processInputProc)(&kevent, (DeviceIntPtr)pKeyboard, 1);
xf86InitialScroll = 0;
}
}
#endif
xf86Info.inputPending = FALSE;
#ifdef XINPUT
xf86eqProcessInputEvents();
#else
mieqProcessInputEvents();
#endif
miPointerUpdate();
miPointerPosition(&x, &y);
//xf86SetViewport(xf86Info.currentScreen, x, y); //added010509
}
void
ExtInputAddEvent(rfbDevInfoPtr dev, int type, int buttons)
{
ValuatorMask mask;
if (!dev)
FatalError("ExtInputDeviceAddEvent(): Invalid argument");
if (rfbVirtualTablet) {
int i;
rfbDevInfoPtr vtDev;
switch (dev->productID) {
case rfbGIIDevTypeStylus:
vtDev = &virtualTabletStylus;
break;
case rfbGIIDevTypeEraser:
vtDev = &virtualTabletEraser;
break;
case rfbGIIDevTypeTouch:
vtDev = &virtualTabletTouch;
break;
case rfbGIIDevTypePad:
vtDev = &virtualTabletPad;
break;
default:
if (stristr(dev->name, "stylus"))
vtDev = &virtualTabletStylus;
else if (stristr(dev->name, "eraser"))
vtDev = &virtualTabletEraser;
else if (stristr(dev->name, "touch"))
vtDev = &virtualTabletTouch;
else if (stristr(dev->name, "pad"))
vtDev = &virtualTabletPad;
else
return;
}
if (dev->valFirst >= vtDev->numValuators ||
buttons > vtDev->numButtons)
return;
vtDev->valFirst = dev->valFirst;
vtDev->valCount = min(dev->valCount,
vtDev->numValuators - vtDev->valFirst);
for (i = vtDev->valFirst; i < vtDev->valFirst + vtDev->valCount; i++)
{
vtDev->values[i] = (int)roundl(
(double)(dev->values[i] - dev->valuators[i].rangeMin) /
(double)(dev->valuators[i].rangeMax -
dev->valuators[i].rangeMin) *
(double)(vtDev->valuators[i].rangeMax -
vtDev->valuators[i].rangeMin) +
(double)vtDev->valuators[i].rangeMin);
}
dev = vtDev;
}
if (dev->valCount > 0) {
valuator_mask_set_range(&mask, 0, dev->numValuators, dev->values);
QueuePointerEvents(dev->pDev, type, buttons,
dev->mode == Absolute ? POINTER_ABSOLUTE :
POINTER_RELATIVE, &mask);
} else {
valuator_mask_set_range(&mask, 0, 0, NULL);
QueuePointerEvents(dev->pDev, type, buttons, POINTER_RELATIVE, &mask);
}
mieqProcessInputEvents();
}
void KeyEvent(CARD32 keysym, Bool down)
{
int i;
unsigned state, new_state;
KeyCode keycode;
unsigned level_three_mask;
KeyCode shift_press = 0, level_three_press = 0;
KeyCode *shift_release = NULL, *level_three_release = NULL;
/*
* Release events must match the press event, so look up what
* keycode we sent for the press.
*/
if (!down) {
for (i = 0; i < 256; i++) {
if (pressedKeys[i] == keysym) {
pressedKeys[i] = NoSymbol;
PressKey(kbdDevice, i, FALSE, "keycode");
mieqProcessInputEvents();
return;
}
}
/*
* This can happen quite often as we ignore some
* key presses.
*/
if (xkbDebug)
rfbLog("Unexpected release of keysym 0x%x\n", keysym);
return;
}
/*
* Since we are checking the current state to determine if we need
* to fake modifiers, we must make sure that everything put on the
* input queue is processed before we start. Otherwise, shift may be
* stuck down.
*/
mieqProcessInputEvents();
state = GetKeyboardState();
keycode = KeysymToKeycode(keysym, state, &new_state);
/* Try some equivalent keysyms if we couldn't find a perfect match */
if (keycode == 0) {
for (i = 0; i < sizeof(altKeysym) / sizeof(altKeysym[0]); i++) {
KeySym altsym;
if (altKeysym[i].a == keysym)
altsym = altKeysym[i].b;
else if (altKeysym[i].b == keysym)
altsym = altKeysym[i].a;
else
continue;
keycode = KeysymToKeycode(altsym, state, &new_state);
if (keycode != 0)
break;
}
}
/* We don't have lock synchronisation... */
if (IsLockModifier(keycode, new_state) && ignoreLockModifiers) {
if (xkbDebug)
rfbLog("Ignoring lock key (e.g. caps lock)\n");
return;
}
/* No matches. Will have to add a new entry... */
if (keycode == 0) {
keycode = AddKeysym(keysym, state);
if (keycode == 0) {
rfbLog("ERROR: Could not add new keysym 0x%x\n", keysym);
return;
}
rfbLog("Mapped unknown keysym 0x%x to keycode %d\n", keysym, keycode);
/*
* The state given to addKeysym() is just a hint and
* the actual result might still require some state
* changes.
*/
keycode = KeysymToKeycode(keysym, state, &new_state);
if (keycode == 0) {
rfbLog("ERROR: Cannot generate keycode for newly-added keysym 0x%x\n",
keysym);
return;
}
}
/*
* X11 generally lets shift toggle the keys on the numeric pad
* the same way NumLock does. This is however not the case on
* other systems like Windows. As a result, some applications
* get confused when we do a fake shift to get the same effect
* that having NumLock active would produce.
*
* Until we have proper NumLock synchronisation (so we can
* avoid faking shift), we try to avoid the fake shifts if we
* can use an alternative keysym.
*/
if (((state & ShiftMask) != (new_state & ShiftMask)) &&
avoidShiftNumLock && IsAffectedByNumLock(keycode)) {
KeyCode keycode2 = 0;
unsigned new_state2;
if (xkbDebug)
rfbLog("Finding alternative to keysym 0x%x to avoid fake shift for numpad\n",
keysym);
for (i = 0; i < sizeof(altKeysym) / sizeof(altKeysym[0]); i++) {
KeySym altsym;
if (altKeysym[i].a == keysym)
altsym = altKeysym[i].b;
else if (altKeysym[i].b == keysym)
altsym = altKeysym[i].a;
else
continue;
keycode2 = KeysymToKeycode(altsym, state, &new_state2);
if (keycode2 == 0)
continue;
if (((state & ShiftMask) != (new_state2 & ShiftMask)) &&
IsAffectedByNumLock(keycode2))
continue;
break;
}
if (i == sizeof(altKeysym) / sizeof(altKeysym[0])) {
if (xkbDebug)
rfbLog("No alternative keysym found\n");
} else {
keycode = keycode2;
new_state = new_state2;
}
}
/*
* "Shifted Tab" is a bit of a mess. Some systems have varying,
* special keysyms for this symbol. VNC mandates that clients
* should always send the plain XK_Tab keysym and the server
* should deduce the meaning based on current Shift state.
* To comply with this, we will find the keycode that sends
* XK_Tab, and make sure that Shift isn't cleared. This can
* possibly result in a different keysym than XK_Tab, but that
* is the desired behaviour.
*
* Note: We never get ISO_Left_Tab here because it's already
* been translated in VNCSConnectionST.
*/
if (keysym == XK_Tab && (state & ShiftMask))
new_state |= ShiftMask;
/*
* We need a bigger state change than just shift,
* so we need to know what the mask is for level 3 shifts.
*/
if ((new_state & ~ShiftMask) != (state & ~ShiftMask))
level_three_mask = GetLevelThreeMask();
else
level_three_mask = 0;
shift_press = level_three_press = 0;
/* Need a fake press or release of shift? */
if (!(state & ShiftMask) && (new_state & ShiftMask) && fakeShift) {
shift_press = PressShift();
if (shift_press == 0) {
rfbLog("ERROR: Unable to find modifier key for Shift key press\n");
return;
}
PressKey(kbdDevice, shift_press, TRUE, "temp shift");
} else if ((state & ShiftMask) && !(new_state & ShiftMask) && fakeShift) {
int index = 0;
KeyCode *shift_release = ReleaseShift();
if (!shift_release) {
rfbLog("ERROR: Unable to find modifier key(s) for Shift key release\n");
return;
}
while (shift_release[index])
PressKey(kbdDevice, shift_release[index++], FALSE, "temp shift");
}
/* Need a fake press or release of level three shift? */
if (!(state & level_three_mask) && (new_state & level_three_mask) &&
fakeShift) {
level_three_press = PressLevelThree();
if (level_three_press == 0) {
rfbLog("ERROR: Unable to find modifier key for ISO_Level3_Shift/Mode_Switch key press\n");
return;
}
PressKey(kbdDevice, level_three_press, TRUE, "temp level 3 shift");
} else if ((state & level_three_mask) && !(new_state & level_three_mask) &&
fakeShift) {
int index = 0;
level_three_release = ReleaseLevelThree();
if (!level_three_release) {
rfbLog("ERROR: Unable to find modifier key(s) for ISO_Level3_Shift/Mode_Switch key release\n");
return;
}
while (level_three_release[index])
PressKey(kbdDevice, level_three_release[index++], FALSE,
"temp level 3 shift");
}
/* Now press the actual key */
PressKey(kbdDevice, keycode, TRUE, "keycode");
/* And store the mapping so that we can do a proper release later */
for (i = 0; i < 256; i++) {
if (i == keycode)
continue;
if (pressedKeys[i] == keysym) {
rfbLog("ERROR: Keysym 0x%x generated by both keys %d and %d\n", keysym,
i, keycode);
pressedKeys[i] = NoSymbol;
}
}
pressedKeys[keycode] = keysym;
/* Undo any fake level three shift */
if (level_three_press != 0)
PressKey(kbdDevice, level_three_press, FALSE, "temp level 3 shift");
else if (level_three_release) {
int index = 0;
while (level_three_release[index])
PressKey(kbdDevice, level_three_release[index++], TRUE,
"temp level 3 shift");
free(level_three_release);
}
/* Undo any fake shift */
if (shift_press != 0)
PressKey(kbdDevice, shift_press, FALSE, "temp shift");
else if (shift_release) {
int index = 0;
while (shift_release[index])
PressKey(kbdDevice, shift_release[index++], TRUE, "temp shift");
free(shift_release);
}
/*
* When faking a modifier we are putting a keycode (which can
* currently activate the desired modifier) on the input
* queue. A future modmap change can change the mapping so
* that this keycode means something else entirely. Guard
* against this by processing the queue now.
*/
mieqProcessInputEvents();
}
void
winRestoreModeKeyStates(void)
{
DWORD dwKeyState;
BOOL processEvents = TRUE;
unsigned short internalKeyStates;
/* X server is being initialized */
if (!inputInfo.keyboard)
return;
/* Only process events if the rootwindow is mapped. The keyboard events
* will cause segfaults otherwise */
if (screenInfo.screens[0]->root &&
screenInfo.screens[0]->root->mapped == FALSE)
processEvents = FALSE;
/* Force to process all pending events in the mi event queue */
if (processEvents)
mieqProcessInputEvents();
/* Read the mode key states of our X server */
/* (stored in the virtual core keyboard) */
internalKeyStates =
XkbStateFieldFromRec(&inputInfo.keyboard->key->xkbInfo->state);
winDebug("winRestoreModeKeyStates: state %d\n", internalKeyStates);
/* Check if modifier keys are pressed, and if so, fake a press */
{
BOOL lctrl = (GetAsyncKeyState(VK_LCONTROL) < 0);
BOOL rctrl = (GetAsyncKeyState(VK_RCONTROL) < 0);
BOOL lshift = (GetAsyncKeyState(VK_LSHIFT) < 0);
BOOL rshift = (GetAsyncKeyState(VK_RSHIFT) < 0);
BOOL alt = (GetAsyncKeyState(VK_LMENU) < 0);
BOOL altgr = (GetAsyncKeyState(VK_RMENU) < 0);
/*
If AltGr and CtrlL appear to be pressed, assume the
CtrL is a fake one
*/
if (lctrl && altgr)
lctrl = FALSE;
if (lctrl)
winSendKeyEvent(KEY_LCtrl, TRUE);
if (rctrl)
winSendKeyEvent(KEY_RCtrl, TRUE);
if (lshift)
winSendKeyEvent(KEY_ShiftL, TRUE);
if (rshift)
winSendKeyEvent(KEY_ShiftL, TRUE);
if (alt)
winSendKeyEvent(KEY_Alt, TRUE);
if (altgr)
winSendKeyEvent(KEY_AltLang, TRUE);
}
/*
Check if latching modifier key states have changed, and if so,
fake a press and a release to toggle the modifier to the correct
state
*/
dwKeyState = GetKeyState(VK_NUMLOCK) & 0x0001;
if (LOGICAL_XOR(internalKeyStates & NumLockMask, dwKeyState)) {
winSendKeyEvent(KEY_NumLock, TRUE);
winSendKeyEvent(KEY_NumLock, FALSE);
}
dwKeyState = GetKeyState(VK_CAPITAL) & 0x0001;
if (LOGICAL_XOR(internalKeyStates & LockMask, dwKeyState)) {
winSendKeyEvent(KEY_CapsLock, TRUE);
winSendKeyEvent(KEY_CapsLock, FALSE);
}
dwKeyState = GetKeyState(VK_SCROLL) & 0x0001;
if (LOGICAL_XOR(internalKeyStates & ScrollLockMask, dwKeyState)) {
winSendKeyEvent(KEY_ScrollLock, TRUE);
winSendKeyEvent(KEY_ScrollLock, FALSE);
}
dwKeyState = GetKeyState(VK_KANA) & 0x0001;
if (LOGICAL_XOR(internalKeyStates & KanaMask, dwKeyState)) {
winSendKeyEvent(KEY_HKTG, TRUE);
winSendKeyEvent(KEY_HKTG, FALSE);
}
/*
For strict correctness, we should also press any non-modifier keys
which are already down when we gain focus, but nobody has complained
yet :-)
*/
}
void
winRestoreModeKeyStates ()
{
DWORD dwKeyState;
BOOL processEvents = TRUE;
unsigned short internalKeyStates;
/* X server is being initialized */
if (!g_winInternalModeKeyStatesPtr)
return;
/* Only process events if the rootwindow is mapped. The keyboard events
* will cause segfaults otherwise */
if (WindowTable && WindowTable[0] && WindowTable[0]->mapped == FALSE)
processEvents = FALSE;
/* Force to process all pending events in the mi event queue */
if (processEvents)
mieqProcessInputEvents ();
/* Read the mode key states of our X server */
internalKeyStates = *g_winInternalModeKeyStatesPtr;
/*
* NOTE: The C XOR operator, ^, will not work here because it is
* a bitwise operator, not a logical operator. C does not
* have a logical XOR operator, so we use a macro instead.
*/
/* Has the key state changed? */
dwKeyState = GetKeyState (VK_NUMLOCK) & 0x0001;
if (WIN_XOR (internalKeyStates & NumLockMask, dwKeyState))
{
winSendKeyEvent (KEY_NumLock, TRUE);
winSendKeyEvent (KEY_NumLock, FALSE);
}
/* Has the key state changed? */
dwKeyState = GetKeyState (VK_CAPITAL) & 0x0001;
if (WIN_XOR (internalKeyStates & LockMask, dwKeyState))
{
winSendKeyEvent (KEY_CapsLock, TRUE);
winSendKeyEvent (KEY_CapsLock, FALSE);
}
/* Has the key state changed? */
dwKeyState = GetKeyState (VK_SCROLL) & 0x0001;
if (WIN_XOR (internalKeyStates & ScrollLockMask, dwKeyState))
{
winSendKeyEvent (KEY_ScrollLock, TRUE);
winSendKeyEvent (KEY_ScrollLock, FALSE);
}
/* Has the key state changed? */
dwKeyState = GetKeyState (VK_KANA) & 0x0001;
if (WIN_XOR (internalKeyStates & KanaMask, dwKeyState))
{
winSendKeyEvent (KEY_HKTG, TRUE);
winSendKeyEvent (KEY_HKTG, FALSE);
}
}
