Ir ao conteúdo

Mudar Cor da fonte no Code::Blocks


Holocausto

Posts recomendados

Postado

Olá Pessoal alguém sabe me informa como consigo mudar a cor da fonte no CodeBlocks ?

Tentei instalar através do plugin o conio2.h do DevPack, mas não tive sucesso não sei se ha incompatibilidade entre as versões do Codeblocks, enfim não consegui.

Outra solução foi instalar o allegro.h que de certa forma funcionou corretamente, mas essa biblioteca é complexa eu queria algo mais simples.

Alguém sabe outra biblioteca do gênero ou conseguiu instalar o DevPack na última versão do codeblocks?

Obs. Exceto a biblioteca Windows.h, que muda a cor de todo o programa.

  • Membro VIP
Postado

Boa tarde, Holocausto, tudo bem?

Não entendi sua dúvida. Você quer trocar a cor do código fonte ou da execução do programa console? Se for a segunda opção, insira este codigo abaixo como uma das primeiras instruções de sua main:


#include <conio.h>

/*

Cores:
0 = Preto 8 = Cinza
1 = Azul 9 = Azul claro
2 = Verde 10 = Verde claro
3 = Verde-água 11 = Verde-água claro
4 = Vermelho 12 = Vermelho claro
5 = Roxo 13 = Lilás
6 = Amarelo 14 = Amarelo claro
7 = Branco 15 = Branco brilhante
*/

system("color X");

onde X é um dos números citados acima.

Att,

Plateu!

Postado
Boa tarde, Holocausto, tudo bem?

Não entendi sua dúvida. Você quer trocar a cor do código fonte ou da execução do programa console? Se for a segunda opção, insira este codigo abaixo como uma das primeiras instruções de sua main:


#include <conio.h>

/*

Cores:
0 = Preto 8 = Cinza
1 = Azul 9 = Azul claro
2 = Verde 10 = Verde claro
3 = Verde-água 11 = Verde-água claro
4 = Vermelho 12 = Vermelho claro
5 = Roxo 13 = Lilás
6 = Amarelo 14 = Amarelo claro
7 = Branco 15 = Branco brilhante
*/

system("color X");

onde X é um dos números citados acima.

Att,

Plateu!

Obrigado pela sugestão Plateu mas o system("color X") da biblioteca conio.h tem a mesma função que a do windows.h (muda todas as fontes) eu gostaria de mudar apenas uma parte da fonte do programa.

Achei essa biblioteca em um site não me recordo qual mas ela tem a funcão de mudar a cor da fonte, mas o problema que ela esta rodando somente em c++, fiz algumas mudanças para conseguir utiliza-la em c, mas não deu muito certo.

Alguem consegue modifica-la para rodar e c?

#include <cstdlib>
#include <iostream>
#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 gotoxy(int coluna, int linha)
{
COORD point;
point.X = coluna; point.Y = linha;
SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE), point);
}
//---------------------------------------------------
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 backcolor (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));
}

Ex: Utilização:

textcolor (Nome da cor igual o que ta escrito no enum);

Postado
Que tal system("color xy");, sendo x e y valores de 0 à 9 ou de A à F(ou seja, xy é um numero hexadecimal)

O system não atende ao que preciso, gostaria de mudar apenas alguns valores de uma matriz.

Ex:

00 01 02

10 11 12

20 21 22

Postado

Boas pessoal achei uma solução tem uma biblioteca do devc++ que se chama conio.c.

include "conio.c"


/* Implementación de conio segun especificaciones de Borland
* para Mingw/Dev-C++.
*
* Por:
* Salvador Pozo Coronado <salvador@conclase.net>
* C++ con Clase: http://c.conclase.net
* Versión 1.0 Abril de 2003.
* Versión 1.1 Agosto de 2003 (fru <elfrucool@yahoo.com.mx>)
* Se adapta el código a ANSI C (la versión anterior contiene
* muchos errores debido al uso de características C++).
* Versión 1.2 Abril de 2004.
* Se corrige bug en función void _setcursortype(int cur_t);
* que no funcionaba correctemente con la opción _NOCURSOR
* Versión 1.3 Agosto de 2004
* Se usa el nombre libconio.a para facilitar el enlace estático.
* Versión 1.31 Agosto de 2005
* Se corrige el error en la función kbhit para que sólo busque
* eventos de teclas pulsadas, e ignore los de tecla soltada.
*
* Para dominio público sin ninguna garantía.
*/

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <windows.h>
#include <string.h>
#include <stdarg.h>
#include "conio.h"

