Existen hoy en día varios tipos de adaptadores de vídeo, o
tarjetas gráficas disponibles para la línea de computadoras tipo PC. Las más
normales son la monocromática, la CGA, la EGA y la VGA. Entre todos estos
adaptadores soportan muchos modos de vídeo distintos, mostraremos a continuación
algunos
| MODO | TIPO | DIMENSIÓN | ADAPTADOR |
| 0 | texto b/n | 40*25 | CGA, EGA, VGA |
| 1 | texto, 16 colores | 40*25 | CGA, EGA, VGA |
| 3 | texto, 16 colores | 80*25 | CGA, EGA, VGA |
| 4 | gráficos, 4 colores | 320*200 | CGA, EGA, VGA |
| 6 | gráficos/n | 640*200 | CGA, EGA, VGA |
| 7 | texto, b/n | 80*25 | monocromático |
| 8 | gráficas, 16 colores | 640*430 | VGA |
estos modos son solo algunos de la gran variedad que podemos tener por lo que es necesario que investiguemos todos los modos posibles.
Como hemos dicho podemos tener dos modos de funcionamiento, modo texto y modo gráfico. La parte mas pequeña de la texto que es direccionable por el usuario en modo texto, es un carácter. Mientras que en modo gráfico se puede mostrar en la pantalla un pixel (punto direccionable sobre el monitor gráfico) en este modo podemos tener tanto texto como imágenes gráficas.Tanto en los modos de texto como en los gráficos las posiciones individuales se refieren mediante su fila y columna. En los modos gráficos a la esquina superior izquierda de la pantalla le corresponde la posición (0,0). Mientras que para modo texto la esquina superior izquierda le corresponde la posición (1,1).
Estas funciones necesitan que se incluya el header conio.h. Este archivo contiene diversas variables, tipos y constantes que las funciones usan, así como sus prototipos.Las funciones de texto de turbo C funcionan por medio de ventanas. Afortunadamente, la ventana por defecto es la pantalla completa. Una ventana es una de las interfaces que usan los programas para mandar mensajes al usuario. Puede ser tan grande como la pantalla u ocupar tan solo varios caracteres. En algunos programas es bastante normal ver varias ventanas activas al mismo tiempo.
Turbo C permite definir la posición y las dimensiones de una ventana. Después de definirla, las rutinas de turbo C que manipulan el texto solo afectaran a la ventana definida y no al resto de la pantalla. Por ejemplo la función clscr() de turbo C limpiara la ventana activa, y no la pantalla completa. Además todas las coordenadas de posición son relativas a la ventana activa y no a la pantalla.
Como las rutinas de salida de C, como printf(), no están diseñadas para usarlas en un entorno de pantalla orientado a ventanas , turbo C contiene funciones de E/S que reconocen las ventanas. La función cprintf() es muy similar a la función printf() y cputs() a puts(). Ambas funciones se diferencian de las de E/S estándar en que reconocen las ventanas. La función putch() es parecida a putchar(), pero no permite que se escriban caracteres fuera de la ventana actual. La función getche() no hace eco de la entrada fuera de la ventana activa. La función cgets() es ligeramente distinta a su pariente de no ventanas gets(). Su prototipo es:char *cgets(char *cad);
El siguiente programa muestra como usar cgets() para leer una cadena de 20 caracteres como máximo:
#include <conio.h>
int main(void)
{
char cad[80],*p;
cad[0] = 20;
cprintf("Introduce una cadena (máximo 20 caracteres): ");
/* leer hasta 20 caracteres */
p= cgets(cad); /* p apunta al principio de la cadena */
p+=2;
cprintf("\n\r Tu cadena es: %s ocupa %d caracteres\n",p,cad[1]);
return (0);
}
Finalmente recopilaremos todas las funciones mencionadas anteriormente a continuación:
| función | propósito |
| cprintf() | escribir salida con formato en la ventana activa |
| cputs() | escribir una cadena en la ventana activa |
| putch() | saca un carácter por la ventana activa |
| getche() | lee un carácter de la ventana activa |
| cgets() | lee una cadena de la ventana activa |
void clrscr(void);
void clreol(void);
Las funciones delline() e insline() se usan,
respectivamente, para borrar una línea o para insertar una en blanco. Sus
prototipo son:
void delline(void);
void insline(void);
La llamada a delline() borra la línea sobre la que esta el cursor y desplaza hacia arriba todas las líneas siguientes. La llamada a insline() inserta una línea en blanco justo debajo de aquella sobre la que se encuentre el curso y desplaza una línea hacia abajo todas las siguientes.
Una de las funciones mas útiles es gotoxy(), que se usa
para colocar el cursor en una posición determinada de la ventana activa. Su
prototipo es:
void gotoxy(int x, int y);
Estas x e y especifican las coordenadas en las que se va a situar el cursor. Si por ejemplo se esta usando la pantalla entera, en los modos de texto con 80 columnas, el rango valido para x es de 1 a 80 ; para y es de 1 a 25.
Las funciones hermanas gettext() y puttext() se
usan respectivamente, para copiar texto de la pantalla a un buffer y de un
buffer a la pantalla. Sus prototipos son :
int gettext(int izquierda, int arriba, int derecha, int abajo, void *buffer);
int puttext(int izquierda, int arriba, int derecha, int abajo, void *buffer);
Para gettext() se especifica las coordenadas de las
esquinas superior izquierda e inferior derecha de la región de la pantalla que
se desea copiar. El puntero buffer debe apuntar a una zona de la memoria lo
suficientemente grande como para contener el texto. El tamaño del buffer se
calcula con la siguiente formula:
tamaño en bytes = filas * columnas * 2
por ejemplo, si se llama a gettext() con 1,1 como primer par de coordenadas y 10,10 como segundo , haría falta 10*10*2=200 bytes de almacenamiento.
Este fragmento de programa copia una región de la pantalla a la zona de memoria apuntada por buf:
void *buf;
buf = malloc(10*10*2);
gettext(10,10,20,20,buf);
Si lo que quieres es copiar texto de una parte de la pantalla a
otra, es mas eficiente usar la función movetext() que llamar a
gettext() y después a puttext(). El prototipo de movetext()
es:
int movetext(int arriba, int izquierda, int derecha, int abajo, int nuevoarriba, int nuevoabajo);
La función movetext() devuelve 0 si alguna coordenada esta fuera del rango permitido; en caso contrario devuelve 1.
La función window() activa una ventana de texto con unas
dimensiones especificas. su prototipo es:
void window(int izquierda, int arriba, int derecha, int abajo);
Si alguna coordenada no es valida window() no hace nada. Una vez llevada a cabo una llamada a window(), todas las referencias a coordenadas de posición se hacen relativas a esa ventana, no a al pantalla. Por ejemplo este fragmento de código crea una ventana y escribe una línea de texto dentro de la ventana en la posición 2,3:
window(10, 10, 60, 15);
gotoxy(2,3);
cprintf("en la posición 2,3");
es importante entender que las coordenada que se usan para window() son absolutas (no relativas a la ventana activa en ese momento). De esta manera se pueden usar múltiples ventanas sin estar anidadas unas dentro de otras.
El siguiente programa dibuja en primer lugar un borde alrededor de la pantalla y después crea dos ventanas separadas.
/* programa de demostración de las ventanas de texto */
#include <conio.h>
void borde(int xinicial, int yinicial, int xfinal, int yfinal);
int main(void)
{
clrscr();
/* dibuja el borde al rededor de la pantalla con perspectiva */
borde(1,1,79,25);
/* crea primera ventana */
window(3,2,40,9);
borde(3,2,40,9);
gotoxy(3,2);
cprintf("primera ventana");
/* crea una segunda ventana */
window(30,10,60,18);
borde(30,10,60,18);
gotoxy(3,2);
cprintf("segunda ventana");
gotoxy(5,4);
cprintf("hola");
getche();
return(0);
}
/* dibuja un borde alrededor de una ventana de texto */
void borde(int xinicial, int yinicial, int xfinal, int yfinal)
{
register int y; /* se utiliza variables register solo por que
es mas rápido su acceso */
gotoxy(1,1);
for(i=0; i<=xfinal-xinicial; i++)
putch(´-´);
gotoxy(1; yfinal-yinicial; i++);
putch(´-´);
for(i=2; i<=yfinal-yinicial; i++)
{
gotoxy(1,i);
putch(´|´);
gotoxy(xfinal-xinicial+1,i);
putch(´|´);
}
}
Es posible cambiar los modos de vídeo, así como controlar el color del texto y del fondo y poner la pantalla en alta o en baja densidad.Las funciones highvideo() y lowvideo() ponen la
pantalla en alta o baja intensidad respectivamente. Sus prototipos son:
void highvideo(void);
void lowvideo(void);
La función norvideo() provoca que los caracteres vuelvan
a mostrarse en la intensidad que estaba activada en el momento de comenzar la
ejecución del programa. Su prototipo es:
void normvideo(void);
La función textcolor() determina el color del texto que
se vaya a mostrar a partir de ese momento. También se usa para provocar el
parpadeo del texto. El prototipo de textcolor() es:
void textcolor(int color);
el argumento color puede tomar valores de 0 a 15, correspondientes cada uno de ellos a un color diferente, o bien usar los macros definidos en conio.h. Estos valores se muestran a continuación:
| Macro | Equivalente entero |
| BLACK | 0 |
| BLUE | 1 |
| GREEN | 2 |
| CYAN | 3 |
| RED | 4 |
| MAGENTA | 5 |
| BROWN | 6 |
| LIGHTGRAY | 7 |
| DARKGRAY | 8 |
| LIGHTBLUE | 9 |
| LIGHTGREEN | 10 |
| LIGHTCYAN | 11 |
| LIGHTRED | 12 |
| LIGHTMAGENTA | 13 |
| YELLOW | 14 |
| WHITE | 15 |
| BLINK | 128 |
Para hacer que el texto parpadee se debe hacer una OR (o lógica) del valor
128, con el color que se desee. Por ejemplo, este fragmento de código provoca
que el texto se muestre a partir del momento de ejecutarlo aparezca verde y
parpadeante:
textcolor(GREEN | BLINK)
La función textbackground() se usa para establecer el color del fondo
del texto. Como con textcolor(), la ejecución de textbackground()
solo afecta al color de fondo de las escrituras subsiguientes. Su prototipo es:
void textbackground(int color);
el valor de color debe estar dentro del rango de 0 a 7.
La función textattr() establece a la vez el color del texto y del
fondo. Su prototipo es:
void textattr(int atributo);
El valor de atributo codifica la información de color de la manera siguiente:
Si el bit 7 esta activado, el texto parpadeara. Los bits del 6 al 4 determinan el color del fondo. Los bits del 3 al 0 el color del texto.
La función textmode() se utiliza para cambiar el modo de vídeo. Su
prototipo es:
void textmode(int modo);
el argumento modo debe tomar uno de los valores que se muestra a continuación:
| Nombre de macro | Entero | Descripción |
| BW40 | 0 | b/n,40 columnas |
| C40 | 1 | color, 40 columnas |
| BW80 | 2 | b/n,80 columnas |
| C80 | 3 | color, 80 columnas |
| MONO | 7 | monocromático, 80 columnas. |
| LASTMODE | -1 | modo anterior |
| C4350 | 64 | EGA, 80*43, VGA, 80*25 líneas |
| Función | Propósito |
| gettexinfo() | Devuelve información sobre la ventana de texto |
| wherex() | Devuelve la coordenada x del cursor |
| wherey() | Devuelve la coordenada y del cursor |
Las funciones wherex() y wherey() tienen como prototipos :
int wherex(void);
int wherey(void);
La función wherex() devuelve la coordenada X de la posición actual del cursor. La función wherey() devuelve la coordenada actual del cursor. Ambas coordenadas son relativas a la ventana de texto actual.
Otra función de interés es cscanf() la cual tiene como prototipo el
siguiente:
int cscanf(char *fmt,.....);
esta función es similar a scanf() excepto en que lee la información desde la consola en lugar de desde stdin. La función cscanf() devuelve el numero de argumento a los que en realidad se les asigna valores. Esta función devuelve el valor EOF si existe algún error.
Ejemplo: Este fragmento de código lee una cadena y un numero float de la consola:
char cad[80];
float f;
cscanf("%s%f",cad,&f);
Finalmente para terminar los gráficos en modo texto realizaremos un pequeño programa de demostración. El cual inicialmente se utiliza la función gotoxy() para colocar un carácter en la posición dada por gotoxy(), después utiliza los distintos colores de modo y de texto, y finalmente mueve una parte del texto por medio de la función movetext() :
#include<conio.h>
int main(void)
{
register int i, j;
textmode(80); /* modo de texto con 80 columnas */
clrscr();
/* demostración de la función gotxy() */
for(i=1;j=1;j<24;i++,j++){
gotoxy(i,j);
printf("x");
}
for ( ; j>0 ; i++ , j-- ){
gotoxy( i, j );
cprintf("x");
}
/* ejemplo de distintos colores de fondo y de texto */
textbackground(LIGHTBLUE);
textcolor(RED);
gotoxy(40,12);
cprintf("Esto es rojo con un fondo azul claro");
gotoxy(45,15);
textcolor(GREEN | BLINK);
textbackground(BLACK);
cprintf("Esto es verde parpadeante sobre negro.");
getch();
/* ejemplo de movetext() mueve. El "pico invertido" de las X */
/* a la parte de arriba de la pantalla */
movetext(20,20,28,24,20,1);
getch();
texmode(LASTMODE);
return (0);
}
Empezaremos con el estudio de los gráficos para lo cual es necesario que el header graphics.h se incluya en cualquier programa que las use.Recuerda que para usar las rutinas de gráficos de Turbo C, la computadora debe estar provista de un adaptador gráfico de vídeo. Esto implica que aquellos sistemas que solo tengan una tarjeta monocroma no podrá mostrar gráficos. Los ejemplos que se incluyen en este capitulo usan todos el modo 16 de VGA (640* 350, 16 colores). Si no se tiene una VGA deberás de hacer los cambios pertinentes en estos ejemplos.
Es necesario poner el adaptador de vídeo en alguno de sus modos gráficos antes de poder usar cualquiera de las funciones de gráficos. Para poner el adaptador en un modo gráfico usa la función initgraph(). Su prototipo es:void far initgraph(int far *controlador, int far *modo, char far *camino);
La función initgraph() carga en memoria el controlador de gráficos correspondiente al numero apuntado por controlador. El parámetro modo apunta a un entero que especifica el modo de vídeo que van a usar las funciones de gráficos. Finalmente, se puede especificar el encaminamiento al controlador en la cadena apuntada por camino. Si no se especifica este ultimo se busca en el directorio actual.
Los archivos BGI. que deben estar disponibles en el sistema contienen los controladores de gráficos. El header graphics.h define varias macros que se pueden usar para este propósito. Son las siguientes:
| Macro | Equivalente |
| DETECT | 0 |
| CGA | 1 |
| MCGA | 2 |
| EGA | 3 |
| EGA64 | 4 |
| EGAMONO | 5 |
| IBM8514 | 6 |
| HERCMONO | 7 |
| ATT400 | 8 |
| VGA | 9 |
| PC3270 | 10 |
Al usar DETECT, initgraph() detecta automáticamente el tipo de hardware de vídeo presente en el sistema y selecciona el modo de vídeo con la resolución mas alta.
El valor de modo debe de ser uno de los modos de gráficos que se muestran en la siguiente tabla:
| Controlador | Modo | Equivalente | Resolución |
| CGA | CGAC0 | 0 | 320*200 |
| CGAC1 | 1 | 320*200 | |
| CGAC2 | 2 | 320*200 | |
| CGAC3 | 3 | 320*200 | |
| CGAC4 | 4 | 640*200 | |
| VGA | VGAL0 | 0 | 640*200 |
| VGAMED | 1 | 640*350 | |
| VGAHI | 2 | 720*350 |
y otros mas que no mencionaremos aquí, pero que debes de investigar. Por ejemplo, para que el sistema se inicialice en gráficos CGA con 4 colores y resolución 320*200, se usaría el siguiente fragmento de programa. Se asume que el archivo .BGI del controlador de gráficos se encuentra en el directorio actual. (de no se así debes colocarlo en " " toda la ruta completa por ejemplo c:\tc\bgi).
#include<graphics.h>
int controlador, modo;
controlador = CGA;
modo = CGAC0;
initgraph(&controlador,&modo," ");
Para dejar de utilizar un modo gráfico de vídeo y volver a un modo de texto,
se usa closegraph() o restorecrtmode(). Sus prototipos son:
void far closegraph(void);
void far restorecrtmode(void);
La función closegraph() debe usarse cuando el programa va a continuar su ejecución en el modo texto. Libera la memoria utilizada por las funciones de gráficos y restablece el modo de vídeo al que estaba antes de la llamada a initgraph(): Si el programa esta terminado, se puede usar restorecrtmode() ya que restablece el adaptador de vídeo al modo en el que estaba antes de la primera llamada a initgraph().
Las funciones fundamentales de gráficos son las que dibujan un punto, una línea y un circulo. En turbo C estas funciones se llaman respectivamente, putpixel(), line() y circle(). Sus prototipos son:void far putpixel( int x, int y , int color);
void far line( int xinicial, int yinicial, int xfinal, int yfinal);
void far circle(int x, int y, int radio);
La función putpixel() pone un pixel en la posición determinada por x e y del color especificado por color. La función line() traza una línea desde la posición especificada por xinicial, yinicial hasta xfinal, yfinal con el color del dibujo, estilo y grosor de línea actuales. La función circle() dibuja un circulo de radio dado con el centro en la posición especificada por x, y , usando el color de dibujo y grosor actuales. Si cualquier de las coordenadas cae fuera de los limites, la función correspondiente no se ejecuta.
Se puede establecer el color actual de dibujo con
setcolor(). Su prototipo es:
void far setcolor(int color);
El valor de color debe estar dentro del rango permitido para el modo de gráfico actual:
| Macro | Valor |
| BLACK | 0 |
| BLUE | 1 |
| GREEN | 2 |
| CYAN | 3 |
| RED | 4 |
| MAGENTA | 5 |
| BROWN | 6 |
| LIGHTGRAY | 7 |
| DARKGRAY | 8 |
| LIGHTBLUE | 9 |
| LIGHTGREEN | 10 |
| LIGHTCYAN | 11 |
| LIGHTRED | 12 |
| LIGHTMAGENTA | 13 |
| YELLOW | 14 |
| WHITE | 15 |
Para rellenar cualquier figura cerrada se usara la función
floodfill(). Su prototipo es:
void far floodflill(int x, int y , int colorborde);
Esta función rellena una figura cerrada. Se le pasan como parámetros las
coordenadas de un punto interior a la figura y el color de las líneas que forman
la figura. Es preciso que el objeto a rellenar este completamente cerrado. El
color de fondo es el que se usa por defecto sin embargo se puede cambiar la
manera en que se rellena los objetos mediante setfillstyle(). Su
prototipo es:
void far setfillstyle(int patron, int color);
Los valores admisibles para patrón se muestran a continuación junto con sus macros equivalentes.
| Macro | Valor | Significado |
| EMPTY_FILL | 0 | Rellena con el color de fondo |
| SOLID_FIL | 1 | Rellena con un color liso |
| LINE_FILL | 2 | Rellena con líneas |
| LTSLASH_FILL | 3 | Rellena con barras finas |
| SLASH_FILL | 4 | Rellena con barras |
| BKSLASH_FILL | 5 | Rellena con barras invertidas |
| LTBKSLASH_FILL | 6 | Rellena con barras invertidas finas |
| HATCH_FILL | 7 | Rellena con una trama fina |
| XHATCH_FILL | 8 | Rellena con una trama |
| INTERLEAVE_FILL | 9 | Rellena dejando espacios |
| WIDE_DOT_FILL | 10 | Rellena con puntos muy espaciados |
| CLOSE_DOT_FILL | 11 | Rellena con puntos poco espacios |
| USER_FILL | 12 | Rellena c/un patrón de usuario |
El siguiente programa es una demostración de estas funciones básicas de gráficos. Como se puede ver mirando el programa, la función box() se usa para dibujar un cuadro de un color determinado dadas las coordenadas de las esquinas superior izquierda e inferior derecha. Es una muestra de como se puede construir fácilmente funciones de gráficos de mas alto nivel a partir del núcleo de rutinas proporcionado por turbo C.
/* Programa de demostración de puntos, líneas, círculos y rellenos */
#include<graphics.h>
#include<conio.h>
void borde(void);
void cuadro(int xinicial, int yinicial, int xfinal, int yfinal, int color);
int main(void)
{
int controlador, modo;
register int i;
controlador = VGA;
modo = VGAMED;
initgraph(&controlador, &modo, "");
borde();
setcolor(1);
line(0,0,639,349);
cuadro(100, 100, 300,200,1);
setcolor(2);
floodfill(110,110,1); /* rellena parte de un cuadro */
setcolor(1);
line(50,200,400,125);
/* algunos puntos */
for( i=0; i<640;i+=10)
putpixel(i,175,5);
/* dibuja varios círculos */
circle( 50, 50, 35);
circle( 320, 175, 100);
circle( 500, 250, 90);
circle( 100, 100, 200);
setfillstyle(SOLID_FILL, GREEN);
floodfill(500, 250, 1); /* rellena parte de un circulo */
getch(); /* espera hasta que se pulse una tecla */
restorecrtmode();
return (0);
}
/* Dibuja un borde alrededor de la pantalla para perspectiva */
void borde(void)
{
line(0, 0, 639, 0);
line(0, 0, 0, 349);
line(0, 349, 639, 349);
line(639, 0, 639, 349);
}
/* dibuja un cuadro dadas las coordenadas de sus dos esquinas */
void cuadro( int xinicial, int yinicial, int xfinal, int yfinal, int color);
{
setcolor(color);
line(xinicial, yinicial, xinicial, yfinal);
line(xinicial, yinicial, xfinal, yinicial);
line(xfinal, yinicial, xfinal, yfinal);
line(xfinal, yfinal, xinicial, yfinal);
}
Aunque se puede usar las rutinas estándar de escritura en la pantalla, como printf(), para mostrar texto en modo gráfico, la mayoría de las veces es mejor usar la función outtext(), específicamente diseñada con este prototipo es:void far outtext(char far abdicad);
Esta función escribe la cadena apuntada por cad en la posición actual. La principal ventaja de usar outtext() es que puede escribir el texto con distintas fuentes, tamaños e incluso direcciones.
Para cambiar el estilo, tamaño o dirección del texto, se usa
settextstyle(). Su prototipo es:
void far settextstyle(int fuente, int dirección, int tamaniocar);
El parámetro fuente determina el tipo de fuente que se va a usar. Por defecto se usa la 8*8 define en hardware. Puede tomar uno de los siguientes valores (las macros están definidos en graphics.h):
| Macro | Valor | Tipo de fuente |
| DEFAULT_FONT | 0 | Mapa de bits de 8*8 |
| TRIPLEX_FONT | 1 | Tipo de letra triplex |
| SMALL_FONT | 2 | Tipo de letra pequeña |
| SANS_SERIF_FONT | 3 | Tipo de letra sans serif |
| GOTHIC_FONT | 4 | Fuente traza gótica |
La dirección en que se imprime el texto, ya sea de izquierda a derecha o de arriba abajo, se determina mediante el valor de dirección, que puede ser HORIZ_DIR (0) o VERT_DIR(1).
El parámetro tamaniocar es un multiplicador que aumenta el tamaño de los caracteres. Puede tomar un valor de 0 a 10.
Para escribir el texto en una posición determinada de la ventana gráfica, se
usa la función outtextxy(). Su prototipo es:
void far outtextxy(int x, int y, char far abdicad);
La cadena se escribe en las coordenadas de la ventana gráfica que se especifican. Si x o y o ambas están fuera de los limites permitidos, no se escribe nada.
/* Demostración de distintas fuentes y tamaño de texto */
#include<graphics.h>
#include<conio.h>
int main(void)
{
int controlador, modo;
controlador = DETEC; /* detección automática */
modo = 0; /* se puede usar otro modo */
initgraph(&controlador, &modo, "");
outtext("normal");
/* Fuente gótica, tamaño doble del normal */
settextstyle(GOTHIC_FONT, HORIZ_DIR, 2);
outtext("gótica");
/* Fuente triplex, tamaño doble del normal */
settextstyle(TRIPLEX_FONT, HORIZ_DIR, 2 );
outtext("triplex");
/* fuente sans serif , tamaño 7 veces el normal);
settextstyle(SANS_SERIF_FONT, VERT_DIR, 7);
outtext("sans serif");
getch(); /* espera una tecla para continuar */
restorecrtmode(); /* restablece modo anterior */
return (0);
}
Existen siete funciones que permiten manipular la pantalla, y además con la que se puede crear ventanas de gráficos. Todas estas funciones se muestran a continuación:| Función | Propósito |
| clearviewport() | limpia la ventana de gráficos |
| getimage() | copia parte de una ventana en el buffer |
| imagesize() | devuelve el numero de bytes que se necesita para salvar una imagen |
| putimage() | copia el contenido del buffer a la ventana gráfica |
| setactivepage() | determina que pagina se vera afectada por las rutinas gráficas |
| setviewport() | crea una ventana gráfica |
| setvisualpage() | determina la pagina que se muestra |
Los prototipos de estas funciones son:
void far clearviewport(void);
void far getimage(int izquierda, int arriba, int derecha, int abajo,
void far *buf);
void far imagesize(int izquierda, int arriba, int derecha, int abajo);
void far putimage(int izquierda, int arriba, void far *buf, int op);
void far setactivepage(int numpagina);
void far setviewport(int izquierda, int arriba, int derecha ,int abajo,
int indclip);
void far setvisualpage(int numpage);
En algunos modos de vídeo, existe suficiente memoria en el adaptador de vídeo como para tener almacenadas al mismo tiempo varias pantallas completas. A la región de RAM que contiene la información que se muestra en una pantalla se le denomina pagina.
La función getimage() copia una región de la ventana de gráficos en un buffer y putimage() pone el contenido de un buffer en la pantalla. La función getimage() copia el contenido de una porción rectangular de la pantalla, definida por las coordenadas de sus esquinas superior izquierda e inferior derecha, al buffer apuntado por buf, El tamaño preciso del buffer, en bytes, para una determinada región lo da la función imagesize(). La función putimage() muestra en la pantalla un buffer de datos gráficos almacenado previamente mediante getimage(). Solo es preciso especificar las coordenadas de la esquina superior izquierda del lugar donde se quiere mostrar la imagen. El valor de op determina la manera exacta en que se escribe la imagen en la pantalla. Los valores validos son:
| Nombre | Valor | Significado |
| COPY_PUT | 0 | copia tal como es |
| XOR_PUT | 1 | O exclusiva con destino |
| OR_PUT | 2 | O inclusiva con destino |
| AND_PUT | 3 | Y lógica con destino |
| NOT_PUT | 4 | invierte la imagen |
El siguiente programa es una demostración de las funciones getimage(), imagesize() y putimage().
/* Este programa demuestra como se puede mover una imagen gráfica usando getimage(), imagesize() y putimage() */
#include<conio.h>
#include<graphics.h>
#include<stdlib.h>
void cuadro(int xinicial, int yinicial, int xfinal, int yfinal, int color);
int main(void)
{
int controlador, modo;
unsigned tamanio;
void *buf;
controlador = VGA;
modo = VGAMED;
initgraph(&controlador, &modo, "");
cuadro(20, 20, 200, 200, 15);
setcolor(RED);
line(20,20,200,200);
setcolor(GREEN);
line(20, 200, 200, 20);
getch();
/* mueve la imagen */
tamanio = imagesize(20, 20, 200, 200);
if(tamanio != -1){ /* proporciona memoria para la imagen */
buf = malloc(tamanio);
if (buf){
getimage(20, 20, 200, 200, buf);
putimage(100,100,buf,COPY_PUT);
putimage(300,50,buf,COPY_PUT);
}
outtext("pulse una tecla");
getch();
restorecrtmode();
return (0);
}
/* Dibuja un cuadro dadas las coordenadas de sus dos esquinas */
void cuadro(int xincial, int yinicial, int xfinal, int yfinal, int color)
{
setcolor(color);
line(xinicial, yinicial, xinicial, yfinal);
line(xinicial, yinicial, xfinal, yinicial);
line(xfinal, yinicial, xfinal, yfinal);
line(xfinal, yfinal, xinicial, yfinal);
}
Se puede crear ventanas de una manera muy similar a como se crean en modo texto. La función que se utiliza para crear una ventana gráfica es setviewport(). Se le pasan las coordenadas de las esquinas superior izquierda e inferior derecha de la ventana. Si el parámetro indclip es distinto de cero, entonces la salida que sobrepase los limites de la ventana gráfica se trunca automáticamente. En caso contrario la salida puede superar lo limites. El siguiente programa ilustra la manera de crear una ventana gráfica y el recorte de la salida.
/* Este programa ilustra el uso de setviewport(). */
#include<conio.h>
#include<graphics.h>
void cuadro(int xinicial, int yinicial, int xfinal, int yfinal);
int main(void)
{
int controlador, modo;
controlador = VGA;
modo = VGAMED;
initgraph(&controlador, &modo, "");
/* encuadrar la pantalla para obtener perspectiva */
cuadro(0, 0, 639, 349, WHITE);
setviewport(20,20,200,200,1);
cuadro(0, 0,179,179, RED);
/* intenta dibujar una línea mas allá del borde de la ventana gráfica */
setcolor(WHITE);
line(0,100,400,100);
outextxy(20, 10, "pulse una tecla");
getch();
restorecrtmode();
return (0);
}
/* Dibuja un cuadro dadas las coordenadas de sus dos esquinas */
void cuadro(int xinicial, int yinicial, int xfinal, int yfinal, int color)
{
setcolor(color);
line(xinicial, yinicial, xinicial, yfinal);
line(xinicial, yinicial, xfinal, yinicial);
line(xfinal, yinicial, xfinal, yfinal, );
line(xfinal, yfinal, xinicial, yfinal);
}