Hp11

CAPÍTULO 11
CONTROLADORES GRÁFICOS
Y LENGUAJE C
11.1. CONTROLADORES GRÁFICOS
El PC compatible IBM, soporta diferentes controladores gráficos, los cuales van desde el CGA hasta el
VGA y SVGA, pasando por EGA y HERCULES. Existen varias formas y modos de programación de estos
controladores, los que pueden ser inicializados sin ningún problema por el lenguaje C. Los modos de trabajo
pueden ser alfanumérico y gráfico, ambos modos pueden programarse utilizando funciones proporcionadas por C,
interrupciones lógicas o haciendo acceso directo a los puertos de programación de la tarjeta gráfica e incluso
pueden combinarse estas alternativas. En este capítulo se revisa la forma más simple de acceso al modo gráfico,
haciendo uso de las funciones defnidas en graphics.h de Borland.
11.2. UTILIZANDO FUNCIONES DE GRAPHICS.H (SÓLO PARA MS-DOS)
El TurboC proporciona una biblioteca para el trabajo en modo gráfico. Las funciones se encuentran
definidas en el archivo graphics.h , permiten inicializar y trabajar en modo gráfico estando en DOS, además de
una muy fácil manipulación de la tarjeta gráfica.
A continuación se describen algunas de las funciones:
Funciones
void far initgraph(int far *__graphdriver,
Descripción
Inicializa el modo gráfico
int far *__graphmode,
const char far *__pathtodriver);
void far detectgraph(int far *__graphdriver,
int far *__graphmode);
Autodetecta el adaptador grafico
void far closegraph(void);
Sale del modo gráfico
Tabla 11.1. Funciones para inicializar el modo gráfico.
Estas funciones permiten detectar e inicializar el adaptador gráfico. El parámetro _graphdriver
permite manipular el adaptador gráfico, _graphmode determina el modo de trabajo del adaptador y
_pathtodriver indica el directorio en el cual se encuentra el manejador gráfico *.BGI que permite enlazar las
funciones gráficas con las tarjeta correspondiente (Borland Graphics Interface).
_graphdriver puede tomar cualquiera de los siguientes valores definidos por la variable enum
graphics_drivers .
94
Preaparado por Juan Ignacio Huircán
Manejadores gráficos
Código
DETECT
CGA, MCGA, EGA, EGA64, EGAMONO, IBM8514
HERCMONO, ATT400, VGA, PC3270
CURRENT_DRIVER= -1
Autodeteccion
1 - 6
7 - 10
Tabla 11.2. Manejadores gráficos.
Los modos de trabajo están definidos por la enumeración enum graphics_modes , las cuales se
encuentran en la siguiente tabla.
Modos de trabajo de los
drivers
CGAC0
CGAC1
CGAC2
CGAC3
CGAHI
MCGAC0
MCGAC1
MCGAC2
MCGAC3
MCGAMED
MCGAHI
EGALO
EGAHI
EGA64LO
EGA64HI
EGAMONOHI
HERCMONOHI
ATT400C0
ATT400C1
ATT400C2
ATT400C3
ATT400MED
ATT400HI
VGALO
VGAMED
VGAHI
PC3270HI
IBM8514LO
IBM8514HI
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
0
1
2
3
4
0
1
2
3
4
5
0
1
0
1
0
0
0
1
2
3
4
5
0
1
2
0
0
1
Resolución
320x200 palette 0; 1
320x200 palette 1; 1
320x200 palette 2: 1
320x200 palette 3; 1
640x200 1 pag.
320x200 palette 0; 1
320x200 palette 1; 1
320x200 palette 2; 1
320x200 palette 3; 1
640x200 1 pag.
640x480 1 pag.
640x200 16 colores 4
640x350 16 colores 2
640x200 16 colores 1
640x350 4 colores 1
640x350 64K on card,
720x348 2 pag.
320x200 palette 0; 1
320x200 palette 1; 1
320x200 palette 2; 1
320x200 palette 3; 1
640x200 1 pag.
640x400 1 pag.
640x200 16 colores 4
640x350 16 colores 2
640x480 16 colores 1
720x350 1 pag.
640x480 256 colores
1024x768 256 colores
pag.
pag.
pag.
pag.
pag.
pag.
pag.
pag.
pag.
pag.
pag.
pag.
1 pag. - 256K on card, 4 pag.
pag.
pag.
pag.
pag.
pag.
pag.
pag.
Tabla 11.3. Modos de trabajo de los diferentes drivers.
Herramientas de Programación
95
Ej 11.1. Programa para inicio modo gráfico.
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
int main(void)
{
int gdriver = DETECT, gmode, errorcode;
/* auto deteccion */
initgraph(&gdriver, &gmode, "c:\\tc\\bgi");
/* inicializa modo grafico */
errorcode = graphresult();
/* lee resultado de inicializacion */
if (errorcode != grOk)
/* si ocurre error*/
{
printf("Graphics error: %s\n", grapherrormsg(errorcode));
printf("Press any key to halt:");
getch();
exit(1);
}
line(0, 0, getmaxx(), getmaxy());
/* dibuja una linea */
getch();
/* espera por tecla */
closegraph();
return 0;
}
Además de las ya mencionadas, existen una gran variedad de funciones gráficas, las más comunes son:
Funciones
setgraphmode(int __mode);
putpixel(int __x, int __y, int __color);
setcolor(int __color);
Descripción
Cambia el modo gráfico
Dibuja un pixel
Cambia el color
rectangle(int __left, int __top,
int __right, int __bottom);
Dibuja un rectangulo
line(int __x1, int __y1,
int __x2, int __y2);
Dibuja una linea
bar(int __left, int __top,
int __right, int __bottom);
setfillstyle(int __pattern,
int __color);
int getmaxx();
int getmaxy();
Dibuja una barra
void
Activa el color y el tipo de relleno de la barra
Retorna el máximo valor de x
Retorna el máximo valor de y
Tabla 11.4. Funciones básicas para dibujar.
96
Preaparado por Juan Ignacio Huircán
Funciones
setttextjustify(int __horiz, int __vert);
settextstyle(int __font, int __direction,
int __charsize);
outtextxy(int __x, int __y,
const char far *__textstring);
Descripción
Justifica una cadena
Estilo de letra
Escribe una cadena
Figura 11.5. Funciones para manejo de cadenas sobre modo gráfico.
Para mayor profundización, es recomendable revisar el archivo de cabecera graphics.h , ya sea de
TurboC 2.0 o TurboC++ 3.0.
Ej 11.2. Inicializando el modo gráfico si chequear la ocurrencia de errores
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
void main(void)
{
int gdriver = VGA, gmode=VGAHI;
initgraph(&gdriver, &gmode, "c:\\tc\\bgi");
setcolor(LIGHTBLUE);
rectangle(0, 0, getmaxx(), getmaxy());
getch();
closegraph();
}
Un ejemplo clásico en el manejo gráfico es la generación de "ventanas", lo que permite realizar menús a
través de barras de selección corredizas. Por último, es posible realizar procedimiento para graficar señales.
Ej 11.3. Generación de Ventanas. Se pueden hacer en modo gráfico. La forma de hacer aparecer y desaparecer la
ventana (abrir y cerrar) es simple. Se debe almacenar el area en donde se va dibujar la ventana, luego se dibuja la
ventana y finalmente, para cerrar dicha ventana, se superpone al área almacenada previamente, sobre la ventana
dibujada.
#include
#include
#include
#include
#include
<graphics.h>
<alloc.h>
<string.h>
<stdio.h>
<conio.h>
char far *dib_vent(int x1, int y1, int x2, int y2, int color_bk);
void borra_vent(int x1, int y1, char far *pvent);
void msg(int x,int y,char *mensaje, int color_msg);
int maxx, maxy;
Herramientas de Programación
void main(void)
{
char far *pvent;
int gdriver = DETECT, gmode;
initgraph(&gdriver, &gmode, "c:\\tc\\bgi"); /*inicia modo grafico */
maxx=getmaxx();maxy=getmaxy();
setcolor(LIGHTGRAY);
rectangle(0,0,maxx,maxy);
msg(100,400,"<PRESIONE UNA TECLA>",GREEN);
getch();
pvent=dib_vent(100,100, 300,200,WHITE);
msg(100,400,"<PRESIONE UNA TECLA>", YELLOW);
getch();
if(pvent!=NULL) borra_vent(100,100,pvent);
msg(100,400,"<PRESIONE UN TECLA PARA SALIR>", RED);
getch();
closegraph();
}
char far *dib_vent(int x1, int y1, int x2, int y2, int color_bk)
{
char far *pvent;
unsigned tam;
tam = imagesize( x1, y1, x2, y2);
pvent=(char far *)farmalloc(tam);
if(pvent!=NULL)
{
getimage(x1, y1, x2, y2, pvent);
setfillstyle(1,color_bk);
bar(x1,y1,x2,y2);
setfillstyle(1,LIGHTBLUE);
bar(x1+1,y1+1,x2-1,y1+15) ;
}
return(pvent);
}
void borra_vent(int x1, int y1, char far *pvent)
{
putimage(x1, y1,pvent ,COPY_PUT);
farfree(pvent);
}
void msg(int x,int y,char *mensaje, int color_msg)
{
int largo;
largo=strlen(mensaje);
setcolor(color_msg);
setfillstyle(1,BLACK);
bar(x,y,x+largo*8,y+8);
outtextxy(x,y,mensaje);
}
97