Séquences de terminal virtuel de console

Les séquences de terminal virtuel 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 lorsqu’elles sont écrites 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 utilisateur lorsque le mode approprié est défini.

Vous pouvez utiliser les fonctions GetConsoleMode et SetConsoleMode pour configurer ce comportement. Un exemple de la méthode suggérée pour activer les comportements de terminal virtuel est inclus à la fin de ce document.

Le comportement des séquences suivantes est basé sur les technologies de l’émulateur de terminal VT100 et dérivées, plus précisément l’émulateur de terminal xterm. Pour plus d’informations sur les séquences de terminal, consultez et à l’adresse http://vt100.nethttp://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 console lorsqu’elles sont écrites dans le flux de sortie, si l’indicateur ENABLE_VIRTUAL_TERMINAL_PROCESSING est défini sur le handle de mémoire tampon d’écran à l’aide de la fonction SetConsoleMode . Notez que l’indicateur de DISABLE_NEWLINE_AUTO_RETURN peut également être utile pour simuler le positionnement du curseur et le comportement de défilement d’autres émulateurs de terminal par rapport aux caractères écrits dans la colonne finale de n’importe quelle ligne.

Positionnement de curseur simple

Dans toutes les descriptions suivantes, esc est toujours la valeur hexadécimale 0x1B. Aucun espace ne doit être inclus dans les séquences de terminal. Les séquences de terminal individuelles peuvent être fractionnées, à n’importe quelle position de caractère ou d’octet, sur plusieurs appels séquentiels à WriteFile ou WriteConsole , mais il est recommandé d’inclure l’ensemble de la séquence dans un seul appel. Pour obtenir un exemple de la façon dont ces séquences sont utilisées dans la pratique, consultez l’exemple à la fin de cette rubrique.

Le tableau suivant décrit des séquences d’échappement simples avec une seule commande d’action directement après le caractère ÉCHAP. Ces séquences n’ont aucun paramètre et prennent effet immédiatement.

Toutes les commandes de cette table sont généralement équivalentes à l’appel de l’API de 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 (s’il est disponible) ne se produit pas.

Positionnement du curseur