#ifdef __cplusplus
extern "C" {
#endif

// Declaramos una estructura text_info para almacenar la información
// sobre la ventana actual.
text_info vActual = {0, 0, 79, 24, WHITE, WHITE, C80, 25, 80, 1, 1};

// Reads a string from the console.
// cgets reads a string of characters from the console, storing the string
// (and the string length) in the location pointed to by str.
// cgets reads characters until it encounters a carriage-return/linefeed
// (CR/LF) combination, or until the maximum allowable number of characters
// have been read. If cgets reads a CR/LF combination, it replaces the
// combination with a \0 (null terminator) before storing the string.
// Before cgets is called, set str[0] to the maximum length of the string to
// be read. On return, str[1] is set to the number of characters actually
// read. The characters read start at str[2] and end with a null terminator.
// Thus, str must be at least str[0] plus 2 bytes long.
char *cgets(char *str)
{
DWORD longitud = 0;
DWORD leidos, modo;

GetConsoleMode(GetStdHandle(STD_INPUT_HANDLE), &modo);
SetConsoleMode(GetStdHandle(STD_INPUT_HANDLE), modo & !ENABLE_ECHO_INPUT);
do {
ReadConsole(GetStdHandle(STD_INPUT_HANDLE), &str[2+longitud], 1,
&leidos, NULL);
if(str[2+longitud] != '\r') putch(str[2+longitud++]);
} while(longitud < str[0] && str[2+longitud] != '\r');
str[1] = longitud;
str[2+longitud] = 0;
SetConsoleMode(GetStdHandle(STD_INPUT_HANDLE), modo);
return &str[2];
}

// Clears to end of line in text window.
// clreol clears all characters from the cursor position to the end of the
// line within the current text window, without moving the cursor.
// Borrar hasta el final de la línea requiere borrar tanto los caracteres
// como los atributos.
void clreol ()
{
COORD coord;
DWORD escrito;

coord.X = vActual.winleft+vActual.curx-1;
coord.Y = vActual.wintop+vActual.cury-1;

FillConsoleOutputCharacter(GetStdHandle(STD_OUTPUT_HANDLE), ' ',
vActual.screenwidth - vActual.curx + 1, coord, &escrito);
FillConsoleOutputAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
vActual.attribute, vActual.screenwidth - vActual.curx + 1,
coord, &escrito);
gotoxy(vActual.curx, vActual.cury);
}

// Clears the text-mode window.
// clrscr clears the current text window and places the cursor in the upper
// left corner (at position 1,1).
// La consola en algunos sistemas operativos no está limitada a 80*25
// caracteres, como en MSDOS, obtenemos el tamaño actual de la consola y la
// borramos entera, usando los valores de atributos actuales.
void clrscr ()
{
DWORD escrito;
int i;

for( i = 0; i < vActual.screenheight; i++) {
FillConsoleOutputAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
vActual.attribute, vActual.screenwidth,
(COORD) {vActual.winleft, vActual.wintop+i}, &escrito);
FillConsoleOutputCharacter(GetStdHandle(STD_OUTPUT_HANDLE), ' ',
vActual.screenwidth,
(COORD) {vActual.winleft, vActual.wintop+i}, &escrito);
}
gotoxy(vActual.curx, vActual.cury);
}

