[Tutorial] coutc - Colorir saída do console [C++]

[Renato Utsch 24]

Olá!

 

Bom, pessoal, esse é a primeira 'biblioteca' que eu crio e gostaria de disponibilizar para vocês...

 

A biblioteca, para windows somente, possui uma função (por enquanto): coutc() (ou CoutColor).

 

 

 

<< 1 >> AS CORES

 

BLACK - Preto          GRAY - Cinza
BLUE - Azul            BRIGHT_BLUE - Azul Brilhante
GREEN - Verde          BRIGHT_GREEN - Verde Brilhante
CYAN - Verde-água      BRIGHT_CYAN - Verde-água Brilhante
RED - Vermelho         BRIGHT_RED - Vermelho Brilhante
PURPLE - Roxo          LILAC - Lilás
YELLOW - Amarelo       BRIGHT_YELLOW - Amarelo Brilhante
WHITE - Branco         BRIGHT_WHITE  - Branco Brilhante

 

 

 

<< 2 >> coutc()

 

Agora vem a parte realmente interessante... o coutc (ou CoutColor).

Com essa função versátil você pode usar uma espécie de printf() que envia para o console texto com cor.

 

Usos:

 

• coutc(char msg[257]);
  Esse é o uso mais básico. Aqui o coutc 'couta' (vou usar esse vocábulo para ficar mais fácil) uma msg passada no primeiro parâmetro (que tem no máximo 256 caracteres), com as cores padrões setadas no .hpp.
   
  
• coutc(char msg[257], int backgroundc, int foregroundc);
  Desse modo, você 'couta' a msg, com a cor de fundo setada no 2º parâmetro (ver as opções de cores setadas na parte 1 desse tuto), e a cor de texto setada no 3º parâmetro.
   
  
• coutc(char msg[257], int backgroundc, int foreground, int dbackground, int dforeground);
  Com esse modo, você 'couta' a msg, com a cor de fundo setada no 2º parâmetro (ver as opções de cores setadas na parte 1 desse tuto), e a cor de texto setada no 3º parâmetro. Normalmente, com os 2 modos de cout identificados acima, a cor volta ao padrão setado no .hpp. Mas com o 2 parâmetros restantes, você pode mudar a cor do texto que é usado depois do coutc.
   
  *]coutc(const char msg[257]);
  Esse é o uso mais básico. Aqui o coutc 'couta' (vou usar esse vocábulo para ficar mais fácil) uma mensagem de char constante passada no primeiro parâmetro (que tem no máximo 256 caracteres), com as cores padrões setadas no .hpp.
   
  
• coutc(const char msg[257], int backgroundc, int foregroundc);
  Desse modo, você 'couta' a mensagem de char constante, com a cor de fundo setada no 2º parâmetro (ver as opções de cores setadas na parte 1 desse tuto), e a cor de texto setada no 3º parâmetro.
   
  
• coutc(const char msg[257], int backgroundc, int foreground, int dbackground, int dforeground);
  Com esse modo, você 'couta' a mensagem constante, com a cor de fundo setada no 2º parâmetro (ver as opções de cores setadas na parte 1 desse tuto), e a cor de texto setada no 3º parâmetro. Normalmente, com os 2 modos de cout identificados acima, a cor volta ao padrão setado no .hpp. Mas com o 2 parâmetros restantes, você pode mudar a cor do texto que é usado depois do coutc.
   
  *]coutc(std::string msg);
  Esse é o uso mais básico. Aqui o coutc 'couta' (vou usar esse vocábulo para ficar mais fácil) uma mensagem passada no primeiro parâmetro (usando das vantagens da std::string), com as cores padrões setadas no .hpp.
   
  
• coutc(std::string msg, int backgroundc, int foregroundc);
  Desse modo, você 'couta' a mensagem, com a cor de fundo setada no 2º parâmetro (ver as opções de cores setadas na parte 1 desse tuto), e a cor de texto setada no 3º parâmetro.
   
  
• coutc(std::string, int backgroundc, int foreground, int dbackground, int dforeground);
  Com esse modo, você 'couta' a mensagem, com a cor de fundo setada no 2º parâmetro (ver as opções de cores setadas na parte 1 desse tuto), e a cor de texto setada no 3º parâmetro. Normalmente, com os 2 modos de cout identificados acima, a cor volta ao padrão setado no .hpp. Mas com o 2 parâmetros restantes, você pode mudar a cor do texto que é usado depois do coutc.
  

 

