Terminal

A classe Terminal do projeto RFW.Terminal fornece uma interface abrangente para o controle do terminal em aplicações de linha de comando, permitindo manipulação avançada de formatação, controle de cursor, manipulação de cores, entre outras funcionalidades.

Aparência e Controle do Terminal

Formatação de Texto

A formatação de texto na classe Terminal permite ao desenvolvedor modificar de forma simples a cor do texto e do fundo, além de aplicar estilos como negrito, sublinhado e outros. As cores de texto e de fundo podem ser ativadas e desativadas independentemente, oferecendo grande flexibilidade.

Para alterar a cor do texto e do fundo no terminal, a classe Terminal utiliza as enumerações TextColor e TextBackgroundColor. Estas permitem aplicar cores específicas tanto para o texto quanto para o fundo, e também oferecem métodos para resetar essas cores de volta aos padrões do terminal.

Terminal.setTextColor(TextColor.RED);  // Define a cor do texto para vermelho

Terminal.setTextBackgroundColor(TextBackgroundColor.BLUE);  // Define o fundo como azul

Terminal.resetTextColor();  // Reseta a cor do texto para o padrão do terminal

Terminal.resetTextBackgroundColor();  // Reseta a cor de fundo para o padrão do terminal


Terminal.setTextFormat(TextFormat.BOLD);  // Aplica negrito
Terminal.setTextFormat(TextFormat.UNDERLINE);  // Aplica sublinhado
Terminal.removeTextFormat(TextFormat.BOLD);  // Remove o negrito
Terminal.removeTextFormat(TextFormat.UNDERLINE);  // Remove o sublinhado

Terminal.setTextFormat(TextFormat.BOLD, TextFormat.UNDERLINE);  // Aplica negrito e sublinhado
Terminal.removeTextFormat(TextFormat.BOLD, TextFormat.UNDERLINE);  // Remove negrito e sublinhado

Esses métodos são suficientes para manipular e restaurar as cores do terminal de forma simples e direta.

Cores Estendidas (256 Cores)

Além das cores básicas para texto e fundo, a classe Terminal também suporta a paleta de 256 cores estendidas, que permite uma gama maior de personalização visual. A paleta é dividida em três seções principais: cores padrão, cores de alta intensidade, e uma série de cores definidas por uma matriz de 6x6x6 de vermelho, verde e azul (RGB), além de 24 níveis de cinza.