// Writes formatted output to the screen.
// cprintf accepts a series of arguments, applies to each a format specifier
// contained in the format string pointed to by format, and outputs the
// formatted data directly to the current text window on the screen. There
// must be the same number of format specifiers as arguments.
// For details details on format specifiers, see printf Format Specifiers.
// The string is written either directly to screen memory or by way of a
// BIOS call, depending on the value of the global variable _directvideo.
// Unlike fprintf and printf, cprintf does not translate linefeed characters
// (\n) into carriage-return/linefeed character pairs (\r\n). Tab characters
// (specified by \t) are not expanded into spaces.
int cprintf(const char *format, ...)
{
// char *buffer; // this is not "c" (this is c++).
char buffer[1024] = { 0 };
va_list p;
int n;

// buffer = new char[1024]; // this is not "c" (this is c++).
// buffer = (char *)malloc(1024);
va_start(p, format);
n = vsprintf(buffer, format, p);
cputs(buffer);
// delete[] buffer; // this is not "c" (this is c++).
// free( buffer ); // usar si buffer = malloc
return n;
}

// Writes a string to the screen.
// cputs writes the null-terminated string str to the current text
// window. It does not append a newline character.
// The string is written either directly to screen memory or by way of a
// BIOS call, depending on the value of the global variable _directvideo.
// Unlike puts, cputs does not translate linefeed characters (\n) into
// carriage-return/linefeed character pairs (\r\n).
int cputs(const char *str) // repasar
{
DWORD escritos;
int n = 0;
int resto = vActual.screenwidth-vActual.curx+1;

do {
if(strlen(&str[n]) < resto) resto = strlen(&str[n]);
gotoxy(vActual.curx, vActual.cury);
WriteConsole(GetStdHandle(STD_OUTPUT_HANDLE), &str[n], resto, &escritos,
NULL);
n+=resto;
vActual.curx+=resto;
if(vActual.curx > vActual.screenwidth) {
vActual.curx -= vActual.screenwidth;
resto = vActual.screenwidth-vActual.curx+1;
vActual.cury++;
resto = vActual.screenwidth;
if(vActual.cury > vActual.screenheight) {
vActual.cury--;
movetext(1, 2, vActual.screenwidth, vActual.screenheight, 1, 1);
}
}
} while(str[n]);
return strlen(str);
}

// Scans and formats input from the console.
// cscanf scans a series of input fields one character at a time, reading
// directly from the console. Then each field is formatted according to a
// format specifier passed to cscanf in the format string pointed to by format.
// Finally, cscanf stores the formatted input at an address passed to it as
// an argument following format, and echoes the input directly to the screen.
// There must be the same number of format specifiers and addresses as there
// are input fields.
// Note: For details on format specifiers, see scanf Format Specifiers.
// cscanf might stop scanning a particular field before it reaches the normal
// end-of-field (whitespace) character, or it might terminate entirely for a
// number of reasons. See scanf for a discussion of possible causes.
/*int cscanf(char *format, ...)
{
char *buffer;
va_list p;
int n;
DWORD leidos;

buffer = new char[260];
buffer[0] = 255;
cgets(buffer);
va_start(p, format);
printf("#%s#%s#\n", &buffer[2], format);
n = sscanf(&buffer[2], format, p);
delete[] buffer;
return n;
}*/

// Deletes line in text window.
// delline deletes the line containing the cursor and moves all lines below
// it one line up. delline operates within the currently active text window.
void delline()
{
COORD coord;
SMALL_RECT origen;
SMALL_RECT clip;
CHAR_INFO ci;

origen.Left = vActual.winleft;
origen.Top = vActual.wintop+vActual.cury;
origen.Right = vActual.winright;
origen.Bottom = vActual.winbottom;
coord.X = vActual.winleft;
coord.Y = vActual.wintop+vActual.cury-1;
clip.Left = vActual.winleft;
clip.Top = vActual.wintop;
clip.Right = vActual.winright;
clip.Bottom = vActual.winbottom;
ci.Char.AsciiChar = ' ';
ci.Attributes = vActual.attribute;
ScrollConsoleScreenBuffer(GetStdHandle(STD_OUTPUT_HANDLE),
&origen, &clip, coord, &ci);
vActual.curx = 1;
gotoxy(vActual.curx, vActual.cury);
}

