Sequências de terminais virtuais do console

As sequências de terminal virtual são sequências de caracteres de controle que podem controlar a movimentação do cursor, a cor do console e outras operações quando gravadas no fluxo de saída. As sequências também podem ser recebidas no fluxo de entrada em resposta a uma sequência de informações de consulta de fluxo de saída ou como uma codificação de entrada do usuário quando o modo apropriado é definido.

Você pode usar as funções GetConsoleMode e SetConsoleMode para configurar esse comportamento. Um exemplo da maneira sugerida de habilitar comportamentos de terminal virtual é incluído no final deste documento.

O comportamento das sequências a seguir baseia-se nas tecnologias VT100 e emuladores de terminal derivados, mais especificamente no emulador de terminal xterm. Mais informações sobre sequências de terminal podem ser encontradas em http://vt100.nethttp://invisible-island.net/xterm/ctlseqs/ctlseqs.html.

Sequências de saída

As sequências de terminal a seguir são interceptadas pelo host do console quando gravadas no fluxo de saída, se o sinalizador ENABLE_VIRTUAL_TERMINAL_PROCESSING for definido no identificador do buffer de tela usando a função SetConsoleMode . Observe que o sinalizador de DISABLE_NEWLINE_AUTO_RETURN também pode ser útil para emular o posicionamento do cursor e o comportamento de rolagem de outros emuladores de terminal em relação aos caracteres gravados na coluna final em qualquer linha.

Posicionamento simples do cursor

Em todas as descrições a seguir, ESC é sempre o valor hexadecimal 0x1B. Nenhum espaço deve ser incluído em sequências de terminal. Sequências de terminais individuais podem ser divididas, em qualquer posição de caractere ou byte, em várias chamadas sequenciais para WriteFile ou WriteConsole , mas é uma prática recomendada incluir toda a sequência em uma chamada. Para obter um exemplo de como essas sequências são usadas na prática, consulte o exemplo no final deste tópico.

A tabela a seguir descreve sequências de escape simples com um único comando de ação logo após o caractere ESC. Essas sequências não têm parâmetros e entrarão em vigor imediatamente.

Todos os comandos nesta tabela geralmente são equivalentes a chamar a API do console SetConsoleCursorPosition para colocar o cursor.

O movimento do cursor será limitado pelo visor atual no buffer. A rolagem (se disponível) não ocorrerá.

Posicionamento do cursor

