Ir ao conteúdo
Regras do Clube do Hardware

C problemas no full screen

yuri_carneiro

Por yuri_carneiro
em C/C#/C++

 Compartilhar

Posts recomendados

yuri_carneiro
 

yuri_carneiro

Postado
Postado

ola boa noite eu usso o compilador dev c e estou desenvolvendo um programa  e console e me surgio um   duvida  porque sou novo em c 

bom eu sei que pra min dar full sreen e esse comado 

     

keybd_event ( VK_MENU, 0x36, 0, 0 ); 
    keybd_event ( VK_RETURN, 0x1C, 0, 0 ); 
    keybd_event ( VK_RETURN, 0x1C, KEYEVENTF_KEYUP, 0 ); 
    keybd_event ( VK_MENU, 0x38, KEYEVENTF_KEYUP, 0 );

 

eu gostaria de saber como faço pra cola junto a ele a opissão de tira do  full sreen tipo se apertasse ESC ele voltava pra um tela meno 

e tambem queria saber  como fazer meu full sreen fica dessa forma com as abas de fechar minimizar  e reduzir 

 

atualmente meu programa esta assim 

image.thumb.png.3aec8cf171faa76150015a55f03edea6.png

 

 e gostaria que ele ficasse assim  com as opções de minimiza fechar e reduzir  

image.thumb.png.7a03cd6646fc5fd11a3b98b67bdec3ab.png

 

e gostaria de sabe se tem um comando pra min centralizar o programa no meio da tela quando ele tiver rodando mo console 

  • Obrigado 1
arfneto
 

arfneto

Postado
Postado

Olá

 

Tem certeza de que precisa disso em um programa para console? Em geral se usa isso para o caso de computadores que não tem interface gráfica, coisa que está se tornando bem comum com os serviços em nuvem e supercomputadores que você só acessa a partir de um emulador de terminal, coisas como Amazon Cloud 9.

 

Isso é um inferno para programar e o resultado não compensa se tiver alternativa, que seria usar a óbvia interface gráfica que vai te dar tudo isso de graça.

 

Tempos atrás postei aqui um programa que simulava um jogo de bingo e usava essas funções para controlar o cursor e cor e tal, porque marcava nas cartelas os números que iam saindo até o final do jogo. E postei uns links para a documentação oficial da Microsoft e alguma coisa do Unix/Linux/MacOS. Dá para pesquisar aqui no forum por isso. Se eu me lembrar depois posto o exato tópico.

 

Se tiver mesmo essa necessidade, talvez faça melhor uso de seu tempo usando uma biblioteca, como todo mundo usa. Eu usava uma nos ´90 chamada curses, que depois passou a se chamar ncurses e acho que pode se usar hoje em windows e Linux e é uma boa opção.Até onde eu me lembro era muito bem escrita.

 

Se portabilidade não for importante, lembro que Windows foi quase que totalmente escrito em C, mesmo caso do Unix e derivados, de modo que pode usar as API -- funções --- do sistema que usa.

 

 

  • Curtir 1
devair1010
 

devair1010

Postado
Postado

@yuri_carneiro @yuri_carneiro   esse link é de outro programa , como você pode ver na postagem acima dele , e o que funciona em qualquer outro código são as primeiras linha onde tem aqueles #include e #define , copie todas as 7 linhas iniciais e coloque no seu código , aliás , poste seu código , para vermos como está , e em que podemos ajudar  ,  e antes da função main , e dentro da main use o o comando gotoxy_2(30,15); por exemplo e o cursor vai ficar piscando nessa posição da tela e aí você pode imprimir alguma coisa lá .; 

#include <stdio.h>
#include <conio.h>
#include <windows.h>
#define  cls system("cls");  /* cls;  limpa a tela                             */
#define u GetStdHandle(STD_OUTPUT_HANDLE)
#define gotoxy_2(x,y) {COORD c={x,y};SetConsoleCursorPosition(u,c);}
#define textcolor_2(l,f) SetConsoleTextAttribute(u,l+(f<<4));/* imprimir letras coloridas com o fundo também colorido */
int main(){
    gotoxy_2(5,4);                 /* coluna 5 da linha 4                                    */
    textcolor_2(12,14);
    printf("Alinhando %c Esquerda . . . !",183);
    getch();
    return 0;
}

 

