🚀 feat(kali): thanks to kalilinux.org

usr/lib/win-kex/VcXsrv/xkbdata/compat/README

@@ -0,0 +1,33 @@
+The core protocol interpretation of keyboard modifiers does not include direct
+support for multiple keyboard groups, so XKB reports the effective keyboard
+group to XKB-aware clients using some of the reserved bits in the state field
+of some core protocol events. This modified state field would not be interpreted
+correctly by XKB-unaware clients, so XKB provides a group compatibility mapping
+which remaps the keyboard group into a core modifier mask that has similar
+effects, when possible.
+
+XKB maintains three compatibility state components that are used to make
+XKB-unaware clients(*) work as well as possible:
+- The compatibility state which corresponds to the effective modifier and
+  effective group state.
+- The compatibility lookup state which is the core-protocol equivalent of the
+  lookup state.
+- The compatibility grab state which is the nearest core-protocol equivalent
+  of the grab state.
+
+Compatibility states are essentially the corresponding XKB states, but with
+the keyboard group possibly encoded as one or more modifiers.
+
+Modifiers that correspond to each keyboard group are described in this
+group compatibility map.
+
+
+----
+(*) The implementation of XKB invisibly extends the X library to use the
+keyboard extension if it is present. That means, clients that use library or
+toolkit routines to interpret keyboard events automatically use all of XKB's
+features; clients that directly interpret the state field of core-protocol
+events or the keymap directly may be affected by some of the XKB differences.
+Thus most clients can take all advantages without modification but it also
+means that XKB state can be reported to clients that have not explicitly
+requested the keyboard extension.

usr/lib/win-kex/VcXsrv/xkbdata/compat/accessx

@@ -0,0 +1,52 @@
+default partial xkb_compatibility "basic" {
+    interpret AccessX_Enable {
+	action= LockControls(controls=AccessXKeys);
+    };
+};
+
+partial xkb_compatibility "full" {
+
+    interpret AccessX_Enable {
+	action= LockControls(controls=AccessXKeys);
+    };
+
+    interpret AccessX_Feedback_Enable {
+	action= LockControls(controls=AccessXFeedback);
+    };
+
+    interpret RepeatKeys_Enable {
+	action= LockControls(controls=RepeatKeys);
+    };
+
+    interpret SlowKeys_Enable {
+	action= LockControls(controls=SlowKeys);
+    };
+
+    interpret BounceKeys_Enable {
+	action= LockControls(controls=BounceKeys);
+    };
+
+    interpret StickyKeys_Enable {
+	action= LockControls(controls=StickyKeys);
+    };
+
+    interpret MouseKeys_Enable {
+	action= LockControls(controls=MouseKeys);
+    };
+
+    interpret MouseKeys_Accel_Enable {
+	action= LockControls(controls=MouseKeysAccel);
+    };
+
+    interpret Overlay1_Enable {
+	action= LockControls(controls=Overlay1);
+    };
+
+    interpret Overlay2_Enable {
+	action= LockControls(controls=Overlay2);
+    };
+
+    interpret AudibleBell_Enable {
+	action= LockControls(controls=AudibleBell);
+    };
+};

usr/lib/win-kex/VcXsrv/xkbdata/compat/basic

@@ -0,0 +1,49 @@
+// Minimal set of symbol interpretations to provide
+// reasonable default behavior (Num lock, Shift lock,
+// Caps lock, and Mode switch) and set up the
+// automatic updating of common keyboard LEDs.
+
+default xkb_compatibility "basic" {
+
+    virtual_modifiers  NumLock,AltGr;
+
+    interpret.repeat= False;
+    setMods.clearLocks= True;
+    latchMods.clearLocks= True;
+    latchMods.latchToLock= True;
+
+    interpret Shift_Lock+AnyOf(Shift+Lock) {
+	action= LockMods(modifiers=Shift);
+    };
+
+    interpret Any+Lock {
+	action= LockMods(modifiers=Lock);
+    };
+
+    interpret Num_Lock+Any {
+	virtualModifier= NumLock;
+	action= LockMods(modifiers=NumLock);
+    };
+
+    interpret Mode_switch {
+	useModMapMods= level1;
+	virtualModifier= AltGr;
+	action= SetGroup(group=+1);
+    };
+
+    interpret Any + Any {
+	action= SetMods(modifiers=modMapMods);
+    };
+
+    group 2 = AltGr;
+    group 3 = AltGr;
+    group 4 = AltGr;
+
+    include "ledcaps"
+    include "lednum"
+    indicator "Shift Lock" {
+	!allowExplicit;
+	whichModState= Locked;
+	modifiers= Shift;
+    };
+};