Além disso, coutc() é uma função que retorna um bool. Assim, para saber se houve algum erro na execução do coutc, use a forma seguinte:

• if( !coutc(parameters) ) statement;

 

 

 

<< 3 >> Exemplos

 

utilize essa função main() para testar as funções:

 

 

#include <iostream>
#include <Windows.h>
#include "evil_console_misc.hpp"
using namespace std;
using namespace coutcolor;

int main()
{
system("color 1F");

// Couta um texto normal
cout << "texto normal\n";

// Couta um texto com as cores setadas no .h
cout << "texto no padrão setado no .h\n";

// Faz o mesmo
coutc("texto no padrão setado no .h_2\n");

// Agora, couta em outra cor
coutc("texto com back vermelho e texto verde\n", 4, 2);

// Couta um texto com as cores setadas no .h
cout << "text no padrão setado no .h_3\n";

// Couta um texto e muda o padrão
coutc("texto com back verde e texto vermelho depois roxo e cinza\n", 2, 4, 5, 8);

// Couta um texto c/ fundo roxo e texto cinza
cout << "texto c/ fundo roxo e texto cinza\n";
// Novamente
cout << "texto c/ fundo roxo e texto cinza_2\n";
// Novamente
coutc("texto c/ fundo roxo e texto cinza_3\n", 5, 8);

// Couta um texto
cout << ("teste\n");

system("pause");

// Retorna
return 0;
}

 

 

O resultado é:

 

 

 

 

 

 

<< 4 >> Falhas Conhecidas

 

Nenhuma falha conhecida.

 

 

 

<< 5 >> Código

 

evil.console.misc v0.07 BETA

 

evil.console.misc.hpp

 

#pragma once
// Copyright (c) LordEvil - Licensed under GNU GPL v3
// evil.console.misc v0.07 BETA


#include <iostream>
#include <string>
#include <Windows.h>

// To be used with the new coutc
enum DOS_COLORS 
{
BLACK, BLUE, GREEN, CYAN, RED, PURPLE, YELLOW,
WHITE, GRAY, BRIGHT_BLUE, BRIGHT_GREEN, BRIGHT_CYAN,
BRIGHT_RED, LILAC, BRIGHT_YELLOW, BRIGHT_WHITE 
};

namespace coutcolor
{
// *** COLOR ***
// Set here the default color of the screen.
// Colors:
// BLACK - Black          GRAY - Gray
// BLUE - Blue            BRIGHT_BLUE - Bright blue
// GREEN - Green          BRIGHT_GREEN - Bright green
// CYAN - Cyan            BRIGHT_CYAN - Bright cyan
// RED - Red              BRIGHT_RED - Bright red
// PURPLE - Purple        LILAC - Lilac
// YELLOW - Yellow        BRIGHT_YELLOW - Bright yellow
// WHITE - White          BRIGHT_WHITE  - Bright white
//
// Set in BACKCOLOR the default color of the background.
// Set in TEXTCOLOR the default color of the text.
//
// Remember that you are only setting the default color.
// You can use coutc from console.misc to print text with
// other colors.
//
// The default from console is Blue, Bright White.
//
//
const DOS_COLORS BACKCOLOR = BLUE;
const DOS_COLORS TEXTCOLOR = BRIGHT_WHITE;

// Instances of coutc to handle c-strings, const c-strings and std::strings.
bool coutc(char msg[257], DOS_COLORS background_color = BACKCOLOR, DOS_COLORS foreground_color = TEXTCOLOR, DOS_COLORS default_background = BACKCOLOR, DOS_COLORS default_foreground = TEXTCOLOR);
bool coutc(const char msg[257], DOS_COLORS background_color = BACKCOLOR, DOS_COLORS foreground_color = TEXTCOLOR, DOS_COLORS default_background = BACKCOLOR, DOS_COLORS default_foreground = TEXTCOLOR);
bool coutc(std::string msg, DOS_COLORS background_color = BACKCOLOR, DOS_COLORS foreground_color = TEXTCOLOR, DOS_COLORS default_background = BACKCOLOR, DOS_COLORS default_foreground = TEXTCOLOR);

	// Function for use of coutc - But can be used by other functions
	bool ColorChange(DOS_COLORS background_color = BACKCOLOR, DOS_COLORS foreground_color = TEXTCOLOR);
};

 

 