Les tableaux suivants englobent les séquences de type CSI (Control Sequence Introducer). Toutes les séquences CSI commencent par ESC (0x1B) suivie de [ (crochet gauche, 0x5B) et peuvent contenir des paramètres de longueur variable pour spécifier plus d’informations pour chaque opération. Cela sera représenté par le raccourci <n>. Chaque tableau ci-dessous est regroupé par fonctionnalité avec des notes ci-dessous pour expliquer le fonctionnement du groupe.

Pour tous les paramètres, les règles suivantes s’appliquent, sauf indication contraire :

• <n> représente la distance à déplacer et est un paramètre facultatif
• Si <n> est omis ou égal à 0, il sera 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 sont généralement équivalentes à l’appel de 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 (s’il est 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 sont généralement équivalentes à l’appel de l’API de console SetConsoleCursorInfo pour activer la visibilité du curseur.

Forme du 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 sont généralement équivalentes à l’appel de l’API de console ScrollConsoleScreenBuffer pour déplacer le contenu de la mémoire tampon de la console.

Prudence Les noms de commandes sont trompeurs. Le défilement fait référence à la direction dans laquelle le texte se déplace pendant l’opération, et non à quel point la fenêtre d’affichage semble se déplacer.

Le texte est déplacé à partir de la ligne sur laquelle le curseur est activé. Si le curseur se trouve sur la ligne centrale de la fenêtre d’affichage, faites défiler vers le haut la moitié inférieure de la fenêtre d’affichage et insérez des lignes vides en bas. Faites défiler vers le bas la moitié supérieure des lignes de la fenêtre d’affichage et insérez de nouvelles lignes en haut.

Il est également important de noter que le défilement vers le haut et le bas sont également affectés par les marges de défilement. Faire défiler vers le haut et le bas n’affecte aucune ligne en dehors des marges de défilement.

La valeur par défaut de <n> est 1 et la valeur peut éventuellement être omise.

Modification de texte

Toutes les commandes de cette section sont généralement équivalentes à l’appel des API de console 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 pour <n> si elle est omise est 0.

Pour les commandes suivantes, le paramètre <n> a 3 valeurs valides :

• 0 efface de la position actuelle du curseur (inclus) à la fin de la ligne/de l’affichage
• 1 efface le début de la ligne/de l’affichage jusqu’à la position actuelle du curseur
• 2 efface toute la ligne/l’affichage

Mise en forme du texte

Toutes les commandes de cette section sont généralement équivalentes à l’appel des API de console SetConsoleTextAttribute pour ajuster la mise en forme de toutes les futures écritures 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.

Lorsqu’aucun paramètre n’est spécifié, il est traité comme un seul paramètre 0.

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 sont appliqués de gauche à droite. L’application d’options de mise en forme concurrentes entraîne la priorité de l’option la plus appropriée.

Pour les options qui spécifient des couleurs, les couleurs seront utilisées comme définies 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 pour faire en sorte que la position « bleue » dans le tableau affiche une nuance RVB de rouge, tous les appels au bleu de premier plan affichent cette couleur rouge jusqu’à ce qu’elles ne changent pas.

Couleurs étendues

Certains émulateurs de terminal virtuel prennent en charge une palette de couleurs supérieures aux 16 couleurs fournies par la console Windows. Pour ces couleurs étendues, la console Windows choisit la couleur appropriée la plus proche de la table de couleurs 16 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 couleurs 88 et 256 conservées en interne pour la comparaison sont basées sur l’émulateur de terminal xterm. Les tables de comparaison/arrondi ne peuvent pas être modifiées pour l’instant.

Couleurs de l’écran

La commande suivante permet à l’application de définir les valeurs de palette de couleurs d’écran sur n’importe quelle valeur RVB.

Les valeurs RVB doivent être des valeurs hexadécimales entre 0 et ff, et séparées par le caractère de barre oblique (par exemple rgb:1/24/86).

Notez que cette séquence est une séquence « Commande du système d’exploitation » OSC, et non pas un CSI comme la plupart des autres séquences répertoriées, et que, par exemple, commencent par « \x1b] », et non « \x1b[ ». En tant que séquences OSC, elles se terminent par un terminateur de chaîne représenté comme <ST> et transmis avec ESC \ (0x1B 0x5C). BEL (0x7) peut être utilisé à la place comme terminateur, mais le formulaire plus long est préféré.

Modifications du 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 curseur et le mode Touches du pavé tactile. Le mode Touches de curseur contrôle les séquences émises par les touches de direction, ainsi que l’accueil et la fin, tandis que le mode touches de touches contrôle les séquences émises par les touches du numpad principalement, ainsi que les touches de fonction.

Chacun de ces modes est des paramètres booléens simples : le mode Touches de curseur est Normal (par défaut) ou Application, et le mode Touches du pavé numérique (par défaut) ou Application.

Consultez les sections Touches de curseur et Touches de fonction pour les séquences émises dans ces modes.

État de requête

Toutes les commandes de cette section sont généralement équivalentes à l’appel des API de console Get* pour récupérer des informations d’état sur l’état actuel de la mémoire tampon de la console.

Onglets

Bien que la console Windows s’attend traditionnellement à ce que les onglets soient exclusivement huit caractères larges, *nix applications utilisant certaines séquences peuvent manipuler l’emplacement où les taquets de tabulation se trouvent 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 emplacements de taquet de tabulation dans la fenêtre de console, de les supprimer et de naviguer entre eux.

• Pour CHT et CBT, <n> est un paramètre facultatif qui (default=1) indiquant le nombre de fois d’avance du curseur dans la direction spécifiée.
• S’il n’existe aucun taquet de tabulation défini via HTS, CHT et CBT traitent les premières et dernières colonnes de la fenêtre comme les deux seuls taquets de tabulation.
• L’utilisation de HTS pour définir un taquet de tabulation entraîne également la navigation dans la console jusqu’à l’arrêt de tabulation suivant dans la sortie d’un caractère TAB (0x09, '\t'), de la même manière que CHT.

Désigner un jeu de caractères

Les séquences suivantes permettent à un programme de modifier le mappage de jeu de caractères actif. Cela permet à un programme d’émettre des caractères ASCII 7 bits, mais qu’ils s’affichent comme d’autres glyphes sur l’écran de terminal lui-même. Actuellement, les deux seuls jeux de caractères pris en charge sont ASCII (valeur par défaut) et le jeu de caractères graphiques spéciaux DEC. Consultez http://vt100.net/docs/vt220-rm/table2-4.html la liste de tous les caractères représentés par le jeu de caractères graphiques spéciaux DEC.

Notamment, le mode dessin de ligne DEC est utilisé pour dessiner des bordures dans les applications console. Le tableau suivant montre ce que le caractère ASCII mappe au caractère de dessin de trait.

Marges de défilement

Les séquences suivantes permettent à un programme de configurer la « région de défilement » de l’écran affectée par les opérations de défilement. Il s’agit d’un sous-ensemble des lignes qui sont ajustées lorsque l’écran défile autrement, par exemple, sur un «\n» ou un ri. Ces marges affectent également les lignes modifiées par insérer une ligne (IL) et supprimer une ligne (DL), faire défiler vers le haut (SU) et faire défiler vers le bas (SD).

Les marges de défilement peuvent être particulièrement utiles pour avoir une partie de l’écran qui ne fait pas défiler lorsque le reste de l’écran est rempli, par exemple avoir 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 sont utilisés pour spécifier les lignes qui représentent les lignes supérieures et inférieures de la région de défilement, inclus. Si les paramètres sont omis, <la valeur par> défaut est 1 et <b> est définie par défaut sur la hauteur actuelle de la fenêtre d’affichage.

Les marges de défilement sont par mémoire tampon. Par conséquent, la mémoire tampon secondaire et la mémoire tampon principale conservent des paramètres de marges de défilement distinctes (par conséquent, une application en plein écran dans la mémoire tampon de remplacement n’empoisonne pas les marges de la mémoire tampon principale).

Titre de la fenêtre

Les commandes suivantes permettent à l’application de définir le titre de la fenêtre de console sur le paramètre de chaîne> donné<. La chaîne doit être inférieure à 255 caractères à accepter. Cela équivaut à appeler SetConsoleTitle avec la chaîne donnée.

Notez que ces séquences sont des séquences « Commande du système d’exploitation » OSC, et non pas un CSI comme bon nombre des autres séquences répertoriées, et comme tel commence par « \x1b] », et non « \x1b[ ». En tant que séquences OSC, elles se terminent par un terminateur de chaîne représenté comme <ST> et transmis avec ESC \ (0x1B 0x5C). BEL (0x7) peut être utilisé à la place comme terminateur, mais le formulaire plus long est préféré.

Le caractère de fin ici est le caractère « Bell », « \x07 »

Mémoire tampon d’écran de remplacement

*Les applications de style Nix utilisent souvent une autre mémoire tampon d’écran, afin qu’elles puissent modifier l’intégralité du contenu de la mémoire tampon, sans affecter l’application qui les a démarrées. La mémoire tampon alternative est exactement les dimensions de la fenêtre, sans aucune région de défilement.

Pour obtenir un exemple de ce comportement, envisagez quand vim est lancé à partir de bash. Vim utilise l’intégralité de l’écran pour modifier le fichier, puis retourne à 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. Ils sont approximativement équivalents à l’appel de l’API de console SetConsoleScreenBufferInfoEx pour définir la largeur de la fenêtre.

Réinitialisation réversible

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 suivantes (également répertoriées sont les séquences qui contrôlent ces propriétés) :

• Visibilité du curseur : visible (DECTEM)
• Pavé numérique : Mode numérique (DECNKM)
• Mode Clés de curseur : Mode normal (DECCKM)
• Marges supérieures et inférieures : Top=1, Bottom=Console height (DECSTBM)
• Jeu de caractères : US ASCII
• Rendu graphique : Default/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 console sur le flux d’entrée si l’indicateur ENABLE_VIRTUAL_TERMINAL_INPUT est défini sur le handle de mémoire tampon d’entrée à l’aide de l’indicateur SetConsoleMode.

Il existe deux modes internes qui contrôlent les séquences émises pour les touches d’entrée données, le mode touches de curseur et le mode touches du pavé numérique. Celles-ci sont décrites dans la section Modifications du mode.

Touches de curseur

En outre, si Ctrl est enfoncée avec l’une de ces touches, les séquences suivantes sont émises à la place, quel que soit le mode touches de curseur :

Touches numpad &fonction

Modificateurs

Alt est traitée en préfixant la séquence avec une séquence d’échappement : ÉCHAP <c où <c>> est le caractère transmis par le système d’exploitation. Alt+Ctrl est gérée de la même façon, sauf que le système d’exploitation aura pré-décalé la <touche c> vers le caractère de contrôle approprié qui sera relayé à l’application.

Ctrl est généralement transmise exactement comme reçu du système. Il s’agit généralement d’un caractère unique déplacé vers le bas dans l’espace réservé du caractère de contrôle (0x0-0x1f). Par exemple, Ctrl+@ (0x40) devient NUL (0x00), Ctrl+[ (0x5b) devient ÉCHAP (0x1b), etc. Quelques combinaisons de touches Ctrl sont traitées spécialement selon le tableau suivant :

Échantillons

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 du 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’intention de l’exemple est de démontrer :

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

2. Vérifiez si SetConsoleMode retourne 0 et GetLastError retourne ERROR_INVALID_PARAMETER est le mécanisme actuel pour déterminer lors de l’exécution sur un système de bas niveau. Une application recevant ERROR_INVALID_PARAMETER avec l’un des indicateurs de mode console les plus récents dans le champ bit doit dégrader correctement le comportement et 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 sélection des fonctionnalités de mise à jour anniversaire

L’exemple suivant est destiné à être un exemple de code plus robuste à l’aide d’une variété de séquences d’échappement pour manipuler la mémoire tampon, en mettant 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 de remplacement, la manipulation des taquets de tabulation, la définition des marges de défilement et la modification 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");

}