Para definir uma cor estendida no texto ou no fundo, utiliza-se um código ANSI específico. O código ANSI para cores estendidas utiliza o formato \u001B[38;5;<color_code>m para texto e \u001B[48;5;<color_code>m para o fundo, onde <color_code> é o valor de 0 a 255.

Terminal.setExtendedTextColor(196);  // Define o texto em vermelho forte (na paleta de 256 cores)
Terminal.setExtendedBackgroundColor(21);  // Define o fundo em azul profundo (na paleta de 256 cores)

Terminal.resetTextColor();  // Reseta a cor do texto para o padrão
Terminal.resetTextBackgroundColor();  // Reseta a cor de fundo para o padrão

Paleta de Cores Estendidas =

A paleta de cores estendidas segue a seguinte estrutura:

• Cores padrão (0 a 15): São as 8 cores básicas e suas variantes brilhantes.
• Cores RGB (16 a 231): Matriz 6x6x6 de cores definidas por combinações de vermelho, verde e azul.
• Tons de Cinza (232 a 255): 24 tons de cinza, que variam de preto a branco.

Definindo as Cores Estendidas Você pode utilizar qualquer valor entre 0 e 255 para personalizar as cores do texto e do fundo no terminal. A paleta estendida oferece mais controle sobre a estética da interface.

Esses códigos fornecem controle total sobre as cores no terminal, permitindo uma personalização visual avançada e rica.

Limpeza de Tela e Linhas

A classe Terminal oferece uma série de métodos de limpeza (clear) que permitem remover o conteúdo da tela ou de linhas específicas no terminal. Esses métodos podem ser utilizados para limpar porções específicas da tela, desde o cursor até o fim da linha ou da tela, ou para limpar toda a tela.

Definindo a Cor de Fundo Uma dica útil é definir a cor de fundo antes de utilizar os métodos clear(). Isso fará com que a cor de fundo selecionada seja aplicada a todas as áreas limpas no terminal, proporcionando um efeito visual personalizado.

Terminal.setTextBackgroundColor(TextBackgroundColor.GREEN);  // Define o fundo verde

Terminal.clearRemainingLine();  // Limpa do cursor até o fim da linha

Terminal.clearLineFromStart();  // Limpa do início da linha até o cursor

Terminal.clearLine();  // Limpa a linha atual completamente

Terminal.clearScreenFromCursor();  // Limpa a tela do cursor até o final da tela

Terminal.clearScreenToCursor();  // Limpa a tela do início até o cursor

Terminal.clearScreen();  // Limpa a tela inteira

Esses métodos são essenciais para manter a tela do terminal organizada e com um visual limpo. Ao combinar a limpeza com a definição de cores de fundo, é possível criar um ambiente visual consistente e controlado no terminal.

Movimentação do Cursor

A classe Terminal oferece controle completo sobre a posição do cursor no terminal, permitindo mover o cursor de forma absoluta ou relativa. Isso inclui salvar e restaurar a posição atual do cursor, além de permitir a ocultação e exibição do mesmo. Essas funcionalidades são úteis para criar interfaces mais interativas e manipuláveis no terminal.

Terminal.moveCursor(5, 10);  // Move o cursor para a linha 5, coluna 10

Terminal.moveCursorUp(3);  // Move o cursor 3 linhas para cima
Terminal.moveCursorDown(2);  // Move o cursor 2 linhas para baixo
Terminal.moveCursorLeft(5);  // Move o cursor 5 colunas para a esquerda
Terminal.moveCursorRight(7);  // Move o cursor 7 colunas para a direita

Terminal.saveCursorPosition();  // Salva a posição atual do cursor
Terminal.restoreCursorPosition();  // Restaura a posição salva do cursor

Terminal.hideCursor();  // Oculta o cursor
Terminal.showCursor();  // Exibe o cursor

Terminal.returnToStartOfLine();  // Move o cursor para o início da linha atual

Esses métodos fornecem a flexibilidade necessária para controlar o cursor no terminal, permitindo uma navegação precisa e eficiente.

Modo Gráfico do Terminal

A classe Terminal também oferece suporte para ativar e desativar o Modo Gráfico, que permite a utilização de caracteres especiais para desenhar formas e estruturas no terminal, como caixas, linhas e bordas. Esse modo é útil para a construção de interfaces visuais mais ricas, utilizando apenas caracteres ASCII.

Habilitando e Desabilitando o Modo Gráfico

O modo gráfico pode ser ativado para desenhar usando os caracteres especiais, e pode ser desativado a qualquer momento para retornar ao modo de texto normal. Aqui estão os métodos para habilitar e desabilitar o modo gráfico:

Terminal.enableGraphicMode();  // Ativa o modo gráfico
Terminal.disableGraphicMode();  // Desativa o modo gráfico e retorna ao modo normal

Visualizando os Caracteres Gráficos Disponíveis

A classe Terminal também fornece um método auxiliar para imprimir os caracteres gráficos disponíveis, permitindo que o desenvolvedor visualize os códigos gráficos que podem ser utilizados para desenhar no terminal:

Terminal.listGraphicChars();  // Imprime os caracteres gráficos disponíveis no modo gráfico

Explorando o Modo Gráfico Você pode utilizar o método listGraphicChars() para ver quais símbolos estão disponíveis ao ativar o modo gráfico, facilitando a criação de interfaces visuais com linhas e bordas no terminal. E observar que nem todos os caracteres são suportados por todos os tipos de terminais.

O modo gráfico oferece uma maneira prática de criar elementos visuais em terminais de texto, utilizando caracteres especiais para desenhar diretamente no terminal.

Inserção de Linhas Vazias

A classe Terminal oferece o método emptyLines(), que permite a inserção de múltiplas linhas vazias no terminal. Este método é útil para criar separações visuais, organizar a saída e manter a cor de fundo definida ao longo do terminal.

Terminal.setTextBackgroundColor(TextBackgroundColor.BLUE);  // Define a cor de fundo azul
Terminal.emptyLines(3);  // Insere 3 linhas vazias com fundo azul

Essas linhas vazias preencherão o terminal com a cor de fundo definida, criando um espaço visualmente consistente.

Dica para Layout Use emptyLines() para organizar a saída no terminal e garantir que o fundo mantenha a cor definida, mesmo em áreas "em branco".

Controle de Scroll

A classe Terminal permite controlar a rolagem do conteúdo da tela, oferecendo métodos para mover o conteúdo para cima e para baixo, além de permitir a definição de regiões específicas de rolagem.

Terminal.scrollUp(5);  // Rola o conteúdo do terminal 5 linhas para cima
Terminal.scrollDown(3);  // Rola o conteúdo do terminal 3 linhas para baixo
Terminal.setScrollRegion(5, 15);  // Define uma região de rolagem entre as linhas 5 e 15
Terminal.resetScrollRegion();  // Reseta a região de rolagem, permitindo rolagem total

Esses métodos são úteis para interfaces de terminal mais complexas, onde é necessário controlar a visualização do conteúdo exibido.

Método de Beep

O método beep() faz o terminal emitir um som (beep). Esse recurso pode ser utilizado em situações onde você deseja chamar a atenção do usuário, como após uma operação importante ou em casos de erro.

Terminal.beep();  // Emite um som no terminal

Este método é simples, mas pode ser eficaz para melhorar a interatividade da aplicação, principalmente em terminais com suporte para som.

Reset Geral do Terminal

O método reset() serve para restaurar o terminal ao estado padrão, removendo qualquer formatação ou cor que tenha sido aplicada durante a execução. Ele é particularmente útil para garantir que o terminal retorne ao estado original ao final da execução do programa, evitando que cores ou formatações indesejadas permaneçam.

Terminal.reset();  // Reseta todas as formatações e cores, restaurando o estado padrão

Definindo Cor de Fundo antes do Reset Antes de usar o método reset(), você pode definir uma cor de fundo com o comando setTextBackgroundColor(). Isso garantirá que todo o terminal seja preenchido com a cor de fundo pré-definida, criando um visual mais uniforme.

Entradas de Valores (Inputs)

Captura Direta de Entrada

A captura direta de entrada no terminal pode ser realizada de forma simples e eficiente utilizando o System.console(). Essa abordagem é ideal para aplicações que interagem com o usuário diretamente no terminal ou prompt de comando, onde a entrada de dados pode ser capturada como texto ou senha, garantindo flexibilidade e segurança.

Abaixo estão os métodos disponíveis para captura de entrada direta:

String userInput = null;

userInput = Terminal.readLine();  // Captura uma linha de texto

userInput = Terminal.readLine("Digite seu nome: ");  // Captura uma linha de texto com prompt

userInput = Terminal.readPassword();  // Captura uma senha sem exibir os caracteres

userInput = Terminal.readPassword("Digite sua senha: ");  // Captura uma senha com um prompt personalizado

Esses métodos utilizam diretamente o System.console(), garantindo que a entrada seja feita de forma segura e controlada. Os métodos readLine() permitem a captura de texto livre, enquanto os métodos readPassword() são ideais para capturar senhas, sem exibir os caracteres digitados. Lembre-se de que System.console() pode retornar null quando a aplicação é executada em alguns ambientes, como IDEs. Portanto, recomenda-se utilizar o terminal ou prompt de comando para garantir a funcionalidade correta.