evil.console.misc.cpp

 

// Copyright (c) LordEvil - Licensed under GNU GPL v3
// evil.console.misc v0.07 BETA

#include "evil.console.misc.hpp"

//-------------------------------------------------------------------------------------

bool coutcolor::coutc(char msg[257], DOS_COLORS background_color, DOS_COLORS foreground_color, 
					DOS_COLORS default_background, DOS_COLORS default_foreground)
{
   // Set color.
   if(!ColorChange(background_color, foreground_color)) 
	return false;

   // Cout's the text sent with the appropriate color.
   std::cout << msg;

   // ** Returns to normal color **

   // Set color.
   if(!ColorChange(default_background, default_foreground)) 
	return false;

   // Now, return...
   return true;
}

//-------------------------------------------------------------------------------------

bool coutcolor::coutc(const char msg[257], DOS_COLORS background_color, DOS_COLORS foreground_color, 
					DOS_COLORS default_background, DOS_COLORS default_foreground)
{
   // Set color.
   if(!ColorChange(background_color, foreground_color)) 
	return false;

   // Cout's the text sent with the appropriate color.
   std::cout << msg;

   // ** Returns to normal color **

   // Set color
   if(!ColorChange(default_background, default_foreground)) 
	return false;

   // Now, return...
   return true;
}

//-------------------------------------------------------------------------------------

bool coutcolor::coutc(std::string msg, DOS_COLORS background_color, DOS_COLORS foreground_color, 
					DOS_COLORS default_background, DOS_COLORS default_foreground)
{
   // Set color.
   if(!ColorChange(background_color, foreground_color)) 
	return false;

   // Cout's the text sent with the appropriate color.
   std::cout << msg;

   // ** Returns to normal color **

   // Set color.
   if(!ColorChange(default_background, default_foreground)) 
	return false;

   // Now, return...
   return true;
}

//-------------------------------------------------------------------------------------

bool coutcolor::ColorChange(DOS_COLORS background_color, DOS_COLORS foreground_color)
{
       // Gets standard handler.
       HANDLE cmd_handle = GetStdHandle(STD_OUTPUT_HANDLE); 

       // Gets the buffer information of the screen.
       CONSOLE_SCREEN_BUFFER_INFO buffer_info;

       // Initializes buffer_info
       if( !GetConsoleScreenBufferInfo(cmd_handle, &buffer_info) )
               return false;

       // Configure wAttributes to make it to work with background.
       buffer_info.wAttributes &= 0x000F;

       // Changes the Background Color.
       if( !SetConsoleTextAttribute (cmd_handle, buffer_info.wAttributes |= (background_color << 4)) )
               return false;

       // Reconfigure the STD Handle
       cmd_handle = GetStdHandle(STD_OUTPUT_HANDLE);

       // Configure wAttributes to make it to work with foreground.
       if( !GetConsoleScreenBufferInfo(cmd_handle, &buffer_info) )
               return false;

   buffer_info.wAttributes &= 0x00F0;

       // Changes the Background Color.
       SetConsoleTextAttribute (cmd_handle, buffer_info.wAttributes |= foreground_color);

       return true;
}

 

 

<< 7 >> Change-Log

 

0.07 BETA: <-- Última versão que usa cout à la printf. A próxima usará streams como std::cout.

