Comment fonctionnent la saisie au clavier et la sortie de texte ?

Supposons que j'appuie sur A clé dans un éditeur de texte et cela insère le caractère a dans le document et l'affiche à l'écran. Je sais que l'application de l'éditeur ne communique pas directement avec le matériel (il y a un noyau et des trucs entre les deux), alors que se passe-t-il à l'intérieur de mon ordinateur ?

Réponse acceptée :

Il existe plusieurs scénarios différents; Je vais décrire les plus courants. Les événements macroscopiques successifs sont :

1. Entrée :l'événement d'appui sur la touche est transmis du matériel du clavier à l'application.
2. Traitement :l'application décide que parce que la clé A a été pressé, il doit afficher le caractère a .
3. Sortie :l'application donne l'ordre d'afficher a à l'écran.

Applications graphiques

L'interface utilisateur graphique standard de facto des systèmes Unix est le système X Window, souvent appelé X11 car il s'est stabilisé dans la 11e version de son protocole principal entre les applications et le serveur d'affichage. Un programme appelé le serveur X se situe entre le noyau du système d'exploitation et les applications; il fournit des services tels que l'affichage de fenêtres à l'écran et la transmission des pressions sur les touches à la fenêtre qui a le focus.

Entrée

+----------+              +-------------+         +-----+
| keyboard |------------->| motherboard |-------->| CPU |
+----------+              +-------------+         +-----+
             USB, PS/2, …                 PCI, …
             key down/up

Tout d'abord, les informations sur la pression et le relâchement des touches sont transmises du clavier à l'ordinateur et à l'intérieur de l'ordinateur. Les détails dépendent du type de matériel. Je ne m'attarderai pas davantage sur cette partie car l'information reste la même tout au long de cette partie de la chaîne :telle touche a été enfoncée ou relâchée.

         +--------+        +----------+          +-------------+
-------->| kernel |------->| X server |--------->| application |
         +--------+        +----------+          +-------------+
interrupt          scancode             keysym
                   =keycode            +modifiers

Lorsqu'un événement matériel se produit, le CPU déclenche une interruption, ce qui provoque l'exécution d'un code dans le noyau. Ce code détecte que l'événement matériel est une pression ou un relâchement de touche provenant d'un clavier et enregistre le code de numérisation qui identifie la clé.

Le serveur X lit les événements d'entrée via un fichier de périphérique, par exemple /dev/input/eventNNN sous Linux (où NNN est un nombre). Chaque fois qu'il y a un événement, le noyau signale qu'il y a des données à lire à partir de ce périphérique. Le fichier de périphérique transmet les événements de touche haut/bas avec un code de balayage, qui peut ou non être identique à la valeur transmise par le matériel (le noyau peut traduire le code de balayage d'une valeur dépendante du clavier en une valeur commune, et Linux ne 't retransmettre les codes de numérisation qu'il ne connaît pas).

X appelle le code de numérisation qu'il lit un keycode . Le serveur X maintient une table qui traduit les codes clés en keysyms (abréviation de "symbole clé"). Les keycodes sont numériques, tandis que les keysyms sont des noms tels que A , aacute , F1 , KP_Add , Control_L , … Le keysym peut différer selon les touches de modification enfoncées (Maj , Ctrl , …).

Il existe deux mécanismes pour configurer le mappage des keycodes aux keysyms :

• xmodmap est le mécanisme traditionnel. Il s'agit d'un simple tableau mappant des codes clés à une liste de symboles clés (non modifiés, décalés, …).
• XKB est un mécanisme plus puissant, mais plus complexe, avec une meilleure prise en charge d'un plus grand nombre de modificateurs, en particulier pour la configuration bilingue, entre autres.

Les applications se connectent au serveur X et reçoivent une notification lorsqu'une touche est enfoncée alors qu'une fenêtre de cette application a le focus. La notification indique qu'un certain keysym a été pressé ou relâché ainsi que les modificateurs actuellement pressés. Vous pouvez voir les keysyms en exécutant le programme xev depuis une borne. Ce que l'application fait avec les informations dépend d'elle ; certaines applications ont des raccourcis clavier configurables.