As tabelas a seguir abrangem sequências de tipos CSI (Control Sequence Introducer). Todas as sequências csi começam com ESC (0x1B) seguidos por [ (colchete esquerdo, 0x5B) e podem conter parâmetros de comprimento variável para especificar mais informações para cada operação. Isso será representado pela abreviação <n>. Cada tabela abaixo é agrupada por funcionalidade com anotações abaixo de cada tabela explicando como o grupo funciona.

Para todos os parâmetros, as seguintes regras se aplicam, a menos que indicado de outra forma:

• <n> representa a distância a ser movida e é um parâmetro opcional
• Se <n> for omitido ou igual a 0, ele será tratado como um 1
• <n> não pode ser maior que 32.767 (valor máximo curto)
• <n> não pode ser negativo

Todos os comandos nesta seção geralmente são equivalentes a chamar a API do console SetConsoleCursorPosition .

O movimento do cursor será limitado pelo visor atual no buffer. A rolagem (se disponível) não ocorrerá.

Visibilidade do cursor

Os comandos a seguir controlam a visibilidade do cursor e seu estado piscando. As sequências de DECTCEM geralmente são equivalentes a chamar a API do console SetConsoleCursorInfo para alternar a visibilidade do cursor.

Forma do cursor

Os comandos a seguir controlam e permitem a personalização da forma do cursor.

Posicionamento do visor

Todos os comandos nesta seção geralmente são equivalentes a chamar a API de console ScrollConsoleScreenBuffer para mover o conteúdo do buffer do console.

Cuidado Os nomes de comando são enganosos. A rolagem refere-se à direção em que o texto se move durante a operação, e não para que modo o visor parece se mover.

O texto é movido a partir da linha em que o cursor está ativado. Se o cursor estiver na linha intermediária do visor, role para cima movendo a metade inferior do visor e insira linhas em branco na parte inferior. Rolar para baixo moveria a metade superior das linhas do visor e inseriria novas linhas na parte superior.

Também é importante observar que a rolagem para cima e para baixo também é afetada pelas margens de rolagem. Rolar para cima e para baixo não afetará nenhuma linha fora das margens de rolagem.

O valor padrão para <n> é 1 e o valor pode ser omitido opcionalmente.

Modificação de texto

Todos os comandos nesta seção geralmente são equivalentes a chamar AS APIs de console FillConsoleOutputCharacter, FillConsoleOutputAttribute e ScrollConsoleScreenBuffer para modificar o conteúdo do buffer de texto.

Para cada uma das sequências, o valor padrão para <n> se ele for omitido é 0.

Para os seguintes comandos, o parâmetro <n> tem três valores válidos:

• 0 apaga da posição atual do cursor (inclusive) até o final da linha/exibição
• 1 apaga desde o início da linha/exibição até e incluindo a posição atual do cursor
• 2 apaga toda a linha/exibição

Formatação de Texto

Todos os comandos nesta seção geralmente são equivalentes a chamar APIs de console SetConsoleTextAttribute para ajustar a formatação de todas as gravações futuras no buffer de texto de saída do console.

Esse comando é especial porque a <posição n> abaixo pode aceitar entre 0 e 16 parâmetros separados por ponto-e-vírgula.

Quando nenhum parâmetro é especificado, ele é tratado da mesma forma que um único parâmetro 0.

A tabela de valores a seguir pode ser usada em <n> para representar modos de formatação diferentes.

Os modos de formatação são aplicados da esquerda para a direita. A aplicação de opções de formatação concorrentes resultará na opção mais à direita tendo precedência.

Para opções que especificam cores, as cores serão usadas conforme definido na tabela de cores do console que pode ser modificada usando a API SetConsoleScreenBufferInfoEx . Se a tabela for modificada para tornar a posição "azul" na tabela exibir um tom RGB de vermelho, todas as chamadas para Foreground Blue exibirão essa cor vermelha até que seja alterada de outra forma.

Cores Estendidas

Alguns emuladores de terminal virtual dão suporte a uma paleta de cores maior que as 16 cores fornecidas pelo Console do Windows. Para essas cores estendidas, o Console do Windows escolherá a cor apropriada mais próxima da tabela de cores 16 existente para exibição. Ao contrário dos valores SGR típicos acima, os valores estendidos consumirão parâmetros adicionais após o indicador inicial de acordo com a tabela abaixo.

*As paletas de cores 88 e 256 mantidas internamente para comparação são baseadas no emulador do terminal xterm. As tabelas de comparação/arredondamento não podem ser modificadas no momento.

Cores da Tela

O comando a seguir permite que o aplicativo defina os valores de paleta de cores de tela para qualquer valor RGB.

Os valores RGB devem ser valores hexadecimal entre 0 e ff, e separados pelo caractere de barra de encaminhamento (por exemplo rgb:1/24/86).

Observe que essa sequência é uma sequência "Comando do sistema operacional" da OSC e não um CSI como muitas das outras sequências listadas e, como tal, comece com "\x1b]", não "\x1b[". Como sequências de OSC, elas são encerradas com um Terminador de Cadeia de Caracteres representado como <ST> e transmitido com ESC \ (0x1B 0x5C). BEL (0x7) pode ser usado como terminador, mas o formulário mais longo é preferencial.

Alterações de modo

Estas são sequências que controlam os modos de entrada. Há dois conjuntos diferentes de modos de entrada, o Modo de Teclas de Cursor e o Modo de Teclas do Teclado. O Modo de Teclas de Cursor controla as sequências emitidas pelas teclas de direção, bem como Página Inicial e Final, enquanto o Modo teclas do teclado controla as sequências emitidas pelas teclas no numpad principalmente, bem como as chaves de função.

Cada um desses modos são configurações boolianas simples– o Modo de Teclas de Cursor é Normal (padrão) ou Aplicativo, e o Modo de Teclas do Teclado é Numérico (padrão) ou Aplicativo.

Consulte as seções Teclas de Cursor e Numpad &Chaves de Função para as sequências emitidas nesses modos.

Estado da consulta

Todos os comandos nesta seção geralmente são equivalentes a chamar APIs de console Get* para recuperar informações de status sobre o estado atual do buffer do console.

Guias

Embora o console do Windows tradicionalmente espere que as guias sejam exclusivamente de oito caracteres de largura, *os aplicativos nix que utilizam determinadas sequências podem manipular onde as paradas de tabulação estão dentro das janelas do console para otimizar o movimento do cursor pelo aplicativo.

As sequências a seguir permitem que um aplicativo defina os locais de parada de tabulação dentro da janela do console, remova-os e navegue entre eles.

• Para CHT e CBT, <n> é um parâmetro opcional que (padrão=1) indica quantas vezes o cursor deve avançar na direção especificada.
• Se não houver nenhuma parada de tabulação definida por meio de HTS, CHT e CBT tratarão as primeiras e últimas colunas da janela como as duas únicas paradas de tabulação.
• Usar o HTS para definir uma parada de tabulação também fará com que o console navegue até a próxima parada de tabulação na saída de um caractere TAB (0x09, '\t'), da mesma maneira que o CHT.

Designar conjunto de caracteres

As sequências a seguir permitem que um programa altere o mapeamento do conjunto de caracteres ativo. Isso permite que um programa emita caracteres ASCII de 7 bits, mas que eles sejam exibidos como outros glifos na própria tela do terminal. Atualmente, os dois únicos conjuntos de caracteres com suporte são ASCII (padrão) e o Conjunto de Caracteres gráficos especiais dec. Consulte http://vt100.net/docs/vt220-rm/table2-4.html uma listagem de todos os caracteres representados pelo conjunto de caracteres gráficos especiais dec.

Notavelmente, o modo desenho de linha DEC é usado para desenhar bordas em aplicativos de console. A tabela a seguir mostra o que o caractere ASCII mapeia para qual caractere de desenho de linha.

Margens de rolagem

As sequências a seguir permitem que um programa configure a "região de rolagem" da tela afetada pelas operações de rolagem. Esse é um subconjunto das linhas que são ajustadas quando a tela rolaria de outra forma, por exemplo, em um '\n' ou RI. Essas margens também afetam as linhas modificadas por IL (Insert Line) e Delete Line (DL), Scroll Up (SU) e Scroll Down (SD).

As margens de rolagem podem ser especialmente úteis para ter uma parte da tela que não rola quando o restante da tela é preenchida, como ter uma barra de título na parte superior ou uma barra de status na parte inferior do aplicativo.

Para DECSTBM, há dois parâmetros opcionais, <t> e <b>, que são usados para especificar as linhas que representam as linhas superior e inferior da região de rolagem, inclusive. Se os parâmetros forem omitidos, <o padrão t> será 1 e <b> será padrão para a altura atual do visor.

As margens de rolagem são por buffer, portanto, o Buffer Alternativo e o Buffer Principal mantêm configurações separadas de margens de rolagem (portanto, um aplicativo de tela inteira no buffer alternativo não envenenará as margens do buffer principal).

Título da janela

Os comandos a seguir permitem que o aplicativo defina o título da janela do console para o parâmetro de cadeia de caracteres> especificado<. A cadeia de caracteres deve ter menos de 255 caracteres para ser aceita. Isso equivale a chamar SetConsoleTitle com a cadeia de caracteres fornecida.

Observe que essas sequências são sequências de "comando do sistema operacional" da OSC, e não um CSI como muitas das outras sequências listadas e, como tal, começa com "\x1b]", não "\x1b[". Como sequências de OSC, elas são encerradas com um Terminador de Cadeia de Caracteres representado como <ST> e transmitido com ESC \ (0x1B 0x5C). BEL (0x7) pode ser usado como terminador, mas o formulário mais longo é preferencial.

O caractere de terminação aqui é o caractere "Bell", '\x07'

Buffer de Tela Alternativo

*Os aplicativos de estilo Nix geralmente utilizam um buffer de tela alternativo, para que possam modificar todo o conteúdo do buffer, sem afetar o aplicativo que os iniciou. O buffer alternativo é exatamente as dimensões da janela, sem qualquer região de rolagem.

Para obter um exemplo desse comportamento, considere quando o vim é iniciado do bash. O Vim usa toda a tela para editar o arquivo e, em seguida, retornar ao bash deixa o buffer original inalterado.

Largura da janela

As sequências a seguir podem ser usadas para controlar a largura da janela do console. Eles são aproximadamente equivalentes à chamada à API de console SetConsoleScreenBufferInfoEx para definir a largura da janela.

Redefinição reversível

A sequência a seguir pode ser usada para redefinir determinadas propriedades para seus valores padrão. As propriedades a seguir são redefinidas para os seguintes valores padrão (também listados são as sequências que controlam essas propriedades):

• Visibilidade do cursor: visível (DECTEM)
• Teclado Numérico: Modo Numérico (DECNKM)
• Modo de Teclas de Cursor: Modo Normal (DECCKM)
• Margens superior e inferior: top=1, altura inferior=console (DECSTBM)
• Conjunto de Caracteres: US ASCII
• Representação de gráficos: SGR (padrão/desativado)
• Salvar o estado do cursor: Posição inicial (0,0) (DECSC)

Sequências de Entrada

As sequências de terminal a seguir são emitidas pelo host do console no fluxo de entrada se o sinalizador ENABLE_VIRTUAL_TERMINAL_INPUT estiver definido no identificador do buffer de entrada usando o sinalizador SetConsoleMode.

Há dois modos internos que controlam quais sequências são emitidas para as chaves de entrada fornecidas, o Modo de Teclas de Cursor e o Modo de Teclas do Teclado. Elas são descritas na seção Alterações de Modo.

Teclas de cursor

Além disso, se Ctrl for pressionado com qualquer uma dessas chaves, as seguintes sequências serão emitidas, independentemente do modo de teclas de cursor:

Numpad &Function Keys

Modificadores

Alt é tratado prefixando a sequência com um escape: ESC <c> onde <c> é o caractere passado pelo sistema operacional. Alt+Ctrl é tratado da mesma maneira, exceto que o sistema operacional terá pré-deslocado a <chave c> para o caractere de controle apropriado que será retransmitido para o aplicativo.

Ctrl geralmente é passado exatamente como recebido do sistema. Normalmente, esse é um único caractere deslocado para baixo no espaço reservado do caractere de controle (0x0-0x1f). Por exemplo, Ctrl+@ (0x40) torna-se NUL (0x00), Ctrl+[ (0x5b) torna-se ESC (0x1b), etc. Algumas combinações de teclas Ctrl são tratadas especialmente de acordo com a tabela a seguir:

Amostras

Exemplo de sequências de terminal do SGR

O código a seguir fornece vários exemplos de formatação 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;
}

O gráfico a seguir mostra a saída do exemplo de código anterior.

Exemplo de habilitação do processamento de terminal virtual

O código a seguir fornece um exemplo da maneira recomendada de habilitar o processamento de terminal virtual para um aplicativo. A intenção do exemplo é demonstrar:

1. O modo existente sempre deve ser recuperado por meio de GetConsoleMode e analisado antes de ser definido com SetConsoleMode.

2. Verificar se SetConsoleMode retorna 0 e GetLastError retorna ERROR_INVALID_PARAMETER é o mecanismo atual para determinar ao executar em um sistema de nível inferior. Um aplicativo que recebe ERROR_INVALID_PARAMETER com um dos sinalizadores de modo de console mais recentes no campo de bits deve degradar normalmente o comportamento e tentar novamente.

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

Exemplo de selecionar recursos de atualização de aniversário

O exemplo a seguir destina-se a ser um exemplo mais robusto de código usando uma variedade de sequências de escape para manipular o buffer, com ênfase nos recursos adicionados na Atualização de Aniversário para Windows 10.

Este exemplo usa o buffer de tela alternativo, manipulando paradas de tabulação, definindo margens de rolagem e alterando o conjunto 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");

}