arfneto
 

arfneto

Postado
Postado
7 minutos atrás, yuri_carneiro disse:

@arfneto fui pedido no meu trabalho se possível 

adicionado 2 minutos depois

@devair1010 conseguiria me ajudar amigo , queria alinha e colar o full screen

 Encontre o tópico de que falei aqui no fórum. Tem um programa pronto que tem tudo a ver com o que você precisa e uma discussão é referencias

 

Para centralizar o texto tem uma função ao que se chama GetSystemMetrics você chama e recebe os valores de que precisa para centralizar o texto 

Tem exemplos lá no post 

 

 

  • Curtir 1
arfneto
 

arfneto

Postado
Postado

Não tenho como ver isso agora. Tenho tempo mas não tenho computador ou documentos. Era um post sobre bingo. O programa que mostrei fazia o sorteio das cartelas e um jogo até alguém ganhar e usava essas coisas todas 

adicionado 4 minutos depois

Mas pode ver no fórum mesmo tem ferramentas de pesquisa

 

Now que centralizar texto nada tem a ver com full-screen. A cada vez que vai escrever na console chama a função parts identificar o tamanho atual da tela. Full screen não muda nada nesse aspecto 

  • Curtir 1
devair1010
 

devair1010

Postado
Postado

@yuri_carneiro    ali você precisa calcular o que vai escrever contar todos os caracteres dividir por dois e subtrair de 40 , pois o meio da tela é na coluna 40 , na horizontal , e na 12ª   linha na vertical . então mude o valor dentro dos parentese  .

  • Amei 1
arfneto
 

arfneto

Postado
Postado
3 minutos atrás, yuri_carneiro disse:

@devair1010 meu amigo ele funcionou mais porém no fico no meio da tela

Yuri, a cada vez que vai escrever na tela você chama a função pra comparar o tamanho da tela porque pode ter que redesenhar tudo . E você calcula o tamanho o do que você vai escrever e faz as contas para identificar a coordenada certa. Só isso. 

adicionado 0 minutos depois

Você é que faz as contas toda vez

  • Obrigado 1
arfneto
 

arfneto

Postado
Postado
15 minutos atrás, Herbertbahia disse:

@devair1010 onde vejo a tabela das cores do gotoxy por numeração?

 

Gitoxy() sequer é uma função de verdade. As coordenadas estão em uma estrutura coord postada logo acima acho que num código que@devair1010 postou e as cores estão em um cabeçalho, um header, um. H que acho que até se chama color no windows. No linux see pode usar as cores do terminal, direto do manual do terminal por exemplo 

  • Curtir 1
arfneto
 

arfneto

Postado
Postado

Olá!

 

Agora tenho um computador :D

 

Como eu disse esse tema é um inferno para programar e pouco útil ou extremamente útil.  Pouco útil se você está usando um computador comum que tem interface gráfica. Extremamente útil no outro caso. Por várias razões -- e não vou deixar tanto o tópico -- esse tema tem crescido de importância nos últimos anos, e uma montanha de dinheiro e grupos de pessoas competentes passaram a trabalhar nisso e o progresso já foi enorme desde a edição de aniversário do Windows 10.

 

O Windows sempre teve um conjunto de funções para acessar a console e a documentação é enorme, claro. Eis o endereço oficial https://docs.microsoft.com/en-us/windows/console/console-reference onde tem tudo.

 

No Unix não tinha nada disso porque a interface gráfica não fazia e não faz parte do sistema. O que se tem e tinha é feito via emulação de terminal. OK, antes eram os terminais mesmo, e os mais populares eram os da marca Digital, modelo VT-100 ou VT-52 e não por acaso nos manuais deles estão todas as sequências de programação da console para o Linux/Unix/MacOS. Como eu disse antes curses foi a primeira biblioteca de grande sucesso para criar interfaces gráficas no modo texto e depois evoluiu nara ncurses que pode usar hoje ainda. Com a interface gráfica veio o X-Windows e um mundo de opções.

 

