Secuencias de terminal virtuales de la consola

Las secuencias de terminal virtual son secuencias de caracteres de control que pueden controlar el movimiento del cursor, el color de la consola y otras operaciones cuando se escriben en el flujo de salida. También se pueden recibir secuencias en el flujo de entrada en respuesta a una secuencia de información de consulta de flujo de salida o como codificación de la entrada del usuario cuando se establece el modo adecuado.

Puede usar las funciones GetConsoleMode y SetConsoleMode para configurar este comportamiento. Al final de este documento se incluye un ejemplo de la manera sugerida de habilitar comportamientos de terminal virtual.

El comportamiento de las siguientes secuencias se basa en las tecnologías de emulador de terminal VT100 y derivadas, más específicamente en el emulador de terminal xterm. Puede encontrar más información sobre las secuencias de terminal en http://vt100.net y en http://invisible-island.net/xterm/ctlseqs/ctlseqs.html.

Secuencias de salida

El host de consola intercepta las siguientes secuencias de terminal cuando se escriben en el flujo de salida, si la marca ENABLE_VIRTUAL_TERMINAL_PROCESSING se establece en el identificador de búfer de pantalla mediante la función SetConsoleMode . Tenga en cuenta que la marca DISABLE_NEWLINE_AUTO_RETURN también puede ser útil para simular el posicionamiento del cursor y el comportamiento de desplazamiento de otros emuladores de terminal en relación con los caracteres escritos en la columna final de cualquier fila.

Posicionamiento simple del cursor

En todas las descripciones siguientes, ESC siempre es el valor hexadecimal 0x1B. No hay espacios que se incluyan en secuencias terminales. Las secuencias de terminal individuales se pueden dividir, en cualquier posición de carácter o byte, en varias llamadas secuenciales a WriteFile o WriteConsole , pero es recomendable incluir toda la secuencia en una sola llamada. Para obtener un ejemplo de cómo se usan estas secuencias en la práctica, consulte el ejemplo al final de este tema.

En la tabla siguiente se describen secuencias de escape simples con un solo comando de acción directamente después del carácter ESC. Estas secuencias no tienen parámetros y surten efecto inmediatamente.

Todos los comandos de esta tabla suelen ser equivalentes a llamar a la API de consola SetConsoleCursorPosition para colocar el cursor.

El movimiento del cursor se enlazará mediante la ventanilla actual en el búfer. No se producirá el desplazamiento (si está disponible).

Posicionamiento de cursores

