From 990bc3f015a4f8fce2eb918375defcd44980a845 Mon Sep 17 00:00:00 2001 From: marha Date: Fri, 8 Jun 2012 09:33:13 +0200 Subject: Used synchronise script to update files --- xorg-server/xkeyboard-config/compat/README | 66 ++--- xorg-server/xkeyboard-config/compat/accessx | 104 +++---- xorg-server/xkeyboard-config/compat/basic | 96 +++--- xorg-server/xkeyboard-config/compat/caps | 24 +- xorg-server/xkeyboard-config/compat/complete | 20 +- xorg-server/xkeyboard-config/compat/japan | 90 +++--- xorg-server/xkeyboard-config/compat/ledcaps | 46 +-- xorg-server/xkeyboard-config/compat/lednum | 46 +-- xorg-server/xkeyboard-config/compat/ledscroll | 46 +-- xorg-server/xkeyboard-config/compat/level5 | 102 +++---- xorg-server/xkeyboard-config/compat/misc | 244 ++++++++-------- xorg-server/xkeyboard-config/compat/mousekeys | 404 +++++++++++++------------- xorg-server/xkeyboard-config/compat/olpc | 102 +++---- xorg-server/xkeyboard-config/compat/pc | 34 +-- xorg-server/xkeyboard-config/compat/pc98 | 110 +++---- xorg-server/xkeyboard-config/compat/xtest | 114 ++++---- 16 files changed, 824 insertions(+), 824 deletions(-) (limited to 'xorg-server/xkeyboard-config/compat') diff --git a/xorg-server/xkeyboard-config/compat/README b/xorg-server/xkeyboard-config/compat/README index 00d591e7b..ea8750fac 100644 --- a/xorg-server/xkeyboard-config/compat/README +++ b/xorg-server/xkeyboard-config/compat/README @@ -1,33 +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. +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 index 26cafab7a..0ed34ced1 100644 --- a/xorg-server/xkeyboard-config/compat/accessx +++ b/xorg-server/xkeyboard-config/compat/accessx @@ -1,52 +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); - }; -}; +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 index ba7e52a6f..393c32445 100644 --- a/xorg-server/xkeyboard-config/compat/basic +++ b/xorg-server/xkeyboard-config/compat/basic @@ -1,48 +1,48 @@ -// 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=+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; - }; -}; +// 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=+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 index d787ab63d..03c47151e 100644 --- a/xorg-server/xkeyboard-config/compat/caps +++ b/xorg-server/xkeyboard-config/compat/caps @@ -1,12 +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); - }; -}; +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 index 0bf171db3..d33c4dbce 100644 --- a/xorg-server/xkeyboard-config/compat/complete +++ b/xorg-server/xkeyboard-config/compat/complete @@ -1,10 +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)" -}; +default xkb_compatibility "complete" { + include "basic" + augment "iso9995" + augment "mousekeys" + augment "accessx(full)" + augment "misc" + augment "xfree86" + augment "level5" + augment "caps(caps_lock)" +}; diff --git a/xorg-server/xkeyboard-config/compat/japan b/xorg-server/xkeyboard-config/compat/japan index e9a6728d4..ab4f85e4c 100644 --- a/xorg-server/xkeyboard-config/compat/japan +++ b/xorg-server/xkeyboard-config/compat/japan @@ -1,45 +1,45 @@ -// 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; - }; -}; +// 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/ledcaps b/xorg-server/xkeyboard-config/compat/ledcaps index fc3084eec..8e3ad4796 100644 --- a/xorg-server/xkeyboard-config/compat/ledcaps +++ b/xorg-server/xkeyboard-config/compat/ledcaps @@ -1,23 +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; - }; -}; +// 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 index 24a60a595..57fb2646e 100644 --- a/xorg-server/xkeyboard-config/compat/lednum +++ b/xorg-server/xkeyboard-config/compat/lednum @@ -1,23 +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; - }; -}; +// 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 index ca5a82c4c..d51fcfc6f 100644 --- a/xorg-server/xkeyboard-config/compat/ledscroll +++ b/xorg-server/xkeyboard-config/compat/ledscroll @@ -1,23 +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; - }; -}; +// 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 index 69296e9f0..8d28051c1 100644 --- a/xorg-server/xkeyboard-config/compat/level5 +++ b/xorg-server/xkeyboard-config/compat/level5 @@ -1,51 +1,51 @@ -// 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 { - 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); - }; -}; +// 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 { + 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/misc b/xorg-server/xkeyboard-config/compat/misc index 6a8b20217..cfe9a39b4 100644 --- a/xorg-server/xkeyboard-config/compat/misc +++ b/xorg-server/xkeyboard-config/compat/misc @@ -1,122 +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 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); - }; -}; +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 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 index bdd3d7c5d..f60c756c4 100644 --- a/xorg-server/xkeyboard-config/compat/mousekeys +++ b/xorg-server/xkeyboard-config/compat/mousekeys @@ -1,202 +1,202 @@ -// 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; - }; -}; +// 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/olpc b/xorg-server/xkeyboard-config/compat/olpc index b8fe667d2..a7a2cc425 100644 --- a/xorg-server/xkeyboard-config/compat/olpc +++ b/xorg-server/xkeyboard-config/compat/olpc @@ -1,51 +1,51 @@ -// -// 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); - }; -}; +// +// 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 index 14ba9c3cc..e970795c7 100644 --- a/xorg-server/xkeyboard-config/compat/pc +++ b/xorg-server/xkeyboard-config/compat/pc @@ -1,17 +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); - }; -}; +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 index 93a620036..f7e40014a 100644 --- a/xorg-server/xkeyboard-config/compat/pc98 +++ b/xorg-server/xkeyboard-config/compat/pc98 @@ -1,55 +1,55 @@ -// 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; -}; +// 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/xtest b/xorg-server/xkeyboard-config/compat/xtest index 6700bedd6..5ee88ccf8 100644 --- a/xorg-server/xkeyboard-config/compat/xtest +++ b/xorg-server/xkeyboard-config/compat/xtest @@ -1,57 +1,57 @@ -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; -}; +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