usr/lib/win-kex/VcXsrv/xkbdata/compat/caps

@@ -0,0 +1,11 @@
+partial xkb_compatibility "caps_lock" {
+    // Keysym Caps_Lock locks the Lock modifier.
+    // With this definition, the keysym Caps_Lock can be used without binding
+    // the whole key to a real modifier.  This is essential when you don't
+    // want to use Caps_Lock on the first level.
+    // This should not have any compatibility issues when used together with
+    // other layouts which don't utilize this capability.
+    interpret Caps_Lock {
+        action = LockMods(modifiers = Lock);
+    };
+};

usr/lib/win-kex/VcXsrv/xkbdata/compat/complete

@@ -0,0 +1,10 @@
+default xkb_compatibility "complete" {
+    include "basic"
+    augment "iso9995"
+    augment "mousekeys"
+    augment "accessx(full)"
+    augment "misc"
+    augment "xfree86"
+    augment "level5"
+    augment "caps(caps_lock)"
+};

usr/lib/win-kex/VcXsrv/xkbdata/compat/iso9995

@@ -0,0 +1,77 @@
+// Fairly complete set of symbol interpretations
+// to provide reasonable default behavior.
+
+default partial xkb_compatibility "default" {
+
+    virtual_modifiers  LevelThree,AltGr;
+
+    interpret.repeat= False;
+    setMods.clearLocks= True;
+    latchMods.clearLocks= True;
+    latchMods.latchToLock= True;
+
+    interpret ISO_Level2_Latch+Shift {
+	useModMapMods= level1;
+	action= LatchMods(modifiers=Shift);
+    };
+
+    interpret ISO_Level3_Shift+Any {
+	useModMapMods= level1;
+	virtualModifier= LevelThree;
+	action= SetMods(modifiers=LevelThree);
+    };
+
+    interpret ISO_Level3_Shift {
+	action= SetMods(modifiers=LevelThree);
+    };
+
+    interpret ISO_Level3_Latch+Any {
+	useModMapMods= level1;
+	virtualModifier= LevelThree;
+	action= LatchMods(modifiers=LevelThree);
+    };
+
+    interpret ISO_Level3_Latch {
+	action= LatchMods(modifiers=LevelThree);
+    };
+
+    interpret ISO_Level3_Lock+Any {
+	useModMapMods= level1;
+	virtualModifier= LevelThree;
+	action= LockMods(modifiers=LevelThree);
+    };
+
+    interpret ISO_Level3_Lock {
+	action= LockMods(modifiers=LevelThree);
+    };
+
+    interpret ISO_Group_Latch {
+	useModMapMods= level1;
+	virtualModifier= AltGr;
+	action= LatchGroup(group=2);
+    };
+
+    interpret ISO_Next_Group {
+	useModMapMods= level1;
+	virtualModifier= AltGr;
+	action= LockGroup(group=+1);
+    };
+
+    interpret ISO_Prev_Group {
+	useModMapMods= level1;
+	virtualModifier= AltGr;
+	action= LockGroup(group=-1);
+    };
+    interpret ISO_First_Group {
+	action= LockGroup(group=1);
+    };
+
+    interpret ISO_Last_Group {
+	action= LockGroup(group=2);
+    };
+
+    indicator "Group 2" {
+	!allowExplicit;
+	groups= All-Group1;
+    };
+};