// Gets character from keyboard, does not echo to screen.
// getch reads a single character directly from the keyboard, without
// echoing to the screen.
int getch(void)
{
int car;
DWORD leidos, modo;

GetConsoleMode(GetStdHandle(STD_INPUT_HANDLE), &modo);
SetConsoleMode(GetStdHandle(STD_INPUT_HANDLE), modo & !ENABLE_ECHO_INPUT & !ENABLE_PROCESSED_INPUT);
ReadConsole(GetStdHandle(STD_INPUT_HANDLE), &car, 1, &leidos, NULL);
SetConsoleMode(GetStdHandle(STD_INPUT_HANDLE), modo);
return car;
}

// Gets character from the keyboard, echoes to screen.
// getche reads a single character from the keyboard and echoes it to the
// current text window using direct video or BIOS.
int getche(void)
{
int car;
DWORD leidos, modo;

GetConsoleMode(GetStdHandle(STD_INPUT_HANDLE), &modo);
SetConsoleMode(GetStdHandle(STD_INPUT_HANDLE), modo & !ENABLE_ECHO_INPUT & !ENABLE_PROCESSED_INPUT);
ReadConsole(GetStdHandle(STD_INPUT_HANDLE), &car, 1, &leidos, NULL);
putch(car);
SetConsoleMode(GetStdHandle(STD_INPUT_HANDLE), modo);
return car;
}

// Reads a password.
// getpass reads a password from the system console after prompting with
// the null-terminated string prompt and disabling the echo. A pointer is
// returned to a null-terminated string of up to eight characters (not
// counting the null-terminator).
char *getpass(const char *prompt)
{
static char pass[9];
DWORD longitud = 0;
DWORD leidos, modo;

cputs(prompt);
GetConsoleMode(GetStdHandle(STD_INPUT_HANDLE), &modo);
SetConsoleMode(GetStdHandle(STD_INPUT_HANDLE), modo & !ENABLE_ECHO_INPUT);
do {
ReadConsole(GetStdHandle(STD_INPUT_HANDLE), &pass[longitud], 1, &leidos,
NULL);
if(pass[longitud] != '\r') longitud++;
} while(longitud < 8 && pass[longitud] != '\r');
pass[longitud] = 0;
SetConsoleMode(GetStdHandle(STD_INPUT_HANDLE), modo);
return pass;
}

// Copies text from text mode screen to memory.
// gettext stores the contents of an onscreen text rectangle defined by left,
// top, right, and bottom into the area of memory pointed to by destin.
// All coordinates are absolute screen coordinates not window-relative. The
// upper left corner is (1,1). gettext reads the contents of the rectangle
// into memory sequentially from left to right and top to bottom.
// Each position onscreen takes 2 bytes of memory: The first byte is the
// character in the cell and the second is the cell's video attribute. The
// space required for a rectangle w columns wide by h rows high is defined as
// bytes = (h rows) x (w columns) x 2
int _gettext(int left, int top, int right, int bottom, void *destin)
{
PCHAR_INFO buffer;
char *pantalla = (char *)destin;
int retval,i;

COORD cSize = {1+right-left, 1+bottom-top};
COORD cDest = {0,0};
SMALL_RECT rect = {vActual.winleft+left-1, vActual.wintop+top-1,
vActual.winleft+right-1, vActual.wintop+bottom-1};
// buffer = new CHAR_INFO[cSize.X * cSize.Y];
buffer = (PCHAR_INFO)malloc(cSize.X*cSize.Y*sizeof(CHAR_INFO));

retval = ReadConsoleOutput(GetStdHandle(STD_OUTPUT_HANDLE),
buffer, cSize, cDest, &rect);
for( i = 0; i < cSize.X * cSize.Y; i++) {
pantalla[2*i] = buffer[i].Char.AsciiChar;
pantalla[2*i + 1] = buffer[i].Attributes & 0xff;
}
// delete[] buffer;
free( buffer );
return retval;
}

// Gets text mode video information.
// gettextinfo fills in the text_info structure pointed to by r with the
// current text video information.
void gettextinfo(struct text_info *r)
{
CONSOLE_SCREEN_BUFFER_INFO csbi;

GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &csbi);

*r = vActual;
}