Convergência no Windows 10

 

Nos últimos anos foi criado o conceito de Terminal Virtual no Windows e é até onde eu vejo simplesmente fazer o Windows processar esses comandos do terminal do Linux, que são os comandos dos terminais da digital dos tempos antigos. Na documentação você vai ver que se chamar em C 

BOOL WINAPI SetConsoleMode(
  _In_ HANDLE hConsoleHandle,
  _In_ DWORD  dwMode
);

Documentada em https://docs.microsoft.com/en-us/windows/console/setconsolemode pode habilitar esse troço de Virtual Terminal

 

E nunca funcionou direito, porque simplesmente não emulava todos os comandos e variava de versão para versão de Windows... Mas está sempre evoluindo

 

Mas você pode habilitar isso e usar os mesmos comandos do Linux que usa os mesmos do Unix que usa os mesmos do terminal da Digital.

 

O novo Terminal do Windows

 

Um resultado desse projeto é o novo Terminal do Windows que você pode instalar a partir claro da loja do Windows. Saiu uma nova versão nessa terça 26 :) e rodar seu programa nesse novo terminal que é bem mais compatível e permite usar os comandos todos que vê nos programas por aí, como em ncurses

 

Veja que também tem Ubuntu Suse e Fedora Linux na loja do windows, de graça e roda sem instalar nada mais, apenas o suporte do Windows. Mundo estranho esse ;) A imagem abaixo é da loja do Windows, direto

 

442461537_lojawindows.png.31e9573f49181947bc723fa56ba5086f.png

 

O desenvolvimento dessas coisas pode ser acompanhado no blog do próprio grupo da Microsoft que está escrevendo isso e o endereço é https://devblogs.microsoft.com/commandline/

 

Como é -- era -- no Windows: um exemplo comum

 

Essa função mostra uns dados na tela a partir de uma posição linha/coluna e foi escrita como parte de um exemplo em C++ mas em C funciona igualzinho. Talvez ajude você a entender o mecanismo. Pode usar assim e seu programa vai funcionar. 

	int		Cartela::mostraXY(short X, short Y, short* cor)
	{	// mostra a cartela a partir da posição (x,y) na tela
		// em principio igual a anterior mostra(), apenas posiciona o 
		// cursor antes de imprimir cada linha
		// usa as cores como marcadas no vetor 'cor'
		int		 i;
		HANDLE	H = GetStdHandle(STD_OUTPUT_HANDLE);
		COORD	 coord;
		coord.X = X;
		coord.Y = Y;
 		SetConsoleCursorPosition(H, coord);
		SetConsoleTextAttribute(H, cor[0]);
		cout <<
			"'" << nome << "' [" <<
			setfill('0') << setw(3) << hits << "]";
		coord.X = X;
		coord.Y++;
		SetConsoleCursorPosition(H, coord);
		// mostra valores[]
		for (i=0; i<tamanho; i++)
		{
			SetConsoleTextAttribute (H, cor[valores[i]]);
			cout << setfill('0') << setw(2) << valores[i] << "  ";
			SetConsoleTextAttribute(H, cor[0]);
			if (i % 5 == 4)
			{
				coord.X = X;
				coord.Y++;
				SetConsoleCursorPosition(H, coord);
			}	// end if
		}	// end for
		coord.X = X;
		coord.Y++;
		SetConsoleCursorPosition(H, coord);
		return 0;
	}	// end mostraXY()

X e Y são as coordenadas e cor e o endereço de um vetor de cores que a lógica do programa preencheu com as cores certas. Acho que era algo como preto para os números que ainda não saíram e verde para os já sorteados. Era um bingo afinal. Posso te enviar o executável ou o programa inteiro, mas foi escrito em C++. Acho que se tirar o Cartela:: já compila em sua máquina e pode rodar em C

 

