fdo-mirrors/xserver
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/xorg/xserver.git synced 2026-05-03 19:27:59 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

Attempt to fix handling of AltGr when TweakUI is enabled. Remove the dead

Browse source 
code that was wrapped with WIN_NEW_KEYBOARD_SUPPORT.
This commit is contained in:
Harold L Hunt II 2003-12-24 21:17:27 +00:00
parent 47b3490130
commit db47caf916
4 changed files with 36 additions and 317 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

24
hw/xwin/win.h
View file

@ -49,7 +49,6 @@
*/
#define WIN_NATIVE_GDI_SUPPORT YES
#define WIN_LAYER_SUPPORT NO
#define WIN_NEW_KEYBOARD_SUPPORT NO
#define WIN_EMULATE_PSEUDO_SUPPORT YES
#define WIN_UPDATE_STATS NO
@ -350,19 +349,6 @@ typedef struct
} winPrivCmapRec, *winPrivCmapPtr;
#if WIN_NEW_KEYBOARD_SUPPORT
/*
* Keyboard event structure
*/
typedef struct
{
DWORD dwXKeycodes[WIN_MAX_KEYS_PER_KEY];
DWORD dwReleaseModifiers;
} winKeyEventsRec, *winKeyEventsPtr;
#endif /* WIN_NEW_KEYBOARD_SUPPORT */
/*
* Screen information structure that we need before privates are available
* in the server startup sequence.
@ -961,13 +947,8 @@ winGetSpansNativeGDI (DrawablePtr pDrawable,
* winkeybd.c
*/
#if WIN_NEW_KEYBOARD_SUPPORT
winKeyEventsRec
winTranslateKey (DWORD dwVirtualKey, DWORD dwKeyData);
#else
void
winTranslateKey (WPARAM wParam, LPARAM lParam, int *piScanCode);
#endif
void
winGetKeyMappings (KeySymsPtr pKeySyms, CARD8 *pModMap);
@ -997,11 +978,6 @@ winKeybdReleaseKeys (void);
void
winSendKeyEvent (DWORD dwKey, Bool fDown);
#if WIN_NEW_KEYBOARD_SUPPORT
void
winProcessKeyEvent (DWORD dwVirtKey, DWORD dwKeyData);
#endif
/*
* winlayer.c

211
hw/xwin/winkeybd.c
View file

@ -48,173 +48,6 @@ static Bool g_winKeyState[NUM_KEYCODES];
/* Stored to get internal mode key states. Must be read-only. */
static unsigned short const *g_winInternalModeKeyStatesPtr = NULL;
#if WIN_NEW_KEYBOARD_SUPPORT
const unsigned int MaxKeysPerKey = 4;
void
winProcessKeyEvent (DWORD dwVirtualKey, DWORD dwKeyData)
{
Bool fDown = ((dwKeyData & 0x80000000) == 0);
winKeyEventsRec kerEvent;
int i;
/* Get the key events */
kerEvent = winTranslateKey (dwVirtualKey, dwKeyData);
if (kerEvent.dwReleaseModifiers & WIN_MOD_LCONTROL)
winSendKeyEvent (XK_Control_L, FALSE);
if (kerEvent.dwReleaseModifiers & WIN_MOD_RCONTROL)
winSendKeyEvent (XK_Control_R, FALSE);
if (kerEvent.dwReleaseModifiers & WIN_MOD_LALT)
winSendKeyEvent (XK_Alt_L, FALSE);
if (kerEvent.dwReleaseModifiers & WIN_MOD_RALT)
winSendKeyEvent (XK_Alt_R, FALSE);
for (i = 0; kerEvent.dwXKeycodes[i] != XK_VoidSymbol; ++i)
winSendKeyEvent (kerEvent.dwXKeycodes[i], fDown);
if (kerEvent.dwReleaseModifiers & WIN_MOD_LCONTROL)
winSendKeyEvent (XK_Control_L, FALSE);
if (kerEvent.dwReleaseModifiers & WIN_MOD_RCONTROL)
winSendKeyEvent (XK_Control_R, TRUE);
if (kerEvent.dwReleaseModifiers & WIN_MOD_LALT)
winSendKeyEvent (XK_Alt_L, FALSE);
if (kerEvent.dwReleaseModifiers & WIN_MOD_RALT)
winSendKeyEvent (XK_Alt_R, TRUE);
}
winKeyEventsRec
winTranslateKey (DWORD dwVirtualKey, DWORD dwKeyData)
{
winKeyEventsRec kerEvents;
Bool fExtended = ((HIWORD (dwKeyData) & KF_EXTENDED) != 0);
int i;
DWORD dwNumEvents = 0;
BYTE bKeyboardState[256];
int iReturn;
unsigned char cAscii[4];
/* Remap extended modifiers to the right version of that key. */
if (fExtended)
{
switch (dwVirtualKey)
{
case VK_MENU:
dwVirtualKey = VK_RMENU;
break;
case VK_CONTROL:
dwVirtualKey = VK_RCONTROL;
break;
}
}
/* Initialize the modifiers to release flag */
kerEvents.dwReleaseModifiers = 0;
/* Look up the current virtual key code in the translation table */
for (i = 0; i < g_winKeymapEntries; ++i)
{
/* Did we find a mapping? */
if (winKeymap[i].dwVirtualKey == dwVirtualKey)
{
/* Mapping found, we have at least one event now */
kerEvents.dwXKeycodes[dwNumEvents] = winKeymap[i].dwXKey;
break;
}
}
/* Break out early, if we found the key in the translation table */
if (dwNumEvents != 0)
{
/* Terminate the last of the key events with a void symbol */
kerEvents.dwXKeycodes[dwNumEvents] = XK_VoidSymbol;
return kerEvents;
}
/* Get the state of all keyboard keys */
GetKeyboardState (bKeyboardState);
/* Try to convert the key to ASCII */
iReturn = ToAscii (dwVirtualKey, 0, bKeyboardState, (WORD *) cAscii, 0);
/*
* Left Control and Alt pressed, combined with a valid result
* from ToAscii means that we have found the Windows version of AltGr.
*/
if ((bKeyboardState[VK_MENU] & 0x80) && (bKeyboardState[VK_CONTROL] & 0x80)
&& (iReturn >= 1)
&& (((cAscii[0] >= 32) && (cAscii[0] <= 126))
|| (cAscii[0] >= 160)))
{
/* These three calls will return 0 on Windows 95/98/Me */
if ((GetKeyState (VK_LCONTROL) & KF_UP))
kerEvents.dwReleaseModifiers |= WIN_MOD_LCONTROL;
if ((GetKeyState (VK_LMENU) & KF_UP))
kerEvents.dwReleaseModifiers |= WIN_MOD_LALT;
if ((GetKeyState (VK_RMENU) & KF_UP))
kerEvents.dwReleaseModifiers |= WIN_MOD_RALT;
/* Windows 95/98/Me handling - pop all of them */
if (kerEvents.dwReleaseModifiers == 0)
kerEvents.dwReleaseModifiers
= WIN_MOD_LCONTROL | WIN_MOD_LALT | WIN_MOD_RALT;
/* Copy the string of character events */
for (i = 0; i < iReturn; ++i)
kerEvents.dwXKeycodes[dwNumEvents++] = cAscii[i];
}
/* Handle non Ctrl+Alt cases*/
if (dwNumEvents == 0)
{
bKeyboardState[VK_CONTROL] = 0;
bKeyboardState[VK_LCONTROL] = 0;
bKeyboardState[VK_RCONTROL] = 0;
iReturn = ToAscii (dwVirtualKey, 0, bKeyboardState, (WORD *)cAscii, 0);
if (iReturn < 0)
{
switch (cAscii[0])
{
case '`':
kerEvents.dwXKeycodes[dwNumEvents++] = XK_dead_grave;
break;
case '\'':
kerEvents.dwXKeycodes[dwNumEvents++] = XK_dead_acute;
break;
case '~':
kerEvents.dwXKeycodes[dwNumEvents++] = XK_dead_tilde;
break;
case '^':
kerEvents.dwXKeycodes[dwNumEvents++] = XK_dead_circumflex;
break;
}
}
/* Send what we've got if its a printable character */
if (iReturn >= 1)
for (i = 0; i < iReturn; ++i)
kerEvents.dwXKeycodes[dwNumEvents++] = cAscii[i];
}
/* Terminate the last of the key events with a void symbol */
kerEvents.dwXKeycodes[dwNumEvents] = XK_VoidSymbol;
return kerEvents;
}
#else /* WIN_NEW_KEYBOARD_SUPPORT */
/*
* Translate a Windows WM_[SYS]KEY(UP/DOWN) message
* into an ASCII scan code.
@ -239,8 +72,6 @@ winTranslateKey (WPARAM wParam, LPARAM lParam, int *piScanCode)
*piScanCode = LOBYTE (HIWORD (lParam));
}
#endif /* WIN_NEW_KEYBOARD_SUPPORT */
/*
* We call this function from winKeybdProc when we are
@ -290,7 +121,6 @@ winGetKeyMappings (KeySymsPtr pKeySyms, CARD8 *pModMap)
pModMap[i] = AltMask;
break;
#if !WIN_NEW_KEYBOARD_SUPPORT
case XK_Num_Lock:
pModMap[i] = NumLockMask;
break;
@ -304,7 +134,6 @@ winGetKeyMappings (KeySymsPtr pKeySyms, CARD8 *pModMap)
case XK_Kana_Shift:
pModMap[i] = KanaMask;
break;
#endif
/* alternate toggle for multinational support */
case XK_Mode_switch:
@ -469,7 +298,6 @@ winKeybdProc (DeviceIntPtr pDeviceInt, int iState)
void
winInitializeModeKeyStates (void)
{
#if !WIN_NEW_KEYBOARD_SUPPORT
/* Restore NumLock */
if (GetKeyState (VK_NUMLOCK) & 0x0001)
{
@ -497,7 +325,6 @@ winInitializeModeKeyStates (void)
winSendKeyEvent (KEY_HKTG, TRUE);
winSendKeyEvent (KEY_HKTG, FALSE);
}
#endif
}
@ -510,9 +337,8 @@ winInitializeModeKeyStates (void)
void
winRestoreModeKeyStates ()
{
#if !WIN_NEW_KEYBOARD_SUPPORT
DWORD dwKeyState;
unsigned short internalKeyStates;
unsigned short internalKeyStates;
/* X server is being initialized */
if (!g_winInternalModeKeyStatesPtr)
@ -561,11 +387,9 @@ winRestoreModeKeyStates ()
winSendKeyEvent (KEY_HKTG, TRUE);
winSendKeyEvent (KEY_HKTG, FALSE);
}
#endif
}
#if !WIN_NEW_KEYBOARD_SUPPORT
/*
* Look for the lovely fake Control_L press/release generated by Windows
* when AltGr is pressed/released on a non-U.S. keyboard.
@ -596,6 +420,21 @@ winIsFakeCtrl_L (UINT message, WPARAM wParam, LPARAM lParam)
WM_KEYDOWN, WM_KEYDOWN,
PM_NOREMOVE);
/*
* Try again if the first call fails.
* NOTE: This usually happens when TweakUI is enabled.
*/
if (!fReturn)
{
/* Voodoo to make sure that the Alt_R message has posted */
Sleep (0);
/* Look for fake Ctrl_L preceeding an Alt_R press. */
fReturn = PeekMessage (&msgNext, NULL,
WM_KEYDOWN, WM_KEYDOWN,
PM_NOREMOVE);
}
/* Is next press an Alt_R with the same timestamp? */
if (fReturn && msgNext.wParam == VK_MENU
&& msgNext.time == lTime
@ -628,6 +467,21 @@ winIsFakeCtrl_L (UINT message, WPARAM wParam, LPARAM lParam)
WM_KEYUP, WM_SYSKEYUP,
PM_NOREMOVE);
/*
* Try again if the first call fails.
* NOTE: This usually happens when TweakUI is enabled.
*/
if (!fReturn)
{
/* Voodoo to make sure that the Alt_R message has posted */
Sleep (0);
/* Look for fake Ctrl_L release preceeding an Alt_R release. */
fReturn = PeekMessage (&msgNext, NULL,
WM_KEYUP, WM_SYSKEYUP,
PM_NOREMOVE);
}
/* Is next press an Alt_R with the same timestamp? */
if (fReturn
&& (msgNext.message == WM_KEYUP
@ -648,7 +502,6 @@ winIsFakeCtrl_L (UINT message, WPARAM wParam, LPARAM lParam)
/* Not a fake control left press/release */
return FALSE;
}
#endif /* WIN_NEW_KEYBOARD_SUPPORT */
/*
@ -658,7 +511,6 @@ winIsFakeCtrl_L (UINT message, WPARAM wParam, LPARAM lParam)
void
winKeybdReleaseKeys ()
{
#if !WIN_NEW_KEYBOARD_SUPPORT
int i;
/* Verify that the mi input system has been initialized */
@ -675,7 +527,6 @@ winKeybdReleaseKeys ()
/* Reset pressed flag for keys */
g_winKeyState[i] = FALSE;
}
#endif
}