// Positions cursor in text window.
// gotoxy moves the cursor to the given position in the current text window.
// If the coordinates are in any way invalid the call to gotoxy is ignored.
// An example of this is a call to gotoxy(40,30) when (35,25) is the bottom
// right position in the window. Neither argument to gotoxy can be zero.
void gotoxy(int x, int y)
{
COORD c;

if(x < 1 || x > vActual.screenwidth ||
y < 1 || y > vActual.screenheight) return;
vActual.curx = x;
vActual.cury = y;
c.X = vActual.winleft + x - 1;
c.Y = vActual.wintop + y - 1;
SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE), c);
}

// Selects high-intensity characters.
// highvideo selects high-intensity characters by setting the high-intensity
// bit of the currently selected foreground color.
// This function does not affect any characters currently onscreen, but does
// affect those displayed by functions (such as cprintf) that perform direct
// video, text mode output after highvideo is called.
void highvideo(void)
{
vActual.attribute |= FOREGROUND_INTENSITY;
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), vActual.attribute);
}

// Funciones no permitidas en Windows:
//inp
//inport
//inportb
//inpw

// Inserts a blank line in the text window.
// insline inserts an empty line in the text window at the cursor position
// using the current text background color. All lines below the empty one move
// down one line, and the bottom line scrolls off the bottom of the window.
void insline(void)
{
COORD coord;
SMALL_RECT origen;
SMALL_RECT clip;
CHAR_INFO ci;

origen.Left = vActual.winleft;
origen.Top = vActual.wintop+vActual.cury-1;
origen.Right = vActual.winright;
origen.Bottom = vActual.winbottom;
coord.X = vActual.winleft;
coord.Y = vActual.wintop+vActual.cury;
clip.Left = vActual.winleft;
clip.Top = vActual.wintop;
clip.Right = vActual.winright;
clip.Bottom = vActual.winbottom;
ci.Char.AsciiChar = ' ';
ci.Attributes = vActual.attribute;
ScrollConsoleScreenBuffer(GetStdHandle(STD_OUTPUT_HANDLE),
&origen, &clip, coord, &ci);
vActual.curx = 1;
gotoxy(vActual.curx, vActual.cury);
}

// Checks for currently available keystrokes.
// kbhit checks to see if a keystroke is currently available. Any available
// keystrokes can be retrieved with getch or getche.
int kbhit(void)
{
DWORD nEventos;
INPUT_RECORD *eventos;
DWORD leidos;
int retval = 0;
int i;

GetNumberOfConsoleInputEvents(GetStdHandle(STD_INPUT_HANDLE),
&nEventos);
// eventos = new INPUT_RECORD[nEventos];
eventos = (INPUT_RECORD *)malloc(nEventos*sizeof(INPUT_RECORD));
PeekConsoleInput(GetStdHandle(STD_INPUT_HANDLE),
eventos, nEventos, &leidos);
for(i = 0; i < nEventos; i++)
if(eventos[i].EventType == KEY_EVENT && eventos[i].Event.KeyEvent.bKeyDown) retval = 1;
// delete[] eventos;
free( eventos );
return retval;
}

// Selects low-intensity characters.
// lowvideo selects low-intensity characters by clearing the high-intensity
// bit of the currently selected foreground color.
// This function does not affect any characters currently onscreen. It affects
// only those characters displayed by functions that perform text mode, direct
// console output after this function is called.
void lowvideo(void)
{
vActual.attribute &= ~FOREGROUND_INTENSITY;
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), vActual.attribute);
}

// Copies text onscreen from one rectangle to another.
// movetext copies the contents of the onscreen rectangle defined by left,
// top, right, and bottom to a new rectangle of the same dimensions. The new
// rectangle's upper left corner is position (destleft, desttop).
// All coordinates are absolute screen coordinates. Rectangles that overlap
// are moved correctly.
// movetext is a text mode function performing direct video output.
int movetext(int left, int top, int right, int bottom, int destleft,
int desttop)
{
COORD coord;
SMALL_RECT origen;
CHAR_INFO ci;

origen.Left = vActual.winleft+left-1;
origen.Top = vActual.wintop+top-1;
origen.Right = vActual.winleft+right-1;
origen.Bottom = vActual.wintop+bottom-1;
coord.X = vActual.winleft+destleft-1;
coord.Y = vActual.wintop+desttop-1;
ci.Char.AsciiChar = ' ';
ci.Attributes = vActual.attribute;
ScrollConsoleScreenBuffer(GetStdHandle(STD_OUTPUT_HANDLE),
&origen, NULL, coord, &ci);
return 0;
}