usr/lib/win-kex/VcXsrv/xkbdata/compat/japan

@@ -0,0 +1,45 @@
+// Japanese keyboards need the Eisu and Kana Shift
+// and Lock keys, which are typically bound to the
+// second shift level of some other modifier key.
+// These interpretations disable the default
+// interpretation (which would have these keys set
+// to the same modifier as the level one symbol).
+
+default partial xkb_compatibility "japan" {
+
+    interpret.repeat= False;
+
+    interpret Eisu_Shift+Lock {
+	action= NoAction();
+    };
+
+    interpret Eisu_toggle+Lock {
+	action= NoAction();
+    };
+
+    interpret Kana_Shift+Lock {
+	action= NoAction();
+    };
+
+    interpret Kana_Lock+Lock {
+	action= NoAction();
+    };
+};
+
+// Some Japanese keyboards have an explict
+// Kana Lock key and matching LED.
+partial xkb_compatibility "kana_lock" {
+
+    virtual_modifiers  Kana_Lock;
+
+    interpret Kana_Lock+AnyOfOrNone(all) {
+	virtualModifier= Kana_Lock;
+	useModMapMods=level1;
+	action= LockGroup(group=+1);
+    };
+
+    indicator "Kana" {
+        !allowExplicit;
+	groups= All-Group1;
+    };
+};

usr/lib/win-kex/VcXsrv/xkbdata/compat/ledcaps

@@ -0,0 +1,24 @@
+// Use the Caps Lock LED to show either
+// Caps Lock, Group, or Shift Lock state.
+
+default partial xkb_compatibility "caps_lock" {
+    indicator "Caps Lock" {
+	!allowExplicit;
+	whichModState= Locked;
+	modifiers= Lock;
+    };
+};
+
+partial xkb_compatibility "group_lock" {
+    indicator "Caps Lock" {
+	modifiers= None;
+	groups=All-group1;
+    };
+};
+
+partial xkb_compatibility "shift_lock" {
+    indicator "Caps Lock" {
+	whichModState= Locked;
+	modifiers= Shift;
+    };
+};

usr/lib/win-kex/VcXsrv/xkbdata/compat/ledcompose

@@ -0,0 +1,16 @@
+
+default partial xkb_compatibility "compose"  {
+
+    virtual_modifiers   Compose;
+
+    interpret Multi_key+Any {
+	virtualModifier= Compose;
+	action = LatchMods(modifiers=modMapMods);
+    };
+
+   indicator "Compose" {
+       allowExplicit;
+       whichModState= Latched;
+       modifiers= Compose;
+   };
+};

usr/lib/win-kex/VcXsrv/xkbdata/compat/lednum

@@ -0,0 +1,24 @@
+// Use the Num Lock LED to show either
+// Num Lock, Group, or Shift Lock state.
+
+default partial xkb_compatibility "num_lock" {
+    indicator "Num Lock" {
+	!allowExplicit;
+	whichModState= Locked;
+	modifiers= NumLock;
+    };
+};
+
+partial xkb_compatibility "group_lock" {
+    indicator "Num Lock" {
+	modifiers= None;
+	groups=All-group1;
+    };
+};
+
+partial xkb_compatibility "shift_lock" {
+    indicator "Num Lock" {
+	whichModState= Locked;
+	modifiers= Shift;
+    };
+};

usr/lib/win-kex/VcXsrv/xkbdata/compat/ledscroll

@@ -0,0 +1,24 @@
+// Use the Scroll Lock LED to show either
+// Scroll Lock, Group, or Shift Lock state.
+
+default partial xkb_compatibility "scroll_lock" {
+    indicator "Scroll Lock" {
+	allowExplicit;
+	whichModState= Locked;
+	modifiers= ScrollLock;
+    };
+};
+
+partial xkb_compatibility "group_lock" {
+    indicator "Scroll Lock" {
+	modifiers= None;
+	groups=All-group1;
+    };
+};
+
+partial xkb_compatibility "shift_lock" {
+    indicator "Scroll Lock" {
+	whichModState= Locked;
+	modifiers= Shift;
+    };
+};

