Otras funciones de la librería graphics.h.
En este capitulo
describimos una a una las librerías de la librería graphics.h. Las funciones serán
explicadas mediante un orden.
Cuando sabemos como
dibujar líneas, círculos, rectángulos, y otras figuras es hora de que empieces
a conocer otro tipo de funciones en las cuales no hacen mucho énfasis los
profesores como lo son las funciones bar3d, palette y otras que presentan una
gran gama de tareas de gran calidad grafica. Dejemos de hablar y comencemos ya
que los puedo aburrir.
Función bar3d
void far bar3d(int izquierda, int superior,int derecha, int
inferior, int profundidad, int banderin_tapa);
Esta
función creará una barra rectangular y rellenada de tres dimensiones. La esquina
superior izquierda de la barra rectangular más frontal está definida por los
argumentos izquierdos y superiores. Estos argumentos corresponden a los
valores x e y de la esquina superior izquierda del rectángulo más
frontal. Similarmente, los argumentos derecha e inferior definen
la esquina inferior derecha del rectángulo más frontal. La barra tiene borde,
en todas las tres dimensiones, rellenada con el color y estilo de línea
actuales. El rectángulo más frontal es rellenado usando la trama de relleno actual
y el color de relleno como es establecido por la función setlinestyle.
El argumento banderin_tapa es usado para especificar si es o no es
posible apilar varias barras
encima
de cada una. Si banderin_tapa tiene un valor distinto a cero, entonces
la barra está "tapada". Si banderin_tapa tiene un valor de
cero, entonces la barra no está "tapada", permitiendo otras barras
ser apiladas encima de ésta.
La
función bar3d no retorna ningún valor.
Ejemplo:
#include <graphics.h>
#include <conio.h>
void main() {
int driver = EGA,modo = EGAHI,color, relleno;
color = 10;
relleno = 11;
initgraph(&driver,&modo,"c:\\tc20\\bin");
setfillstyle( relleno, color );
bar3d( 100, 50, 300, 150, 25, 1 );
getch(); /* Pausa */
closegraph();
getch();
}
Función clearviewport
void far clearviewport(void);
Esta
función es usada para rellenar la pantalla actual del usuario con el color de
fondo actual. El color de fondo puede ser establecido con la función setbkcolor.
La posición del cursor gráfico es la esquina superior izquierda de la pantalla
actual del usuario. Esta posición es (0,0) según la pantalla actual del
usuario.
La
función clearviewport no retorna ningún valor.
Ejemplo:
#include <graphics.h>
#include <conio.h>
void main() {
int a = EGA,b = EGAHI,color;
initgraph( &a, &b, "C:\\tc20\\BIN"
);
setviewport( 150, 150, 350, 350, 0 );
for( color = 0; color<16; color++ ) {
circle( 100, 100, 60 );
getch();
setbkcolor( color );
clearviewport();
}
getch(); /* Pausa */
closegraph();
}
Función closegraph
void far closegraph(void);
Esta
función es usada para cerrar el sistema gráfico como es iniciada por la función
initgraph. La función closegraph libera toda la
memoria usada por el sistema gráfico y luego restaura el modo de vídeo al modo
de texto que estaba en uso anteriormente a la llamada a la función initgraph.
La
función closegraph no retorna ningún valor.
Ejemplo:
#include <graphics.h>
#include <conio.h>
void main() {
int driver = EGA,modo = EGAHI;
initgraph( &driver, &modo,
"C:\\tc20\\BIN”);
circle( 300, 200, 80 );
getch(); /* Pausa */
closegraph();
getch();
}
Función detectgraph
void far detectgraph(int far *driver, int
far *modo);
Esta
función es usada para detectar el adaptador gráfico y el modo óptimo para usar
con el sistema en uso. Si la función detectgraph no puede detectar
ningún dispositivo gráfico, el argumento *driver es asignado grNotDetected
(-2). Una llamada a graphresult resultará
en un valor de retorno de -2, o grNotDetected. Existen varios valores
que indican los diferentes dispositivos gráficos que pueden ser
usados por el argumento *driver. Un valor de 0, o DETECT, inicia la Funciónalidad de auto
detección, el cual determina el driver
óptimo
a usar. Para cada dispositivo existen varios valores que
indican los diferentes modos gráficos que pueden ser usados por el argumento *modo.
Sin embargo, si el argumento *driver es asignado el valor de 0, o
DETECT, el argumento *modo es automáticamente
establecido al modo de resolución mas alto para el driver.
La
función detectgraph no retorna ningún valor.
Ejemplo:
#include <graphics.h>
#include <conio.h>
#include <stdio.h>
void main() {
int driver, modo;
detectgraph( &driver, &modo, );
initgraph( &driver, &modo, "C:\\tc20\\BIN"
);
circle( 300, 200, 80 );
getch(); /* Pausa */
closegraph();
printf( "Driver: %d\tModo: %d\n\n", driver, modo
);
getch();
}
Función drawpoly
void far drawpoly(int numpuntos, int far
*puntos);
Esta función es usada para crear un polígono con un número
especificado de puntos. El argumento numpuntos es usado para definir el
número de puntos en el polígono. Para la función drawpoly, el número de
puntos debe ser el número actual de puntos más 1 para poder crear un polígono
cerrado. En otras palabras, el primer punto debe ser igual al último punto. El
argumento *puntos apunta a un array de números de longitud numpuntos multiplicado
por 2. Los dos primeros miembros del array identifica las coordenadas x e
y del primer punto, respectivamente, mientras que los dos siguientes
especifican el siguiente punto, y así sucesivamente. La función drawpoly dibuja
el perímetro del polígono con el estilo de línea y color actuales, pero no
rellena el polígono.
La
función drawpoly no retorna ningún valor.
Ejemplo:
#include <graphics.h>
#include <conio.h>
#include <stdio.h>
void main() {
int driver = EGA;
int
modo = EGAHI;
int
puntos[8] = { 300, 50, 500, 300, 100, 300, 300, 50 };
initgraph( &driver, &modo, "C:\\tc20\\BIN"
);
drawpoly( 4, puntos );
getch(); /* Pausa */
closegraph();
getch();
}
Función fillellipse
void far fillellipse(int x, int y,int x_radio,
int y_radio);
Esta
función es usada para dibujar y rellenar una elipse. El centro de la elipse es
especificado por los argumentos x e y. El argumento x_radio especifica
el radio horizontal y el argumento y_radio especifica el radio vertical
de la elipse. La elipse es dibujado con el perímetro en el color actual y
rellenada con el color de relleno y la trama de relleno actuales.
La
función fillellipse no retorna ningún valor.
Ejemplo:
#include <graphics.h>
#include <conio.h>
void inicializar(void);
void main() {
int
trama, color;
inicializar();
trama
= SOLID_FILL;
color = 4;
setfillstyle( trama, color );
fillellipse( 300, 150, 100, 50 );
getch(); /* Pausa */
closegraph();
}
void inicializar(void)
{
int driver = EGA,modo = EGAHI;
initgraph( &driver, &modo,
"C:\\tc20\\BIn" );
}
Función getarccords
void far getarccoords(struct arccoordstype
far *coordenadas_arco);
Esta
función es usada para recoger las coordenadas del centro, y los puntos del
comienzo y final de la última llamada con éxito a la función arc.
El argumento *coordenadas_arco apunta a la estructura de tipo arccoordstype
que guarda la información recogida. La sintaxis de la estructura arccoordstype
es:
struct
arccoordstype {
int
x, y;
int xstart, ystart;
int xend, yend;
};
Los
miembros x e y definen el centro del arco. Los miembros xstart
e ystart definen las coordenadas x e y del punto de
comienzo del arco. Similarmente, los miembros xend e yend definen
las coordenadas x e y del punto de final del arco.
La
función getarccoords no retorna ningún valor.
Ejemplo:
#include <graphics.h>
#include <conio.h>
void main() {
int driver = EGA;
int modo = EGAHI,radio;
struct arccoordstype info_arco;
initgraph( &driver, &modo, "C:\\tc20\\BIN"
);
for( radio=25; radio<=100; radio+=25 ) {
arc( 300, 150, 45, 315, radio );
getarccoords( &info_arco );
moveto( info_arco.xstart, info_arco.ystart );
lineto( info_arco.xend, info_arco.yend );
}
getch(); /* Pausa */
closegraph();
getch();
}
Función getaspectratio
void far getaspectratio(int far *x_proporcion,int far
*y_proporcion);
Esta
función es usada para obtener la proporción anchura-altura del modo gráfico
actual. La proporción anchura-altura puede definirse como la proporción de la
anchura del píxel del modo gráfico y la altura del píxel. Esta proporción,
usando los modos gráficos existentes, es siempre menor o igual que 1. El valor
para determinar la proporción anchura-altura con respecto al eje horizontal es
retornado en el argumento *x_proporcion. Similarmente, el valor para el
eje vertical es retornado en el argumento *y_proporcion. El argumento *y_proporcion
es asignado 10000, el cual es retornado cuando se llama a la función getaspectratio.
El argumento *x_proporcion es casi siempre menor que el valor de *y_proporcion.
Esto es debido al hecho de que la mayoría de los modos gráficos tiene píxeles
más altos que anchos. La única excepción es en los modos de VGA que produce píxeles
cuadrados; es decir, x_proporcion = y_proporcion.
La
función getaspectratio no retorna ningún valor, directamente.
Ejemplo:
#include <graphics.h>
#include <conio.h>
#include <stdio.h>
void main() {
int driver = EGA, modo = EGAHI;
int
x_proporcion, y_proporcion;
initgraph( &driver, &modo, "C:\\tc20\\BIN"
);
getaspectratio(
&x_proporcion, &y_proporcion );
circle(
300, 150, 50 );
getch();
/* Pausa */
closegraph();
printf(
"Proporción anchura-altura.\nFactor x: %d\tFactor y: %d\n",
x_proporcion,
y_proporcion );
getch();
}
Función getcolor
int far getcolor(void);
Esta
función obtiene el valor del color actual. El color actual es el color usado
para dibujar líneas, arcos, etc.. Este color no es el mismo que el color de
relleno. El valor del color obtenido es interpretado según el modo que esté en
uso. Existen varios valores para ciertos colores de
fondo.
La
función getcolor retorna el valor del color actual.
Ejemplo:
#include <graphics.h>
#include <conio.h>
#include <stdio.h>
void main() {
int driver = EGA;
int modo = EGAHI,color;
initgraph( &driver, &modo, "C:\\Tc20\\BIN"
);
setcolor( 4 );
circle( 300, 150, 50 );
color = getcolor();
getch(); /* Pausa */
closegraph();
printf(
"Color del perímetro: %d\n", color );
getch();
}
Función
getdefaultpalette
struct palettetype far
*getdefaultpalette(void);
Esta
función es usada para obtener una estructura que define la paleta según el
dispositivo en la inicialización - esto es, cuando se llama a initgraph.
La estructura palettetype se define de la siguiente manera:
#define
MAXCOLORS 15
struct palettetype {
unsigned char size;
signed
char colors[MAXCOLORS+1];
}
El
campo size indica el tamaño de la paleta. El campo colors contiene
los valores numéricos que representan los colores que ofrece el dispositivo en
su paleta de colores.
La
función getdefaultpalette retorna un puntero a una estructura del tipo palettetype.
Ejemplo:
#include <graphics.h>
#include <conio.h>
#include <stdio.h>
void main() {
int driver = EGA;
int modo = EGAHI;
struct palettetype *palette = NULL;
int i;
initgraph( &driver, &modo, "C:\\tc20\\BIN" );
initgraph( &driver, &modo, "C:\\tc20\\BIN" );
palette = getpalettetype();
circle( 300, 150, 50 );
getch(); /* Pausa */
closegraph();
printf( "Paleta\n\nTamaño: %d\nColores: %d",
palette->size, palette->colors[0] );
for( i=1; i<palette->size; i++ )
printf( ", %d", palette->colors[i] );
printf( "\n" );
getch();
}
Función getdrivename
char *far getdrivername(void);
Esta
función es usada para obtener una cadena de caracteres que contiene el nombre
del dispositivo gráfico actual. Esta función debería ser llamada después de que
un dispositivo haya sido definido e inicializado – esto es, después de llamar a
initgraph.
La
función getdrivername retorna una cadena de caracteres conteniendo el
nombre del dispositivo gráfico.
Ejemplo:
#include <graphics.h>
#include <conio.h>
#include <stdio.h>
#include <string.h>
void main() {
int driver = EGA, modo = EGAHI;
char
*nombre;
initgraph(
&driver, &modo, "C:\\tc20\\BIN" );
strcpy( nombre, getdrivername() );
circle( 300, 150, 50 );
getch(); /* Pausa */
closegraph();
printf(
"Nombre del dispositivo gráfico: %s\n", nombre );
getch();}
Función
getfillpattern
void far getfillpattern(char far *trama);
Esta
función es usada para obtener una trama de relleno definido por el usuario,
como es definida por la función setfillpattern,
y la guarda en memoria. El argumento *trama es un puntero a una serie de
ocho bytes que representa una trama de relleno de bits de 8 x 8. Cada byte
representa una fila de ocho bits, donde cada bit está encendido o no (1 ó 0).
Un bit de 0 indica que el píxel correspondiente será asignado el color de
relleno actual. Un bit de 0 indica que el píxel correspondiente no será
alterado.
La
función getfillpattern no retorna ningún valor, directamente.
Ejemplo:
#include <graphics.h>
#include <conio.h>
void main() {
int driver = EGA;
int modo = EGAHI;
char
trama1[8] = { 0x33, 0xEE, 0x33, 0xEE, 0x33, 0xEE, 0x33, 0xEE };
char
trama2[8] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
initgraph( &driver, &modo, "C:\\tc20\\bin"
);
getfillpattern( trama2 );
bar( 50, 50, 150, 150 );
setfillpattern( trama1, 9 );
bar( 160, 50, 260, 150 );
setfillpattern( trama2, 4 );
bar( 105, 160, 205, 260 );
getch(); /* Pausa */
closegraph();
getch();
}
Función getfillsettings
void far getfillsettings(struct
fillsettingstype far *info);
Esta
función es usada para obtener la información de tramas de relleno. El argumento
*info apunta a una estructura de tipo fillsettingstype,
el cual es actualizado cuando se llama a la función getfillsettings. La estructura
es:
struct
fillsettingstype {
int
pattern;
int
color;
};
El
campo pattern es la trama y el campo color es el color de relleno
de la trama.
Existen
trece valores ya definidos para tramas.
La
función getfillsettings no retorna ningún valor, directamente.
Ejemplo:
#include <graphics.h>
#include <conio.h>
#include <stdio.h>
void main() {
int driver = EGA;
int modo = EGAHI;
struct fillsettingstype info;
initgraph( &driver, &modo, "C:\\tc20\\BIN"
);
getfillsettings( &info );
bar( 50, 50, 350, 300 );
getch(); /* Pausa */
closegraph();
printf(
"Trama de relleno: %d\tColor de relleno: %d\n", info.pattern,
info.color );
getch();
}
Función getgraphmode
int far getgraphmode(void);
Esta
función es usada para obtener el valor del modo gráfico actual. El dispositivo
actual debe ser considerado cuando se interprete el valor de retorno. Esta
función sólo debería ser llamada después de que el sistema gráfico haya sido inicializado
con la función initgraph. Existen varios valores para
los modos de cada dispositivo.
La
función getgraphmode retorna el modo gráfico como es establecido por initgraph
o setgraphmode.
Ejemplo:
#include <graphics.h>
#include <conio.h>
#include <stdio.h>
void main() {
int driver = EGA, modo = EGAHI,modo;
initgraph( &driver, &modo, "C:\\tc20\\BIN"
);
modo = getgraphmode();
bar( 50, 50, 350, 300 );
getch(); /* Pausa */
closegraph();
printf(
"Modo gráfico: %d\n", modo );
getch();
}
Función getlinesettings
void far getlinesettings(struct
linesettingstype far *info);
Esta
función obtiene la información actual para las líneas. Esta información es
guardada en una estructura de tipo linesettingstype que
es apuntado por el argumento *info. El estilo de línea, trama, y grosor
actuales son guardados en esta estructura. La sintaxis para la estructura linesettingstype:
struct linesettingstype {
int linestyle;
unsigned
upattern;
int
thickness;
}
El
campo linestyle es el estilo de la línea recta. El campo upattern es
la trama de la línea del usuario solamente cuando el campo linestyle es
igual a USERBIT_LINE, ó 4. Cuando esto sea el caso, el miembro upattern
contiene una trama de línea definido por el usuario de 16 bits. Un bit 1 en
esta trama indica que el píxel correspondiente será asignado el color actual.
Un bit 0 indica que el píxel correspondiente no será alterado. El campo thickness
es el grosor de la línea. Existen varios valores para
los diferentes estilos y grosores de líneas rectas.
La
función getlinesettings no retorna ningún valor, directamente.
Ejemplo:
#include <graphics.h>
#include <conio.h>
#include <stdio.h>
void main() {
int driver = EGA;
int modo = EGAHI;
struct linesettingstype info;
initgraph( &driver, &modo, "C:\\tc20\\bin"
);
setlinestyle( DOTTED_LINE, 0xFF33, THICK_WIDTH );
circle( 350, 250, 50 );
getlinesettings( &info );
getch(); /* Pausa */
closegraph();
printf(
"Líneas rectas.\nEstilo: %d\tTrama: %X\tGrosor: %d\n",
info.linestyle, info.upattern, info.thickness );
getch();
}
Función getmaxcolor
int far getmaxcolor(void);
Esta
función es usada para obtener el valor más alto de color en la paleta actual.
La paleta en uso depende del dispositivo y modo inicializados. Para los modos
de 16 colores, el valor de retorno es 15. Similarmente, para los modos de dos
colores, el valor de retorno es 1.
La
función getmaxcolor retorna el valor máximo del color en la paleta en
uso.
Ejemplo:
#include <graphics.h>
#include <conio.h>
#include <stdio.h>
void main() {
int driver =EGA,modo =EGAH,color_max;
initgraph( &driver, &modo,
"C:\\tc20\\BIN" );
color_max = getmaxcolor();
closegraph();
printf( "Color m ximo: %d\n", color_max
);
getch();
}
Función
getmodename
char *far getmodename(int num_modo);
Esta
función es usada para obtener el nombre del modo gráfico especificado por el
argumento num_modo.
La
función getmodename retorna el nombre del modo gráfico que está
contenido en todos los dispositivos gráficos.
Ejemplo:
#include <graphics.h>
#include <conio.h>
#include <stdio.h>
#include <string.h>
void main() {
int driver = IBM8514;
int modo = IBM8514HI,i;
char
*nombre;
int
num_modo;
initgraph( &driver,
&modo,"C:\\TC20\\BIN");
num_modo = getgraphmode();
strcpy(nombre,getmodename(num_modo));
closegraph();
for(i=0;nombre[i];i++)
printf("%c",nombre[i]);
getch();
}
Función
getmoderange
void far getmoderange(int driver, int far
*modo_bajo, int far *modo_alto);
Esta
función es usada para obtener los valores altos y bajos del modo gráfico del
dispositivo especificado por el argumento driver. El valor más bajo del
modo es retornado en *modo_bajo, y el valor más alto del modo es retornado
en *modo_alto. Si el dispositivo especificado es inválido, el valor de
-1 es retornado en ambos argumentos: *modo_bajo y *modo_alto. Sin
embargo, si el argumento driver es asignado -1, los modos alto y bajo
del dispositivo actual son retornados.
La
función getmoderange no retorna ningún valor, directamente.
Ejemplo:
#include <graphics.h>
#include <conio.h>
#include <stdio.h>
void main() {
int driver = EGA;
int
modo = EGAHI;
int
modo_bajo, modo_alto;
initgraph( &driver, &modo, “C:\\TC20\\BIN” );
getmoderange(
driver, &modo_bajo, &modo_alto );
closegraph();
printf(
"Alcance de modos, de %d á %d\n", modo_bajo, modo_alto );
getch();
}
Función
getpalette
void far getpalette(struct palettetype far
*paleta);
Esta
función es usada para obtener la información de la paleta actual. El argumento *paleta
apunta a una estructura del tipo palettetype donde
la información de la paleta es guardada. La estructura palettetype se
define de la siguiente manera:
#define
MAXCOLORS 15
struct palettetype {
unsigned char size;
signed
char colors[MAXCOLORS+1];
}
El
campo size indica el número de colores en la paleta. El campo colors contiene
los valores numéricos que representan los colores que ofrece el dispositivo en
su paleta de colores.
La
función getpalette no retorna ningún valor, directamente.
Ejemplo:
#include <graphics.h>
#include <conio.h>
#include <stdio.h>
void main() {
int driver = EGA;
int modo = EGAHI,i;
struct palettetype palette;
initgraph( &driver, &modo,
"C:\\TC20\\BIN" );
getpalette( &palette );
closegraph();
printf( "\t\t\t\t\tPaleta\n\nTama¤o:
%d\n",palette.size);
printf("Colores: %d,",palette.colors[0] );
for( i=1; i<palette.size; i++ )
printf( "%d, ", palette.colors[i] );
printf( "\n" );
getch();
}
Función
getpalettesize
int far getpalettesize(void);
Esta
función es usada para obtener el número de entradas de paleta válidas para la
paleta actual, considerando el modo gráfico en uso.
La
función getpalettesize retorna el número de colores en la paleta actual.
Para modos de 16 colores, la función getpalettesize retorna 16.
Ejemplo:
#include
<graphics.h>
#include <conio.h>
#include <stdio.h>
void main() {
int driver = EGA;
int modo = EGAHI;
int num_colores;
initgraph( &driver, &modo, “C:\\TC20\\BIN” );
num_colores
= getpalettesize();
closegraph();
printf(
"Paleta\n\nNúmero de colores: %d\n", num_colores );
getch();
}
Función
getpixel
unsigned far getpixel(int x, int y);
Esta
función es usada para obtener el valor del color del píxel especificado por los
argumentos x e y. Estos argumentos especifican las coordenadas de
la pantalla del píxel a ser evaluado. Cuando se evalúa el valor del color
retornado, el modo gráfico en uso debe ser considerado. Existen varios valores
para describir colores.
La
función getpixel retorna el número del color del píxel especificado.
Ejemplo:
#include <graphics.h>
#include <conio.h>
#include <stdio.h>
void main() {
int driver = EGA, modo = EGAHI, x, y, color;
initgraph( &driver, &modo, “C:\\TC20\\BIN” );
x = 300;
y = 100;
setfillstyle( SOLID_FILL, 2 );
fillellipse( 300, 160, 50, 150 );
color = getpixel( x, y );
getch();
closegraph();
printf(
"Colores\n\nEl color del píxel (%d,%d): %d\n", x, y, color );
getch();
}
Función
gettextsettings
void far gettextsettings(struct
textsettingstype far *info);
Esta
función es usada para obtener información acerca de la fuente gráfica actual.
Esta información es guardada en una estructura de tipo textsettingstype,
la cual es apuntada por el argumento *info. Esta estructura contiene
información de la fuente actual en uso, la orientación del texto, el tamaño del
carácter, y la justificación horizontal y vertical. La síntaxis de la
estructura textsettingstype es la siguiente:
struct
textsettingstype {
int font;
int direction;
int charsize;
int
horiz;
int
vert;
};
Existen
varios valores para describir el tipo, la orientación, y
justificación de fuentes.
La
función gettextsettings no retorna ningún valor.
Ejemplo:
#include <graphics.h>
# include<conio.h>
#include <stdio.h>
void main() {
int driver = EGA;
int modo = EGAHI;
struct textsettingstype info;
initgraph( &driver, &modo,
"C:\\TC20\\BIN" );
gettextsettings( &info );
closegraph();
printf( "Texto\n\nFuente: %d\tSentido:
%d\tTamaño: %d\n""Justificación:\nHorizontal: %d, Vertical:
%d\n",
info.font, info.direction, info.charsize, info.horiz,
info.vert);
getch();
}
Función getviewsettings
void far getviewsettings(struct
viewporttype far *info);
Esta
función es usada para obtener información acerca del área gráfica actual. Esta
información es guardada en una estructura de tipo viewporttype,
la cual es apuntada por el argumento *info. Esta estructura contiene información
acerca de las esquinas superior izquierda e inferior derecha, también como el
banderín de recorte del área gráfica. La síntaxis de la estructura viewporttype
es la siguiente:
struct
viewporttype {
int left, top;
int right, bottom;
int
clip;
};
La
función getviewsettings no retorna ningún valor, directamente.
Ejemplo:
#include <graphics.h>
# include<conio.h>
#include <stdio.h>
void main() {
int driver = VGA, modo = VGAHI;
struct viewporttype info;
initgraph( &driver, &modo,
"C:\\TC20\\BIN" );
getviewsettings( &info );
closegraph();
printf( "\t\t\t\tPantalla\n\nIzquierda:
%d\tSuperior: %d\tDerecha: %d\t"
"Inferior: %d\tBander¢n: %d\n",
info.left, info.top, info.right, info.bottom,
info.clip );
getch();
}
Función
graphdefaults
void far graphdefaults(void);
Esta
función es usada para reiniciar todos los datos gráficos a sus valores
originales, o por defecto. La función graphdefaults reinicia la pantalla
del usuario para que cubra la pantalla entera, mueve el cursor a la posición (0,0),
y reinicia la paleta actual a sus colores por defecto. También reinicia el
color de fondo y el actual a sus valores por defecto, reinicia el estilo y
trama de relleno a sus valores por defecto, y reinicia la fuente y
justificación
de texto.
La
función graphdefaults no retorna ningún valor.
Ejemplo:
#include <graphics.h>
#include <conio.h>
void main() {
int driver = VGA;
int modo = VGAHI;
initgraph( &driver, &modo,
"C:\\TC20\\BIN" );
setcolor( 4 );
setviewport( 250, 150, 350, 250, 1 );
graphdefaults();
circle( 300, 200, 50 );
getch();
closegraph();
getch();
}
Función
grapherrormsg
char *far grapherrormsg(int codigo_error);
Esta
función es usada para obtener una cadena de caracteres conteniendo el mensaje
de error para un código de error especificado. El argumento codigo_error específica
el valor del código de error. La función graphresult debe
ser usada para obtener el código de error usado para el argumento codigo_error.
La
función grapherrormsg retorna una cadena de caracteres.
Ejemplo:
#include <graphics.h>
#include <conio.h>
#include <stdio.h>
void main() {
int driver = EGA;
int
modo = EGAHI;
int
codigo_error;
char
*mensaje_error;
initgraph(
&driver, &modo, “C:\\TC20\\BIN” );
setgraphmode(
40 ); /* Creamos un ERROR */
codigo_error
= graphresult();
strcpy(
mensaje_error, grapherrormsg( codigo_error ) );
closegraph();
printf(
"ERROR: \"%s\" (%d)\n", mensaje_error, codigo_error );
getch();
}
Función
graphfreemem
void far _graphfreemem(void far *ptr,
unsigned tamanyo);
Esta
función es usada por la librería gráfica para desadjudicar memoria previamente
reservada mediante una llamada a la función _graphgetmem.
Esta función es llamada por la librería gráfica cuando se quiere liberar memoria.
Por defecto, la función simplemente llama a free, pero se puede
controlar la administración de memoria de la librería gráfica. La forma de
hacer esto es simplemente creando la definición de la función, con el mismo
prototipo mostrado aquí.
La
función _graphfreemem no retorna ningún valor.
Ejemplo:
#include <graphics.h>
#include <conio.h>
#include <stdio.h>
#include <stdlib.h>
void far _graphfreemem( void far *ptr, unsigned
tamanyo ) {
printf(
"__graphfreemem ha sido llamado para "
"desadjudicar
%d bytes en memoria\n" );
printf(
"para el montón (heap) interno\n", tamanyo );
printf(
"Pulse cualquier tecla...\n\n" );
getch();
free( ptr );
}
void far * far _graphgetmem( unsigned tamanyo ) {
printf(
"__graphgetmem ha sido llamado para "
"adjudicar
%d bytes en memoria\n" );
printf(
"para el montón (heap) interno\n", tamanyo );
printf(
"Pulse cualquier tecla...\n\n" );
getch();
return malloc( tamanyo );
}
void main() {
int driver = EGA,modo = EGAHI;
initgraph( &driver, &modo, “C:\\TC20\\BIN” );
circle( 200, 100, 50 );
getch();
closegraph();
getch();
}
Función
graphgetmem
void far * far _graphgetmem(unsigned
tamanyo);
Esta
función es usada por la librería gráfica para adjudicar memoria gráfica para búferes
internos, dispositivos gráficos, y fuentes. Esta función tiene como intención
ser llamada por la librería gráfica cuando se quiere adjudicar memoria. Por
defecto, la función simplemente llama a malloc, pero se puede controlar
la administración de memoria de la librería gráfica. La forma de hacer esto es
simplemente creando la definición
de
la función, con el mismo prototipo mostrado aquí.
La
función _graphgetmem no retorna ningún valor.
Ejemplo:
#include <graphics.h>
#include <conio.h>
#include <stdio.h>
#include <stdlib.h>
void far _graphfreemem( void far *ptr, unsigned
tamanyo ) {
printf(
"__graphfreemem ha sido llamado para "
"desadjudicar
%d bytes en memoria\n" );
printf(
"para el montón (heap) interno\n", tamanyo );
printf(
"Pulse cualquier tecla...\n\n" );
getch();
free( ptr );
}
void far * far _graphgetmem( unsigned tamanyo ) {
printf(
"__graphgetmem ha sido llamado para "
"adjudicar
%d bytes en memoria\n" );
printf(
"para el montón (heap) interno\n", tamanyo );
printf(
"Pulse cualquier tecla...\n\n" );
getch();
return malloc( tamanyo );
}
void main() {
int driver = EGA, modo = EGAHI;
initgraph( &driver, &modo, “C:\\TC20\\BIN” );
circle( 200, 100, 50 );
getch();
closegraph();
getch();
}
Función
graphresult
int far graphresult(void);
Esta
función obtiene y retorna el código de error para la última llamada sin éxito.
Además, reinicia el nivel de error a 0, o grOk. Existen varios valores
de códigos de error.
La
función graphresult retorna el código de error de la última llamada
gráfica sin éxito.
Ejemplo:
#include <graphics.h>
#include <conio.h>
#include <stdio.h>
void main() {
int driver = EGA;
int
modo = EGAHI;
int
codigo_error;
char
*mensaje_error;
initgraph(
&driver, &modo, "C:\\TC20\\BIN" );
setgraphmode(
40 ); /* Creamos un ERROR debe de ser 0 o 1*/
codigo_error
= graphresult();
strcpy(
mensaje_error, grapherrormsg( codigo_error ) );
closegraph();
printf(
"ERROR: \"%s\" (%d)\n", mensaje_error, codigo_error );
getch();
}
Función
installuserdriver
int far installuserdriver(char far *nombre,
int huge (*detectar)(void));
Esta
función permite al usuario añadir dispositivos adicionales de otras compañías o
grupos
a la tabla interna BGI de los dispositivos. El argumento *nombre define
el nombre del fichero nuevo del dispositivo .BGI. El parámetro *detectar es
un puntero a una función opcional para autodetectar que puede ser o no ser
provisto con el dispositivo nuevo. La función de autodetectación espera no
recibir ningún parámetro y retorna un valor entero.
La
función installuserdriver retorna el parámetro del número del
dispositivo que
hubiese
sido pasado a la función initgraph para
seleccionar un dispositivo nuevo.
Ejemplo:
/*
Este programa no Funcionará, ya que se
necesitaría otra tarjeta gráfica
desconocida por las librerías gráficas de BGI.
Esto sólo es para poner un ejemplo.*/
#include <graphics.h>
#include <conio.h>
int huge detectarSMGGA( void ) {
int driver, modo, modo_sugerirdo=0;
detectgraph( &driver, &modo );
if( SMGGA == driver ) return modo_sugerido;
return grError;
}
void main() {
int driver, modo;
/*
Intentamos instalar nuestra tarjeta gráfica:
** Súper Mega Guay Graphics Array (SMGGA)
**
Ya sé que suena muy cursi, pero esto sólo es un ejemplo :)
*/
driver
= installuserdriver( "SMGGA", detectarSMGGA );
/*
Forzamos a que use nuestra función para autodetectar */
driver = DETECT;
initgraph( &driver, &modo, “C:\\TC20\\BIN” );
closegraph();
getch();
}
Función
installuserfont
int far installuserfont(char far *nombre);
Esta
función carga un fichero de fuente escalable que no está provisto con el
sistema BGI. El parámetro *nombre especifica el nombre del fichero
fuente a cargar, en el directorio de inicio. El sistema gráfico puede tener
hasta veinte fuentes instaladas a la vez.
La
función installuserfont retorna el número de identificación de la fuente
que es usada para seccionar la fuente nueva a través de la función settextstyle.
Si la tabla interna de fuentes está llena, un valor de -11 (grError)
es retornado, indicando un error.
Ejemplo
/*
Este programa no Funcionará, ya que se
*
necesitaría tener una fuente nueva
*
y desconocida por las librerías gráficas de BGI.
*
Esto sólo es para poner un ejemplo.
*/
#include <graphics.h>
#include<stdio.h>
# include<conio.h>
void main() {
int driver = EGA;
int modo = EGAHI;
int fuente_SMCF;
initgraph( &driver,
&modo,"C:\\TC20\\BIN" );
/*
Intentamos instalar nuestra fuente nueva:
**
Súper Mega Chula Fuente (SMCF)
**
Ya sé que suena muy cursi, pero esto sólo es un ejemplo :)
*/
if( (fuente_SMGF = installuserfont(
"SMGF.CHR" )) != grError ){
settextstyle(
fuente_SMGF, HORIZ_DIR, 4 );
printf("Instalación
completada");getch();}
else{
settextstyle( DEFAULT_FONT, HORIZ_DIR, 4 );
printf("Error
de al instalar la aplicación");getch();}
closegraph();
getch();
}
Función
kbhit
int kbhit(void);
Revisa
si se ha presionado una tecla. Cualesquier pulsadas disponibles pueden ser
recogidas con las Funciones getch o getche.
La
función kbhit retorna 0 si no se ha registrado una pulsada de tecla; si lo
fue, entonces el valor retornado es distinto a cero.
Veremos
el uso de esta función en el modo grafico; para utilizar esta función se tiene
que declarar la cabecera conio.h
Ejemplo:
#include <graphics.h>
#include <conio.h>
# include <dos.h>
#include <stdio.h>
void main() {
int driver = EGA;
int modo = EGAHI,i;
initgraph( &driver, &modo,
"C:\\TC20\\BIN" );
setcolor(BLUE);
i=1;
do{
delay(30000);
rectangle(10+i,10,100+i,100);
setfillstyle(i,BLUE);
floodfill(20,20,BLUE);
i++;
}while(!kbhit());
}
Función outtext
void far outtext(char far *cadena_texto);
Esta
función es usada para mostrar una cadena de caracteres. El argumento *cadena_texto
define la cadena de texto a ser
mostrado. La cadena es mostrado donde está el cursor gráfico actualmente usando
el color actual y fuente, dirección, valores, y justificaciones de texto. La
posición del cursor permanece sin ser cambiado al
menos
que la justificación horizontal actual es LEFT_TEXT y
la orientación del texto es HORIZ_DIR. Cuando esto
sea el caso, la posición del cursor es colocada horizontalmente a la anchura
del píxel de la cadena de texto. Además, cuando se use la fuente por defecto,
cualquier texto que se extiende a fuera del área gráfica actual es truncado.
Aunque
la función outtext está diseñada para texto sin formato, texto con
formato puede ser mostrada a través del
uso de un búfer de caracteres y la función sprintf.
La
función outtext no retorna ningún valor.
Ejemplo:
#include <graphics.h>
#include <conio.h>
#include <stdio.h>
void main() {
int driver = EGA;
int
modo = EGAHI;
char
mensaje[40];
char
nombre[25];
printf(
"Escribe tu nombre: " );
scanf(
"%s", nombre );
sprintf(
mensaje, "Hola %s!", nombre );
initgraph( &driver, &modo, “C:\\TC20\\BIN” );
outtext( mensaje );
outtextxy( 300, 150, mensaje );
getch();
closegraph();
getch();
}
Función
outtextxy
void far outtextxy(int x, int y, char far
*cadena_texto);
Esta
función es usada para mostrar una cadena de caracteres. El argumento *cadena_texto
define la cadena de texto a ser mostrado. La cadena es mostrada en la
posición descrita por los argumentos x e y usando el color actual
y fuente, dirección, valores, y justificaciones de texto. Cuando se use la
fuente por defecto, cualquier texto que se extiende fuera del área gráfica
actual es truncado. Aunque la función outtextxy está diseñada para texto
sin formato, texto con formato puede ser mostrada a través del uso de un búfer
de caracteres y la función sprintf.
La
función outtextxy no retorna ningún valor.
Ejemplo:
#include <graphics.h>
#include <conio.h>
#include <stdio.h>
void main() {
int driver = EGA;
int
modo = EGAHI;
char
mensaje[40];
char
nombre[25];
printf(
"Escribe tu nombre: " );
scanf(
"%s", nombre );
sprintf(
mensaje, "Hola %s!", nombre );
initgraph( &driver, &modo, “C:\\TC20\\BIN” );
outtext( mensaje );
outtextxy( 300, 150, mensaje );
getch();
closegraph();
getch();
}
No hay comentarios:
Publicar un comentario