Mas a lógica é a mesma e as funções também em 😄 Veja que no início você obtem o handle para a console, porque pode ter várias consoles, e salva em H porque vai usar toda hora. Preenche a estrutura COORD com o óbvio X e Y e depois usa as funções para salvar as cores e fontes em uso para poder restaurar ao final e aí imprime os dados e restaura ao sair.

 

Cores no Windows em consoleapi.h 

 

Note que você só precisa incluir isso em seu programa ou talvez nem precise.  E veja que você pode combinar as cores e atributo usando | o operador ou em C 

//
// Attributes flags:
//

#define FOREGROUND_BLUE      0x0001 // text color contains blue.
#define FOREGROUND_GREEN     0x0002 // text color contains green.
#define FOREGROUND_RED       0x0004 // text color contains red.
#define FOREGROUND_INTENSITY 0x0008 // text color is intensified.
#define BACKGROUND_BLUE      0x0010 // background color contains blue.
#define BACKGROUND_GREEN     0x0020 // background color contains green.
#define BACKGROUND_RED       0x0040 // background color contains red.
#define BACKGROUND_INTENSITY 0x0080 // background color is intensified.
#define COMMON_LVB_LEADING_BYTE    0x0100 // Leading Byte of DBCS
#define COMMON_LVB_TRAILING_BYTE   0x0200 // Trailing Byte of DBCS
#define COMMON_LVB_GRID_HORIZONTAL 0x0400 // DBCS: Grid attribute: top horizontal.
#define COMMON_LVB_GRID_LVERTICAL  0x0800 // DBCS: Grid attribute: left vertical.
#define COMMON_LVB_GRID_RVERTICAL  0x1000 // DBCS: Grid attribute: right vertical.
#define COMMON_LVB_REVERSE_VIDEO   0x4000 // DBCS: Reverse fore/back ground attribute.
#define COMMON_LVB_UNDERSCORE      0x8000 // DBCS: Underscore.

No Linux

 

Aí não tem nada disso porque não existe essa tal console. No entanto quando você vai escrever num terminal o sistema interpreta esses caracteres de controle que um dia foram do VT-100 e por isso não existem funções. Claro que ao final ou você vai escrever ou vai usar algumas que alguém escreveu porque é um porre inserir isso nos comandos...

