Dimanche 26 décembre 2021

Extension de «X keyboard»

Traduction de X keyboard extension du Wiki de archlinux. J'ai utilisé l'excellent DeepL comme outil d'aide à la traduction.

L'extension du clavier de XWindow X keyboard extension ou XKB, définit la manière dont les codes de clavier sont traités dans X et fournit l'accès aux tables de traduction internes. Il s'agit du mécanisme de base qui permet d'utiliser plusieurs dispositions.

Cet article décrit comment créer et modifier des dispositions de clavier. Si vous cherchez plutôt comment configurer votre clavier, voyez X keyboard configuration(en).

Attention :

Pendant que vous travaillez avec XKB, il est possible que votre serveur X se bloque ou se plante, ou que votre clavier devienne inutilisable, ce qui ne peut être rétabli qu'en terminant votre session actuelle. Avant d'effectuer des changements, veuillez suivre les «Précautions et préparations» pour vous assurer que vous pouvez récupérer.

Précautions et préparations

Pour vous préparer à l'éventualité d'un plantage de votre serveur X ou d'une mise hors service de votre clavier :

Astuce

Pour rendre le débogage plus facile, arrêtez des applications telles que xxkb qui changent de disposition de clavier ou qui modifient l'état de XKB.

Obtenir et modifier les dispositions de clavier XCB

Utiliser «rules»

Jetez un œil sur les fichiers *.lst dans /usr/share/xkb/rules ou à XKB Homepage pour avoir une idée sur comment configurer les règles. Votre propre configuration peut être placée dans /etc/X11/xorg.conf.d/.

Par exemple, on peut vouloir réaffecter la touche de verrouillage des majuscules @Caps Lock) à la touche d'échappement (Échap) :

90-custom-kbd.conf
 
Section "InputClass"
    Identifier "keyboard defaults"
    MatchIsKeyboard "on"
 
    Option "XKbOptions" "caps:escape"
EndSection

Utiliser «keymap»

Utilisez xkbcomp (paquet xorg-xkbcom) pour manipuler les donnés de XKB. Pour obtenir la configuration courante, faites :

$ xkbcomp $DISPLAY output.xkb

Pour recharger les données vers le serveur X, faites :

$ xkbcomp input.xkb $DISPLAY

Obervez que sans $DISPLAY comme second paramètre, xkbcomp va essayer de compiler le fichier .xkb (rarement utile) en un fichier .xkm sans rien envoyer au serveur. Il va cependant analyser la syntaxe et renvoyer les erreurs éventuelles.

Lorsque la disposition de clavier est prête, enregistrez-la sous ~/.Xkeymap faites la charger par ~/.xinitrc au démarrage :

~/.xinitrc
 
...
 
test -f ~/.Xkeymap && xkbcomp ~/.Xkeymap $DISPLAY*

Le nom du fichier .Xkeymap n'a pas d'importance, on peut en choisir un autre. Notez que contrairement à la configuration standard du système via xorg.conf, il s'agit d'un keymap propre à l'utilisateur. De plus on peut modifier la configuration pendant que X est en cours d'utilisation.

Informations de base sur XKB

Le cœur du fonctionnement de XKB est assez simple, mais il est nécessaire d'avoir une idée de comment il marche avant de commencer à travailler avec les keymap.

Outils et valeurs