Dans une configuration typique, lorsque vous appuyez sur la touche étiquetée A sans modificateurs, cela envoie le keysym a à la candidature ; si l'application est dans un mode où vous tapez du texte, cela insère le caractère a .

La relation entre la disposition du clavier et xmodmap donne plus de détails sur la saisie au clavier. Comment fonctionnent les événements de souris sous Linux? donne un aperçu de la saisie de la souris aux niveaux inférieurs.

Sortie

+-------------+        +----------+          +-----+         +---------+
| application |------->| X server |---····-->| GPU |-------->| monitor |
+-------------+        +----------+          +-----+         +---------+
               text or              varies          VGA, DVI,
               image                                HDMI, …

Il existe deux manières d'afficher un caractère.

• Rendu côté serveur :l'application indique au serveur X "dessine cette chaîne dans cette police à cette position". La police réside sur le serveur X.
• Rendu côté client  :l'application construit une image qui représente le caractère dans une police qu'elle choisit, puis indique au serveur X d'afficher cette image.

En relation :Utiliser un mot de passe pour protéger un fichier texte ?

Voir A quoi servent les différents types de polices XWindows ? pour une discussion sur le rendu de texte côté client et côté serveur sous X11.

Ce qui se passe entre le serveur X et l'unité de traitement graphique (le processeur de la carte vidéo) dépend fortement du matériel. Les systèmes simples font dessiner le serveur X dans une région de mémoire appelée framebuffer, que le GPU récupère pour l'affichage. Les systèmes avancés tels que ceux que l'on trouve sur n'importe quel PC ou smartphone du 21e siècle permettent au GPU d'effectuer certaines opérations directement pour de meilleures performances. En fin de compte, le GPU transmet le contenu de l'écran pixel par pixel chaque fraction de seconde au moniteur.

Application en mode texte, s'exécutant dans un terminal

Si votre éditeur de texte est une application en mode texte exécutée dans un terminal, c'est le terminal qui est l'application aux fins de la section ci-dessus. Dans cette section, j'explique l'interface entre l'application en mode texte et le terminal. Je décris d'abord le cas d'un émulateur de terminal fonctionnant sous X11. Quelle est la différence exacte entre un « terminal », un « shell », un « tty » et une « console » ? peut être utile ici. Après avoir lu ceci, vous voudrez peut-être lire le document beaucoup plus détaillé Quelles sont les responsabilités de chaque composant Pseudo-Terminal (PTY) (logiciel, côté maître, côté esclave) ?

Entrée

      +-------------------+               +-------------+
----->| terminal emulator |-------------->| application |
      +-------------------+               +-------------+
keysym                     character or
                           escape sequence

L'émulateur de terminal reçoit des événements comme "Left a été pressé pendant que Shift était en panne ». L'interface entre l'émulateur de terminal et l'application en mode texte est un pseudo-terminal (pty) , un périphérique de caractères qui transmet des octets. Lorsque l'émulateur de terminal reçoit un événement d'appui sur une touche, il le transforme en un ou plusieurs octets que l'application peut lire à partir du périphérique pty.

Les caractères imprimables en dehors de la plage ASCII sont transmis sous la forme d'un ou plusieurs octets en fonction du caractère et de l'encodage. Par exemple, dans le codage UTF-8 du jeu de caractères Unicode, les caractères de la plage ASCII sont codés comme un seul octet, tandis que les caractères en dehors de cette plage sont codés comme plusieurs octets.

Touches enfoncées correspondant à une touche de fonction ou à un caractère imprimable avec des modificateurs tels que Ctrl ou Alt sont envoyés sous la forme d'une séquence d'échappement . Les séquences d'échappement consistent généralement en un caractère d'échappement (valeur d'octet 27 =0x1B =