Exemplo: se você enviar ESCAPE [ 33 m Algo para um terminal no Linux vai sair 'Algo' escrito em amarelo. E de modo similar você muda o cursor de posição, escreve em reverso, sublinhado, negrito, limpa a tela e outras funções mais exóticas.

 

Direto de https://en.wikipedia.org/wiki/VT100 

vt-100.png.e6676afd1707c9f0f27e7257dd7b0415.png

 

Usei muito esse terminal e o VT52 🙄

 

Espero que ajude a ter uma referência de como a console chegou onde está hoje.

 

Vou repetir o que já disse antes: se tiver opção fuja disso e use algo como GTK que é bem moderno e funciona em C, ou use algo como C# e a interface do Windows, bem mais elegante e fácil. 

 

E se precisa de portabilidade e modo texto e C recomendo GTK ou o Windows Terminal novo e ncurses. 

 

 

 

 

adicionado 12 minutos depois
5 horas atrás, devair1010 disse:

@yuri_carneiro    ali você precisa calcular o que vai escrever contar todos os caracteres dividir por dois e subtrair de 40 , poid o meio da tela é na coluna 40 , na horizontal , e na 12ª   linha na vertical . então mude o valor dentro dos parentese  .

 

Bem... na verdade não. o certo é você escrever 

	HANDLE	H = GetStdHandle(STD_OUTPUT_HANDLE);
	CONSOLE_SCREEN_BUFFER_INFO info;
	GetConsoleScreenBufferInfo(H, &info);

E aí o sistema faz a gentileza de preencher info com os dados corretos.  

typedef struct _CONSOLE_SCREEN_BUFFER_INFO {
    COORD dwSize;
    COORD dwCursorPosition;
    WORD  wAttributes;
    SMALL_RECT srWindow;
    COORD dwMaximumWindowSize;
} CONSOLE_SCREEN_BUFFER_INFO, *PCONSOLE_SCREEN_BUFFER_INFO;

Como dá pra ver lá está dwSize do tipo COORD já conhecido 

typedef struct _COORD {
    SHORT X;
    SHORT Y;
} COORD, *PCOORD;

E lá estão as informações do tamanho da console no momento. Ela pode mudar a toda hora ou ser fixada com outro tamanho nas propriedades....

 

E aí você faz as contas para posicionar o texto, usando info->dwSize.X e info->dwSize.Y

  • Obrigado 1
devair1010
 

devair1010

Postado
Postado

@Herbertbahia      esse é o textcolor com enumeração , onde pode colocar tanto os números das cores que vão de zero até quinze , como os nomes delas de acordo com o quê está escrito dentro do  typedef enum , ali você pode modificar aqueles nomes do jeito que quiser . 

#include <windows.h>
/*             0     1    2     3   4      5      6      7         8  */
typedef enum{black,blue,green,cyan,red,magenta,brown,lightgray,darkgray,   /* nome das cores */
lightblue,lightgreen,lightcyan,lightred,lightmagenta,yellow,white} colors;
/*  9         10         11        12        13         14    15 */

static int __BACKGROUND = 1/*BLACK*/;/*pode ser o numero ou o nome da cor*/
static int __FOREGROUND = lightgray;

void textcolor_2 (int letras, int fundo){/*para mudar a cor de fundo mude o background*/
    __FOREGROUND = letras;
    __BACKGROUND = fundo;
    SetConsoleTextAttribute (GetStdHandle (STD_OUTPUT_HANDLE),
    letras + (__BACKGROUND << 4));
}

e coloquei textcolor_2 para não ficar igual ao textcolor da biblioteca conio2 que funciona da mesma  maneira , mas as coordenadas de uma não confere com a outra .

  • Obrigado 1
arfneto
 

arfneto

Postado
Postado
9 horas atrás, devair1010 disse:

@Herbertbahia      esse é o textcolor com enumeração , onde pode colocar tanto os números das cores que vão de zero até quinze , como os nomes delas de acordo com o quê está escrito dentro do  typedef enum , ali você pode modificar aqueles nomes do jeito que quiser . 


#include <windows.h>
/*             0     1    2     3   4      5      6      7         8  */
typedef enum{black,blue,green,cyan,red,magenta,brown,lightgray,darkgray,   /* nome das cores */
lightblue,lightgreen,lightcyan,lightred,lightmagenta,yellow,white} colors;
/*  9         10         11        12        13         14    15 */

static int __BACKGROUND = 1/*BLACK*/;/*pode ser o numero ou o nome da cor*/
static int __FOREGROUND = lightgray;

void textcolor_2 (int letras, int fundo){/*para mudar a cor de fundo mude o background*/
    __FOREGROUND = letras;
    __BACKGROUND = fundo;
    SetConsoleTextAttribute (GetStdHandle (STD_OUTPUT_HANDLE),
    letras + (__BACKGROUND << 4));
}

 


textcolor_2


Já tinha visto esse código aqui no forum antes, e na verdade eu não conhecia. Entendi que é uma herença dos compiladores da Borland do início dos anos 80 e fazia parte de uma biblioteca chamada conio ao que parece. Mas não entendo
porque ainda é usada e muito menos porque foi escrita assim.

  • Qual a razão para os static int __BACKGROUND e __FOREGROUND "globais" e estáticos que não são usados, já que os valores são imediatamente redefinidos
  • porque não passar o Handle da console como argumento já que é sempre o mesmo para o programa todo?
  • porque misturar operadores aritméticos e de bit no mesmo comando, sendo que a cor é um bitmask por definição?
  • textcolor_2 podia ser um simples #define e não uma função 
    #define textcolor_2( letras,  fundo)  SetConsoleTextAttribute( GetStdHandle(STD_OUTPUT_HANDLE), (letras|(fundo<<4)) )

    e você poderia escrever  

    	printf("\nteste antes de mudar a cor\n");
	textcolor_2 (amarelo, preto);
	printf("Amarelo sobre preto\n");
	text_color(H, 15, 0);	/* preto sobre branco */
	printf("\nteste depois de mudar a cor\n");

    Usando os códigos corretos. E o texto seria escrito em amarelo sobre preto, claro
    ch-191128-usando-define.png.51105adac6cf283bd4acf812cd631b9b.png

As 16 cores, em português 

	typedef enum
	{
		preto,				// 0
		azul,				// 1
		verde, 				// 2
		ciano, 				// 3
		vermelho, 			// 4
		magenta, 			// 5
		marron, 			// 6
		cinza_claro, 			// 7
		cinza_escuro,  			// 8
		azul_claro, 			// 9
		verde_claro, 			// 10
		ciano_claro, 			// 11
		vermelho_claro, 		// 12
		magenta_claro, 			// 13
		amarelo, 			// 14
		branco				// 15
	} colors;

 

Em consoleapi2.h, como eu disse, estão as constantes de cor. É o que se chama de bitmask, máscara de bits, e é um byte, um valor entre 0 e 255 que cobre ao mesmo tempo a cor de fundo e a cor da letra. E isso é autoritativo, então claro que essa textcolor_2 bem como a anterior :) se existiu usa os mesmos números. 1, 2 e 4 para azul, verde e vermelho, 8 para usar um tom mais intenso. E a mesma coisa acontece com as cores de fundo, só que deslocadas 4 bits para a esquerda para poder definir ao mesmo tempo. 
 