usr/lib/win-kex/VcXsrv/xkbdata/compat/level5

@@ -0,0 +1,56 @@
+// Fairly complete set of symbol interpretations
+// to provide reasonable default behavior.
+
+default partial xkb_compatibility "default" {
+
+    virtual_modifiers  LevelFive;
+
+    interpret.repeat= False;
+    setMods.clearLocks= True;
+    latchMods.clearLocks= True;
+    latchMods.latchToLock= True;
+
+    interpret ISO_Level5_Shift+Any {
+	useModMapMods= level1;
+	virtualModifier= LevelFive;
+	action= SetMods(modifiers=LevelFive);
+    };
+
+    interpret ISO_Level5_Shift {
+	action= SetMods(modifiers=LevelFive);
+    };
+
+    interpret ISO_Level5_Latch+Any {
+	useModMapMods= level1;
+	virtualModifier= LevelFive;
+	action= LatchMods(modifiers=LevelFive);
+    };
+
+    interpret ISO_Level5_Latch {
+	action= LatchMods(modifiers=LevelFive);
+    };
+
+    interpret ISO_Level5_Lock+Any {
+	useModMapMods= level1;
+	virtualModifier= LevelFive;
+	action= LockMods(modifiers=LevelFive);
+    };
+
+    interpret ISO_Level5_Lock {
+	action= LockMods(modifiers=LevelFive);
+    };
+};
+
+partial xkb_compatibility "level5_lock" {
+    // This defines a Level5-Lock using the NumLock real modifier
+    // in order to create arbitrary level-behaviour, which would
+    // not be possible with the virtual modifier.
+    // See also: types/level5 : EIGHT_LEVEL_LEVEL_FIVE_LOCK
+    // See also: symbols/level5(lock)
+
+    virtual_modifiers  NumLock;
+
+    interpret ISO_Level5_Lock {
+	action = LockMods(modifiers = NumLock);
+    };
+};

usr/lib/win-kex/VcXsrv/xkbdata/compat/misc

@@ -0,0 +1,122 @@
+default partial xkb_compatibility "misc" {
+
+    virtual_modifiers  Alt,Meta,Super,Hyper,ScrollLock;
+
+    // Interpretations for some other useful keys.
+
+    interpret Terminate_Server {
+	action = Terminate();
+    };
+
+    setMods.clearLocks= True;
+
+    // Sets the "Alt" virtual modifier.
+
+    interpret Alt_L+Any {
+        //useModMapMods= level1;
+	virtualModifier= Alt;
+	action = SetMods(modifiers=modMapMods);
+    };
+
+    interpret Alt_L {
+	action = SetMods(modifiers=Alt);
+    };
+
+    interpret Alt_R+Any {
+        //useModMapMods= level1;
+	virtualModifier= Alt;
+	action = SetMods(modifiers=modMapMods);
+    };
+
+    interpret Alt_R {
+	action = SetMods(modifiers=Alt);
+    };
+
+    // Sets the "Meta" virtual modifier.
+
+    interpret Meta_L+Any {
+        //useModMapMods= level1;
+	virtualModifier= Meta;
+	action = SetMods(modifiers=modMapMods);
+    };
+
+    interpret Meta_L {
+	action = SetMods(modifiers=Meta);
+    };
+
+    interpret Meta_R+Any {
+        //useModMapMods= level1;
+	virtualModifier= Meta;
+	action = SetMods(modifiers=modMapMods);
+    };
+
+    interpret Meta_R {
+	action = SetMods(modifiers=Meta);
+    };
+
+    // Sets the "Super" virtual modifier.
+
+    interpret Super_L+Any {
+        //useModMapMods= level1;
+	virtualModifier= Super;
+	action = SetMods(modifiers=modMapMods);
+    };
+
+    interpret Super_L {
+	action = SetMods(modifiers=Super);
+    };
+
+    interpret Super_R+Any {
+        //useModMapMods= level1;
+	virtualModifier= Super;
+	action = SetMods(modifiers=modMapMods);
+    };
+
+    interpret Super_R {
+	action = SetMods(modifiers=Super);
+    };
+
+    // Sets the "Hyper" virtual modifier.
+
+    interpret Hyper_L+Any {
+        //useModMapMods= level1;
+	virtualModifier= Hyper;
+	action = SetMods(modifiers=modMapMods);
+    };
+
+    interpret Hyper_L {
+	action = SetMods(modifiers=Hyper);
+    };
+
+    interpret Hyper_R+Any {
+        //useModMapMods= level1;
+	virtualModifier= Hyper;
+	action = SetMods(modifiers=modMapMods);
+    };
+
+    interpret Hyper_R {
+	action = SetMods(modifiers=Hyper);
+    };
+
+    // Sets the "ScrollLock" virtual modifier and
+    // makes it actually lock when pressed.  Sets
+    // up a map for the scroll lock indicator.
+    interpret Scroll_Lock+Any {
+	virtualModifier= ScrollLock;
+	action = LockMods(modifiers=modMapMods);
+    };
+
+    include "ledscroll"
+
+    include "misc(assign_shift_left_action)"
+};
+
+partial xkb_compatibility "assign_shift_left_action" {
+    // Because of the irrevertable modifier mapping in symbols/pc,
+    // <LFSH> is getting bound to the Lock modifier when using
+    // symbols/shift(both_capslock), creating unwanted behaviour.
+    // This is a quirk, to circumvent the problem.
+    interpret Shift_L {
+	action = SetMods(modifiers = Shift);
+    };
+};

