From d8f81c980a46279ac619312a914b563144894512 Mon Sep 17 00:00:00 2001 From: marha Date: Tue, 13 Jul 2010 07:48:55 +0000 Subject: Renamed xkbdata.src also on trunk since the current merging of subversion will loose all the changes in xkbdata.src when the directory is renamed on the source branch. --- xorg-server/xkeyboard-config/compat/Makefile.am | 15 ++ xorg-server/xkeyboard-config/compat/README | 33 ++++ xorg-server/xkeyboard-config/compat/accessx | 54 +++++++ xorg-server/xkeyboard-config/compat/basic | 52 ++++++ xorg-server/xkeyboard-config/compat/caps | 12 ++ xorg-server/xkeyboard-config/compat/complete | 12 ++ xorg-server/xkeyboard-config/compat/default.in | 13 ++ xorg-server/xkeyboard-config/compat/iso9995 | 84 ++++++++++ xorg-server/xkeyboard-config/compat/japan | 48 ++++++ xorg-server/xkeyboard-config/compat/keypad | 60 +++++++ xorg-server/xkeyboard-config/compat/ledcaps | 23 +++ xorg-server/xkeyboard-config/compat/lednum | 23 +++ xorg-server/xkeyboard-config/compat/ledscroll | 23 +++ xorg-server/xkeyboard-config/compat/level5 | 56 +++++++ xorg-server/xkeyboard-config/compat/makefile | 20 +++ xorg-server/xkeyboard-config/compat/misc | 127 +++++++++++++++ xorg-server/xkeyboard-config/compat/mousekeys | 205 ++++++++++++++++++++++++ xorg-server/xkeyboard-config/compat/norepeat | 11 ++ xorg-server/xkeyboard-config/compat/olpc | 52 ++++++ xorg-server/xkeyboard-config/compat/pc | 18 +++ xorg-server/xkeyboard-config/compat/pc98 | 62 +++++++ xorg-server/xkeyboard-config/compat/xfree86 | 57 +++++++ xorg-server/xkeyboard-config/compat/xtest | 58 +++++++ 23 files changed, 1118 insertions(+) create mode 100644 xorg-server/xkeyboard-config/compat/Makefile.am create mode 100644 xorg-server/xkeyboard-config/compat/README create mode 100644 xorg-server/xkeyboard-config/compat/accessx create mode 100644 xorg-server/xkeyboard-config/compat/basic create mode 100644 xorg-server/xkeyboard-config/compat/caps create mode 100644 xorg-server/xkeyboard-config/compat/complete create mode 100644 xorg-server/xkeyboard-config/compat/default.in create mode 100644 xorg-server/xkeyboard-config/compat/iso9995 create mode 100644 xorg-server/xkeyboard-config/compat/japan create mode 100644 xorg-server/xkeyboard-config/compat/keypad create mode 100644 xorg-server/xkeyboard-config/compat/ledcaps create mode 100644 xorg-server/xkeyboard-config/compat/lednum create mode 100644 xorg-server/xkeyboard-config/compat/ledscroll create mode 100644 xorg-server/xkeyboard-config/compat/level5 create mode 100644 xorg-server/xkeyboard-config/compat/makefile create mode 100644 xorg-server/xkeyboard-config/compat/misc create mode 100644 xorg-server/xkeyboard-config/compat/mousekeys create mode 100644 xorg-server/xkeyboard-config/compat/norepeat create mode 100644 xorg-server/xkeyboard-config/compat/olpc create mode 100644 xorg-server/xkeyboard-config/compat/pc create mode 100644 xorg-server/xkeyboard-config/compat/pc98 create mode 100644 xorg-server/xkeyboard-config/compat/xfree86 create mode 100644 xorg-server/xkeyboard-config/compat/xtest (limited to 'xorg-server/xkeyboard-config/compat') diff --git a/xorg-server/xkeyboard-config/compat/Makefile.am b/xorg-server/xkeyboard-config/compat/Makefile.am new file mode 100644 index 000000000..54a659eec --- /dev/null +++ b/xorg-server/xkeyboard-config/compat/Makefile.am @@ -0,0 +1,15 @@ +compatdir = $(xkb_base)/compat + +dist_compat_DATA = \ +accessx basic caps complete \ +default iso9995 \ +japan keypad ledcaps \ +lednum ledscroll level5 \ +misc mousekeys norepeat \ +olpc pc pc98 xfree86 \ +xtest README + +dir_data = $(dist_compat_DATA) + +include $(top_srcdir)/xkbrules.am + diff --git a/xorg-server/xkeyboard-config/compat/README b/xorg-server/xkeyboard-config/compat/README new file mode 100644 index 000000000..00d591e7b --- /dev/null +++ b/xorg-server/xkeyboard-config/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 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 state are essentially the corresponding XKB states, but with +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 +features; clients that directly interpret the state field of core protocol +events or the keymap direcly 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. diff --git a/xorg-server/xkeyboard-config/compat/accessx b/xorg-server/xkeyboard-config/compat/accessx new file mode 100644 index 000000000..3e4b46163 --- /dev/null +++ b/xorg-server/xkeyboard-config/compat/accessx @@ -0,0 +1,54 @@ +// $Xorg: accessx,v 1.3 2000/08/17 19:54:34 cpqbld Exp $ + +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); + }; +}; diff --git a/xorg-server/xkeyboard-config/compat/basic b/xorg-server/xkeyboard-config/compat/basic new file mode 100644 index 000000000..8f99c7b73 --- /dev/null +++ b/xorg-server/xkeyboard-config/compat/basic @@ -0,0 +1,52 @@ +// $Xorg: basic,v 1.3 2000/08/17 19:54:34 cpqbld Exp $ + +// Minimal set of symbol interpretations to provide +// reasonable default behavior (Num lock, shift and +// caps lock and mode switch) and set up the +// automatic updating of common keyboard LEDs. + +// $XFree86: xc/programs/xkbcomp/compat/basic,v 1.2 2000/11/06 19:24:10 dawes Exp $ + +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; + }; +}; diff --git a/xorg-server/xkeyboard-config/compat/caps b/xorg-server/xkeyboard-config/compat/caps new file mode 100644 index 000000000..d787ab63d --- /dev/null +++ b/xorg-server/xkeyboard-config/compat/caps @@ -0,0 +1,12 @@ +partial xkb_compatibility "caps_lock" { + // Keysym Caps_Lock locks Lock modifier. + // With this, 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); + }; +}; diff --git a/xorg-server/xkeyboard-config/compat/complete b/xorg-server/xkeyboard-config/compat/complete new file mode 100644 index 000000000..dd49a5c43 --- /dev/null +++ b/xorg-server/xkeyboard-config/compat/complete @@ -0,0 +1,12 @@ +// $XKeyboardConfig$ +// $Xorg: complete,v 1.3 2000/08/17 19:54:34 cpqbld Exp $ +default xkb_compatibility "complete" { + include "basic" + augment "iso9995" + augment "mousekeys" + augment "accessx(full)" + augment "misc" + augment "xfree86" + augment "level5" +}; + diff --git a/xorg-server/xkeyboard-config/compat/default.in b/xorg-server/xkeyboard-config/compat/default.in new file mode 100644 index 000000000..5355e1318 --- /dev/null +++ b/xorg-server/xkeyboard-config/compat/default.in @@ -0,0 +1,13 @@ +// $XKeyboardConfig$ +// $Xorg: default,v 1.3 2000/08/17 19:54:34 cpqbld Exp $ +default xkb_compatibility "default" { + include "basic" + augment "mousekeys" + augment "accessx(basic)" + augment "misc" + augment "iso9995" + augment "level5" +// ??should be changed/renamed/removed +// augment "xfree86" + augment "japan" +}; diff --git a/xorg-server/xkeyboard-config/compat/iso9995 b/xorg-server/xkeyboard-config/compat/iso9995 new file mode 100644 index 000000000..d513c1ce4 --- /dev/null +++ b/xorg-server/xkeyboard-config/compat/iso9995 @@ -0,0 +1,84 @@ +// $Xorg: iso9995,v 1.3 2000/08/17 19:54:34 cpqbld Exp $ + +// Fairly complete set of symbol interpretations +// to provide reasonable default behavior + +// $XFree86: xc/programs/xkbcomp/compat/iso9995,v 1.3 2003/02/21 03:16:34 dawes Exp $ + +default partial xkb_compatibility "default" { + virtual_modifiers LevelThree,AltGr; + + interpret.repeat= False; + setMods.clearLocks= True; + latchMods.clearLocks= True; + latchMods.latchToLock= True; + + interpret ISO_Lock+Any { + action= ISOLock(affect= all,modifiers=modMapMods); + }; + + 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; + }; +}; diff --git a/xorg-server/xkeyboard-config/compat/japan b/xorg-server/xkeyboard-config/compat/japan new file mode 100644 index 000000000..00187d00f --- /dev/null +++ b/xorg-server/xkeyboard-config/compat/japan @@ -0,0 +1,48 @@ +// $Xorg: japan,v 1.3 2000/08/17 19:54:34 cpqbld Exp $ + +// Japanese keyboards need Eisu and Kana shift and +// lock keys, which are typically bound to the +// second shift level for some other modifier key. +// These interpretations disable the default +// interpretation (which would have these keys set +// 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 & 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; + }; +}; + diff --git a/xorg-server/xkeyboard-config/compat/keypad b/xorg-server/xkeyboard-config/compat/keypad new file mode 100644 index 000000000..469edec28 --- /dev/null +++ b/xorg-server/xkeyboard-config/compat/keypad @@ -0,0 +1,60 @@ +// $Xorg: keypad,v 1.3 2000/08/17 19:54:34 cpqbld Exp $ + +// Interpretations needed to implement the numeric keypad +// as an overlay instead of a modifier. + +partial hidden xkb_compatibility "overlay" { + include "keypad(overlay1)" +}; +partial hidden xkb_compatibility "overlay1" { + virtual_modifiers NumLock,AltGr; + + interpret.repeat= False; + setMods.clearLocks= True; + latchMods.clearLocks= True; + latchMods.latchToLock= True; + + interpret Num_Lock { + virtualModifier= NumLock; + action= LockControls(ctrls=overlay1); + }; + interpret Num_Lock+Any { + virtualModifier= NumLock; + action= LockControls(ctrls=overlay1); + }; + + indicator.allowExplicit= True; + indicator.driveskbd= True; + replace indicator "Num Lock" { + whichModState= Locked; + modifiers= NumLock; + controls= Overlay1; + }; + indicator.allowExplicit= True; +}; +partial hidden xkb_compatibility "overlay2" { + virtual_modifiers NumLock,AltGr; + + interpret.repeat= False; + setMods.clearLocks= True; + latchMods.clearLocks= True; + latchMods.latchToLock= True; + + interpret Num_Lock { + virtualModifier= NumLock; + action= LockControls(ctrls=overlay2); + }; + interpret Num_Lock+Any { + virtualModifier= NumLock; + action= LockControls(ctrls=overlay1); + }; + + indicator.allowExplicit= True; + indicator.driveskbd= True; + replace indicator "Num Lock" { + whichModState= Locked; + modifiers= NumLock; + controls= Overlay2; + }; + indicator.allowExplicit= True; +}; diff --git a/xorg-server/xkeyboard-config/compat/ledcaps b/xorg-server/xkeyboard-config/compat/ledcaps new file mode 100644 index 000000000..fc3084eec --- /dev/null +++ b/xorg-server/xkeyboard-config/compat/ledcaps @@ -0,0 +1,23 @@ +// Use 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; + }; +}; diff --git a/xorg-server/xkeyboard-config/compat/lednum b/xorg-server/xkeyboard-config/compat/lednum new file mode 100644 index 000000000..24a60a595 --- /dev/null +++ b/xorg-server/xkeyboard-config/compat/lednum @@ -0,0 +1,23 @@ +// Use 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; + }; +}; diff --git a/xorg-server/xkeyboard-config/compat/ledscroll b/xorg-server/xkeyboard-config/compat/ledscroll new file mode 100644 index 000000000..ca5a82c4c --- /dev/null +++ b/xorg-server/xkeyboard-config/compat/ledscroll @@ -0,0 +1,23 @@ +// Use 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; + }; +}; diff --git a/xorg-server/xkeyboard-config/compat/level5 b/xorg-server/xkeyboard-config/compat/level5 new file mode 100644 index 000000000..47693549f --- /dev/null +++ b/xorg-server/xkeyboard-config/compat/level5 @@ -0,0 +1,56 @@ +// $XKeyboardConfig$ +// $Xorg: level5,v 1.3 2000/08/17 19:54:34 cpqbld Exp $ + +// Fairly complete set of symbol interpretations +// to provide reasonable default behavior + +// $XFree86: xc/programs/xkbcomp/compat/iso9995,v 1.3 2003/02/21 03:16:34 dawes Exp $ + +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 { + virtualModifier= LevelFive; + action= LatchMods(modifiers=LevelFive); + }; + + interpret ISO_Level5_Latch { + action= LatchMods(modifiers=LevelFive); + }; + + interpret ISO_Level5_Lock+Any { + 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); + }; +}; diff --git a/xorg-server/xkeyboard-config/compat/makefile b/xorg-server/xkeyboard-config/compat/makefile new file mode 100644 index 000000000..225163288 --- /dev/null +++ b/xorg-server/xkeyboard-config/compat/makefile @@ -0,0 +1,20 @@ +ifeq ($(MAKESERVER),1) +$(error Please do not specify MAKESERVER=1) +endif + +THISDIR=compat + +DESTDIR=$(MHMAKECONF)\xorg-server\xkbdata\$(THISDIR) + +dist_xkbdata_compat_DATA = \ +accessx basic caps complete \ +default iso9995 \ +japan keypad ledcaps \ +lednum ledscroll level5 \ +misc mousekeys norepeat \ +olpc pc pc98 xfree86 \ +xtest README + +DATA_FILES=$(dist_xkbdata_compat_DATA:%=$(DESTDIR)\%) + +include ..\xkbrules.mak diff --git a/xorg-server/xkeyboard-config/compat/misc b/xorg-server/xkeyboard-config/compat/misc new file mode 100644 index 000000000..68cda9594 --- /dev/null +++ b/xorg-server/xkeyboard-config/compat/misc @@ -0,0 +1,127 @@ +// $XdotOrg: xc/programs/xkbcomp/compat/misc,v 1.1.4.4 2004/03/05 13:41:28 eich Exp $ +// $Xorg: misc,v 1.3 2000/08/17 19:54:34 cpqbld Exp $ +// +// +// +// $XFree86: xc/programs/xkbcomp/compat/misc,v 1.4 2003/05/15 13:31:57 pascal Exp $ + +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" +}; + +partial xkb_compatibility "assign_shift_left_action" { + // Because of the irrevertable modifier mapping in symbols/pc 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); + }; +}; diff --git a/xorg-server/xkeyboard-config/compat/mousekeys b/xorg-server/xkeyboard-config/compat/mousekeys new file mode 100644 index 000000000..fbd2b889a --- /dev/null +++ b/xorg-server/xkeyboard-config/compat/mousekeys @@ -0,0 +1,205 @@ + +// $Xorg: mousekeys,v 1.3 2000/08/17 19:54:34 cpqbld Exp $ + +// 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; + }; +}; diff --git a/xorg-server/xkeyboard-config/compat/norepeat b/xorg-server/xkeyboard-config/compat/norepeat new file mode 100644 index 000000000..07b0b7a60 --- /dev/null +++ b/xorg-server/xkeyboard-config/compat/norepeat @@ -0,0 +1,11 @@ +// $Xorg: norepeat,v 1.3 2000/08/17 19:54:34 cpqbld Exp $ + +// Put any otherwise normal keys that you don't want to repeat in +// this file + +default partial xkb_compatibility "norepeat" { + interpret Return { + action= NoAction(); + repeat= False; + }; +}; diff --git a/xorg-server/xkeyboard-config/compat/olpc b/xorg-server/xkeyboard-config/compat/olpc new file mode 100644 index 000000000..001da12c1 --- /dev/null +++ b/xorg-server/xkeyboard-config/compat/olpc @@ -0,0 +1,52 @@ +// $XKeyboardConfig$ +// +// Created by Bernardo Innocenti +// +// Map the OLPC game keys to virtual modifiers +// + +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); + }; +}; diff --git a/xorg-server/xkeyboard-config/compat/pc b/xorg-server/xkeyboard-config/compat/pc new file mode 100644 index 000000000..5ce7d767d --- /dev/null +++ b/xorg-server/xkeyboard-config/compat/pc @@ -0,0 +1,18 @@ +// $Xorg: pc,v 1.3 2000/08/17 19:54:34 cpqbld Exp $ +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); + }; +}; diff --git a/xorg-server/xkeyboard-config/compat/pc98 b/xorg-server/xkeyboard-config/compat/pc98 new file mode 100644 index 000000000..23f3f7987 --- /dev/null +++ b/xorg-server/xkeyboard-config/compat/pc98 @@ -0,0 +1,62 @@ +// $Xorg: pc98,v 1.3 2000/08/17 19:54:34 cpqbld Exp $ + + + + +// $XFree86: xc/programs/xkbcomp/compat/pc98,v 3.1 1997/10/26 13:25:33 dawes Exp $ + +// Minimal set of symbol interpretations to provide +// reasonable default behavior (Num lock, shift and +// 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=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; +}; diff --git a/xorg-server/xkeyboard-config/compat/xfree86 b/xorg-server/xkeyboard-config/compat/xfree86 new file mode 100644 index 000000000..2da65fd6a --- /dev/null +++ b/xorg-server/xkeyboard-config/compat/xfree86 @@ -0,0 +1,57 @@ +// $XFree86$ +// 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 XF86_Ungrab { + action = Private(type=0x86, data="Ungrab"); + }; + interpret XF86_ClearGrab { + action = Private(type=0x86, data="ClsGrb"); + }; + interpret XF86_Next_VMode { + action = Private(type=0x86, data="+VMode"); + }; + interpret XF86_Prev_VMode { + action = Private(type=0x86, data="-VMode"); + }; +}; diff --git a/xorg-server/xkeyboard-config/compat/xtest b/xorg-server/xkeyboard-config/compat/xtest new file mode 100644 index 000000000..a35ced915 --- /dev/null +++ b/xorg-server/xkeyboard-config/compat/xtest @@ -0,0 +1,58 @@ +// $Xorg: xtest,v 1.3 2000/08/17 19:54:34 cpqbld Exp $ +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 num lock 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; +}; -- cgit v1.2.3