* Substituídas mensagens de "Error!" do coutc por return false;, pois então não será mostrada nenhuma mensagem de erro e você poderá identificar com a instrução if( !coutc(parameters) ) statement; se houve algum problema (não vi que não tinha posto os return false;'s...)

- Na próxima versão vejo se adiciono um bool no .hpp para você escolher entre a mensagem e o return false ou só o return false...

* Substitituído sistema do ChangeColor por um MUITO mais enxuto e simples...

- Agradecimentos a Myho e a quitZAUMMM...

07/05/2011: CORREÇÃO - backgroundcolor e foregroundcolor estavam invertidos em ColorChange()

 

0.06 BETA: <-- Última versão com sistema de cor por switchs.

* Corrigida cor: Background amarelo estava sendo mostrado como roxo, e background amarelo com texto amarelo (foreground amarelo) estava ficando tudo roxo.

 

0.05 BETA:

* Adicionado default no switch do backgroundc.

- Tinha esquecido :X

* Adionado suporte a std::string.

- Apenas a use sua std::string no lugar de sua antiga c-string.

* Remoção da classe Basic_CoutC - agora é uma função separada o colorchange()

- Isso tornará o programa mais rápido, já que não será necessário inicializar nenhum objeto hora nenhuma.

* Adicionados comentários sobre como usar o BACKCOLOR e o TEXTCOLOR (em inglês).

* Corrigido bug da cor 0, 0 (fundo preto com texto preto)

* Agora o header tem extensão .hpp, e não .h

 

0.04 BETA:

* Tinha esquecido de incluir o header do .h no .cpp na 0.03 BETA :X

* Adicionado suporte para const chars...

 

0.03 BETA:

* Verde-Água - 3 - e Verde-Água Brilhante - 11 - estavam invertidos com Amarelo - 6 - e Amarelo Brilhante - 14 -, respectivamente.

* Adicionado comentário que mostra a versão do CoutC nos arquivos de código fonte.

 

0.02 BETA:

* namespace basic_coutc mudado para class Basic_CoutC

* Basic_CoutC::colorchange()

- Na primeira série de loops para mudar a cor, mudei da escada if-else-if para um switch, com a finalidade de aumentar a velocidade do coutc (não que estivesse lento, e só uma otimização a mais)

 

0.01 BETA:

* Código liberado

 

 

 

Ah, e não esqueçam de colocar a licensa do GNU GPL v3 no programa de vocês, ok?

 

 

 

Espero que gostem!! :)

 

 

Abraços :D

[Bruno Alano 0]

Em vez de tantos Switchs e Cases, não seria possível armazenar todas as combinações em um array multidimensional e dependendo de X números carregar tal posição do array?

[Renato Utsch 24]

Olá!

 

Sim, talvez seria possível sim, e seria muitos mais prático também.

 

Mas eu fiz desse jeito pois é a forma mais eficaz de fazer.

 

Poderia fazer algo simples com poucas linhas (comparadas com o nº de linhas do meu atual coutc), mas decidi que por um aumento quase insignificante no tamanho de um programa (e por um aumento muito significante na complexidade de manutenção desse coutc) tivesse um ganho considerável no desempenho do mesmo: não aloco nada na memória, (arrays multidimensionais pesam muito na memória), o que impede algum efeito colateral do uso excessivo do coutc em programas grandes, e usar switchs também é muito mais rápido do que usar arrays (digo em questão de tempo de resposta).

 

 

Abraços :D

[Myho 2]

Nessa própria area tem um outro tópico sobre trocar cores no console. E está bem mais enxuto, apesar de não estar orientado a objeto ( o que seria super simples ).

 

http://forum.imasters.com.br/topic/265771-tutorial-colocando-cor-em-c/

 

#include <windows.h> 
enum DOS_COLORS {
       BLACK, BLUE, GREEN, CYAN, RED, MAGENTA, BROWN,
       LIGHT_GRAY, DARK_GRAY, LIGHT_BLUE, LIGHT_GREEN, LIGHT_CYAN,
       LIGHT_RED, LIGHT_MAGENTA, YELLOW, WHITE };

//-------------------------------------------------------------

void textcolor (DOS_COLORS iColor)
{
       HANDLE hl = GetStdHandle(STD_OUTPUT_HANDLE);
       CONSOLE_SCREEN_BUFFER_INFO bufferInfo;
       BOOL b = GetConsoleScreenBufferInfo(hl, &bufferInfo);
       bufferInfo.wAttributes &= 0x00F0;
       SetConsoleTextAttribute (hl, bufferInfo.wAttributes |= iColor);
}

// -------------------------------------------------------------------------
void textbackground (DOS_COLORS iColor)

{
       HANDLE hl = GetStdHandle(STD_OUTPUT_HANDLE);
       CONSOLE_SCREEN_BUFFER_INFO bufferInfo;
       BOOL b = GetConsoleScreenBufferInfo(hl, &bufferInfo);
       bufferInfo.wAttributes &= 0x000F;
       SetConsoleTextAttribute (hl, bufferInfo.wAttributes |= (iColor << 4));
}

[Renato Utsch 24]

Hum...

 

 

Isso só coloca a cor no console, não escreve. Agora, sim, é bem mais simples... eu fiz isso quando ainda estava começando em C++... bom, quem sabe um dia eu refaço...

 

 

Obrigado!

 

Abraços :D