Assim a letra em verde vale  2 e o fundo em verde vale 32 por exemplo.

 

Eis de novo as constantes do Windows 

#define FOREGROUND_BLUE      0x0001 // text color contains blue.
#define FOREGROUND_GREEN     0x0002 // text color contains green.
#define FOREGROUND_RED       0x0004 // text color contains red.
#define FOREGROUND_INTENSITY 0x0008 // text color is intensified.
#define BACKGROUND_BLUE      0x0010 // background color contains blue.
#define BACKGROUND_GREEN     0x0020 // background color contains green.
#define BACKGROUND_RED       0x0040 // background color contains red.
#define BACKGROUND_INTENSITY 0x0080 // background color is intensified.

Porque isso? 
Simples: para salvar uma configuração de cor azul intenso sobre vermelho normal você pode usar 

    cor = FOREGROUND_BLUE | FOREGROUND_INTENSITY | BACKGROUND_RED;

ou mesmo  

    SetConsoleTextAttribute(
        GetStdHandle(STD_OUTPUT_HANDLE),
        FOREGROUND_BLUE | FOREGROUND_INTENSITY | BACKGROUND_RED
    );

O amarelo por exemplo é o verde combinado com o vermelho no tom intenso então não por acaso o amarelo vale 14: 8 + 4 + 2 e você poderia escrever  

    amarelo = FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_INTENSITY;

Note que não se usa soma para essas coisas: trata-se de uma máscara de bits e a tradição é usar os operadores de bits...

 

Um gabarito para Windows


Existem milhões desses mas porque não escrever mais um? Eis o código 

    for (int letra = 0; letra < 16; letra += 1)
    {
        for (int fundo = 0; fundo < 16; fundo += 1)
        {
            text_color(H, letra, fundo);
            printf(" %2d %2d ", letra, fundo);
            text_color(H, 15, 0);    /* para delimitar os blocos */
            printf(" ");
        }
        printf("\n");
    }

Eis o resultadoch-191128-gabarito.thumb.png.1fb56783df3bbe418645ba482dc8d98d.png

 

Assim fica fácil ver: a cor de fundo é o número da direita, a cor das letras o número da esquerda em cada coluna. 16 linhas, 16 colunas e temos as possíveis combinações. Nada original.

O texto inicial foi escrito em (5,10) para ter um exemplo de como posicionar o cursor no Windows.

Eis o programa todo, que inclui uma textcolor_2 como macro --- #define --- e um teste do enun com as cores em português e mostra o gabarito em si. 

#define			_CRT_SECURE_NO_WARNINGS