usr/lib/win-kex/VcXsrv/xkbdata/compat/mousekeys

@@ -0,0 +1,201 @@
+// Interpretations for arrow keys and a bunch of
+// other common keysyms which make it possible to
+// bind "mouse" keys using xmodmap and activate or
+// deactivate them from the keyboard.
+
+default partial xkb_compatibility "mousekeys" {
+
+    // Keypad actions.
+
+    interpret.repeat= True;
+
+    interpret KP_1 {
+	action = MovePtr(x=-1,y= +1);
+    };
+    interpret KP_End {
+	action = MovePtr(x=-1,y= +1);
+    };
+
+    interpret KP_2 {
+	action = MovePtr(x=+0,y= +1);
+    };
+    interpret KP_Down {
+	action = MovePtr(x=+0,y= +1);
+    };
+
+    interpret KP_3 {
+	action = MovePtr(x=+1,y=+1);
+    };
+    interpret KP_Next {
+	action = MovePtr(x=+1,y=+1);
+    };
+
+    interpret KP_4 {
+	action = MovePtr(x=-1,y=+0);
+    };
+    interpret KP_Left {
+	action = MovePtr(x=-1,y=+0);
+    };
+
+    interpret KP_6 {
+	action = MovePtr(x=+1,y=+0);
+    };
+    interpret KP_Right {
+	action = MovePtr(x=+1,y=+0);
+    };
+
+    interpret KP_7 {
+	action = MovePtr(x=-1,y=-1);
+    };
+    interpret KP_Home {
+	action = MovePtr(x=-1,y=-1);
+    };
+
+    interpret KP_8 {
+	action = MovePtr(x=+0,y=-1);
+    };
+    interpret KP_Up {
+	action = MovePtr(x=+0,y=-1);
+    };
+
+    interpret KP_9 {
+	action = MovePtr(x=+1,y=-1);
+    };
+    interpret KP_Prior {
+	action = MovePtr(x=+1,y=-1);
+    };
+
+    interpret KP_5 {
+	action = PointerButton(button=default);
+    };
+    interpret KP_Begin {
+	action = PointerButton(button=default);
+    };
+
+    interpret KP_F2 {
+	action = SetPtrDflt(affect=defaultButton,button=1);
+    };
+    interpret KP_Divide {
+	action = SetPtrDflt(affect=defaultButton,button=1);
+    };
+
+    interpret KP_F3 {
+	action = SetPtrDflt(affect=defaultButton,button=2);
+    };
+    interpret KP_Multiply {
+	action = SetPtrDflt(affect=defaultButton,button=2);
+    };
+
+    interpret KP_F4 {
+	action = SetPtrDflt(affect=defaultButton,button=3);
+    };
+    interpret KP_Subtract {
+	action = SetPtrDflt(affect=defaultButton,button=3);
+    };
+
+    interpret KP_Separator {
+	action = PointerButton(button=default,count=2);
+    };
+    interpret KP_Add {
+	action = PointerButton(button=default,count=2);
+    };
+
+    interpret KP_0 {
+	action = LockPointerButton(button=default,affect=lock);
+    };
+    interpret KP_Insert {
+	action = LockPointerButton(button=default,affect=lock);
+    };
+
+    interpret KP_Decimal {
+	action = LockPointerButton(button=default,affect=unlock);
+    };
+    interpret KP_Delete {
+	action = LockPointerButton(button=default,affect=unlock);
+    };
+
+    // Additional mappings for Solaris keypad compatibility.
+
+    interpret F25 { // aka KP_Divide
+	action = SetPtrDflt(affect=defaultButton,button=1);
+    };
+    interpret F26 { // aka KP_Multiply
+	action = SetPtrDflt(affect=defaultButton,button=2);
+    };
+    interpret F27 { // aka KP_Home
+	action = MovePtr(x=-1,y=-1);
+    };
+    interpret F29 { // aka KP_Prior
+	action = MovePtr(x=+1,y=-1);
+    };
+    interpret F31 { // aka KP_Begin
+	action = PointerButton(button=default);
+    };
+    interpret F33 { // aka KP_End
+	action = MovePtr(x=-1,y= +1);
+    };
+    interpret F35 { // aka KP_Next
+	action = MovePtr(x=+1,y=+1);
+    };
+
+    interpret.repeat= False;
+
+    // New keysym actions.
+
+    interpret Pointer_Button_Dflt {
+	action= PointerButton(button=default);
+    };
+    interpret Pointer_Button1 {
+	action= PointerButton(button=1);
+    };
+    interpret Pointer_Button2 {
+	action= PointerButton(button=2);
+    };
+    interpret Pointer_Button3 {
+	action= PointerButton(button=3);
+    };
+    interpret Pointer_DblClick_Dflt {
+	action= PointerButton(button=default,count=2);
+    };
+    interpret Pointer_DblClick1 {
+	action= PointerButton(button=1,count=2);
+    };
+    interpret Pointer_DblClick2 {
+	action= PointerButton(button=2,count=2);
+    };
+    interpret Pointer_DblClick3 {
+	action= PointerButton(button=3,count=2);
+    };
+    interpret Pointer_Drag_Dflt {
+	action= LockPointerButton(button=default);
+    };
+    interpret Pointer_Drag1 {
+	action= LockPointerButton(button=1);
+    };
+    interpret Pointer_Drag2 {
+	action= LockPointerButton(button=2);
+    };
+    interpret Pointer_Drag3 {
+	action= LockPointerButton(button=3);
+    };
+
+    interpret Pointer_EnableKeys {
+	action= LockControls(controls=MouseKeys);
+    };
+    interpret Pointer_Accelerate {
+	action= LockControls(controls=MouseKeysAccel);
+    };
+    interpret Pointer_DfltBtnNext {
+	action= SetPtrDflt(affect=defaultButton,button= +1);
+    };
+    interpret Pointer_DfltBtnPrev {
+	action= SetPtrDflt(affect=defaultButton,button= -1);
+    };
+
+    // Allow an indicator for MouseKeys.
+    indicator "Mouse Keys" {
+        //!allowExplicit;
+	indicatorDrivesKeyboard;
+	controls= MouseKeys;
+    };
+};

