Sequenze del terminale virtuale della console

Le sequenze di terminale virtuale sono sequenze di caratteri di controllo che possono controllare lo spostamento del cursore, il colore della console e altre operazioni quando vengono scritte nel flusso di output. Le sequenze possono anche essere ricevute nel flusso di input in risposta a una sequenza di informazioni di query del flusso di output o come codifica dell'input utente quando viene impostata la modalità appropriata.

Per configurare questo comportamento, è possibile usare le funzioni GetConsoleMode e SetConsoleMode. Alla fine di questo documento è incluso un esempio della modalità consigliata per abilitare i comportamenti del terminale virtuale.

Il comportamento delle sequenze seguenti si basa su VT100 e sulle tecnologie dell'emulatore di terminale derivate, in particolare sull'emulatore di terminale xterm. Per altre informazioni sulle sequenze di terminale, visitare i siti Web agli indirizzi http://vt100.net e http://invisible-island.net/xterm/ctlseqs/ctlseqs.html.

Sequenze di output

Le sequenze di terminale seguenti vengono intercettate dall'host della console quando vengono scritte nel flusso di output, se il flag ENABLE_VIRTUAL_TERMINAL_PROCESSING viene impostato nell'handle del buffer dello schermo usando la funzione SetConsoleMode. Si noti che il flag DISABLE_NEWLINE_AUTO_RETURN può essere utile anche per simulare il comportamento di posizionamento e scorrimento del cursore di altri emulatori di terminale in relazione ai caratteri scritti nella colonna finale in qualsiasi riga.

Posizionamento semplice del cursore

In tutte le descrizioni seguenti ESC è sempre rappresentato dal valore esadecimale 0x1B. Non è necessario includere spazi nelle sequenze di terminale. Le singole sequenze di terminale possono essere suddivise, in qualsiasi posizione di caratteri o byte, in più chiamate sequenziali a WriteFile o WriteConsole, ma è consigliabile includere l'intera sequenza in una sola chiamata. Per informazioni su come vengono usate in pratica le sequenze, vedere l'esempio alla fine di questo argomento.

Nella tabella seguente vengono descritte le sequenze di escape semplici con un solo comando di azione subito dopo il carattere ESC. Queste sequenze non hanno parametri e hanno effetto immediato.

Tutti i comandi inclusi in questa tabella sono generalmente equivalenti alla chiamata dell'API della console SetConsoleCursorPosition per posizionare il cursore.

Lo spostamento del cursore verrà limitato dal riquadro di visualizzazione corrente nel buffer. Lo scorrimento, se disponibile, non si verificherà.

Posizionamento del cursore