97
hw/xwin/winkeybd.h
View file

@ -1,3 +1,6 @@
#if !defined(WINKEYBD_H)
#define WINKEYBD_H
/*
*Copyright (C) 1994-2000 The XFree86 Project, Inc. All Rights Reserved.
*
@ -42,97 +45,6 @@
*/
#include "../xfree86/common/xf86Keymap.h"
#if WIN_NEW_KEYBOARD_SUPPORT
/* Define the keymap structure */
typedef struct
{
DWORD dwVirtualKey;
DWORD dwXKey;
} winKeymappingRec, *winKeymappingPtr;
static const winKeymappingRec
winKeymap[] = {
{VK_BACK, XK_BackSpace},
{VK_TAB, XK_Tab},
{VK_CLEAR, XK_Clear},
{VK_RETURN, XK_Return},
{VK_LSHIFT, XK_Shift_L},
{VK_RSHIFT, XK_Shift_R},
{VK_SHIFT, XK_Shift_L},
{VK_LCONTROL, XK_Control_L},
{VK_RCONTROL, XK_Control_R},
{VK_CONTROL, XK_Control_L},
{VK_LMENU, XK_Alt_L},
{VK_RMENU, XK_Alt_R},
{VK_MENU, XK_Alt_L},
{VK_PAUSE, XK_Pause},
{VK_CAPITAL, XK_Caps_Lock},
{VK_ESCAPE, XK_Escape},
{VK_SPACE, XK_space},
{VK_PRIOR, XK_Page_Up},
{VK_NEXT, XK_Page_Down},
{VK_END, XK_End},
{VK_HOME, XK_Home},
{VK_LEFT, XK_Left},
{VK_UP, XK_Up},
{VK_RIGHT, XK_Right},
{VK_DOWN, XK_Down},
{VK_SELECT, XK_Select},
{VK_EXECUTE, XK_Execute},
{VK_SNAPSHOT, XK_Print},
{VK_INSERT, XK_Insert},
{VK_DELETE, XK_Delete},
{VK_HELP, XK_Help},
{VK_NUMPAD0, XK_KP_0},
{VK_NUMPAD1, XK_KP_1},
{VK_NUMPAD2, XK_KP_2},
{VK_NUMPAD3, XK_KP_3},
{VK_NUMPAD4, XK_KP_4},
{VK_NUMPAD5, XK_KP_5},
{VK_NUMPAD6, XK_KP_6},
{VK_NUMPAD7, XK_KP_7},
{VK_NUMPAD8, XK_KP_8},
{VK_NUMPAD9, XK_KP_9},
{VK_MULTIPLY, XK_KP_Multiply},
{VK_ADD, XK_KP_Add},
{VK_SEPARATOR, XK_KP_Separator}, // often comma
{VK_SUBTRACT, XK_KP_Subtract},
{VK_DECIMAL, XK_KP_Decimal},
{VK_DIVIDE, XK_KP_Divide},
{VK_F1, XK_F1},
{VK_F2, XK_F2},
{VK_F3, XK_F3},
{VK_F4, XK_F4},
{VK_F5, XK_F5},
{VK_F6, XK_F6},
{VK_F7, XK_F7},
{VK_F8, XK_F8},
{VK_F9, XK_F9},
{VK_F10, XK_F10},
{VK_F11, XK_F11},
{VK_F12, XK_F12},
{VK_F13, XK_F13},
{VK_F14, XK_F14},
{VK_F15, XK_F15},
{VK_F16, XK_F16},
{VK_F17, XK_F17},
{VK_F18, XK_F18},
{VK_F19, XK_F19},
{VK_F20, XK_F20},
{VK_F21, XK_F21},
{VK_F22, XK_F22},
{VK_F23, XK_F23},
{VK_F24, XK_F24},
{VK_NUMLOCK, XK_Num_Lock},
{VK_SCROLL, XK_Scroll_Lock}
};
static int g_winKeymapEntries = sizeof (winKeymap) / sizeof (winKeymappingRec);
#else /* WIN_NEW_KEYBOARD_SUPPORT */
#define WIN_KEYMAP_COLS 3
const int
@ -395,4 +307,5 @@ g_iKeyMap [] = {
/* 254 */ 0, 0, 0,
/* 255 */ 0, 0, 0
};
#endif /* WIN_NEW_KEYBOARD_SUPPORT */
#endif /* WINKEYBD_H */