usr/lib/win-kex/VcXsrv/xkbdata/compat/olpc

@@ -0,0 +1,51 @@
+//
+// Map the OLPC game keys to virtual modifiers.
+//
+// Created by Bernardo Innocenti <bernie@codewiz.org>
+//
+
+default xkb_compatibility "olpc" {
+    include "complete"
+
+    virtual_modifiers  Square,Cross,Triangle,Circle;
+
+    interpret KP_Home+Any {
+        //useModMapMods= level1;
+        virtualModifier= Square;
+        action = SetMods(modifiers=modMapMods);
+    };
+
+    interpret KP_Home {
+        action = SetMods(modifiers=Square);
+    };
+
+    interpret KP_Next+Any {
+        //useModMapMods= level1;
+        virtualModifier= Cross;
+        action = SetMods(modifiers=modMapMods);
+    };
+
+    interpret KP_Next {
+        action = SetMods(modifiers=Cross);
+    };
+
+    interpret KP_End+Any {
+        //useModMapMods= level1;
+        virtualModifier= Circle;
+        action = SetMods(modifiers=modMapMods);
+    };
+
+    interpret KP_End {
+        action = SetMods(modifiers=Circle);
+    };
+
+    interpret KP_Prior+Any {
+        //useModMapMods= level1;
+        virtualModifier= Triangle;
+        action = SetMods(modifiers=modMapMods);
+    };
+
+    interpret KP_Prior {
+        action = SetMods(modifiers=Triangle);
+    };
+};