// Selects normal-intensity characters.
// normvideo selects normal characters by returning the text attribute
// (foreground and background) to the value it had when the program started.
// This function does not affect any characters currently on the screen, only
// those displayed by functions (such as cprintf) performing direct console
// output functions after normvideo is called.
void normvideo(void)
{
vActual.attribute = vActual.normattr;
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), vActual.attribute);
}

// Funciones no permitidas en Windows:
//outp
//outport
//outportb
//outpw

// Outputs character to screen.
// putch outputs the character c to the current text window. It is a text mode
// function performing direct video output to the console. putch does not
// translate linefeed characters (\n) into carriage-return/linefeed pairs.
// The string is written either directly to screen memory or by way of a BIOS
// call, depending on the value of the global variable _directvideo.
int putch(int c)
{
DWORD escritos;

gotoxy(vActual.curx, vActual.cury);
WriteConsole(GetStdHandle(STD_OUTPUT_HANDLE), (char*)&c, 1, &escritos,
NULL);
vActual.curx++;
if(vActual.curx > vActual.screenwidth) {
vActual.curx -= vActual.screenwidth;
vActual.cury++;
if(vActual.cury > vActual.screenheight) {
vActual.cury--;
movetext(1, 2, vActual.screenwidth, vActual.screenheight, 1, 1);
}
}
return 0;
}

// Copies text from memory to the text mode screen.
// puttext writes the contents of the memory area pointed to by source out to
// the onscreen rectangle defined by left, top, right, and bottom.
// All coordinates are absolute screen coordinates, not window-relative. The
// upper left corner is (1,1).
// puttext places the contents of a memory area into the defined rectangle
// sequentially from left to right and top to bottom.
// Each position onscreen takes 2 bytes of memory: The first byte is the
// character in the cell, and the second is the cell's video attribute. The
// space required for a rectangle w columns wide by h rows high is defined as
// bytes = (h rows) x (w columns) x 2
// puttext is a text mode function performing direct video output.
int puttext(int left, int top, int right, int bottom, void *source)
{
PCHAR_INFO buffer;
char *pantalla = (char *)source;
int retval,i;

COORD cSize = {1+right-left, 1+bottom-top};
COORD cDest = {0,0};
SMALL_RECT rect = {vActual.winleft+left-1, vActual.wintop+top-1,
vActual.winleft+right-1, vActual.wintop+bottom-1};
// buffer = new CHAR_INFO[cSize.X * cSize.Y];
buffer = (PCHAR_INFO)malloc(sizeof(CHAR_INFO)*cSize.X * cSize.Y);

for( i = 0; i < cSize.X * cSize.Y; i++) {
buffer[i].Char.AsciiChar = pantalla[2*i];
buffer[i].Attributes = (WORD)pantalla[2*i + 1];
}

retval = WriteConsoleOutput(GetStdHandle(STD_OUTPUT_HANDLE),
buffer, cSize, cDest, &rect);
// delete[] buffer;
free(buffer);
return retval;
}

// Selects cursor appearance.
// Sets the cursor type to
//
// _NOCURSOR Turns off the cursor
// _NORMALCURSOR Normal underscore cursor
// _SOLIDCURSOR Solid block cursor
void _setcursortype(int cur_t)
{
CONSOLE_CURSOR_INFO cci;

switch(cur_t) {
case _NOCURSOR:
cci.dwSize = 100;
cci.bVisible = FALSE;
break;
case _SOLIDCURSOR:
cci.dwSize = 100;
cci.bVisible = TRUE;
break;
case _NORMALCURSOR:
cci.dwSize = 10;
cci.bVisible = TRUE;
break;
}
SetConsoleCursorInfo(GetStdHandle(STD_OUTPUT_HANDLE), &cci);
}