Utilisez xev (paquet xorg-xev pour retrouver les keycodes et découvrir comment votre disposition de clavier fonctionne.

Simple extrait :

KeyPress event, serial 45, synthetic NO, window 0x2200001,
   root 0xad, subw 0x0, time 183176240, (796,109), root:(867,413),
   state 0x1, keycode 21 (keysym 0x2b, plus), same_screen YES,
   XLookupString gives 1 bytes: (2b) "+"
   XmbLookupString gives 1 bytes: (2b) "+"
   XFilterEvent returns: False

Notez le keycode 21, l'état 0x1 et le keysym 0x2b alias plus. Le keycode 21 est ce que le périphérique d'entrée a fourni à X, typiquement un index de touche physique en quelque sorte. L'état représente les touches modificatrices, 0x01 correspond à Shift. Le code de la touche et la valeur de l'état sont ce que X envoie à l'application dans la structure XKeyEvent. Le Keysym et la chaîne correspondante sont ce que le client obtient en utilisant XLookupString et ses amis.

Les bits du champ d'état state ont des noms prédéfinis : Shift, Lock, Control, Mod1, Mod2, Mod3, Mod4 et Mod5, en allant du plus bas au plus élevé. Ainsi Ctrl+Shift correspond à 0x05, etc. Les applications clientes ne vérifient généralement que les bits qui les intéresse de sorte qu'une application avec une entrée clavier normale et des raccourcis clavier Ctrl+ ne fait généralement aucune distinction entre les états Control et Control+Mod3.

Les keysym sont aussi de type numérique. Beaucoup d'entre eux ont des noms, déclarés dans /usr/include/X11/keysymdef.h avec comme préfixe KP_ Cependant, le nombre est ce que les clients reçoivent réellement. Les Keysyms ne sont importants que lorsqu'une application attend des valeurs particulières ; il s'agit généralement de touches comme les flèches, la touche Entrée, la touche Retour arrière, les touches de fonction et divers raccourcis. Pour le reste, la chaîne de caractères est utilisée.

Traduction des «keycode»

XKB travaille principalement au stade de XLookupString, transformant le code de touche en keysym en fonction des valeurs de group et de state :

(keycode, group, state) → keysym

group correspond à la disposition comme Anglais-US, Français(Azerty), Russe, Grec etc. Il ne peut y avoir que 4 groupes au plus.

En interne, la traduction comporte d'autres étapes :

   (keycode [, group]) → type
   (state, type) → level
   (keycode, group, level) → S[keycode][group][level]

où S est la table de traduction (nommée xkb_symbols, voir ci-dessous).

Les type servent à indiquer quels modificateurs affectent la touche; il s'agit essentiellement d'un moyen de réduire la troisième dimension de S. Par exemple une touche de caractère alphanumérique ne peut être affectée que par Shift, donc son type est défini par TOW_LEVEL, et

(state, TWO_LEVEL) → level = ((state >> 0) & 0x01) = state & 0x01

qui est soit 0, soit 1. Donc c'est S[keycode][0..4][0..1] au lieu de S[keycode][0..4][0..255].

«keysym» et «state»

En termes de X, a et Ctrl+a ont le même keysym et des state différents, alors que a et A ont des keysym disctincts.

Généralement c'est le rôle de XKB de fournir les keysym, et c'est à l'application de gérer les états state.

Aussi, les états state dans XKB ont en quelque sorte un effet différé, c'est pourquoi on doit définir l'état avant d'appuyer sur une touche.

Exemple : Ctrl+h peut être configuré pour agir comme un Retour arrière (   ←) dans la configuration de rxvt. De cette manière rxvt recevra h comme keysym avec le bit de Control placé, ce qui est clairement différent du symbole Backspace. Alternativement XKB peut générer à partir de Ctrl+h un Backspace avec le bit de Control placé. Dans ce cas rxvt n'y verra aucune différence. Obtenir de XKB la génération d'un keysym Bacspace sans bit de Control est possible mais c'est plus difficile à implémenter.

Actions

Le keysym obtenu par la table ci-dessus peut aussi déclencher une action.

(keysym, state) → action

Pour XKB mettre ou verrouiller un bit modificateur est une action, de même que toute interaction avec le serveur, comme le changement de console, le déplacement du curseur, etc. Géneralement les actions n'affectent pas les keysym et la génération d'un keysym n'est pas une action.

Il n'y a qu'une action possible par paire (keysym, state).

Édition de la disposition du clavier (layout)

Commencez par la configuration de votre serveur et dans la mesure du possible effectuez les changements progressivement tout en les testant.

Le fichier .xkb produit par xkbcomp est un simple fichier texte. Les commentaires utilisent le style C++ (// commentaire). Les sections comme dans xkb_keycodes peuvent être ignorées pour l'instant.

xkb_keycodes

Définition des keycodes symboliques. Le reste du fichier n'utilise pas les keycodes numériques mais seulement ces codes symboliques.

C'est une bonne idée de ne laisser ici que les définitions des touches que le clavier possède réellement.

Ces étiquette sont arbitraires. Elles ne sont utilisées que dans la section xkb_symbols.

xkb_types

Cette section vient avant xkb_symbols, alors jetez-y un coup d'œil, mais essayez de ne pas encore faire de changements. Les types standards dépendent beaucoup des modificateurs virtuels, qui seront expliqués plus tard. Pour l'instant, trouvez simplement les types dont vous avez besoin. Commencez par les suivants : ONE_LEVEL, TWO_LEVEL, ALPHABETIC.

Les touches ONE_LEVEL ne sont pas affectées par les modificateurs ; il s'agit généralement des touches Enter, Space, Escape, F, Shift/Alt/Ctrl et ainsi de suite. Les touches TWO_LEVEL et ALPHABETIC produisent des keysyms différents selon l'état de Shift. Toutes les touches alphanumériques sont de ces types. ALPHABETIC respecte en outre le verrouillage des majuscules.

La description des types eux-mêmes est assez simple. La ligne

modifiers= Shift+NumLock+LevelThree;

signifie que les touches de ce type ne sont concernées que par Shift, NumLock et LevelThree.

Les lignes Map telle que :

map[Shift+LevelThree]= Level4;

définit que telle combinaison correspond à tel niveau (level). Xkbcomp utilise "LevelN" lors de l'extraction des données, mais on pourrait aussi bien les nommer simplement N.

Les lignes level_name peuvent être ignorées.

xkb_compatibility

Définitions d'action (interpret) et des leds du clavier (indicator) parmi d'autres choses. Vous pouvez effacer les parties dont vous n'avez pas besoin comme les actions du pavé numérique, la simulation du contrôle de la souris, ou des modificateurs supplémentaires.

Notez que key+AnyOfOrNone(all) est tout simplement équivalent à key, qui est beaucoup plus simple.

Vérifier les commutations de groupes si vous en avez besoin. LockGroup(group=N) peut être utile si vous avez quatre groupes, sinon ISO_Next_Group ou ISO_Prev_Group suffisent.

LatchGroup peut être utile pour des configurations spécifiques.

xkb_symbols

La section principale qui définit ce que chaque touche fait. Syntaxe :

key <LABL> { [ G1L1, G1L2, G1L3, ... ], [ G2L1, G2L2, G2L3, ... ], ... }

<LABL est le nom symbolique de la touche défini dans la section xkb_keycodes, GiLj est le keysym pour le groupe i niveau j. Le nombre de keysym doit correspondre au nombre de niveaux (level) défini pour ce type (sinon xkbcomp vous préviendra).

Examiner /usr/include/X11/keysymdef.h pour avoir la liste des keysyms possibles. En outre vous pouvez des symboles unicode de la forme Uxxxx, e.g. ́́U0301 pour composer un accent aigu. Notez que a et U0061 sont traités différemment, par exemple la plupart des applications attendent Ctrl+a et non Ctrl+U0061 parce que leurs valeurs numériques diffèrent.

Le type des touches sont aussi spécifiés dans cette section par :

   key.type = "T1";
   key <...> { ... };
   key <...> { ... };
   key <...> { ... };
   key.type = "T2";
   key <...> { ... };
   key <...> { ... };

ou individuellement

key <...> { type = "T", [ .... ], [ .... ] };

Le type de touche peut différer d'un groupe à l'autre. Ceci peut sembler contre intuitif, mais a en fait quelques applications utiles. Pour celà utilisez :

   key <...> { type[1] = "T1", type[2] = "T2", [ ... ], [ ... ] };

Vous pouvez utiliser des étiquettes pour les groupes comme suit :

   name[1] = "EN";     // group 1
   name[2] = "RU";     // group 2
   name[3] = "UA";     // group 3

C'est ce que xxkb affichera si les étiquettes sont définies ici.

La section comprend aussi des lignes modifier_map. Laissez-les de côté pour l'instant ou examinez Virutal Modifiers plus bas.

xkb_geometry

Cette section est destinée à l'impression de la disposition du clavier avec l'application xkbprint. Elle peut être ignorée ici et même supprimée complètement.

Exemples basiques

Simple assignation d'une touche

Activation de touches supplémentaires (multimédia) :

xkb_keycodes {
   <VOL-> = 122;       // check with xev
   <VOL+> = 123;
}
 
xkb_symbols {
   key.type = "ONE_LEVEL";
   key <VOL-> { [ XF86AudioLowerVolume ] };
   key <VOL+> { [ XF86AudioRaiseVolume ] };
}

Échap en , essentiellement pour les utilisateurs de Vim :

key.type = "ONE_LEVEL";
key <CAPS> { [ Escape ] };

Échange de Ins et impécr parfois inversées sur les portables Dell

key.type = "ONE_LEVEL";
key <INS>  { [    Print ] };
key <PRSC> { [   Insert ] };

Ça ne marche pas sur certains HP. À la place, les keycodes eux-même doivent être rredéfinis :

partial xkb_keycodes "insert" {
   alias <I118> = <IN?>;
   <INS>  = 218;
   <I218> = 118;
};

Modifier Shift en touche collante :

remplacer

key <LFSH> {         [         Shift_L ] };

par

key <LFSH> {         [         ISO_Level2_Latch ] };

Vous devez alors ajouter à /usr/share/X11/xkb/compat/basic ceci :

interpret ISO_Level2_Latch+AnyOf(all) {
   useModMapMods=level1;
   action= LatchMods(modifiers=Shift,clearLocks,latchToLock);
};
interpret ISO_Level2_Latch+AnyOfOrNone(all) {
   action= LatchMods(modifiers=Shift,clearLocks,latchToLock);
};

Dispositons de clavier multiples

Pour les touches alphanumériques ordinaires, ajoutez juste une deuxième, troisième, quatrième section à la définition de la clé.

key.type = "ALPHABETIC";
key <AD01> { [ q, Q ], [ a, A ] };      // QWERTY-AZERTY
 
key <AC02> { [        s,        S ],        // two cyrillic layouts
			[    U044B,    U042B ],
			[    U0456,    U0406 ] };

La commutation entre les dispositions est obtenue en activant l'action LockGroup :

interpret ISO_Next_Group { action = LockGroup(group=+1); };
interpret ISO_Prev_Group { action = LockGroup(group=-1); };

Ça veut dire qu'on place ISO_Next_Group et ISO_Prev_Group dans le bon group/level. Notez que les groupes cyclent, ainsi si vous avez deux groupes et que vous tapez deux foix ISO_Next_Group vous revenez au premier groupe.

Cycler entre deux groupes ou plus se fait avec une touche dédiée par :

key.type = "ONE_LEVEL";
key <RWIN> { [ ISO_Next_Group ] }

Si vous avez plus de deux dispositions de clavier et des touches à perdre, une bonne idée serait de dédier une touche à chaque groupe :

key.type = "ONE_LEVEL";
key <RCTL> { [ ISO_Next_Group ],    // g1: switch to g2
			[ ISO_Prev_Group ],    // g2: switch back to g1
			[ ISO_Prev_Group ] };  // g3: switch to g2
 
key <MENU> { [ ISO_Prev_Group ],    // g1: switch to g3
			[ ISO_Next_Group ],    // g2: switch to g3
			[ ISO_Next_Group ] };  // g3: switch back to g1

Avec quatre groupes, vous avez peut-être intérêt à utiliser ISO_Next_Group et ISO_Prev_Group.

La même idée peut s'implémenter avec une seule touche en utilisant le type TWO_LEVEL :

key.type = "TWO_LEVEL";
key <MENU> { [ ISO_Next_Group, ISO_Prev_Group ],   
             [ ISO_Prev_Group, ISO_Next_Group ],   
             [ ISO_Prev_Group, ISO_Next_Group ] }; 

De cette façon on a Menu pour le groupe 2 et Shift-Menu pour le groupe 3. Pour utiliser Ctrl ou Alt à la place de Shift, remplacez TWO_LEVEL respectivment par PC_CONTROL_LEVEL2 ou PC_ALT_LEVEL2.

Basculer en utilisant deux touches de modificateurs (Shif+Shift, Ctrl+Shift, etc.)peut s'obtenir en utilisant quelque chose d'autre que ONE_ELVEL pour ces touches, exemple de Shift+Shift :

key.type = "TWO_LEVEL";

key { [ Shift_L, ISO_Prev_Group ] };

key { [ Shift_R, ISO_Next_Group ] };e

Une touche collante peut s'obtenir avec l'action LatchGroup liée à symbole de touche ISO_Group_Latch :

key <RCTL> { [ ISO_Group_Latch ] }

Ajustez la définition de ISO_Group_Latch dans xkb_compatibility pour utiliser le bon groupe :

interpret ISO_Group_Latch { action = LatchGroup(group=3); };

Examinez /usr/share/X11/xkb/symbols/group pour avoir davantage d'exemples classiques.

Capitales hijk à la manière de Vim

Creating keymappings that clear modifiers from the keypress is necessary if the target key is to be used in keyboard shortcuts. For instance, highlighting text from the main keyboard (Shift+Left), or changing chats in most messengers (Alt+Down) will not work if there is an additional Caps modifier sent. However, an additional modifier must be sent if a user rebinds a letter key by simply putting the keysym in the symbols section. Rebinding as follows permits functionality like AHK's blind command.

The types section (which defines layer mapping) must contain an entry such that:

Add this to the bottom of your types section:

 xkb_types "complete" {
   ...
   type "CUST_CAPSLOCK" {
       modifiers= Shift+Lock; 
       map[Shift] = Level2;            //maps shift and no Lock. Shift+Alt goes here, too, because Alt isn't in modifiers.
       map[Lock] = Level3;
       map[Shift+Lock] = Level3;       //maps shift and Lock. Shift+Lock+Alt goes here, too.
       level_name[Level1]= "Base";
       level_name[Level2]= "Shift";
       level_name[Level3]= "Lock";
   };
 };

Now change caps from a lock (toggle) to a set (press) by modifying the already existing definition in compatability from LockMods to SetMods:

(Note that this means you cannot use capslock like normal)

 xkb_compatibility "complete" {
   ...
   interpret Caps_Lock+AnyOfOrNone(all) {
       action= SetMods(modifiers=Lock);
   };
   ...
 };

Finally, modify your symbols file as follows.

xkb_symbols "pc_us_inet(evdev)" {
   ...
key <AC06> {
   type= "CUST_CAPSLOCK",
   symbols[Group1]= [           h,           H,               Left],
   actions[Group1]= [  NoAction(),  NoAction(), RedirectKey(keycode=<LEFT>, clearmods=Lock) ]
   };

Symboles supplémentaires

Taper plus avec les mêmes touches.

Touche de composition

Facile à configurer et extrèmement utile pour saisir les caractères Unicode usuels.

key <RALT> { [ Multi_key ] };
Niveau Level3

L'idée est similaire à Alt ou AltGr dans leur sens originel : les touches alphanumériques ont des caractères supplémentaires, obtenues en appuyant sur certaines touches modificatrices.

Pour commencer mettons en place le modificateur.

xkb_symbols { 
   key <LWIN> { [ISO_Level3_Shift ] };
   modifier_map Mod5 { ISO_Level3_Shift };
}

En outre, ce qui suit devrait déjà être déjà défini dans les sections concernées, mais au cas où ce ne serait pas le cas :

xkb_compatibility {
   interpret ISO_Level3_Shift { action= SetMods(modifiers=Mod5); };
}
 
xkb_types {
   type "THREE_LEVEL" {
	   modifiers= Shift+Mod5;
	   map[Shift]= Level2;
	   map[Mod5]= Level3;
	   map[Shift+Mod5]= Level3;
	   level_name[Level1]= "Base";
	   level_name[Level2]= "Shift";
	   level_name[Level3]= "Level3";
   };
   type "FOUR_LEVEL" {
	   modifiers= Shift+LevelThree;
	   map[Shift]= Level2;
	   map[LevelThree]= Level3;
	   map[Shift+LevelThree]= Level4;
	   level_name[Level1]= "Base";
	   level_name[Level2]= "Shift";
	   level_name[Level3]= "Alt Base";
	   level_name[Level4]= "Shift Alt";
   };
}

Notez que les définitions standard ont LevelThree au lieu de Mod5 dans xkb_compatibility et xkb_types. Tant que modifier_map ci-dessus utilise Mod5, il n'y a pas de différence pratique, vous finirez par utiliser le bit de Mod5 de toute façon.

Maintenant, les touches elles-mêmes, les curseurs de style vi dans ce cas :

key.type = "THREE_LEVEL";
key <AC06> { [ h, H,  Left ] };
key <AC07> { [ j, J,  Down ] };
key <AC08> { [ k, K,    Up ] };
key <AC09> { [ l, L, Right ] };

Comme vous pourrez le découvrir en utilisant xev, ceci produit Mod5+Left au lieu de juste Left. Mais c'est bon car la majorité des applications ignorent les états de bits qu'elles n'utilisent pas. Pour une solution alternative, voyez Overlay plus bas.

Meta, Super et Hyper

Les modifieurs réels

Certaines applications (notamment Emacs) permettent un usage significatif d'états de bits supérieurs. On suppose qu'il existe sur le clavier des tpuches appelées Meta, Super, et Hyper en plus des touches Shift, Ctrl et Alt standard, qui contrôlent ces bits. Du point de vue du XKB, cela signifie qu'il faut définir les bits modificateurs Mod2, Mod3, Mod4 et Mod5. Comme vous n'avez besoin que des bits eux-mêmes, il n'est pas nécessaire d'éditer les types comme dans l'exemple Level3 ci-dessus.

xkb_compatibility {
   interpret Super_L { action = SetMods(modifiers=Mod3); };
}
 
xkb_symbols {
   key <LWIN> { [ Super_L ] };
   modifier_map Mod3 { Super_L };
}

Les définitions standard utilisent le modificateur Super au lieu de Mod3 dans xkb_compatibility. Vous pouvez le garder, assurez-vous simplement que la ligne modifier_map est en place.

Gardez à l'esprit qu'il n'y a pas de correspondance stricte entre ModN et les modificateurs nommés comme Super, Hyper ou même Alt. Mod1 est le seul qui est largement utilisé ; certaines applications l'appellent Meta, d'autres Alt. Pour les autres, vérifiez comment l'application particulière traite les bits d'état, et/ou vérifiez les modificateurs virtuels ci-dessous.

Suivi des keysyms

Au moins une application (openbox) est connue pour suivre les événements KeyPress/KeyRelease pour les keysyms Meta_[LR], Super_[LR] et Hyper_[LR] au lieu de se fier aux bits d'état. Dans ce cas

xkb_symbols {
   key <LWIN> { [ Super_L ] };
}

est suffisant et vous pouvez omettre les lignes interpret et modifier_map.

Parlant d'Openbox, notez qu'effectivement il permet deux méthodes : "S-h" suit les évènements Super_[LR] tandis que "Mod3-h" vérifie les bits d'état pertinents.

Configuration prédéfinie

XKB est souvent configuré en spécifiant XkbTypes/XkbCompat/XkbSymbols, ou XkbModel/XkbLayout (+XkbVariant/XkbOptions), ou XkbKeymap, généralement dans /etc/X11/xorg.conf ou /etc/X11/xorg.conf.d/*.conf, comme ceci :

   Option "XkbModel" "thinkpad60" (en anglais)
   Option "XkbLayout" "us,sk,de"             
   Option "XkbVariant" "altgr-intl,qwerty,"
   Option "XkbOptions" "grp:menu_toggle,grp_led:caps"

Ces valeurs définissent la carte XKB complète (celle qui peut être vidée par xkbcomp en combinant plusieurs fichiers de /usr/share/X11/xkb. En fait, le fichier .xkb équivalent pour xkbcomp peut être obtenu en utilisant Msetxkbmap -print :

$ setxkbmap -model thinkpad60 -layout us,sk,de -variant altgr-intl,qwerty \
       -option -option grp:menu_toggle -option grp_led:caps -print

Notez les déclarations d'inclusion dans la sortie. Les fichiers de chaque section sont récupérés dans les sous-répertoires appropriés sous /usr/share/X11/xkb, c'est-à-dire

   xkb_types { include "complete" } ;

signifie que xkbcomp cherchera /usr/share/X11/xkb/types/complete. Les signes plus signifient une concaténation, donc

   xkb_keycodes { include "evdev+aliases(qwerty)" } ;

signifie

   xkb_keycodes {
       inclure "evdev" ;
       inclure "alias(qwerty)" ;
   } ;

Les parenthèses sélectionnent la section nommée dans le fichier. Voyez /usr/share/X11/xkb/keycodes/aliases et notez

   xkb_keycodes "qwerty" { ... } ;

c'est la partie à laquelle alias(qwerty) fait référence. Enfin, les deux-points permettent de déplacer des parties de la présentation vers un autre groupe.

Contrairement aux valeurs XkbTypes/XkbCompat/XkbSymbols/XkbGeometry, qui définissent directement les sections correspondantes du fichier .xkb, XkbModel, XkbLayout et XkbRules font référence à des fichiers non-xkb supplémentaires qui se trouvent dans /usr/share/X11/xkb/rules/ et qui associent les valeurs de modèle et de disposition à des symboles et à une géométrie spécifiques. XkbKeymap fait référence à des cartes de touches complètes. Consultez la page de Ivan Pascal pour une description détaillée.

Tout comme avec l'approche xkbcomp(1), ce type de configuration peut être fait à la volée : utilisez setxkbmap sans l'option -print.

Les fichiers de /usr/share/X11/xkb sont une bonne source d'exemples, spécialement lorsqu'il s'agit de fonctionnalités de clavier standard avec une implémentation XKB non triviale (par exemple, la gestion du clavier/NumLock). De plus, ce sont les fichiers que vous devez éditer pour pousser vos changements en amont. Vérifiez cependant les règles de configuration du clavier X avant de le faire.

Dossier local pour XKB

Vous pouvez configurer une disposition de clavier depuis un fichier local avec la commande suivante

$ xkbcomp keymap.xkb $DISPLAY

keymap.xkb doit avoir la structure suivante :

keymap.xkb
 
xkb_keymap {
    xkb_keycodes  { ... };
    xkb_types     { ... };
    xkb_compat    { ... };
    xkb_symbols   { ... };
 
    // Geometry is completely optional.
    // xkb_geometry  { include "pc(pc104)" };
};

Vous pouvez faire des inclusions depuis ce fichier, lesquelles se réfèrent à un dossier local, au lieu de /usr/share/X11/xkb/. Pour ce faire vous devez utiliser une directive -I/chemin/ pour xkbcomp. Exemple :

$ xkbcomp -I$HOME/.xkb $HOME/.keymap.xkb $DISPLAY
$HOME/.keymap.xkb
 
xkb_keymap {
    xkb_keycodes  { include "evdev+aliases(qwerty)" };
    xkb_types     { include "complete" };
    xkb_compat    { include "complete" };
    xkb_symbols   { include "pc+custom+inet(evdev)" };
};

Le fichier symbol doit avoir le même nom que celui spécifié dans xkb_symbols juste au dessus.

$HOME/.xkb/symbols/custom
 
partial alphanumeric_keys xkb_symbols "custom" { ... };




Réalisé avec Qlam - LGPL