#define textcolor_2( letras,  fundo)  SetConsoleTextAttribute( GetStdHandle(STD_OUTPUT_HANDLE), (letras|(fundo<<4)) )

#include <stdio.h>
#include <windows.h>

void text_color(HANDLE, int, int);

int main(int argc, char** argv)
{
	typedef enum
	{

		preto,					// 0
		azul,					// 1
		verde, 					// 2
		ciano, 					// 3
		vermelho, 				// 4
		magenta, 				// 5
		marron, 				// 6
		cinza_claro, 			// 7
		cinza_escuro,  			// 8
		azul_claro, 			// 9
		verde_claro, 			// 10
		ciano_claro, 			// 11
		vermelho_claro, 		// 12
		magenta_claro, 			// 13
		amarelo, 				// 14
		branco					// 15

	} colors;

	HANDLE	H = GetStdHandle(STD_OUTPUT_HANDLE);
	text_color(H, 15, 0 );	/* preto sobre branco */
	COORD	 coord;
	coord.X = 5;
	coord.Y = 10;
	SetConsoleCursorPosition(H, coord);

	text_color(H, 15, 0);	/* preto sobre branco */
	printf("Gabarito (Frente|Fundo) escrito em (5,10) \n\n\n");

	for (int letra = 0; letra < 16; letra += 1)
	{
		for (int fundo = 0; fundo < 16; fundo += 1)
		{
			text_color(H, letra, fundo);
			printf(" %2d %2d ", letra, fundo);
			text_color(H, 15, 0);	/* para delimitar os blocos */
			printf(" ");
		}
		text_color(H, 15, 0);	/* para delimitar os blocos */
		printf("\n");
	}

	printf("\nteste antes de mudar a cor\n");
	textcolor_2 (amarelo, preto);
	printf("Amarelo sobre preto\n");
	text_color(H, 15, 0);	/* preto sobre branco */
	printf("\nteste depois de mudar a cor\n");
}


void text_color(HANDLE Console, int letras, int fundo)
{
	SetConsoleTextAttribute(Console, letras | (fundo<<4));
}

 

Espero que os exemplos ajudem

ch-191128-usando-define.png

ch-191128-gabarito.png

  • Curtir 1
  • Obrigado 1
  • Moderador
DiF
 

DiF

Postado
  • Moderador
Postado

Caros, devo lembrar que como se trata de um trabalho de faculdade,  todo e qualquer material aqui apresentado NÃO deve ser copiado. Isso inclui variáveis, comentários, funções criadas e etc.  Use apenas como material de referência para estudo e TENTAR implementar de sua forma.

 

Dito isso, deixo claro, que obviamente todos os professores irão pesquisar aqui e procurar ver se o aluno copiou de fato. 

Caso tenha copiado algo, nós não iremos nos responsabilizar por quaisquer problemas com sua matéria, professores e uma eventual nota baixa ou na pior hipótese, ficar sem nota.

 

Deixo claro também, que nenhum usuário está autorizado a dar respostas prontas e nem indicar "posts e tópicos" que contenham respostas prontas.

 

Ainda, informo que é totalmente proibido pedir contatos extra-fórum ou manter conversas privadas sobre os assuntos, de forma que privem outras pessoas de conseguirem informações. 

 

Certo da compreensão de todos.

Agradeço desde já.

Moderador DiF

  • Curtir 2
arfneto
 

arfneto

Postado
Postado
2 minutos atrás, Herbertbahia disse:

@arfneto @devair1010 seria muito interessante se nessa regiao que fica com texto de outra cor pudesse implementar para receber clicks do mouse ne? Isso é possivel?

 

Herbert, isso funciona ao contrário: na nomenclatura mais usual, o click do mouse gera um evento e o sistema é avisado sobre a posição (x,y) do mouse no momento do click e mais algumas coisas tipo qual botão do mouse foi usado, alguma tecla tipo shift, control ou alt pressionada e tal.

 