21
hw/xwin/winwndproc.c
View file

@ -846,26 +846,6 @@ winWindowProc (HWND hwnd, UINT message,
winKeybdReleaseKeys ();
return 0;
#if WIN_NEW_KEYBOARD_SUPPORT
case WM_SYSKEYDOWN:
case WM_KEYDOWN:
case WM_SYSKEYUP:
case WM_KEYUP:
if (s_pScreenPriv == NULL || s_pScreenInfo->fIgnoreInput)
break;
/* Don't process keys if we are not active */
if (!s_pScreenPriv->fActive)
return 0;
winProcessKeyEvent ((DWORD)wParam, (DWORD) lParam);
return 0;
case WM_DEADCHAR:
case WM_SYSDEADCHAR:
return 0;
#else /* WIN_NEW_KEYBOARD_SUPPORT */
case WM_SYSKEYDOWN:
case WM_KEYDOWN:
if (s_pScreenPriv == NULL || s_pScreenInfo->fIgnoreInput)
@ -955,7 +935,6 @@ winWindowProc (HWND hwnd, UINT message,
winTranslateKey (wParam, lParam, &iScanCode);
winSendKeyEvent (iScanCode, FALSE);
return 0;
#endif /* WIN_NEW_KEYBOARD_SUPPORT */
case WM_HOTKEY:
if (s_pScreenPriv == NULL)