// Sets text attributes.
// textattr lets you set both the foreground and background colors in a
// single call. (Normally, you set the attributes with textcolor and
// textbackground.)
// This function does not affect any characters currently onscreen; it affects
// only those characters displayed by functions (such as cprintf) performing
// text mode, direct video output after this function is called.
// Windows no permite colores parpadeantes (BLINK), en su lugar es posible
// usar 16 colores para el fondo, en lugar de los 8 de DOS
void textattr(int newattr)
{
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), newattr);
vActual.attribute = newattr;
}

// Selects new text background color.
// textbackground selects the background color. This function works for
// functions that produce output in text mode directly to the screen.
// newcolor selects the new background color. You can set newcolor to an
// integer from 0 to 7, or to one of the symbolic constants defined in
// conio.h. If you use symbolic constants, you must include conio.h.
// Once you have called textbackground, all subsequent functions using direct
// video output (such as cprintf) will use newcolor. textbackground does not
// affect any characters currently onscreen.
// En windows se permiten colores del 0 al 15 para el fondo.
void textbackground(int newcolor)
{
CONSOLE_SCREEN_BUFFER_INFO csbi;

GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &csbi);
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
(csbi.wAttributes & 0x0f) | (newcolor << 4));
vActual.attribute = (csbi.wAttributes & 0x0f) | (newcolor << 4);
}

// Selects new character color in text mode.
// textcolor selects the foreground character color. This function works for
// the console output functions. newcolor selects the new foreground color.
// You can set newcolor to an integer as given in the table below, or to one
// of the symbolic constants defined in conio.h. If you use symbolic constants,
// you must include conio.h.
// Once you have called textcolor, all subsequent functions using direct video
// output (such as cprintf) will use newcolor. textcolor does not affect any
// characters currently onscreen.
void textcolor(int newcolor)
{
CONSOLE_SCREEN_BUFFER_INFO csbi;

GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &csbi);
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
(csbi.wAttributes & 0xf0) | newcolor);
vActual.attribute = (csbi.wAttributes & 0xf0) | newcolor;
}

// Puts screen in text mode.
void textmode(int newmode)
{
}

// Pushes a character back to the keyboard buffer.
// ungetch pushes the character ch back to the console, causing ch to be the
// next character read. The ungetch function fails if it is called more than
// once before the next read.
int ungetch(int ch)
{
INPUT_RECORD ir[2];
DWORD escritos;

ir[0].EventType = KEY_EVENT;
ir[0].Event.KeyEvent.bKeyDown = TRUE;
ir[0].Event.KeyEvent.wRepeatCount = 1;
ir[0].Event.KeyEvent.wVirtualKeyCode = 0;
ir[0].Event.KeyEvent.wVirtualScanCode = 0;
ir[0].Event.KeyEvent.uChar.AsciiChar = ch;
ir[0].Event.KeyEvent.dwControlKeyState = 0;
ir[1].EventType = KEY_EVENT;
ir[1].Event.KeyEvent.bKeyDown = FALSE;
ir[1].Event.KeyEvent.wRepeatCount = 1;
ir[1].Event.KeyEvent.wVirtualKeyCode = 0;
ir[1].Event.KeyEvent.wVirtualScanCode = 0;
ir[1].Event.KeyEvent.uChar.AsciiChar = ch;
ir[1].Event.KeyEvent.dwControlKeyState = 0;
if(WriteConsoleInput(GetStdHandle(STD_INPUT_HANDLE),
ir, 2, &escritos)) return ch;
return EOF;
}

// Gives horizontal cursor position within window.
// wherex returns the x-coordinate of the current cursor position (within the
// current text window).
int wherex(void)
{
return vActual.curx;
}

// Gives vertical cursor position within window.
// wherey returns the y-coordinate of the current cursor position (within the
// current text window).
int wherey(void)
{
return vActual.cury;
}

// Defines active text mode window.
// window defines a text window onscreen. If the coordinates are in any way
// invalid, the call to window is ignored.
// left and top are the screen coordinates of the upper left corner of the
// window.
// right and bottom are the screen coordinates of the lower right corner.
// The minimum size of the text window is one column by one line. The default
// window is full screen, with the coordinates:
// 1,1,C,R
// where C is the number of columns in the current video mode, and R is the
// number of rows.
void window(int left, int top, int right, int bottom)
{
vActual.winleft = left-1;
vActual.wintop = top-1;
vActual.winright = right-1;
vActual.winbottom = bottom-1;
vActual.screenheight = 1+bottom-top;
vActual.screenwidth = 1+right-left;
vActual.curx = 1;
vActual.cury = 1;
clrscr();
}