O programa que recebe essa mensagem tem controle sobre a tela, a janela toda, e avisa todo mundo sobre o click. tipo a região em que está em outra cor, que seria um botão, a região mais ampla que seria a janela. e assim por diante...

 

Sendo bem repetitivo, não há razão pra fazer isso porque por definição é a interface gráfica, seja em Windows, seja na Web seja em Linux, seja nos telefones. Então você usa a interface e pronto.

 

Grandes programadores criaram essas coisas, então é melhor usar do que reescrever

  • Curtir 1
devair1010
 

devair1010

Postado
Postado

@Herbertbahia     você está usando qual compilador ?  se for codeblocks ou dev c++ , precisa linkar a biblioteca lá em setting / compiler / linker settings / other links options e colocar

                       -lwinmm

                       -lconio  

                       -lgdi32

                                                            1425106926_linkersettings.thumb.JPG.ed22151eea77cb0403fdc8b937efa8cb.JPG

-lwinmm  serve para tocar música usando o playsaound  

/*#pragma comment(lib, "winmm.lib")*/
/* precisa colocar  -lwinmm   em linker comand line em tools/compiler options */
/* no console a música roda por 45 segundos , na API do windows roda até o final e repete pois tem o SND_LOOP */
/* a música wave  .wav precisa ser informado o local dela como ali -> c:som2.wav */
#include <stdio.h>
#include <windows.h>'
#include <windowsx.h>
#include <mmsystem.h>
int main(int argc, char *argv[]){
    PlaySound("c:som2.wav",NULL,SND_SYNC | SND_LOOP | SND_FILENAME);
    return 0;
}

http://vulms.vu.edu.pk/Courses/CS410/Downloads/Charles Petzold - Programming Windows - 5th Ed.pdf

https://forum.zwame.pt/threads/tutorial-programar-para-windows.75878/

e o -lgdi32 é para trabalhar com os pixeis da tela  

#define _WIN32_WINNT 0x0600
#include <stdio.h>
#include <conio.h>
#include <windows.h>
#define cls ;system("cls");InvalidateRect(csl,NULL,TRUE);
int alien[1][8]={260,136,508,886,
             2047,2047,1285,216};
int l=5,a_c=170,j,i,n,a_l,c,f,tm,g;
COLORREF cor,clr;
HWND     csl;
HDC      hdc;
HBRUSH   NewBrush;
void pix(float sn,float cs,int h2){
    int w2,i2;
    for(w2=0;w2<h2;w2++)
        for(i2=0;i2<h2;i2++)
            SetPixel(hdc,sn+w2,cs+i2,cor);      /* desenha um ponto com grossura h2           */
}
int main(){
    cor      = RGB(255,255,0);
    csl      = GetConsoleWindow();
    hdc      = GetDC(csl);
    NewBrush = CreateSolidBrush(RGB(255, 2, 5));
    SelectObject(hdc, NewBrush);
    clr = RGB(0,255,0);
    tm=3;
    for(j=0;j<8;j++){
        n = alien[0][j];
        c=a_c;
        while(n > 0){
            if( n % 2 != 0 )
                pix(c+g,l+f,tm);
            n/=2;
            c-=tm;
        }
        l+=tm;
    }
    getch();

    printf("\n\n\n");
    return 0;
}

 

  • Curtir 1

Crie uma conta ou entre para comentar

Você precisa ser um usuário para fazer um comentário

Criar uma conta

Crie uma nova conta em nossa comunidade. É fácil!

Crie uma nova conta

Entrar

Já tem uma conta? Faça o login.

Entrar agora
 Compartilhar
Ir à lista de tópicos

Sobre o Clube do Hardware

No ar desde 1996, o Clube do Hardware é uma das maiores, mais antigas e mais respeitadas comunidades sobre tecnologia do Brasil. Leia mais

Direitos autorais

Não permitimos a cópia ou reprodução do conteúdo do nosso site, fórum, newsletters e redes sociais, mesmo citando-se a fonte. Leia mais

Mais

×
×
  • Criar novo...

LANÇAMENTO!

eletronica2025-popup.jpg


CLIQUE AQUI E BAIXE AGORA MESMO!