usr/lib/win-kex/VcXsrv/xkbdata/compat/pc

@@ -0,0 +1,17 @@
+default partial xkb_compatibility "pc" {
+
+    // Sets the "Alt" virtual modifier.
+
+    virtual_modifiers  Alt;
+
+    setMods.clearLocks= True;
+    interpret Alt_L+Any {
+	virtualModifier= Alt;
+	action = SetMods(modifiers=modMapMods);
+    };
+
+    interpret Alt_R+Any {
+	virtualModifier= Alt;
+	action = SetMods(modifiers=modMapMods);
+    };
+};

usr/lib/win-kex/VcXsrv/xkbdata/compat/pc98

@@ -0,0 +1,56 @@
+// Minimal set of symbol interpretations to provide
+// reasonable default behavior (Num lock, Shift lock,
+// and Mode switch) and set up the automatic updating
+// of common keyboard LEDs.
+
+default xkb_compatibility "basic" {
+
+    virtual_modifiers  NumLock,AltGr;
+
+    interpret.repeat= False;
+    setMods.clearLocks= True;
+    latchMods.clearLocks= True;
+    latchMods.latchToLock= True;
+
+    interpret Shift_Lock+AnyOf(Shift+Lock) {
+	action= LockMods(modifiers=Shift);
+    };
+
+//    interpret Any+Lock {
+//	action= LockMods(modifiers=Lock);
+//    };
+
+    interpret Num_Lock+Any {
+	virtualModifier= NumLock;
+	action= LockMods(modifiers=NumLock);
+    };
+
+    interpret Mode_switch {
+	useModMapMods= level1;
+	virtualModifier= AltGr;
+	action= SetGroup(group=2,clearLocks);
+    };
+
+    interpret Any + Any {
+	action= SetMods(modifiers=modMapMods);
+    };
+
+    group 2 = AltGr;
+    group 3 = AltGr;
+    group 4 = AltGr;
+
+    indicator.allowExplicit= False;
+    indicator "Caps Lock" {
+	whichModState= Locked;
+	modifiers= Lock;
+    };
+    indicator "Num Lock" {
+	whichModState= Locked;
+	modifiers= NumLock;
+    };
+    indicator "Shift Lock" {
+	whichModState= Locked;
+	modifiers= Shift;
+    };
+    indicator.allowExplicit= True;
+};

usr/lib/win-kex/VcXsrv/xkbdata/compat/xfree86