#ifdef __cplusplus
}
#endif


include <conio.h>


/* Implementación de conio segun especificaciones de Borland
* para Mingw/Dev-C++.
*
* Por:
* Salvador Pozo Coronado <salvador@conclase.net>
* C++ con Clase: http://c.conclase.net
* Versión 1.0 Abril de 2003.
* Versión 1.1 Agosto de 2003 (fru <elfrucool@yahoo.com.mx>)
* Se adapta el código a ANSI C (la versión anterior contiene
* muchos errores debido al uso de características C++).
* Versión 1.2 Abril de 2004.
* Se corrige bug en función void _setcursortype(int cur_t);
* que no funcionaba correctemente con la opción _NOCURSOR
* Versión 1.3 Agosto de 2004
* Se usa el nombre libconio.a para facilitar el enlace estático.
*
* Para dominio público sin ninguna garantía.
*/

#ifndef _CONIO_H_
#define _CONIO_H_

#include <stdio.h>

#ifdef __cplusplus
extern "C" {
#endif

#define BLINK 0

typedef
struct text_info {
unsigned char winleft; /* left window coordinate */
unsigned char wintop; /* top window coordinate */
unsigned char winright; /* right window coordinate */
unsigned char winbottom; /* bottom window coordinate */
unsigned char attribute; /* text attribute */
unsigned char normattr; /* normal attribute */
unsigned char currmode; /* BW40, BW80, C40, C80, or C4350 */
unsigned char screenheight; /* text screen's height */
unsigned char screenwidth; /* text screen's width */
unsigned char curx; /* x-coordinate in current window */
unsigned char cury; /* y-coordinate in current window */
} text_info;

typedef enum {
BLACK,
BLUE,
GREEN,
CYAN,
RED,
MAGENTA,
BROWN,
LIGHTGRAY,
DARKGRAY,
LIGHTBLUE,
LIGHTGREEN,
LIGHTCYAN,
LIGHTRED,
LIGHTMAGENTA,
YELLOW,
WHITE
} COLORS;

enum text_modes {
LASTMODE=-1,
BW40=0,
C40,
BW80,
C80,
MONO=7,
C4350=64
};

#define _NOCURSOR 0
#define _SOLIDCURSOR 1
#define _NORMALCURSOR 2

#define cscanf scanf

/* Funciones de conio según Borland: */
char *cgets(char *str);
void clreol(void);
void clrscr(void);
int cprintf(const char *format, ...);
int cputs(const char *str);
//int cscanf(char *format, ...);
void delline(void);
int getch(void);
int getche(void);
char *getpass(const char *prompt);
int _gettext(int left, int top, int right, int bottom, void *destin);
void gettextinfo(struct text_info *r);
void gotoxy(int, int);
void highvideo(void);
//inp
//inport
//inportb
//inpw
void insline(void);
int kbhit(void);
void lowvideo(void);
int movetext(int left, int top, int right, int bottom, int destleft, int desttop);
void normvideo(void);
//outp
//outport
//outportb
//outpw
int putch(int c);
int puttext(int left, int top, int right, int bottom, void *source);
void _setcursortype(int cur_t);
void textattr(int newattr);
void textbackground(int newcolor);
void textcolor(int newcolor);
void textmode(int newmode);
int ungetch(int ch);
int wherex(void);
int wherey(void);
void window(int left, int top, int right, int bottom);

#ifdef __cplusplus
}
#endif

#endif /* _CONIO_H_ */

Utilizar as duas bibliotecas na mesma pasta.

Ex de utilização: textcolor(12); printf("Teste");

Arquivado

Este tópico foi arquivado e está fechado para novas respostas.

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

×
×
  • Criar novo...

LANÇAMENTO!

eletronica2025-popup.jpg


CLIQUE AQUI E BAIXE AGORA MESMO!