Séquences de terminaux virtuels de console
Les séquences de terminaux virtuels sont des séquences de caractères de contrôle qui peuvent contrôler le déplacement du curseur, la couleur de la console, et d’autres opérations lors de leur écriture dans le flux de sortie. Les séquences peuvent également être reçues sur le flux d’entrée en réponse à une séquence d’informations de requête de flux de sortie ou en tant qu’encodage d’entrée d’utilisateur quand le mode approprié est défini.
Pour configurer ce comportement, vous pouvez utiliser les fonctions GetConsoleMode et SetConsoleMode. Vous trouverez un exemple de la méthode suggérée pour activer les comportements des terminaux virtuels à la fin de ce document.
Le comportement des séquences suivantes est basé sur les technologies d’émulateur de terminal VT100 et dérivés, plus spécifiquement l’émulateur de terminal xterm. Pour plus d’informations sur les séquences de terminal, consultez http://vt100.net et http://invisible-island.net/xterm/ctlseqs/ctlseqs.html.
Séquences de sortie
Les séquences de terminal suivantes sont interceptées par l’hôte de la console quand elles sont écrites dans le flux de sortie, si l’indicateur ENABLE_VIRTUAL_TERMINAL_PROCESSING est défini sur le descripteur de mémoire tampon d’écran à l’aide de la fonction SetConsoleMode. Notez que l’indicateur DISABLE_NEWLINE_AUTO_RETURN peut également être utile pour émuler le comportement de défilement et de positionnement de curseur d’autres émulateurs de terminal par rapport aux caractères écrits dans la dernière colonne de n’importe quelle ligne.
Positionnement de curseur simple
Dans toutes les descriptions suivantes, le caractère d’échappement (ESC) est toujours la valeur hexadécimale 0x1B. Aucun espace ne doit être inclus dans les séquences de terminal. Les séquences individuelles de terminaux peuvent être fractionnées, à tout caractère ou octet, en plusieurs appels séquentiels à WriteFile ou WriteConsole, mais il est de meilleure pratique d'inclure l'ensemble de la séquence dans un seul appel. Pour obtenir un exemple d’utilisation pratique de ces séquences, consultez l’exemple à la fin de cette rubrique.
Le tableau suivant décrit des séquences d’échappement simples avec une commande d’action unique directement après le caractère d’échappement (ESC). Ces séquences n’ont pas de paramètres et prennent effet immédiatement.
Toutes les commandes de ce tableau équivalent généralement à appeler l’API console SetConsoleCursorPosition pour placer le curseur.
Le déplacement du curseur est limité par la fenêtre d’affichage actuelle dans la mémoire tampon. Le défilement (si disponible) ne se produit pas.
| Séquence | Forme abrégée | Comportement |
|---|---|---|
| ESC M | Instance réservée | Index inverse : effectue l’opération inverse de \n, déplace le curseur d’une ligne vers le haut, conserve la position horizontale, fait défiler le tampon si nécessaire* |
| ESC 7 | DECSC | Enregistrer la position du curseur en mémoire** |
| ESC 8 | DECSR | Restaurer la position du curseur à partir de la mémoire** |
Remarque
* Si des marges de défilement sont définies, l’index inverse (RI) à l’intérieur des marges fait défiler uniquement le contenu des marges et laisse la fenêtre d’affichage inchangée. (Voir Marges de défilement)
**Aucune valeur n’est enregistrée en mémoire tant que la commande d’enregistrement n’a pas été utilisée une première fois. La seule façon d’accéder à la valeur enregistrée consiste à utiliser la commande de restauration.
Positionnement du curseur
Les tableaux suivants englobent les séquences de types CSI (Control Sequence Introducer, Introducteur de séquence de commandes). Toutes les séquences CSI commencent par ESC (0x1B) suivi de [ (crochet gauche, 0x5B) et peuvent contenir des paramètres de longueur variable afin de spécifier plus d’informations pour chaque opération. Cela est représenté par la forme abrégée <n>. Chaque tableau ci-dessous est regroupé par fonctionnalité et est suivi de notes expliquant le fonctionnement du groupe.
Pour tous les paramètres, les règles suivantes s’appliquent, sauf indication contraire :
- <n> représente la distance de déplacement et est un paramètre facultatif
- Si <n> est omis ou est égal à 0, il est traité comme un 1
- <n> ne peut pas être supérieur à 32 767 (valeur courte maximale)
- <n> ne peut pas être négatif
Toutes les commandes de cette section équivalent généralement à appeler l’API console SetConsoleCursorPosition.
Le déplacement du curseur est limité par la fenêtre d’affichage actuelle dans la mémoire tampon. Le défilement (si disponible) ne se produit pas.
| Séquence | Code | Description | Comportement |
|---|---|---|---|
| ESC [ <n> A | CUU | Déplacement du curseur vers le haut | Déplacement du curseur vers le haut de <n> ligne(s) |
| ESC [ <n> B | CUD | Déplacement du curseur vers le bas | Déplacement du curseur vers le bas de <n> ligne(s) |
| ESC [ <n> C | CUF | Déplacement du curseur vers l’avant | Déplacement du curseur vers l’avant (à droite) de <n> colonne(s) |
| ESC [ <n> D | CUB | Déplacement du curseur vers l’arrière | Déplacement du curseur vers l’arrière (à gauche) de <n> colonne(s) |
| ESC [ <n> E | CNL | Déplacement du curseur vers la ligne suivante | Déplacement du curseur vers le bas de <n> lignes à partir de la position actuelle |
| ESC [ <n> F | CPL | Déplacement du curseur vers la ligne précédente | Déplacement du curseur vers le haut de <n> lignes à partir de la position actuelle |
| ESC [ <n> G | CHA | Déplacement horizontal absolu du curseur | Le curseur se déplace horizontalement jusqu’à la <n>ième position dans la ligne actuelle |
| ESC [ <n> d | VPA | Déplacement vertical absolu jusqu’à une ligne | Le curseur se déplace verticalement jusqu’à la <n>ième position dans la colonne actuelle |
| ESC [ <y> ; <x> H | CUP | Position du curseur | *Le curseur se déplace jusqu’à la position <x>; <y> dans la fenêtre d’affichage, où <x> correspond à la colonne de la ligne <y> |
| ESC [ <y> ; <x> f | HVP | Position verticale horizontale | *Le curseur se déplace jusqu’à la position <x>; <y> dans la fenêtre d’affichage, où <x> correspond à la colonne de la ligne <y> |
| ESC [ s | ANSISYSSC | Enregistrer le curseur – émulation Ansi.sys | **Sans paramètre, effectue une opération d’enregistrement du curseur comme DECSC |
| ESC [ u | ANSISYSRC | Restaurer le curseur – émulation Ansi.sys | **Sans paramètre, effectue une opération de restauration du curseur comme DECRC |
Remarque
Les paramètres <x> et <y> présentent les mêmes limitations que <n> ci-dessus. Si <x> et <y> sont omis, ils sont définis sur 1;1.
**La documentation historique sur ANSI.sys est disponible à l’adresse https://msdn.microsoft.com/library/cc722862.aspx et est implémentée pour des raisons pratiques et de compatibilité.
Visibilité du curseur
Les commandes suivantes contrôlent la visibilité du curseur et son état de clignotement. Les séquences DECTCEM équivalent généralement à appeler l’API console SetConsoleCursorInfo pour changer l’état de la visibilité du curseur.
| Séquence | Code | Description | Comportement |
|---|---|---|---|
| ESC [ ? 12 h | ATT160 | Curseur de texte - Activer le clignotement | Démarrer le clignotement du curseur |
| ESC [ ? 12 l | ATT160 | Curseur de texte - Désactiver le clignotement | Arrêter le clignotement du curseur |
| ESC [ ? 25 h | DECTCEM | Curseur de texte - Activer le mode affichage | Afficher le curseur |
| ESC [ ? 25 l | DECTCEM | Curseur de texte - Activer le mode masquage | Masquer le curseur |
Conseil
Les séquences d’activation se terminent par un caractère H minuscule (h), tandis que les séquences de désactivation se terminent par un caractère L minuscule (l).
Forme de curseur
Les commandes suivantes contrôlent et autorisent la personnalisation de la forme du curseur.
| Séquence | Code | Description | Comportement |
|---|---|---|---|
| ESC [ 0 SP q | DECSCUSR | Forme d’utilisateur | Forme de curseur par défaut configurée par l’utilisateur |
| ESC [ 1 SP q | DECSCUSR | Bloc de clignotement | Forme de curseur de bloc de clignotement |
| ESC [ 2 SP q | DECSCUSR | Bloc stable | Forme de curseur de bloc stable |
| ESC [ 3 SP q | DECSCUSR | Soulignement de clignotement | Forme de curseur de soulignement de clignotement |
| ESC [ 4 SP q | DECSCUSR | Soulignement stable | Forme de curseur de soulignement stable |
| ESC [ 5 SP q | DECSCUSR | Barre clignotante | Forme de curseur de barre de clignotement |
| ESC [ 6 SP q | DECSCUSR | Barre stable | Forme de curseur de barre stable |
Remarque
SP est un espace littéral (0x20) en position intermédiaire, et il est suivi par q (0x71) en position finale.
Positionnement de la fenêtre d’affichage
Toutes les commandes de cette section équivalent généralement à appeler l’API console ScrollConsoleScreenBuffer pour déplacer le contenu de la mémoire tampon de la console.
Attention Les noms des commandes sont trompeurs. Le défilement fait référence à la direction dans laquelle le texte se déplace au cours de l’opération, et non à celle que semblerait emprunter la fenêtre d’affichage.
| Séquence | Code | Description | Comportement |
|---|---|---|---|
| ESC [ <n> S | Unités de diffusion en continu | Faire défiler vers le haut | Faire défiler le texte vers le haut de <n>. Opération également appelée « panoramique vers le bas » ; les nouvelles lignes se remplissent à partir du bas de l’écran |
| ESC [ <n> T | SD | Faire défiler vers le bas | Faire défiler vers le bas de <n>. Opération également appelée « panoramique vers le haut » ; les nouvelles lignes se remplissent à partir du haut de l’écran |
Le texte est déplacé à partir de la ligne sur laquelle se trouve le curseur. Si le curseur se trouve sur la ligne du milieu de la fenêtre d’affichage, le défilement vers le haut déplace la moitié inférieure de la fenêtre d’affichage et insère des lignes vides en bas. Le défilement vers le bas déplace la moitié supérieure des lignes de la fenêtre d’affichage et insère de nouvelles lignes en haut.
En outre, il est important de noter que le défilement vers le haut et vers le bas est également affecté par les marges de défilement. Le défilement vers le haut et vers le bas n’affecte pas les lignes situées en dehors des marges de défilement.
La valeur par défaut de <n> est 1 et la valeur peut éventuellement être omise.
Modification du texte
Toutes les commandes de cette section équivalent généralement à appeler les API consoles FillConsoleOutputCharacter, FillConsoleOutputAttribute et ScrollConsoleScreenBuffer pour modifier le contenu de la mémoire tampon de texte.
| Séquence | Code | Description | Comportement |
|---|---|---|---|
| ESC [ <n> @ | ICH | Insérer un caractère | Insérer <n> espaces à la position actuelle du curseur, en décalant tout le texte existant vers la droite. Le texte qui quitte l’écran à droite est supprimé. |
| ESC [ <n> P | DCH | Supprimer un caractère | Supprimer <n> caractères à la position actuelle du curseur, entraînant par effet de décalage la création d’autant de caractères d’espace à partir du bord droit de l’écran. |
| ESC [ <n> X | ECH | Effacer un caractère | Effacer <n> caractères de la position actuelle du curseur en les remplaçant par un espace. |
| ESC [ <n> L | IL | Insérer une ligne | Insérer <n> lignes dans la mémoire tampon à la position du curseur. La ligne sur laquelle se trouve le curseur et les lignes au-dessous de celle-ci sont décalées vers le bas. |
| ESC [ <n> M | DL | Supprimer la ligne | Supprime <n> lignes de la mémoire tampon, en commençant par la ligne sur laquelle se trouve le curseur. |
Remarque
Pour IL et DL, seules les lignes dans les marges de défilement (voir Marges de défilement) sont affectées. Si aucune marge n’est définie, les bordures de marge par défaut sont la fenêtre d’affichage actuelle. Si des lignes sont décalées en dessous des marges, elles sont ignorées. Quand des lignes sont supprimées, des lignes vides sont insérées en bas des marges et les lignes en dehors de la fenêtre d’affichage ne sont jamais affectées.
Pour chacune des séquences, la valeur par défaut de <n> s’il est omis est 0.
Pour les commandes suivantes, le paramètre <n> a 3 valeurs valides :
- 0 efface de la position actuelle du curseur (comprise) jusqu’à la fin de la ligne/de l’affichage
- 1 efface du début de la ligne/de l’affichage jusqu’à la position actuelle du curseur comprise
- 2 efface l’intégralité de la ligne/de l’affichage
| Séquence | Code | Description | Comportement |
|---|---|---|---|
| ESC [ <n> J | ED | Effacer dans l’affichage | En fonction de la valeur de <n>, remplacer par des espaces tout le texte de la fenêtre d’affichage ou de l’écran actuel |
| ESC [ <n> K | EL | Effacer dans la ligne | En fonction de la valeur de <n>, remplacer par des espaces tout le texte de la ligne contenant le curseur |
Mise en forme du texte
Toutes les commandes de cette section équivalent généralement à appeler les API consoles SetConsoleTextAttribute pour ajuster la mise en forme de toutes les écritures futures dans la mémoire tampon de texte de sortie de la console.
Cette commande est spéciale dans la mesure où la position <n> ci-dessous peut accepter entre 0 et 16 paramètres séparés par des points-virgules.
L’absence de paramètre équivaut à la présence d’un paramètre 0 unique.
| Séquence | Code | Description | Comportement |
|---|---|---|---|
| ESC [ <n> m | SGR | Définir un rendu graphique | Définir le format de l’écran et du texte tel que spécifié par <n> |
Le tableau de valeurs suivant peut être utilisé dans <n> pour représenter différents modes de mise en forme.
Les modes de mise en forme s’appliquent de gauche à droite. Si des options de mise en forme concurrentes sont appliquées, l’option la plus à droite est prioritaire.
Pour les options qui spécifient des couleurs, celles-ci sont utilisées comme défini dans la table de couleurs de la console, qui peut être modifiée à l’aide de l’API SetConsoleScreenBufferInfoEx. Si la table est modifiée afin que la position « bleu » dans la table affiche une nuance RVB rouge, tous les appels à Premier plan en bleu affichent cette couleur rouge jusqu’à ce qu’une nouvelle modification soit effectuée.
| Valeur | Description | Comportement |
|---|---|---|
| 0 | Par défaut | Retourne tous les attributs à l’état par défaut avant la modification |
| 1 | Mise en gras/couleur brillante | Applique l’indicateur de luminosité/intensité à la couleur de premier plan |
| 22 | Aucune mise en gras/couleur brillante | Supprime l’indicateur de luminosité/intensité de la couleur de premier plan |
| 4 | Souligner | Ajoute un soulignement |
| 24 | Pas de soulignement | Supprime le soulignement |
| 7 | Négatif | Permute les couleurs de premier plan et d’arrière-plan |
| 27 | Image positive (non négative) | Rétablit le premier plan et l’arrière-plan à l’état normal |
| 30 | Premier plan en noir | Applique la couleur noir brillant sans mise en gras au premier plan |
| 31 | Premier plan en rouge | Applique la couleur rouge vif sans mise en gras au premier plan |
| 32 | Premier plan en vert | Applique la couleur vert clair sans mise en gras au premier plan |
| 33 | Premier plan en jaune | Applique la couleur jaune vif sans mise en gras au premier plan |
| 34 | Premier plan en bleu | Applique la couleur bleu brillant sans mise en gras au premier plan |
| 35 | Premier plan en magenta | Applique la couleur magenta brillant sans mise en gras au premier plan |
| 36 | Premier plan en cyan | Applique la couleur cyan brillant sans mise en gras au premier plan |
| 37 | Premier plan en blanc | Applique la couleur blanc brillant sans mise en gras au premier plan |
| 38 | Premier plan avec valeur de couleur étendue | Applique la valeur de couleur étendue au premier plan (voir les détails ci-dessous). |
| 39 | Définition par défaut du premier plan | Applique uniquement la partie du premier plan des valeurs par défaut (voir 0). |
| 40 | Arrière-plan en noir | Applique la couleur noir brillant sans mise en gras à l’arrière-plan |
| 41 | Arrière-plan en rouge | Applique la couleur rouge vif sans mise en gras à l’arrière-plan |
| 42 | Arrière-plan en vert | Applique la couleur vert clair sans mise en gras à l’arrière-plan |
| 43 | Arrière-plan en jaune | Applique la couleur jaune vif sans mise en gras à l’arrière-plan |
| 44 | Arrière-plan en bleu | Applique la couleur bleu brillant sans mise en gras à l’arrière-plan |
| 45 | Arrière-plan en magenta | Applique la couleur magenta brillant sans mise en gras à l’arrière-plan |
| 46 | Arrière-plan en cyan | Applique la couleur cyan brillant sans mise en gras à l’arrière-plan |
| 47 | Arrière-plan en blanc | Applique la couleur blanc brillant sans mise en gras à l’arrière-plan |
| 48 | Arrière-plan avec valeur de couleur étendue | Applique une valeur de couleur étendue à l’arrière-plan (voir les détails ci-dessous). |
| 49 | Définition par défaut de l’arrière-plan | Applique uniquement la partie de l’arrière-plan des valeurs par défaut (voir 0). |
| 90 | Premier plan en noir brillant | Applique la couleur noir brillant avec mise en gras au premier plan |
| 91 | Premier plan en rouge vif | Applique la couleur rouge vif avec mise en gras au premier plan |
| 92 | Premier plan en vert clair | Applique la couleur vert clair avec mise en gras au premier plan |
| 93 | Premier plan en jaune vif | Applique la couleur jaune vif avec mise en gras au premier plan |
| 94 | Premier plan en bleu brillant | Applique la couleur bleu brillant avec mise en gras au premier plan |
| 95 | Premier plan en magenta brillant | Applique la couleur magenta brillant avec mise en gras au premier plan |
| 96 | Premier plan en cyan brillant | Applique la couleur cyan brillant avec mise en gras au premier plan |
| 97 | Premier plan en blanc brillant | Applique la couleur blanc brillant avec mise en gras au premier plan |
| 100 | Arrière-plan en noir brillant | Applique la couleur noir brillant avec mise en gras à l’arrière-plan |
| 101 | Arrière-plan en rouge vif | Applique la couleur rouge vif avec mise en gras à l’arrière-plan |
| 102 | Arrière-plan en vert clair | Applique la couleur vert clair avec mise en gras à l’arrière-plan |
| 103 | Arrière-plan en jaune vif | Applique la couleur jaune vif avec mise en gras à l’arrière-plan |
| 104 | Arrière-plan en bleu brillant | Applique la couleur bleu brillant avec mise en gras à l’arrière-plan |
| 105 | Arrière-plan en magenta brillant | Applique la couleur magenta brillant avec mise en gras à l’arrière-plan |
| 106 | Arrière-plan en cyan brillant | Applique la couleur cyan brillant avec mise en gras à l’arrière-plan |
| 107 | Arrière-plan en blanc brillant | Applique la couleur blanc brillant avec mise en gras à l’arrière-plan |
Couleurs étendues
Certains émulateurs de terminaux virtuels prennent en charge une palette de couleurs supérieure aux 16 couleurs fournies par la console Windows. Pour ces couleurs étendues, la console Windows choisit la couleur appropriée la plus proche dans la table de 16 couleurs existante pour l’affichage. Contrairement aux valeurs SGR classiques ci-dessus, les valeurs étendues consomment des paramètres supplémentaires après l’indicateur initial, conformément au tableau ci-dessous.
| Sous-séquence SGR | Description |
|---|---|
| 38 ; 2 ; <r> ; <g> ; <b> | Définir la couleur de premier plan sur la valeur RVB spécifiée dans les paramètres* <r>, <g>, <b> |
| 48 ; 2 ; <r> ; <g> ; <b> | Définir la couleur d’arrière-plan sur la valeur RVB spécifiée dans les paramètres* <r>, <g>, <b> |
| 38 ; 5 ; <s> | Définir la couleur de premier plan sur l’index <s> dans la table de 88 ou 256 couleurs* |
| 48 ; 5 ; <s> | Définir la couleur d’arrière-plan sur l’index <s> dans la table de 88 ou 256 couleurs* |
*Les palettes de 88 et 256 couleurs gérées en interne pour la comparaison sont basées sur l’émulateur de terminal xterm. Les tables de comparaison et d’arrondi ne peuvent pas être modifiées pour l’instant.
Couleurs d’écran
La commande suivante permet à l’application de définir les valeurs de la palette de couleurs d’écran sur n’importe quelle valeur RVB.
Les valeurs RVB doivent être des valeurs hexadécimales comprises entre 0 et ff séparées par le caractère barre oblique (par exemple, rgb:1/24/86).
Notez que cette séquence est une séquence OSC (Operating System Command, commande de système d’exploitation), et non une séquence CSI telle que la plupart des autres séquences listées. Ainsi, elle commence par « \x1b] », et non pas par « \x1b[ ». Comme les séquences OSC, elles finissent par un terminateur de chaîne representé par <ST> et transmis avec ESC \ (0x1B 0x5C). BEL (0x7) peut être utilisé à la place comme terminateur, mais la forme la plus longue est préférée.
| Séquence | Description | Comportement |
|---|---|---|
| ESC ] 4 ; <i> ; rgb : <r> / <g> / <b><ST> | Modifier les couleurs d’écran | Définit l’index <i> de la palette de couleurs d’écran sur les valeurs RVB spécifiées dans <r>, <g>, <b> |
Changements de mode
Il s’agit de séquences qui contrôlent les modes d’entrée. Il existe deux ensembles différents de modes d’entrée : le mode touches de direction et le mode touches du pavé numérique. Le mode touches de direction contrôle les séquences émises par les touches de direction, Début et Fin, tandis que le mode touches du pavé numérique contrôle les séquences émises par les touches du pavé numérique, essentiellement, ainsi que par les touches de fonction.
Chacun de ces modes est constitué de paramètres booléens simples : le mode touches de direction est Normal (valeur par défaut) ou Application, tandis que le mode touches du pavé numérique est soit Numérique (valeur par défaut), soit Application.
Consultez les sections Touches de direction et Touches de fonction et pavé numérique pour connaître les séquences émises dans ces modes.
| Séquence | Code | Description | Comportement |
|---|---|---|---|
| ESC = | DECKPAM | Activer le mode Application du pavé numérique | Les touches du pavé numérique émettent leurs séquences en mode Application. |
| ESC > | DECKPNM | Activer le mode Numérique du pavé numérique | Les touches du pavé numérique émettent leurs séquences en mode Numérique. |
| ESC [ ? 1 h | DECCKM | Activer le mode Application de touches de direction | Les touches du pavé numérique émettent leurs séquences en mode Application. |
| ESC [ ? 1 l | DECCKM | Désactiver le mode Application de touches de direction (utiliser le mode Normal) | Les touches du pavé numérique émettent leurs séquences en mode Numérique. |
État de requête
Toutes les commandes de cette section équivalent généralement à appeler* les API consoles pour récupérer les informations sur l’état actuel de la mémoire tampon de la console.
Remarque
Ces requêtes émettent leurs réponses dans le flux d’entrée de la console immédiatement après avoir été reconnues sur le flux de sortie si l’indicateur ENABLE_VIRTUAL_TERMINAL_PROCESSING est défini. L’indicateur ENABLE_VIRTUAL_TERMINAL_INPUT ne s’applique pas aux commandes de requête, car il est supposé qu’une application qui effectue la requête doit toujours recevoir la réponse.
| Séquence | Code | Description | Comportement |
|---|---|---|---|
| ESC [ 6 n | DECXCPR | Signaler la position du curseur | Émettre la position du curseur comme suit : ESC [ <r> ; <c> R Où <r> = ligne de curseur and <c> = colonne de curseur |
| ESC [ 0 c | DA | Attributs de l’appareil | Signaler l’identité du terminal. Émet « \x1b[?1;0c », en indiquant « VT101 with No Options » (VT101 sans options). |
Tabulations
Alors que la console Windows s’attend traditionnellement à ce que les tabulations aient exclusivement une largeur de huit caractères, les applications *nix utilisant certaines séquences peuvent manipuler la position des taquets de tabulation dans les fenêtres de console pour optimiser le déplacement du curseur par l’application.
Les séquences suivantes permettent à une application de définir les positions des taquets de tabulation dans la fenêtre de console, de supprimer ces derniers et de passer de l’un à l’autre.
| Séquence | Code | Description | Comportement |
|---|---|---|---|
| ESC H | HTS | Définir une tabulation horizontale | Définit un taquet de tabulation au niveau de la colonne à laquelle se trouve actuellement le curseur. |
| ESC [ <n> I | CHT | Déplacer le curseur vers un taquet de tabulation horizontale (vers l’avant) | Avance le curseur jusqu’à la colonne suivante (sur la même ligne) ayant un taquet de tabulation. S’il n’y a plus de taquets de tabulation, passe à la dernière colonne de la ligne. Si le curseur se trouve à la dernière colonne, passe à la première colonne de la ligne suivante. |
| ESC [ <n> Z | CBT | Déplacer le curseur vers un taquet de tabulation vers l’arrière | Déplace le curseur jusqu’à la colonne précédente (sur la même ligne) ayant un taquet de tabulation. S’il n’y a plus de taquets de tabulation, déplace le curseur jusqu’à la première colonne. Si le curseur se trouve à la première colonne, ne déplace pas le curseur. |
| ESC [ 0 g | À confirmer | Effacer un taquet de tabulation (colonne actuelle) | Efface le taquet de tabulation à la colonne actuelle, s’il en existe un. Sinon, ne fait rien. |
| ESC [ 3 g | À confirmer | Effacer les taquets de tabulation (toutes les colonnes) | Efface tous les taquets de tabulation actuellement définis. |
- Pour CHT et CBT, <n> est un paramètre facultatif (valeur par défaut = 1) qui indique combien de fois il faut avancer le curseur dans la direction spécifiée.
- Si aucun taquet de tabulation n’est défini par le biais de HTS, CHT et CBT traitent les première et dernière colonnes de la fenêtre comme étant les deux seuls taquets de tabulation.
- En outre, quand HTS est utilisé pour définir un taquet de tabulation, la console accède au taquet de tabulation suivant sur la sortie d’un caractère de tabulation (0x09, « t »), de la même manière que CHT.
Désigner le jeu de caractères
Les séquences suivantes permettent à un programme de changer le mappage du jeu de caractères actif. Ainsi, un programme peut émettre des caractères ASCII de 7 bits, mais les faire s’afficher sous la forme d’autres glyphes sur l’écran de terminal lui-même. Les deux seuls jeux de caractères pris en charge sont ASCII (par défaut) et le jeu de caractères DEC Special Graphics. Consultez http://vt100.net/docs/vt220-rm/table2-4.html pour obtenir la liste de tous les caractères représentés par le jeu de caractères DEC Special Graphics.
| Séquence | Description | Comportement |
|---|---|---|
| ESC ( 0 | Désigner le jeu de caractères – Dessin de ligne DEC | Active le mode de dessin de la ligne DEC |
| ESC ( B | Désigner le jeu de caractères – ASCII des États-Unis | Active le mode ASCII (par défaut) |
En particulier, le mode de dessin de ligne DEC est utilisé pour dessiner les bordures dans les applications de console. Le tableau suivant indique les correspondances entre les caractères ASCII et les caractères de dessin de ligne.
| Hex | ASCII | Dessin de ligne DEC |
|---|---|---|
| 0x6a | j | ┘ |
| 0x6b | k | ┐ |
| 0x6c | l | ┌ |
| 0x6d | m | └ |
| 0x6e | n | ┼ |
| 0x71 | q | ─ |
| 0x74 | t | ├ |
| 0x75 | u | ┤ |
| 0x76 | v | ┴ |
| 0x77 | w | ┬ |
| 0x78 | x | │ |
Marges de défilement
Les séquences suivantes permettent à un programme de configurer la « zone de défilement » de l’écran qui est affectée par les opérations de défilement. Il s’agit d’un sous-ensemble des lignes qui sont ajustées en cas de défilement de l’écran, par exemple, sur une commande « n » ou RI. Ces marges affectent également les lignes modifiées par les commandes d’insertion de ligne (IL), de suppression de ligne (DL), de défilement vers le haut (SU) et de défilement vers le bas (SD).
Les marges de défilement peuvent être particulièrement utiles pour disposer d’une partie de l’écran qui ne défile pas quand le reste de l’écran est rempli, par exemple une barre de titre en haut ou une barre d’état en bas de votre application.
Pour DECSTBM, il existe deux paramètres facultatifs, <t> et <b>, qui servent à spécifier les lignes qui représentent les lignes supérieure et inférieure de la zone de défilement, celles-ci incluses. Si les paramètres sont omis, <t> a la valeur par défaut 1 et <b> est défini par défaut sur la hauteur de la fenêtre d’affichage actuelle.
Les marges de défilement sont définies par mémoire tampon. Il est donc important que la mémoire tampon secondaire et la mémoire tampon principale aient constamment des paramètres de marges de défilement distincts (afin qu’une application en plein écran dans la mémoire tampon secondaire n’altère pas les marges de la mémoire tampon principale).
| Séquence | Code | Description | Comportement |
|---|---|---|---|
| ESC [ <t> ; <b> r | DECSTBM | Définir la zone de défilement | Définit les marges de défilement des tabulations verticales de la fenêtre d’affichage. |
Titre de fenêtre
Les commandes suivantes permettent à l’application de définir le titre de la fenêtre de console sur le paramètre <chaîne> donné. La chaîne doit contenir moins de 255 caractères pour être acceptée. Cela équivaut à appeler SetConsoleTitle avec la chaîne donnée.
Notez que ces séquences sont des séquences OSC, et non des séquence CSI telles que la plupart des autres séquences listées. Ainsi, elle commence par « x1b », et non pas par « x1b ». Comme les séquences OSC, elles finissent par un terminateur de chaîne representé par <ST> et transmis avec ESC \ (0x1B 0x5C). BEL (0x7) peut être utilisé à la place comme terminateur, mais la forme la plus longue est préférée.
| Séquence | Description | Comportement |
|---|---|---|
| ESC ] 0 ; <string><ST> | Définir le titre de la fenêtre | Définit le titre de la fenêtre de console sur <chaîne>. |
| ESC ] 2 ; <chaîne><ST> | Définir le titre de la fenêtre | Définit le titre de la fenêtre de console sur <chaîne>. |
En l’occurrence, le caractère de fin est le caractère « sonnerie », « x07 »
Mémoire tampon d’écran secondaire
Les applications de style *nix utilisent souvent une mémoire tampon d’écran secondaire, afin de pouvoir modifier l’ensemble du contenu de la mémoire tampon, sans affecter l’application qui les a démarrées. La mémoire tampon secondaire épouse les dimensions de la fenêtre, sans aucune zone de défilement.
À titre d’exemple de ce comportement, pensez à la façon dont vim est lancé à partir de bash. Vim utilise l’intégralité de l’écran pour modifier le fichier, puis le retour à bash laisse la mémoire tampon d’origine inchangée.
| Séquence | Description | Comportement |
|---|---|---|
| ESC [ ? 1 0 4 9 h | Utiliser une mémoire tampon d’écran secondaire | Bascule vers une nouvelle mémoire tampon d’écran secondaire. |
| ESC [ ? 1 0 4 9 l | Utiliser la mémoire tampon d’écran principale | Bascule vers la mémoire tampon principale. |
Largeur de la fenêtre
Les séquences suivantes peuvent être utilisées pour contrôler la largeur de la fenêtre de console. Elles équivalent plus ou moins à appeler l’API console SetConsoleScreenBufferInfoEx pour définir la largeur de la fenêtre.
| Séquence | Code | Description | Comportement |
|---|---|---|---|
| ESC [ ? 3 h | DECCOLM | Définir le nombre de colonnes sur 132 | Définit la largeur de la console sur une largeur de 132 colonnes. |
| ESC [ ? 3 l | DECCOLM | Définir le nombre de colonnes sur 80 | Définit la largeur de la console sur une largeur de 80 colonnes. |
Réinitialisation à chaud
La séquence suivante peut être utilisée pour réinitialiser certaines propriétés à leurs valeurs par défaut. Les propriétés suivantes sont réinitialisées aux valeurs par défaut indiquées (les séquences qui contrôlent ces propriétés sont également listées) :
- Visibilité du curseur : visible (DECTEM)
- Pavé numérique : Mode numérique (DECNKM)
- Mode touche de direction : Mode normal (DECCKM)
- Marges supérieures et inférieures : Haut=1, Bas=Hauteur de console (DECSTBM)
- Jeu de caractères : US ASCII
- Rendu graphique : Défaut/Off (SGR)
- Enregistrer l’état du curseur : Position d’accueil (0,0) (DECSC)
| Séquence | Code | Description | Comportement |
|---|---|---|---|
| ESC [ ! p | DECSTR | Réinitialisation à chaud | Réinitialiser certains paramètres de terminal à leurs valeurs par défaut. |
Séquences d’entrée
Les séquences de terminal suivantes sont émises par l’hôte de la console sur le flux d’entrée si l’indicateur ENABLE_VIRTUAL_TERMINAL_INPUT est défini sur le descripteur de mémoire tampon d’entrée à l’aide de l’indicateur SetConsoleMode.
Il existe deux modes internes qui déterminent les séquences émises pour les touches d’entrée données : le mode touches de direction et le mode touches du pavé numérique. Ces modes sont décrits dans la section Changements de mode.
Touches de direction
| Clé | Mode Normal | Mode Application |
|---|---|---|
| Haut | ESC [ A | ESC O A |
| Flèche bas | ESC [ B | ESC O B |
| Droite | ESC [ C | ESC O C |
| Gauche | ESC [ D | ESC O D |
| Accueil | ESC [ H | ESC O H |
| End | ESC [ F | ESC O F |
En outre, si la touche CTRL est enfoncée avec l’une de ces touches, les séquences suivantes sont émises à la place, indépendamment du mode touches de direction :
| Clé | N’importe quel mode |
|---|---|
| Ctrl + flèche haut | ESC [ 1 ; 5 A |
| Ctrl + flèche bas | ESC [ 1 ; 5 B |
| Ctrl + flèche droite | ESC [ 1 ; 5 C |
| Ctrl + flèche gauche | ESC [ 1 ; 5 D |
Touches de fonction et pavé numérique
| Clé | Séquence |
|---|---|
| Retour arrière | 0x7f (DEL) |
| Pause | 0x1a (SUB) |
| Caractère d'échappement | 0x1b (ESC) |
| Insérer | ESC [ 2 ~ |
| Supprimer | ESC [ 3 ~ |
| Page précédente | ESC [ 5 ~ |
| Page suivante | ESC [ 6 ~ |
| F1 | ESC O P |
| F2 | ESC O Q |
| F3 | ESC O R |
| F4 | ESC O S |
| F5 | ESC [ 1 5 ~ |
| F6 | ESC [ 1 7 ~ |
| F7 | ESC [ 1 8 ~ |
| F8 | ESC [ 1 9 ~ |
| F9 | ESC [ 2 0 ~ |
| F10 | ESC [ 2 1 ~ |
| F11 | ESC [ 2 3 ~ |
| F12 | ESC [ 2 4 ~ |
Modificateurs
Alt est traitée en préfixant la séquence avec une séquence d’échappement : ESC <c où <c>> est le caractère transmis par le système d’exploitation. La séquence Alt+Ctrl est gérée de la même façon, à la différence que le système d’exploitation aura préalablement décalé la touche <c> vers le caractère de contrôle approprié qui sera relayé à l’application.
La touche Ctrl est généralement transmise telle qu’elle est reçue du système. Il s’agit généralement d’un caractère unique baissé dans l’espace réservé de caractères de contrôle (0x0-0x1f). Par exemple, Ctrl+@ (0x40) devient NUL (0x00), Ctrl+[ (0x5b) devient ESC (0x1b), etc. Quelques combinaisons de touches Ctrl sont traitées spécialement selon le tableau suivant :
| Clé | Séquence |
|---|---|
| Ctrl + espace | 0x00 (NUL) |
| Ctrl + flèche haut | ESC [ 1 ; 5 A |
| Ctrl + flèche bas | ESC [ 1 ; 5 B |
| Ctrl + flèche droite | ESC [ 1 ; 5 C |
| Ctrl + flèche gauche | ESC [ 1 ; 5 D |
Remarque
Ctrl gauche + Alt droite est traité comme AltGr. Quand ils apparaissent ensemble, ils sont supprimés et la valeur Unicode du caractère présenté par le système est transmise à la cible. Le système pré-convertit les valeurs AltGr en fonction des paramètres d’entrée système actuels.
Exemples
Exemple de séquences de terminal SGR
Le code suivant fournit plusieurs exemples de mise en forme de texte.
#include <stdio.h>
#include <wchar.h>
#include <windows.h>
int main()
{
// Set output mode to handle virtual terminal sequences
HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);
if (hOut == INVALID_HANDLE_VALUE)
{
return GetLastError();
}
DWORD dwMode = 0;
if (!GetConsoleMode(hOut, &dwMode))
{
return GetLastError();
}
dwMode |= ENABLE_VIRTUAL_TERMINAL_PROCESSING;
if (!SetConsoleMode(hOut, dwMode))
{
return GetLastError();
}
// Try some Set Graphics Rendition (SGR) terminal escape sequences
wprintf(L"\x1b[31mThis text has a red foreground using SGR.31.\r\n");
wprintf(L"\x1b[1mThis text has a bright (bold) red foreground using SGR.1 to affect the previous color setting.\r\n");
wprintf(L"\x1b[mThis text has returned to default colors using SGR.0 implicitly.\r\n");
wprintf(L"\x1b[34;46mThis text shows the foreground and background change at the same time.\r\n");
wprintf(L"\x1b[0mThis text has returned to default colors using SGR.0 explicitly.\r\n");
wprintf(L"\x1b[31;32;33;34;35;36;101;102;103;104;105;106;107mThis text attempts to apply many colors in the same command. Note the colors are applied from left to right so only the right-most option of foreground cyan (SGR.36) and background bright white (SGR.107) is effective.\r\n");
wprintf(L"\x1b[39mThis text has restored the foreground color only.\r\n");
wprintf(L"\x1b[49mThis text has restored the background color only.\r\n");
return 0;
}
Remarque
Dans l’exemple précédent, la chaîne « \x1b[31m » correspond à l’implémentation de ESC [ <n> m où <n> a pour valeur 31.
Le graphique suivant montre la sortie de l’exemple de code précédent.
Exemple d’activation de traitement de terminal virtuel
Le code suivant fournit un exemple de la méthode recommandée pour activer le traitement de terminal virtuel pour une application. L’exemple vise à illustrer les points suivants :
Le mode existant doit toujours être récupéré par le biais de GetConsoleMode et analysé avant d’être défini avec SetConsoleMode.
Le fait de vérifier si la fonction SetConsoleMode renvoie
0et la fonction GetLastError renvoie ERROR_INVALID_PARAMETER est le mécanisme actuel pour déterminer si l’exécution a lieu sur un système de niveau inférieur. Une application qui reçoit ERROR_INVALID_PARAMETER avec l’un des nouveaux indicateurs de mode de console dans le champ de bit doit progressivement dégrader le comportement, puis réessayer.
#include <stdio.h>
#include <wchar.h>
#include <windows.h>
int main()
{
// Set output mode to handle virtual terminal sequences
HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);
if (hOut == INVALID_HANDLE_VALUE)
{
return false;
}
HANDLE hIn = GetStdHandle(STD_INPUT_HANDLE);
if (hIn == INVALID_HANDLE_VALUE)
{
return false;
}
DWORD dwOriginalOutMode = 0;
DWORD dwOriginalInMode = 0;
if (!GetConsoleMode(hOut, &dwOriginalOutMode))
{
return false;
}
if (!GetConsoleMode(hIn, &dwOriginalInMode))
{
return false;
}
DWORD dwRequestedOutModes = ENABLE_VIRTUAL_TERMINAL_PROCESSING | DISABLE_NEWLINE_AUTO_RETURN;
DWORD dwRequestedInModes = ENABLE_VIRTUAL_TERMINAL_INPUT;
DWORD dwOutMode = dwOriginalOutMode | dwRequestedOutModes;
if (!SetConsoleMode(hOut, dwOutMode))
{
// we failed to set both modes, try to step down mode gracefully.
dwRequestedOutModes = ENABLE_VIRTUAL_TERMINAL_PROCESSING;
dwOutMode = dwOriginalOutMode | dwRequestedOutModes;
if (!SetConsoleMode(hOut, dwOutMode))
{
// Failed to set any VT mode, can't do anything here.
return -1;
}
}
DWORD dwInMode = dwOriginalInMode | dwRequestedInModes;
if (!SetConsoleMode(hIn, dwInMode))
{
// Failed to set VT input mode, can't do anything here.
return -1;
}
return 0;
}
Exemple de certaines fonctionnalités de mise à jour anniversaire
L’exemple suivant se veut un exemple plus robuste de code utilisant une variété de séquences d’échappement pour manipuler la mémoire tampon et met l’accent sur les fonctionnalités ajoutées dans la mise à jour anniversaire pour Windows 10.
Cet exemple utilise la mémoire tampon d’écran secondaire et illustre la manipulation des taquets de tabulation, la définition des marges de défilement et le changement du jeu de caractères.
// System headers
#include <windows.h>
// Standard library C-style
#include <wchar.h>
#include <stdlib.h>
#include <stdio.h>
#define ESC "\x1b"
#define CSI "\x1b["
bool EnableVTMode()
{
// Set output mode to handle virtual terminal sequences
HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);
if (hOut == INVALID_HANDLE_VALUE)
{
return false;
}
DWORD dwMode = 0;
if (!GetConsoleMode(hOut, &dwMode))
{
return false;
}
dwMode |= ENABLE_VIRTUAL_TERMINAL_PROCESSING;
if (!SetConsoleMode(hOut, dwMode))
{
return false;
}
return true;
}
void PrintVerticalBorder()
{
printf(ESC "(0"); // Enter Line drawing mode
printf(CSI "104;93m"); // bright yellow on bright blue
printf("x"); // in line drawing mode, \x78 -> \u2502 "Vertical Bar"
printf(CSI "0m"); // restore color
printf(ESC "(B"); // exit line drawing mode
}
void PrintHorizontalBorder(COORD const Size, bool fIsTop)
{
printf(ESC "(0"); // Enter Line drawing mode
printf(CSI "104;93m"); // Make the border bright yellow on bright blue
printf(fIsTop ? "l" : "m"); // print left corner
for (int i = 1; i < Size.X - 1; i++)
printf("q"); // in line drawing mode, \x71 -> \u2500 "HORIZONTAL SCAN LINE-5"
printf(fIsTop ? "k" : "j"); // print right corner
printf(CSI "0m");
printf(ESC "(B"); // exit line drawing mode
}
void PrintStatusLine(const char* const pszMessage, COORD const Size)
{
printf(CSI "%d;1H", Size.Y);
printf(CSI "K"); // clear the line
printf(pszMessage);
}
int __cdecl wmain(int argc, WCHAR* argv[])
{
argc; // unused
argv; // unused
//First, enable VT mode
bool fSuccess = EnableVTMode();
if (!fSuccess)
{
printf("Unable to enter VT processing mode. Quitting.\n");
return -1;
}
HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);
if (hOut == INVALID_HANDLE_VALUE)
{
printf("Couldn't get the console handle. Quitting.\n");
return -1;
}
CONSOLE_SCREEN_BUFFER_INFO ScreenBufferInfo;
GetConsoleScreenBufferInfo(hOut, &ScreenBufferInfo);
COORD Size;
Size.X = ScreenBufferInfo.srWindow.Right - ScreenBufferInfo.srWindow.Left + 1;
Size.Y = ScreenBufferInfo.srWindow.Bottom - ScreenBufferInfo.srWindow.Top + 1;
// Enter the alternate buffer
printf(CSI "?1049h");
// Clear screen, tab stops, set, stop at columns 16, 32
printf(CSI "1;1H");
printf(CSI "2J"); // Clear screen
int iNumTabStops = 4; // (0, 20, 40, width)
printf(CSI "3g"); // clear all tab stops
printf(CSI "1;20H"); // Move to column 20
printf(ESC "H"); // set a tab stop
printf(CSI "1;40H"); // Move to column 40
printf(ESC "H"); // set a tab stop
// Set scrolling margins to 3, h-2
printf(CSI "3;%dr", Size.Y - 2);
int iNumLines = Size.Y - 4;
printf(CSI "1;1H");
printf(CSI "102;30m");
printf("Windows 10 Anniversary Update - VT Example");
printf(CSI "0m");
// Print a top border - Yellow
printf(CSI "2;1H");
PrintHorizontalBorder(Size, true);
// // Print a bottom border
printf(CSI "%d;1H", Size.Y - 1);
PrintHorizontalBorder(Size, false);
wchar_t wch;
// draw columns
printf(CSI "3;1H");
int line = 0;
for (line = 0; line < iNumLines * iNumTabStops; line++)
{
PrintVerticalBorder();
if (line + 1 != iNumLines * iNumTabStops) // don't advance to next line if this is the last line
printf("\t"); // advance to next tab stop
}
PrintStatusLine("Press any key to see text printed between tab stops.", Size);
wch = _getwch();
// Fill columns with output
printf(CSI "3;1H");
for (line = 0; line < iNumLines; line++)
{
int tab = 0;
for (tab = 0; tab < iNumTabStops - 1; tab++)
{
PrintVerticalBorder();
printf("line=%d", line);
printf("\t"); // advance to next tab stop
}
PrintVerticalBorder();// print border at right side
if (line + 1 != iNumLines)
printf("\t"); // advance to next tab stop, (on the next line)
}
PrintStatusLine("Press any key to demonstrate scroll margins", Size);
wch = _getwch();
printf(CSI "3;1H");
for (line = 0; line < iNumLines * 2; line++)
{
printf(CSI "K"); // clear the line
int tab = 0;
for (tab = 0; tab < iNumTabStops - 1; tab++)
{
PrintVerticalBorder();
printf("line=%d", line);
printf("\t"); // advance to next tab stop
}
PrintVerticalBorder(); // print border at right side
if (line + 1 != iNumLines * 2)
{
printf("\n"); //Advance to next line. If we're at the bottom of the margins, the text will scroll.
printf("\r"); //return to first col in buffer
}
}
PrintStatusLine("Press any key to exit", Size);
wch = _getwch();
// Exit the alternate buffer
printf(CSI "?1049l");
}