Sekwencje konsoli wirtualnego terminala

Wirtualne sekwencje terminali to sekwencje znaków sterowania, które mogą kontrolować ruch kursora, kolor konsoli i inne operacje podczas zapisywania do strumienia wyjściowego. Sekwencje mogą być również odbierane na strumieniu wejściowym w odpowiedzi na sekwencję informacji o kwerendzie strumienia wyjściowego lub jako kodowanie danych wejściowych użytkownika po ustawieniu odpowiedniego trybu.

Aby skonfigurować to zachowanie, można użyć funkcji GetConsoleMode i SetConsoleMode . Na końcu tego dokumentu znajduje się przykład sugerowanego sposobu włączania zachowań terminali wirtualnych.

Zachowanie poniższych sekwencji opiera się na technologiach emulatora terminalu VT100 i pochodnych, a w szczególności na emulatorze terminalu xterm. Więcej informacji o sekwencjach terminali można znaleźć na stronie i pod http://vt100.net adresem http://invisible-island.net/xterm/ctlseqs/ctlseqs.html.

Sekwencje wyjściowe

Następujące sekwencje terminalu są przechwytywane przez hosta konsoli podczas zapisywania w strumieniu wyjściowym, jeśli flaga ENABLE_VIRTUAL_TERMINAL_PROCESSING jest ustawiona na uchwyt buforu ekranu przy użyciu funkcji SetConsoleMode . Należy pamiętać, że flaga DISABLE_NEWLINE_AUTO_RETURN może być również przydatna w emulowaniu położenia kursora i przewijaniu innych emulatorów terminalu w odniesieniu do znaków zapisanych w końcowej kolumnie w dowolnym wierszu.

Proste pozycjonowanie kursora

We wszystkich poniższych opisach esc to zawsze wartość szesnastkowa 0x1B. Nie należy uwzględniać spacji w sekwencjach terminali. Poszczególne sekwencje terminalowe można podzielić na dowolny znak lub pozycję bajtów w wielu sekwencyjnych wywołaniach metody WriteFile lub WriteConsole , ale najlepszym rozwiązaniem jest uwzględnienie całej sekwencji w jednym wywołaniu. Przykład użycia tych sekwencji w praktyce można znaleźć w przykładzie na końcu tego tematu.

W poniższej tabeli opisano proste sekwencje ucieczki za pomocą pojedynczego polecenia akcji bezpośrednio po znaku ESC. Te sekwencje nie mają żadnych parametrów i natychmiast zastosować je.

Wszystkie polecenia w tej tabeli są zwykle równoważne wywołaniu interfejsu API konsoli SetConsoleCursorPosition , aby umieścić kursor.

Ruch kursora zostanie ograniczony przez bieżące wyeksportuj do buforu. Przewijanie (jeśli jest dostępne) nie zostanie wykonane.

Pozycjonowanie kursora

