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.

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.

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.

Forme de curseur

Les commandes suivantes contrôlent et autorisent la personnalisation de la forme du curseur.

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.

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.

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

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.

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.

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.

*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.

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.

É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.

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.

• 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.

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.

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).

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.

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.

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.

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é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

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 :

Touches de fonction et pavé numérique

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 :

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;
}

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 :

1. Le mode existant doit toujours être récupéré par le biais de GetConsoleMode et analysé avant d’être défini avec SetConsoleMode.

2. Le fait de vérifier si la fonction SetConsoleMode renvoie 0 et 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");

}