Las tablas siguientes abarcan secuencias de tipos del introducidor de secuencia de control (CSI). Todas las secuencias CSI comienzan con ESC (0x1B) seguidas de [ (corchete izquierdo, 0x5B) y pueden contener parámetros de longitud variable para especificar más información para cada operación. Esto se representará mediante la abreviatura <n>. Cada tabla siguiente se agrupa por funcionalidad con notas debajo de cada tabla que explica cómo funciona el grupo.

Para todos los parámetros, se aplican las reglas siguientes a menos que se indique lo contrario:

• <n> representa la distancia que se va a mover y es un parámetro opcional.
• Si <n> se omite o es igual a 0, se tratará como 1.
• <n> no puede ser mayor que 32 767 (valor corto máximo)
• <n> no puede ser negativo

Todos los comandos de esta sección suelen ser equivalentes a llamar a la API de consola SetConsoleCursorPosition .

El movimiento del cursor se enlazará mediante la ventanilla actual en el búfer. No se producirá el desplazamiento (si está disponible).

Visibilidad del cursor

Los siguientes comandos controlan la visibilidad del cursor y su estado de parpadeo. Las secuencias DECTCEM suelen ser equivalentes a llamar a la API de consola SetConsoleCursorInfo para alternar la visibilidad del cursor.

Forma del cursor

Los siguientes comandos controlan y permiten la personalización de la forma del cursor.

Posicionamiento de ventanilla

Todos los comandos de esta sección suelen ser equivalentes a llamar a la API de consola ScrollConsoleScreenBuffer para mover el contenido del búfer de la consola.

Cautela Los nombres de comando son engañosos. El desplazamiento hace referencia a la dirección en la que se mueve el texto durante la operación, no en qué forma parecería moverse la ventanilla.

El texto se mueve a partir de la línea en la que está el cursor. Si el cursor está en la fila central de la ventanilla, desplácese hacia arriba movería la mitad inferior de la ventanilla e insertaría líneas en blanco en la parte inferior. Desplazarse hacia abajo movería la mitad superior de las filas de la ventanilla e insertaría nuevas líneas en la parte superior.

También es importante tener en cuenta que el desplazamiento hacia arriba y hacia abajo también se ve afectado por los márgenes de desplazamiento. Desplazarse hacia arriba y hacia abajo no afectará a ninguna línea fuera de los márgenes de desplazamiento.

El valor predeterminado para <n> es 1 y el valor se puede omitir opcionalmente.

Modificación de texto

Todos los comandos de esta sección suelen ser equivalentes a llamar a fillConsoleOutputCharacter, FillConsoleOutputAttribute y las API de consola ScrollConsoleScreenBuffer para modificar el contenido del búfer de texto.

Para cada una de las secuencias, el valor predeterminado de <n> si se omite es 0.

Para los siguientes comandos, el parámetro <n> tiene 3 valores válidos:

• 0 borra de la posición actual del cursor (incluido) al final de la línea o pantalla
• 1 borra desde el principio de la línea o presentación hasta e incluye la posición actual del cursor
• 2 borra toda la línea o pantalla

Formato de texto

Todos los comandos de esta sección suelen ser equivalentes a llamar a las API de consola SetConsoleTextAttribute para ajustar el formato de todas las escrituras futuras en el búfer de texto de salida de la consola.

Este comando es especial en que la <posición n> siguiente puede aceptar entre 0 y 16 parámetros separados por punto y coma.

Cuando no se especifica ningún parámetro, se trata igual que un único parámetro 0.

La siguiente tabla de valores se puede usar en <n> para representar diferentes modos de formato.

Los modos de formato se aplican de izquierda a derecha. La aplicación de opciones de formato de competencia dará lugar a que la opción más adecuada tenga prioridad.

Para las opciones que especifican colores, los colores se usarán según se define en la tabla de colores de la consola que se puede modificar mediante la API SetConsoleScreenBufferInfoEx . Si la tabla se modifica para hacer que la posición "azul" de la tabla muestre un tono RGB de rojo, todas las llamadas a Foreground Blue mostrarán ese color rojo hasta que cambie lo contrario.

Colores extendidos

Algunos emuladores de terminal virtual admiten una paleta de colores mayor que los 16 colores proporcionados por la consola de Windows. Para estos colores extendidos, la consola de Windows elegirá el color más cercano adecuado de la tabla de colores existente de 16 para su visualización. A diferencia de los valores típicos de SGR anteriores, los valores extendidos consumirán parámetros adicionales después del indicador inicial según la tabla siguiente.

*Las paletas de colores 88 y 256 mantenidas internamente para la comparación se basan en el emulador de terminal xterm. Las tablas de comparación y redondeo no se pueden modificar en este momento.

Colores de pantalla

El siguiente comando permite a la aplicación establecer los valores de la paleta de colores de pantalla en cualquier valor RGB.

Los valores RGB deben ser valores hexadecimales entre 0 y ffy y separados por el carácter de barra diagonal (por ejemplo, rgb:1/24/86).

Tenga en cuenta que esta secuencia es una secuencia de OSC "Comando del sistema operativo", y no csi como muchas de las otras secuencias enumeradas, y como tal comienza con "\x1b]", no "\x1b[". Como secuencias de OSC, finalizan con un terminador de cadena representado como <ST> y transmitido con ESC \ (0x1B 0x5C). BEL (0x7) se puede usar en su lugar como terminador, pero se prefiere el formato más largo.

Cambios en modo

Estas son secuencias que controlan los modos de entrada. Hay dos conjuntos diferentes de modos de entrada, el modo de teclas de cursor y el modo de teclas del Teclado. El modo de teclas de cursor controla las secuencias emitidas por las teclas de dirección, así como inicio y fin, mientras que el modo de teclas del teclado controla las secuencias emitidas por las teclas en el teclado numérico principalmente, así como las teclas de función.

Cada uno de estos modos es una configuración booleana simple: el modo de teclas de cursor es Normal (predeterminado) o Aplicación, y el modo de claves del Teclado es Numérico (predeterminado) o Aplicación.

Consulte las secciones Teclas de cursor y Numpad y Teclas de función para ver las secuencias emitidas en estos modos.

Estado de consulta

Todos los comandos de esta sección suelen ser equivalentes a llamar a las API de consola Get* para recuperar información de estado sobre el estado actual del búfer de la consola.

Pestañas

Aunque la consola de Windows espera que las pestañas sean exclusivamente ocho caracteres de ancho, *nix aplicaciones que usan determinadas secuencias pueden manipular dónde se encuentran las tabulaciones dentro de las ventanas de consola para optimizar el movimiento del cursor por parte de la aplicación.

Las secuencias siguientes permiten a una aplicación establecer las ubicaciones de tabulación dentro de la ventana de la consola, quitarlas y navegar entre ellas.

• Para CHT y CBT, <n> es un parámetro opcional que (default=1) indica cuántas veces se debe avanzar el cursor en la dirección especificada.
• Si no hay tabulaciones establecidas a través de HTS, CHT y CBT tratarán las primeras y últimas columnas de la ventana como las dos únicas tabulaciones.
• El uso de HTS para establecer una tabulación también hará que la consola navegue hasta la siguiente tabulación en la salida de un carácter TAB (0x09, '\t'), de la misma manera que CHT.

Designar juego de caracteres

Las secuencias siguientes permiten que un programa cambie la asignación del juego de caracteres activo. Esto permite que un programa emita caracteres ASCII de 7 bits, pero que se muestren como otros glifos en la propia pantalla del terminal. Actualmente, los dos únicos juegos de caracteres admitidos son ASCII (valor predeterminado) y el juego de caracteres gráficos especiales de DEC. Vea http://vt100.net/docs/vt220-rm/table2-4.html para obtener una lista de todos los caracteres representados por el juego de caracteres gráficos especiales de DEC.

En particular, el modo de dibujo de línea de DEC se usa para dibujar bordes en aplicaciones de consola. En la tabla siguiente se muestra qué caracteres ASCII se asignan a qué carácter de dibujo de líneas.

Márgenes de desplazamiento

Las secuencias siguientes permiten a un programa configurar la "región de desplazamiento" de la pantalla que se ve afectada por las operaciones de desplazamiento. Se trata de un subconjunto de las filas que se ajustan cuando la pantalla se desplaza de otro modo, por ejemplo, en una "\n" o ri. Estos márgenes también afectan a las filas modificadas por Insert Line (IL) y Delete Line (DL), Scroll Up (SU) y Scroll Down (SD).

Los márgenes de desplazamiento pueden ser especialmente útiles para tener una parte de la pantalla que no se desplaza cuando se rellena el resto de la pantalla, como tener una barra de título en la parte superior o una barra de estado en la parte inferior de la aplicación.

Para DECSTBM, hay dos parámetros opcionales, <t> y <b>, que se usan para especificar las filas que representan las líneas superior e inferior de la región de desplazamiento, inclusivas. Si se omiten los parámetros, <t> tiene como valor predeterminado 1 y <b> el alto de la ventanilla actual.

Los márgenes de desplazamiento son por búfer, por lo que, importantemente, el búfer alternativo y el búfer principal mantienen la configuración de márgenes de desplazamiento independientes (por lo que una aplicación de pantalla completa en el búfer alternativo no envenenará los márgenes del búfer principal).

Título de la ventana

Los comandos siguientes permiten a la aplicación establecer el título de la ventana de la consola en el parámetro de cadena> especificado<. La cadena debe tener menos de 255 caracteres para aceptarse. Esto equivale a llamar a SetConsoleTitle con la cadena especificada.

Tenga en cuenta que estas secuencias son secuencias de OSC "Comando del sistema operativo", y no csi como muchas de las otras secuencias enumeradas, y como tal comienza con "\x1b]", no "\x1b[". Como secuencias de OSC, finalizan con un terminador de cadena representado como <ST> y transmitido con ESC \ (0x1B 0x5C). BEL (0x7) se puede usar en su lugar como terminador, pero se prefiere el formato más largo.

El carácter de terminación aquí es el carácter "Bell", '\x07'

Búfer de pantalla alternativo

*Las aplicaciones de estilo Nix suelen usar un búfer de pantalla alternativo para que puedan modificar todo el contenido del búfer, sin afectar a la aplicación que las inició. El búfer alternativo es exactamente las dimensiones de la ventana, sin ninguna región de desplazamiento.

Para obtener un ejemplo de este comportamiento, considere cuándo se inicia vim desde Bash. Vim usa la totalidad de la pantalla para editar el archivo y, a continuación, volver a Bash deja el búfer original sin cambios.

Ancho de ventana

Las secuencias siguientes se pueden usar para controlar el ancho de la ventana de la consola. Son aproximadamente equivalentes a la llamada a la API de consola SetConsoleScreenBufferInfoEx para establecer el ancho de la ventana.

Restablecimiento temporal

La secuencia siguiente se puede usar para restablecer determinadas propiedades a sus valores predeterminados. Las siguientes propiedades se restablecen a los siguientes valores predeterminados (también se enumeran las secuencias que controlan esas propiedades):

• Visibilidad del cursor: visible (DECTEM)
• Teclado numérico: modo numérico (DECNKM)
• Modo de teclas de cursor: modo normal (DECCKM)
• Márgenes superior e inferior: Top=1, Bottom=Console height (DECSTBM)
• Juego de caracteres: US ASCII
• Representación de gráficos: Valor predeterminado/desactivado (SGR)
• Guardar estado del cursor: Posición principal (0,0) (DECSC)

Secuencias de entrada

El host de consola emite las siguientes secuencias de terminal en el flujo de entrada si la marca ENABLE_VIRTUAL_TERMINAL_INPUT está establecida en el identificador de búfer de entrada mediante la marca SetConsoleMode.

Hay dos modos internos que controlan qué secuencias se emiten para las claves de entrada dadas, el modo de teclas de cursor y el modo de teclas del teclado. Estos se describen en la sección Cambios en modo.

Teclas de cursor

Además, si ctrl se presiona con cualquiera de estas teclas, se emiten en su lugar las siguientes secuencias, independientemente del modo de teclas de cursor:

Numpad & Function Keys

Modificadores

Alt se trata mediante el prefijo de la secuencia con un escape: ESC <c> donde <c> es el carácter pasado por el sistema operativo. Alt+Ctrl se controla de la misma manera, excepto que el sistema operativo tendrá desplazado previamente la <tecla c> al carácter de control adecuado que se retransmitirá a la aplicación.

Por lo general, Ctrl se pasa exactamente como se recibe del sistema. Normalmente, se trata de un solo carácter desplazado hacia abajo en el espacio reservado de caracteres de control (0x0-0x1f). Por ejemplo, Ctrl+@ (0x40) se convierte en NUL (0x00), Ctrl+[ (0x5b) se convierte en ESC (0x1b), etc. Algunas combinaciones de teclas Ctrl se tratan especialmente según la tabla siguiente:

Muestras

Ejemplo de secuencias de terminales SGR

El código siguiente proporciona varios ejemplos de formato de texto.

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

En el gráfico siguiente se muestra la salida del ejemplo de código anterior.

Ejemplo de habilitación del procesamiento de terminal virtual

El código siguiente proporciona un ejemplo de la manera recomendada de habilitar el procesamiento de terminal virtual para una aplicación. La intención del ejemplo es demostrar lo siguiente:

1. El modo existente siempre debe recuperarse a través de GetConsoleMode y analizarse antes de establecerse con SetConsoleMode.

2. Comprobar si SetConsoleMode devuelve 0 y GetLastError devuelve ERROR_INVALID_PARAMETER es el mecanismo actual para determinar cuándo se ejecuta en un sistema de nivel inferior. Una aplicación que recibe ERROR_INVALID_PARAMETER con una de las marcas de modo de consola más recientes en el campo de bits debe degradar correctamente el comportamiento e intentarlo de nuevo.

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

Ejemplo de seleccionar características de actualización de aniversario

El ejemplo siguiente está pensado para ser un ejemplo más sólido de código mediante una variedad de secuencias de escape para manipular el búfer, con énfasis en las características agregadas en la Actualización de aniversario para Windows 10.

En este ejemplo se usa el búfer de pantalla alternativo, la manipulación de tabulaciones, el establecimiento de márgenes de desplazamiento y el cambio del juego de caracteres.

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

}