Poniższe tabele obejmują sekwencje typów Control Sequence Introducer (CSI). Wszystkie sekwencje CSI zaczynają się od esc (0x1B), a następnie [ (lewy nawias, 0x5B) i mogą zawierać parametry zmiennej długości, aby określić więcej informacji dla każdej operacji. Będzie to reprezentowane przez skrót <n>. Każda poniższa tabela jest pogrupowana według funkcji z notatkami poniżej każdej tabeli wyjaśniającej, jak działa grupa.

Dla wszystkich parametrów obowiązują następujące reguły, chyba że określono inaczej:

• <n> reprezentuje odległość do przeniesienia i jest opcjonalnym parametrem
• Jeśli <n> zostanie pominięty lub równy 0, będzie traktowany jako 1
• <n> nie może być większe niż 32 767 (maksymalna krótka wartość)
• <n> nie może być ujemna

Wszystkie polecenia w tej sekcji są zwykle równoważne wywołaniu interfejsu API konsoli SetConsoleCursorPosition .

Ruch kursora zostanie ograniczony przez bieżące wyeksportuj do buforu. Przewijanie (jeśli jest dostępne) nie zostanie wykonane.

Widoczność kursora

Następujące polecenia kontrolują widoczność kursora i jego stan. Sekwencje DECTCEM są zwykle równoważne wywołaniu interfejsu API konsoli SetConsoleCursorInfo , aby przełączyć widoczność kursora.

Kształt kursora

Następujące polecenia kontrolują i umożliwiają dostosowanie kształtu kursora.

Pozycjonowanie widoku

Wszystkie polecenia w tej sekcji są zwykle równoważne wywołaniu interfejsu API konsoli ScrollConsoleScreenBuffer w celu przeniesienia zawartości buforu konsoli.

Ostrożność Nazwy poleceń są mylące. Przewijanie odwołuje się do kierunku, w którym tekst jest przesuwany podczas operacji, a nie do tego, w jaki sposób widokport wydaje się przenosić.

Tekst jest przenoszony od wiersza, na który znajduje się kursor. Jeśli kursor znajduje się w środkowym wierszu okna widoku, przewiń w górę spowoduje przeniesienie dolnej połowy okna widoku i wstawienie pustych wierszy u dołu. Przewinięcie w dół spowoduje przeniesienie górnej połowy wierszy widoku i wstawienie nowych wierszy u góry.

Należy również pamiętać, że przewijanie w górę i w dół również wpływa na marginesy przewijania. Przewijanie w górę i w dół nie wpłynie na żadne wiersze poza marginesami przewijania.

Wartość domyślna n <> to 1, a wartość można opcjonalnie pominąć.

Modyfikacja tekstu

Wszystkie polecenia w tej sekcji są zwykle równoważne wywołaniu interfejsów API konsoli FillConsoleOutputCharacter, FillConsoleOutputAttribute i ScrollConsoleScreenBuffer w celu zmodyfikowania zawartości buforu tekstu.

Dla każdej z sekwencji wartość domyślna n<>, jeśli zostanie pominięta, to 0.

W przypadku następujących poleceń parametr <n> ma 3 prawidłowe wartości:

• 0 wymazuje się z bieżącego położenia kursora (włącznie) na końcu wiersza/wyświetlania
• 1 wymazuje się z początku wiersza/wyświetlania do i uwzględnia bieżące położenie kursora
• 2 usuwa cały wiersz/wyświetlacz

Formatowanie tekstu

Wszystkie polecenia w tej sekcji są zwykle równoważne wywołaniu interfejsów API konsoli SetConsoleTextAttribute w celu dostosowania formatowania wszystkich przyszłych zapisów do buforu tekstu wyjściowego konsoli.

To polecenie jest specjalne, ponieważ <n> pozycji poniżej może zaakceptować od 0 do 16 parametrów oddzielonych średnikami.

Jeśli nie określono parametrów, jest traktowany tak samo jak jeden parametr 0.

Poniższa tabela wartości może służyć w <n> do reprezentowania różnych trybów formatowania.

Tryby formatowania są stosowane od lewej do prawej. Zastosowanie konkurencyjnych opcji formatowania spowoduje, że pierwszeństwo będzie miało najbardziej odpowiednia opcja.

W przypadku opcji określających kolory kolory będą używane zgodnie z definicją w tabeli kolorów konsoli, które można modyfikować przy użyciu interfejsu API SetConsoleScreenBufferInfoEx . Jeśli tabela zostanie zmodyfikowana tak, aby pozycja "niebieska" w tabeli wyświetlała odcień RGB na czerwono, wszystkie wywołania elementu Foreground Blue będą wyświetlać ten czerwony kolor do momentu zmiany w inny sposób.

Kolory rozszerzone

Niektóre emulatory terminali wirtualnych obsługują paletę kolorów większych niż 16 kolorów dostarczonych przez konsolę systemu Windows. W przypadku tych kolorów rozszerzonych konsola systemu Windows wybierze najbliższy odpowiedni kolor z istniejącej tabeli kolorów 16 do wyświetlenia. W przeciwieństwie do typowych wartości SGR powyżej wartości rozszerzone będą zużywać dodatkowe parametry po początkowym wskaźniku zgodnie z poniższą tabelą.

*Palety kolorów 88 i 256 obsługiwane wewnętrznie na potrzeby porównania są oparte na emulatorze terminalu xterm. Obecnie nie można modyfikować tabel porównania/zaokrąglania.

Kolory ekranu

Następujące polecenie umożliwia aplikacji ustawienie wartości palety kolorów ekranu na dowolną wartość RGB.

Wartości RGB powinny być wartościami szesnastkowymi między 0 i ff, a oddzielone znakiem ukośnika do przodu (np. rgb:1/24/86).

Należy pamiętać, że ta sekwencja to sekwencja OSC "Polecenie systemu operacyjnego", a nie CSI, taka jak wiele innych wymienionych sekwencji, a w związku z tym zaczyna się od "\x1b]", a nie "\x1b[". Jako sekwencje OSC są one zakończone terminatorem ciągu reprezentowanym jako <ST> i przesyłane za ESC \ pomocą (0x1B 0x5C). BEL (0x7) może być używany zamiast tego jako terminator, ale preferowana jest dłuższa forma.

Zmiany trybu

Są to sekwencje sterujące trybami wprowadzania. Istnieją dwa różne zestawy trybów wprowadzania, Tryb kursora i Tryb klawiatury. Tryb kursora kontroluje sekwencje emitowane przez strzałek, a także Home and End, podczas gdy tryb klawiatury kontroluje sekwencje emitowane przez klucze na numpad przede wszystkim, a także klucze funkcji.

Każdy z tych trybów jest prostymi ustawieniami logicznymi — tryb kursora jest normalny (domyślny) lub aplikacja, a tryb kluczy klawiatury jest numeryczny (domyślny) lub Aplikacja.

Zobacz sekcje kursora i funkcji Numpad i Function, aby zapoznać się z sekwencjami emitowanych w tych trybach.

Stan zapytania

Wszystkie polecenia w tej sekcji są zwykle równoważne wywołaniu interfejsów API konsoli Get* w celu pobrania informacji o stanie bieżącego stanu buforu konsoli.

Karty

Chociaż konsola systemu Windows tradycyjnie oczekuje, że karty będą mieć wyłącznie osiem znaków szerokości, *aplikacje nix korzystające z niektórych sekwencji mogą manipulować, gdzie tabulatory znajdują się w oknach konsoli, aby zoptymalizować ruch kursora przez aplikację.

Następujące sekwencje umożliwiają aplikacji ustawianie lokalizacji zatrzymania tabulatora w oknie konsoli, usuwanie ich i nawigowanie między nimi.

• W przypadku zarówno CHT, jak i CBT n> jest opcjonalnym parametrem wskazującym, <ile razy należy przejść kursor w określonym kierunku.
• Jeśli nie ma żadnych zatrzymań tabulatorów ustawionych za pośrednictwem HTS, CHT i CBT będą traktować pierwsze i ostatnie kolumny okna jako jedyną kartę zatrzymuje się.
• Użycie funkcji HTS do ustawienia zatrzymania karty spowoduje również przejście konsoli do następnego zatrzymania karty na danych wyjściowych tabulatora (0x09, '\t'), w taki sam sposób jak CHT.

Wyznaczanie zestawu znaków

Następujące sekwencje umożliwiają programowi zmianę mapowania aktywnego zestawu znaków. Dzięki temu program może emitować 7-bitowe znaki ASCII, ale wyświetlać je jako inne glify na samym ekranie terminalu. Obecnie jedynymi obsługiwanymi zestawami znaków są ASCII (ustawienie domyślne) i zestaw znaków specjalnych DEC. Zobacz http://vt100.net/docs/vt220-rm/table2-4.html listę wszystkich znaków reprezentowanych przez zestaw znaków specjalnych DEC.

W szczególności tryb rysunku liniowego DEC jest używany do rysowania obramowań w aplikacjach konsoli. W poniższej tabeli przedstawiono, co znak ASCII mapuje na jaki znak rysunku wiersza.

Przewijanie marginesów

Następujące sekwencje umożliwiają programowi skonfigurowanie "regionu przewijania" ekranu, którego dotyczy operacja przewijania. Jest to podzbiór wierszy, które są dostosowywane, gdy ekran w przeciwnym razie przewija się, na przykład na\n" lub wystąpień zarezerwowanych. Te marginesy wpływają również na wiersze zmodyfikowane przez wstaw wiersz (IL) i usuń linię (DL), przewiń w górę (SU) i przewiń w dół (SD).

Marginesy przewijania mogą być szczególnie przydatne w przypadku części ekranu, która nie przewija się po wypełnieniu reszty ekranu, na przykład paska tytułu u góry lub paska stanu w dolnej części aplikacji.

W przypadku DECSTBM istnieją dwa parametry opcjonalne, <t> i <b>, które są używane do określania wierszy reprezentujących górne i dolne linie regionu przewijania, włącznie. Jeśli parametry zostaną pominięte, <wartość t> jest domyślnie ustawiona na 1 i <b> na bieżącą wysokość widoku.

Marginesy przewijania są buforem, więc co ważne, bufor alternatywny i bufor główny zachowują oddzielne ustawienia marginesów przewijania (więc aplikacja pełnoekranowa w buforze alternatywnym nie zatruwa marginesów buforu głównego).

Tytuł okna

Następujące polecenia umożliwiają aplikacji ustawienie tytułu okna konsoli na podany <parametr ciągu> . Ciąg musi być akceptowany mniej niż 255 znaków. Jest to odpowiednik wywołania metody SetConsoleTitle z danym ciągiem.

Należy pamiętać, że te sekwencje to sekwencje OSC "Polecenie systemu operacyjnego", a nie CSI, takie jak wiele innych wymienionych sekwencji, a w związku z tym rozpoczyna się od "\x1b]", a nie "\x1b[". Jako sekwencje OSC są one zakończone terminatorem ciągu reprezentowanym jako <ST> i przesyłane za ESC \ pomocą (0x1B 0x5C). BEL (0x7) może być używany zamiast tego jako terminator, ale preferowana jest dłuższa forma.

Znak zakończenia w tym miejscu to znak "Bell", "\x07"

Alternatywny bufor ekranu

*Aplikacje w stylu Nix często korzystają z alternatywnego buforu ekranu, dzięki czemu mogą modyfikować całą zawartość buforu bez wpływu na aplikację, która je uruchomiła. Alternatywny bufor jest dokładnie wymiarami okna bez żadnego regionu przewijania.

Na przykład tego zachowania rozważ uruchomienie programu vim z powłoki bash. Program Vim używa całego ekranu do edycji pliku, a następnie powrotu do powłoki bash pozostawia oryginalny bufor bez zmian.

Szerokość okna

Poniższe sekwencje mogą służyć do kontrolowania szerokości okna konsoli. Są one w przybliżeniu równoważne wywołaniu interfejsu API konsoli SetConsoleScreenBufferInfoEx w celu ustawienia szerokości okna.

Resetowanie nietrwałe

Poniższa sekwencja może służyć do resetowania niektórych właściwości do ich wartości domyślnych. Następujące właściwości są resetowane do następujących wartości domyślnych (wymienione są również sekwencje kontrolujące te właściwości):

• Widoczność kursora: widoczne (DECTEM)
• Klawiatura liczbowa: tryb liczbowy (DECNKM)
• Tryb kursora: tryb normalny (DECCKM)
• Marginesy górne i dolne: Top=1, Bottom=Console height (DECSTBM)
• Zestaw znaków: US ASCII
• Odwzorowanie grafiki: domyślne/wyłączone (SGR)
• Zapisz stan kursora: pozycja strony głównej (0,0) (DECSC)

Sekwencje wejściowe

Następujące sekwencje terminalu są emitowane przez hosta konsoli w strumieniu wejściowym, jeśli flaga ENABLE_VIRTUAL_TERMINAL_INPUT jest ustawiona na dojściu buforu wejściowego przy użyciu flagi SetConsoleMode.

Istnieją dwa tryby wewnętrzne kontrolujące, które sekwencje są emitowane dla podanych kluczy wejściowych, tryb kursora i tryb klawiatury. Są one opisane w sekcji Mode Changes (Zmiany trybu).

kursora

Ponadto w przypadku naciśnięcia Ctrl przy użyciu dowolnego z tych następujące sekwencje są emitowane zamiast tego niezależnie od trybu kursora:

Numpad i funkcji

Modyfikatorów

Alt jest traktowany przez prefiks sekwencji z ucieczką: ESC <c gdzie <c>> jest znakiem przekazywanym przez system operacyjny. Alt+Ctrl są obsługiwane w taki sam sposób, z tą różnicą, że system operacyjny będzie wstępnie przesunięty <c> do odpowiedniego znaku sterującego, który zostanie przekazany do aplikacji.

Naciśnięcie Ctrl jest zwykle przekazywane dokładnie tak, jak odebrano z systemu. Zazwyczaj jest to pojedynczy znak przesunięty w dół do zarezerwowanego miejsca znaku sterującego (0x0-0x1f). Na przykład ctrl+@ (0x40) staje się NUL (0x00), Ctrl+[ (0x5b) staje się ESC (0x1b), itp. Kilka kombinacji Ctrl jest traktowanych specjalnie zgodnie z poniższą tabelą:

Próbki

Przykład sekwencji terminali SGR

Poniższy kod zawiera kilka przykładów formatowania tekstu.

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

Poniższa ilustracja przedstawia dane wyjściowe poprzedniego przykładu kodu.

Przykład włączania wirtualnego przetwarzania terminalu

Poniższy kod zawiera przykład zalecany sposób włączania przetwarzania terminali wirtualnych dla aplikacji. Celem przykładu jest pokazanie:

1. Istniejący tryb powinien być zawsze pobierany za pośrednictwem funkcji GetConsoleMode i analizowany przed ustawieniem polecenia SetConsoleMode.

2. Sprawdzanie, czy funkcja SetConsoleMode zwraca 0 polecenie GetLastError, a funkcja GetLastError zwraca ERROR_INVALID_PARAMETER jest bieżącym mechanizmem do określenia podczas uruchamiania w systemie na poziomie podrzędnym. Aplikacja odbierana ERROR_INVALID_PARAMETER z jedną z nowszych flag trybu konsoli w polu bitowym powinna bezpiecznie obniżyć zachowanie i spróbować ponownie.

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

Przykład wybierania funkcji aktualizacji rocznicowej

Poniższy przykład ma być bardziej niezawodnym przykładem kodu używającego różnych sekwencji ucieczki do manipulowania buforem, z naciskiem na funkcje dodane w rocznicowej aktualizacji systemu Windows 10.

W tym przykładzie użyto alternatywnego buforu ekranu, manipulowania zatrzymaniem tabulatorów, ustawianiem marginesów przewijania i zmienianiem zestawu znaków.

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

}