@@ -0,0 +1,66 @@
+// XFree86 special keysyms.
+
+default partial xkb_compatibility "basic" {
+
+    interpret.repeat= True;
+
+    interpret  XF86_Switch_VT_1 {
+        action = SwitchScreen(Screen=1, !SameServer);
+    };
+    interpret  XF86_Switch_VT_2 {
+        action = SwitchScreen(Screen=2, !SameServer);
+    };
+    interpret  XF86_Switch_VT_3 {
+        action = SwitchScreen(Screen=3, !SameServer);
+    };
+    interpret  XF86_Switch_VT_4 {
+        action = SwitchScreen(Screen=4, !SameServer);
+    };
+    interpret  XF86_Switch_VT_5 {
+        action = SwitchScreen(Screen=5, !SameServer);
+    };
+    interpret  XF86_Switch_VT_6 {
+        action = SwitchScreen(Screen=6, !SameServer);
+    };
+    interpret  XF86_Switch_VT_7 {
+        action = SwitchScreen(Screen=7, !SameServer);
+    };
+    interpret  XF86_Switch_VT_8 {
+        action = SwitchScreen(Screen=8, !SameServer);
+    };
+    interpret  XF86_Switch_VT_9 {
+        action = SwitchScreen(Screen=9, !SameServer);
+    };
+    interpret  XF86_Switch_VT_10 {
+        action = SwitchScreen(Screen=10, !SameServer);
+    };
+    interpret  XF86_Switch_VT_11 {
+        action = SwitchScreen(Screen=11, !SameServer);
+    };
+    interpret  XF86_Switch_VT_12 {
+        action = SwitchScreen(Screen=12, !SameServer);
+    };
+
+    interpret XF86LogGrabInfo {
+        action = Private(type=0x86, data="PrGrbs");
+    };
+    interpret XF86LogWindowTree {
+        action = Private(type=0x86, data="PrWins");
+    };
+
+    interpret XF86_Next_VMode {
+        action = Private(type=0x86, data="+VMode");
+    };
+    interpret XF86_Prev_VMode {
+        action = Private(type=0x86, data="-VMode");
+    };
+};
+
+partial xkb_compatibility "grab_break" {
+    interpret XF86_Ungrab {
+        action = Private(type=0x86, data="Ungrab");
+    };
+    interpret XF86_ClearGrab {
+        action = Private(type=0x86, data="ClsGrb");
+    };
+};

usr/lib/win-kex/VcXsrv/xkbdata/compat/xtest

@@ -0,0 +1,56 @@
+default xkb_compatibility "xtest" {
+
+    // Minimal set of symbol interpretations to provide
+    // reasonable behavior for testing.
+    // The X Test Suite assumes that it can set any modifier
+    // by simulating a KeyPress and clear it by simulating a
+    // KeyRelease.  Because of the way that XKB implements
+    // locking/latching modifiers, this approach fails in
+    // some cases (typically the Lock or NumLock modifiers).
+    // These symbol interpretations make all modifier keys
+    // just set the corresponding modifier so that xtest
+    // will see the behavior it expects.
+
+    virtual_modifiers  NumLock,AltGr;
+
+    interpret.repeat= False;
+    setMods.clearLocks= True;
+    latchMods.clearLocks= True;
+    latchMods.latchToLock= False;
+
+    interpret Shift_Lock+AnyOf(Shift+Lock) {
+	action= SetMods(modifiers=Shift);
+    };
+
+    interpret Num_Lock+Any {
+	virtualModifier= NumLock;
+	action= SetMods(modifiers=NumLock);
+    };
+
+    interpret Mode_switch {
+	useModMapMods= level1;
+	virtualModifier= AltGr;
+	action= SetGroup(group=2);
+    };
+
+    interpret Any + Any {
+	action= SetMods(modifiers=modMapMods);
+    };
+
+    group 2 = AltGr;
+    group 3 = AltGr;
+    group 4 = AltGr;
+
+    indicator.allowExplicit= False;
+    indicator "Caps Lock" {
+	modifiers= Lock;
+    };
+    indicator "Num Lock" {
+	modifiers= NumLock;
+    };
+    indicator "Shift Lock" {
+	whichModState= Locked;
+	modifiers= Shift;
+    };
+    indicator.allowExplicit= True;
+};