Le tabelle seguenti includono le sequenze di tipo CSI (Control Sequence Introducer). Tutte le sequenze CSI iniziano con ESC (0x1B) seguite da [ (parentesi quadra sinistra, 0x5B) e possono contenere parametri di lunghezza variabile per specificare altre informazioni per ogni operazione. Tali informazioni saranno rappresentate dalla sintassi abbreviata <n>. Ogni tabella riportata di seguito è raggruppata per funzionalità, con note sotto ogni tabella che illustrano il funzionamento del gruppo.

Se non diversamente specificato, le regole seguenti si applicano a tutti i parametri:

• <n> rappresenta la distanza di spostamento ed è un parametro facoltativo
• Se <n> viene omesso o è uguale a 0, verrà considerato come 1
• <n> non può essere maggiore di 32.767 (valore short massimo)
• <n> non può essere un valore negativo

Tutti i comandi inclusi in questa sezione sono generalmente equivalenti alla chiamata dell'API della console SetConsoleCursorPosition.

Lo spostamento del cursore verrà limitato dal riquadro di visualizzazione corrente nel buffer. Lo scorrimento, se disponibile, non si verificherà.

Visibilità del cursore

I comandi seguenti controllano la visibilità del cursore e del relativo stato intermittente. Le sequenze DECTCEM sono generalmente equivalenti alla chiamata dell'API della console SetConsoleCursorInfo per attivare o disattivare la visibilità del cursore.

Forma cursore

I comandi seguenti controllano e consentono la personalizzazione della forma del cursore.

Posizionamento del riquadro di visualizzazione

Tutti i comandi inclusi in questa sezione sono generalmente equivalenti alla chiamata dell'API della console ScrollConsoleScreenBuffer per spostare il contenuto del buffer della console.

Attenzione I nomi dei comandi sono fuorvianti. Il termine "scorrere" si riferisce alla direzione di spostamento del testo durante l'operazione, non alla modalità di spostamento del riquadro di visualizzazione.

Il testo viene spostato a partire dalla riga in cui si trova il cursore. Se il cursore si trova nella riga centrale del riquadro di visualizzazione, lo scorrimento verso l'alto determinerà lo spostamento della metà inferiore del riquadro e l'inserimento di righe vuote in fondo. Lo scorrimento verso il basso determinerà lo spostamento della metà superiore delle righe del riquadro di visualizzazione e l'inserimento di nuove righe in cima.

È inoltre importante notare che lo scorrimento verso l'alto e lo scorrimento verso il basso dipendono anche dai margini di scorrimento. Lo scorrimento verso l'alto e lo scorrimento verso il basso non influiranno sulle righe esterne ai margini di scorrimento.

Il valore predefinito per <n> è 1 che facoltativamente può essere omesso.

Modifica del testo

Tutti i comandi inclusi in questa sezione sono generalmente equivalenti alla chiamata delle API della console FillConsoleOutputCharacter, FillConsoleOutputAttribute e ScrollConsoleScreenBuffer per modificare il contenuto del buffer di testo.

Per ognuna delle sequenze, il valore predefinito di <n>, se omesso, è 0.

Per i comandi seguenti il parametro <n> ha 3 valori validi:

• 0 cancella il contenuto dalla posizione corrente del cursore (inclusa) alla fine della riga o del display
• 1 cancella il contenuto dall'inizio della riga o del display fino alla posizione corrente del cursore inclusa
• 2 cancella il contenuto di tutta la riga o di tutto il display

Formattazione del testo

Tutti i comandi inclusi in questa sezione sono generalmente equivalenti alla chiamata delle API della console SetConsoleTextAttribute per regolare la formattazione di tutte le operazioni di scrittura future nel buffer di testo di output della console.

Questo comando è speciale in quanto la posizione <n> indicata di seguito può accettare da 0 a 16 parametri separati da punti e virgola.

Se non è specificato alcun parametro, si considera come se fosse specificato un singolo parametro 0.

La seguente tabella di valori può essere usata in <n> per rappresentare modalità di formattazione diverse.

Le modalità di formattazione vengono applicate da sinistra a destra. Se si applicano opzioni di formattazione concorrenti, l'opzione più a destra avrà la precedenza.

Per le opzioni che specificano i colori, i colori verranno usati come definito nella tabella dei colori della console, che può essere modificata usando l'API SetConsoleScreenBufferInfoEx. Se la tabella viene modificata in modo che la posizione "blu" visualizzi una sfumatura di rosso RGB, tutte le chiamate a Blu primo piano visualizzeranno il colore rosso fino a quando questa opzione non viene modificata.

Colori estesi

Alcuni emulatori di terminale virtuale supportano una tavolozza di colori più estesa dei 16 colori forniti dalla console di Windows. Per questi colori estesi, la console di Windows sceglierà il colore appropriato più vicino dalla tavola dei 16 colori esistente per la visualizzazione. Diversamente dai valori SGR tipici sopraindicati, i valori estesi utilizzano parametri aggiuntivi dopo l'indicatore iniziale, in base alle informazioni riportate nella tabella seguente.

*Le tavolozze dei colori 88 e 256 gestite internamente per il confronto sono basate sull'emulatore del terminale xterm. Non è possibile modificare le tabelle di confronto o di arrotondamento in questa fase.

Colori dello schermo

Il comando seguente consente all'applicazione di impostare i valori della tavolozza dei colori dello schermo su qualsiasi valore RGB.

I valori RGB devono essere valori esadecimali compresi tra 0 e ff e separati dal carattere barra (ad esempio, rgb:1/24/86).

Si noti che questa sequenza è una sequenza "Comando del sistema operativo" OSC e non un CSI come molte delle altre sequenze elencate e, ad esempio, inizia con "\x1b]", non "\x1b[". Come sequenze OSC, vengono terminate con un terminatore di stringa rappresentato come <ST> e trasmesso con ESC \ (0x1B 0x5C). BEL (0x7) può essere usato invece come carattere di terminazione, ma la forma più lunga è preferibile.

Modifiche della modalità

Si tratta di sequenze che controllano le modalità di input. Esistono due diversi set di modalità di input, ovvero la modalità tasti cursore e la modalità tasti del tastierino. La modalità tasti cursore controlla le sequenze generate dai tasti di direzione, nonché da Home e Fine, mentre la modalità tasti del tastierino controlla le sequenze generate principalmente dai tasti sul tastierino numerico, nonché dai tasti funzione.

Ognuna di queste modalità è una semplice impostazione booleana. La modalità tasti cursore è impostata su normale (impostazione predefinita) o applicazione e la modalità tasti del tastierino è impostata su numerica (impostazione predefinita) o applicazione.

Per le sequenze generate in queste modalità, vedere le sezioni Tasti cursore e Tastierino numerico.

Stato delle query

Tutti i comandi di questa sezione sono in genere equivalenti alla chiamata alle API della console Get* per recuperare informazioni sullo stato del buffer della console corrente.

Tabulazioni

Mentre la console di Windows prevede tradizionalmente che le schede siano a larghezza esclusiva di otto caratteri, *nix applicazioni che usano determinate sequenze possono modificare dove le tabulazioni si trovano all'interno delle finestre della console per ottimizzare lo spostamento del cursore da parte dell'applicazione.

Le sequenze seguenti consentono a un'applicazione di impostare le posizioni delle tabulazioni nella finestra della console, rimuoverle e spostarsi da una posizione all'altra.

• Per CHT e CBT, <n> è un parametro facoltativo (valore predefinito = 1) che indica il numero di volte in cui spostare il cursore nella direzione specificata.
• Se non sono presenti tabulazioni impostate tramite HTS, CHT e CBT, la prima e l'ultima colonna della finestra verranno considerate come le uniche due tabulazioni.
• L'uso di HTS per impostare una tabulazione causerà anche che la console passi alla tabulazione successiva nell'output di un carattere TAB (0x09, '\t'), allo stesso modo di CHT.

Designare il set di caratteri

Le sequenze seguenti consentono a un programma di modificare il mapping del set di caratteri attivo. In questo modo un programma può generare caratteri ASCII a 7 bit, ma visualizzarli come altri glifi nello schermo del terminale. Attualmente gli unici due set di caratteri supportati sono ASCII (impostazione predefinita) e il set di caratteri grafici speciali DEC. Per un elenco di tutti i caratteri rappresentati dal set di caratteri grafici speciali DEC, visitare il sito Web all'indirizzo http://vt100.net/docs/vt220-rm/table2-4.html.

In particolare, la modalità DEC Line Drawing viene usata per disegnare i bordi nelle applicazioni console. La tabella seguente illustra il mapping tra caratteri ASCII e caratteri DEC Line Drawing.

Margini di scorrimento

Le sequenze seguenti consentono a un programma di configurare l'"area di scorrimento" dello schermo interessata dalle operazioni di scorrimento. Si tratta di un subset delle righe regolate quando lo schermo scorre in altro modo, ad esempio in un'istanza riservata o '\n'. Questi margini influiscono anche sulle righe modificate da Inserimento riga (IL) ed Eliminazione riga (DL), Scorrimento verso l'alto (SU) e Scorrimento verso il basso (SD).

I margini di scorrimento possono essere utili soprattutto per fare in modo che una parte dello schermo non scorra quando il resto dello schermo viene riempito, ad esempio con una barra del titolo nella parte superiore o una barra di stato nella parte inferiore dell'applicazione.

Per DECSTBM sono disponibili due parametri facoltativi, <t> e <b>, usati per specificare le righe che rappresentano la riga superiore e quella inferiore dell'area di scorrimento incluse. Se i parametri vengono omessi, <t> viene impostato automaticamente su 1 e <b> sull'altezza del riquadro di visualizzazione corrente.

I margini di scorrimento vanno considerati per buffer. È quindi importante che il buffer alternativo e il buffer principale mantengano impostazioni separate dei margini di scorrimento (di conseguenza, un'applicazione a schermo intero nel buffer alternativo non comprometterà i margini del buffer principale).

Titolo della finestra

I comandi seguenti consentono all'applicazione di impostare il titolo della finestra della console sul parametro <stringa> specificato. Per essere accettata, la stringa deve contenere meno di 255 caratteri. L'operazione è equivalente alla chiamata di SetConsoleTitle con la stringa specificata.

Si noti che queste sequenze sono sequenze di "comando del sistema operativo" OSC e non un CSI come molte delle altre sequenze elencate e, di conseguenza, inizia con "\x1b]", non "\x1b[". Come sequenze OSC, vengono terminate con un terminatore di stringa rappresentato come <ST> e trasmesso con ESC \ (0x1B 0x5C). BEL (0x7) può essere usato invece come carattere di terminazione, ma la forma più lunga è preferibile.

Il carattere di terminazione qui è il carattere "Bell", '\x07'

Buffer alternativo dello schermo

*Le applicazioni di stile Nix spesso utilizzano un buffer dello schermo alternativo, in modo che possano modificare l'intero contenuto del buffer, senza influire sull'applicazione che li ha avviati. Il buffer alternativo è esattamente delle dimensioni della finestra, senza area di scrollback.

Per un esempio di questo comportamento, si prenda in considerazione quando vim viene avviato da bash. Vim usa l'intero schermo per modificare il file e quindi, tornando a bash, lascia invariato il buffer originale.

Larghezza della finestra

Le sequenze seguenti possono essere usate per controllare la larghezza della finestra della console. Sono approssimativamente equivalenti alla chiamata dell'API della console SetConsoleScreenBufferInfoEx per impostare la larghezza della finestra.

Soft reset

La sequenza seguente può essere usata per reimpostare i valori predefiniti di determinate proprietà. Le proprietà seguenti vengono reimpostate sui valori predefiniti indicati di seguito (sono elencate anche le sequenze che controllano tali proprietà):

• Visibilità cursore: visibile (DECTEM)
• Tastierino numerico: modalità numerica (DECNKM)
• Modalità tasti cursore: modalità normale (DECCKM)
• Margini superiore e inferiore: Top=1, Bottom=Altezza console (DECSTBM)
• Set di caratteri: US ASCII
• Rendering grafico: impostazione predefinita/disattivata (SGR)
• Salva stato cursore: posizione iniziale (0,0) (DECSC)

Sequenze di input

Le sequenze di terminale seguenti vengono generate dall'host della console nel flusso di input se il flag ENABLE_VIRTUAL_TERMINAL_INPUT è impostato sull'handle del buffer di input usando il flag SetConsoleMode.

Sono disponibili due modalità interne che controllano le sequenze generate per i tasti di input specificati: la modalità tasti cursore e la modalità tasti del tastierino. Queste modalità sono descritte nella sezione Modifiche della modalità.

Tasti cursore

Inoltre, se si preme CTRL con uno qualsiasi di questi tasti, vengono generate le sequenze seguenti, indipendentemente dalla modalità tasti cursore:

Tastierino numerico e tasti funzione

Modificatori

Alt viene trattato anteponendo alla sequenza un carattere di escape: ESC <c> dove <c> è il carattere passato dal sistema operativo. La combinazione di tasti ALT + CTRL viene gestita allo stesso modo, tranne per il fatto che il sistema operativo avrà preliminarmente spostato il tasto <c> sul carattere di controllo appropriato che verrà inoltrato all'applicazione.

Il tasto CTRL viene in genere passato esattamente come viene ricevuto dal sistema. Si tratta in genere di un singolo carattere spostato nello spazio riservato al carattere di controllo (0x0-0x1f). Ad esempio, CTRL+@ (0x40) diventa NUL (0x00), CTRL+[ (0x5b) diventa ESC (0x1b) e così via. Alcune combinazioni di tasti CTRL vengono trattate appositamente in base alla tabella seguente:

Esempi

Esempio di sequenze di terminale SGR

Il codice seguente fornisce alcuni esempi di formattazione del testo.

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

La figura seguente mostra l'output dell'esempio di codice precedente.

Esempio di abilitazione dell'elaborazione del terminale virtuale

Il codice seguente fornisce un esempio della modalità consigliata per abilitare l'elaborazione del terminale virtuale per un'applicazione. Lo scopo dell'esempio è dimostrare quanto segue:

1. La modalità esistente deve sempre essere recuperata tramite GetConsoleMode e analizzata prima di essere impostata con SetConsoleMode.

2. Controllare se SetConsoleMode restituisce 0 e GetLastError restituisce ERROR_INVALID_PARAMETER è il meccanismo corrente per determinare quando viene eseguito in un sistema di livello inferiore. Un'applicazione che riceve ERROR_INVALID_PARAMETER con uno dei flag di modalità console più recenti nel campo bit dovrebbe ridurre normalmente il comportamento e riprovare.

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

Esempio di alcune funzionalità dell'aggiornamento dell'anniversario

L'esempio seguente è destinato a essere un esempio di codice più affidabile che usa una serie di sequenze di escape per modificare il buffer, con particolare attenzione alle funzionalità aggiunte nell'aggiornamento dell'anniversario per Windows 10.

Questo esempio usa il buffer alternativo dello schermo, la modifica delle tabulazioni, l'impostazione dei margini di scorrimento e la modifica del set di caratteri.

// 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");

}