Gráficos en lenguaje C

Restringiremos nuestra discusión sobre gráficos en el lenguaje C a la programación en C de 16 bits y

Entorno MS DOS. En un programa C, primero necesitas inicializar los gráficos
controladores en la computadora. Esto se hace utilizando el método initgraph proporcionado en graphics.h
biblioteca. En las próximas páginas discutiremos la biblioteca graphics.h en detalle. Importante
las funciones de la biblioteca graphic.h se discutirán en detalle y se proporcionarán programas de muestra
proporcionado para mostrar el poder del lenguaje de programación C.

Inicialización del modo gráfico

Primero que nada, tenemos que llamar a la función initgraph que inicializará el modo gráfico en
la computadora. initigraph tiene el siguiente prototipo.

void initgraph(int far *graphdriver, int far *graphmode, char far

*rutaalcontrolador);

Initgraph inicializa el sistema gráfico cargando un controlador gráfico desde el disco (o

validando un conductor registrado) luego poniendo el sistema en
El modo gráfico. Initgraph también restablece todas las configuraciones gráficas (color, paleta, posición actual,
restablece el viewport, etc.) a sus valores predeterminados, luego restablece graphresult a 0.

*controlador de gráficos
Entero que especifica el controlador gráfico que se va a utilizar. Puedes darle un valor a graphdriver
utilizando una constante del tipo de enumeración graphics_drivers.

*modográfico
Número entero que especifica el modo gráfico inicial (a menos que *graphdriver = DETECT). Si
*graphdriver = DETECT, initgraph establece *graphmode a la resolución más alta disponible
para el controlador detectado. Puedes darle a *graphmode un valor utilizando una constante de la
tipo de enumeración graphics_modes.

*rutaalconductordriver
Especifica la ruta del directorio donde initgraph busca primero los controladores gráficos (*.BGI).

1. Si no están allí, initgraph busca en el directorio actual.

2. Si pathtodriver es nulo, los archivos del controlador deben estar en el directorio actual.

*graphdriver y *graphmode deben establecerse en drivers_gráficos y modo_gráfico válidos

valores o obtendrás resultados impredecibles. (La excepción es graphdriver = DETECT.)
Después de una llamada a initgraph, *graphdriver se establece en el controlador de gráficos actual, y
*graphmode está configurado al modo gráfico actual. Puedes decirle a initgraph que use un particular
controlador gráfico y modo, o detectar automáticamente el adaptador de video conectado en tiempo de ejecución y seleccionar
el controlador correspondiente. Si le dices a initgraph que autodetecte, llama a detectgraph para seleccionar un
controlador de gráficos y modo.

Normalmente, initgraph carga un controlador de gráficos asignando memoria para el controlador (a través de
_graphgetmem), luego cargando el archivo .BGI apropiado desde el disco. Como alternativa a esto
esquema de carga dinámica, puedes vincular un archivo de controlador gráfico (o varios de ellos) directamente
en tu archivo de programa ejecutable.

Aquí hay un programa de ejemplo que inicializa el modo gráfico en lenguaje C.

#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
int main(void)
{
/* detección automática de solicitudes */
int gdriver = DETECCIÓN, gmode, códigoDeError;
/* inicializar modo gráfico */
initgraph(&gdriver, &gmode, "");
/* leer el resultado de la inicialización */
resultado del gráfico();
si (códigoError != grOk) /* ocurrió un error */
{
printf("Error gráfico: %s\n", grapherrormsg(errorcode));
printf("Presione cualquier tecla para detener:");
getch();
exit(1); /* devolver con código de error */
}
/* dibujar una línea */
línea(0, 0, getmaxx(), getmaxy());
/* limpiar */
getch();
cerrargráfico();
return 0;
}

La programación gráfica en lenguaje C se discute brevemente para proporcionar una visión general de
el principiante.

/* Programa de ejemplo para dibujar un círculo */

#include<graphics.h>
#include<conio.h>
principal()
{
int gd=DETECT,gm;
initgraph(&gd,&gm,"""); /* inicialización del modo gráfico */
círculo(150,150,100);
getch();
cerrargráfica(); /* Restaurar el modo de pantalla original */
}
/* Fin del programa */

Normalmente la pantalla que ves en DOS está en modo texto, lo que significa que está destinada a
texto. Y para gráficos necesitas inicializar el modo gráfico. Y para que esto suceda necesitas
incluye ?graphics.h?.

círculo(coordenada x, coordenada y, radio);

El comando de círculo toma una coordenada X que significa eje vertical y una coordenada Y
lo que significa el eje horizontal. Y el último es el radio del círculo. cerrar gráfico();

Sin esta función, el modo de pantalla seguirá en modo gráfico y cuando tú

salir, en DOS verás una pantalla diferente, que no está en modo de texto.

/*Un programa para dibujar un espacio con estrellas*/

#include<gráficos.h>
principal()
{
int gd=DETECT,gm;
int i,x,y;
initgraph(&gd,&gm,"");
línea(0,0,640,0);
línea(0,0,0,480);
línea(639,0,639,480);
línea(639,479,0,479);
for(i=0;i<=1000;i++)
{
x=rand()%639;
y=rand()%480;
poner_pixel(x,y,15);
}
getch();
cerrar_gráfica();
}
/* Fin del programa */
/* Aquí hay un programa de muestra para ilustrar cómo usar BARS que se utilizan
para estadísticas visuales */
#include<graphics.h>
main() {
int gd=DETECT, gm, maxx, maxy, x, y, button;
initgraph(&gd,&gm,"");
línea(80,150,200,150);
línea(80,150,80,50);
settextstyle(1,HORIZ_DIR,1);
outtextxy(100,153,"<-Eje X");
settextstyle(1,VERT_DIR,1);
outtextxy(60,50,"<-Eje Y");
bar(100,100,120,150);
bar(130,120,150,150);
getch();
cerrargráfico();
}
Programación gráfica en Turbo C
Harsha

Para empezar con la programación gráfica, Turbo C es una buena opción. A pesar de que DOS tiene sus propias limitaciones,
tiene un gran número de funciones útiles y es fácil de programar. Para implementar algoritmos gráficos, Para dar
visualización gráfica de estadísticas, Para ver señales de cualquier fuente, podemos usar gráficos de C. Aquí hay un artículo para comenzar
programación con Turbo C. 'Ejecutar y Aprender' es nuestro método. Hemos utilizado códigos fuente a lo largo de las explicaciones.
Simplemente ejecútalos para entender lo que está sucediendo.

VisitarDescargaspágina para códigos fuente gratuitos de programas gráficos.

Turbo C tiene una buena colección de bibliotecas gráficas. Si conoces el

los fundamentos de C, puedes aprender fácilmente programación gráfica. Para empezar a programar,
escribamos un pequeño programa que muestre un círculo en la pantalla.

/* simple.c
ejemplo 1.0
*/
#include<gráficos.h>
#include<conio.h>

void main()
{
int gd=DETECT, gm;

initgraph(&gd, &gm, "c:\turboc3\bgi ");

círculo(200,100,150);

getch();
cerrargráfico();
}

Para ejecutar este programa, necesitas el archivo de cabecera graphics.h y el archivo de biblioteca graphics.lib
y el controlador de gráficos (archivo BGI) en la carpeta del programa. Estos archivos son parte de
Paquete Turbo C. En todos nuestros programas utilizamos un monitor VGA de 640x480. Así que todo
los programas están de acuerdo con esa especificación. Necesitas hacer lo necesario
cambios en tus programas según la resolución de pantalla. Para VGA
monitor, el controlador gráfico utilizado es EGAVGA.BGI.

Aquí, la función initgraph() inicializa el modo gráfico y limpia la pantalla.

Estudiaremos en detalle la diferencia entre el modo de texto y el modo gráfico.
último.
InitGraph:

Inicializa el sistema gráfico.

Declaración:
void far initgraph(int far *graphdriver, int far *graphmode, char far *pathtodriver);

Observaciones: Para iniciar el sistema de gráficos, primero debes llamar a initgraph.

initgraph inicializa el sistema gráfico cargando un controlador gráfico desde el disco (o

validando a un conductor registrado) luego poniendo el sistema en modo gráfico.

initgraph también restablece todas las configuraciones gráficas (color, paleta, posición actual, ventana de visualización, etc.) a
sus valores predeterminados, luego restablece graphresult a 0.
Argumentos:

*controlador gráfico: Entero que especifica el controlador gráfico que se utilizará. Puedes dar
controlador gráfico un valor utilizando una constante del tipo de enumeración de controladores gráficos.

*mododegraficacion : Entero que especifica el modo gráfico inicial (a menos que *controladordegráficos =
DETECT). Si *graphdriver = DETECT, initgraph establece *graphmode en el más alto
resolución disponible para el controlador detectado. Puedes darle a *graphmode un valor usando un
constante del tipo de enumeración graphics_modes.

Especifica la ruta del directorio donde initgraph busca controladores gráficos

( *.BGI ) primero. Si no están allí, initgraph busca en el directorio actual. Si pathtodriver
es nulo, los archivos del controlador deben estar en el directorio actual. Este también es el camino settextstyle
busca los archivos de fuente de caracteres trazados (*.CHR).

La función closegraph() cambia la pantalla del modo gráfico al modo de texto

modo. También limpia la pantalla. Un programa gráfico debería tener un closegraph
función al final de los gráficos. De lo contrario, la pantalla DOS no irá al modo de texto
después de ejecutar el programa. Aquí, closegraph() se llama después de getch() ya que
la pantalla no debe borrarse hasta que el usuario presione una tecla.

Si tienes el archivo BGI en la misma carpeta que tu programa, puedes simplemente

déjalo en "" solamente. no es necesario mencionar *graphmode si das *graphdriver
como DETECTAR.

Para obtener detalles de los diferentes modos gráficos y controladores gráficos, consulte
apéndice.

En modo gráfico, todas las coordenadas de la pantalla se mencionan en términos de

píxeles. El número de píxeles en la pantalla determina la resolución de la pantalla. En el
ejemplo 1.0, se dibuja un círculo con la coordenada x del centro 200, coordenada y
100 y radio 150 píxeles. Todas las coordenadas se mencionan con respecto a
esquina superior izquierda de la pantalla.

Formas y Colores Básicos

Ahora escribamos un programa para dibujar algunas formas básicas.

/*
formas.c
ejemplo 1.1
*/

#include<graphics.h>
#include<conio.h>

void main()
{
int gd=DETECT, gm;
int poly[12]={350,450, 350,410, 430,400,
350,350, 300,430, 350,450 };
initgraph(&gd, &gm, "");

círculo(100,100,50);
outtextxy(75,170, "Círculo");
rectángulo(200,50,350,150);
outtextxy(240, 170, "Rectángulo");
elipse(500, 100,0,360, 100,50);
outtextxy(480, 170, "Elipse");
línea(100,250,540,250);
outtextxy(300,260,"Línea");

sector(150, 400, 30, 300, 100, 50);

outtextxy(120, 460, "Sector");
dibujarPolígono(6, polígono);
outtextxy(340, 460, "Polígono");
getch();
cerrar gráfico();
}

Aquí está la captura de pantalla de la salida:

 Aquí, la función circle() toma las coordenadas x, y del círculo con respecto a la izquierda
parte superior de la pantalla y radio del círculo en términos de píxeles como argumentos. No
que, en gráficos, casi todos los parámetros de la pantalla se miden en términos de
pixeles.

La función outtextxy() muestra una cadena en modo gráfico. Puedes usar

diferentes fuentes, tamaños de texto, alineaciones, colores y direcciones del texto que nosotros
estudiará más tarde. Los parámetros pasados son las coordenadas x e y de la posición en
la pantalla donde se mostrará el texto. Hay otra función outtext() que
muestra un texto en la posición actual. La posición actual es el lugar donde fue el último
el dibujo ha terminado. Estas funciones se declaran de la siguiente manera:

void far outtextxy(int x, int y, char *texto);

void far outtext(char *texto);
Círculo, arco, porción de pastel se declaran de la siguiente manera:
Declaración:

• void arco lejano(int x, int y, int anglest, int angulof, int radio);
• void lejos círculo(int x, int y, int radio);
• void far pieslice(int x, int y, int stangle, int endangle, int radius);

Observaciones:

• arc dibuja un arco circular en el color de dibujo actual.

• círculo dibuja un círculo en el color de dibujo actual.
• pieslice dibuja una porción de tarta en el color de dibujo actual, luego la rellena usando
el patrón de relleno actual y el color de relleno.

Argumentos:

• (x,y): Punto central del arco, círculo o rebanada de pastel

• Ángulo de inicio en grados
• Ángulo final en grados

• Radio de arco, círculo y rebanada

Aquí, el ángulo de estrangulación y el ángulo final están en grados comenzando desde el eje x positivo en el
sistema de coordenadas polares en dirección antihoraria. si el ángulo es 0, ángulo final
son 360, dibujará un círculo completo. Consulta esta figura para una idea clara: Para los detalles
de color actual, color de relleno y patrones de relleno, consulte las secciones Líneas y Colores.
 Otra forma básica con la que nos encontramos es un rectángulo. Para dibujar un borde,
usa un rectángulo con las coordenadas del contorno, para dibujar un cuadrado usa un rectángulo
con la misma altura y ancho. drawpoly() y fillpoly() son dos funciones útiles
dibujar cualquier polígono. Para usar estas funciones, almacene las coordenadas de la forma en
un arreglo y pasar la dirección del arreglo como un argumento a la función. Por
mirando la salida del programa anterior, puedes entender lo que
drawpoly es. fillpoly es similar, excepto que llena la forma con el relleno actual.
color.

Declaración:

• void rectángulo lejano(int izquierda, int arriba, int derecha, int abajo);
• void far drawpoly(int numpoints, int far *polypoints);
• void far fillpoly(int numpoints, int far *polypoints);

Comentarios:

• el rectángulo dibuja un rectángulo en el estilo de línea actual, grosor y

color de dibujo.
• drawpoly dibuja un polígono usando el estilo y color de línea actuales.
• fillpoly dibuja el contorno de un polígono usando el estilo de línea actual y
color, luego llena el polígono utilizando el patrón de relleno actual y el color de relleno.
 Argumentos:

• (izquierda, arriba) es la esquina superior izquierda del rectángulo, y (derecha, abajo) es su

esquina inferior derecha.
• Especifica el número de puntos

• *polypoints: Se refiere a una secuencia de (numpoints x 2) enteros. Cada par

de enteros da las coordenadas x e y de un punto en el polígono.

Para dibujar un polígono cerrado con N puntos, numpoints debe ser N+1 y el
el arreglo polypoints[] debería contener 2(N+1) enteros con los primeros 2 enteros iguales a
últimos 2 enteros.

Estudemos más sobre formas más tarde. Aquí hay algunas ideas sobre colores.
Hay 16 colores declarados en graphics.h como se enumera a continuación.

NEGRO: 0
AZUL 1
VERDE 2
Cian: 3
RED: 4
MAGENTA 5
MARRÓN 6
GRIS CLARO 7
GRIS OSCURO 8
AZUL CLARO 9
VERDE CLARO 10
CYAÑO CLARO: 11
ROJO CLARO 12
MAGENTA_CLARO: 13
AMARILLO catorce
BLANCO 15

Para usar estos colores, utiliza las funciones setcolor(), setbkcolor() y setfillstyle().
La función setcolor() establece el color de dibujo actual. Si usamos setcolor(ROJO); y
dibuja cualquier forma, línea o texto después de eso, el dibujo será de color rojo. Puedes
usa el color definido arriba o un número como setcolor(4);. setbkcolor() establece
color de fondo para dibujar. Setfillstyle establece el patrón de relleno y los colores de relleno. Después de
llamando a setfillstyle, si usamos funciones como floodfill, fillpoly, bar, etc., las formas se
estar llenos con color de relleno y patrón establecidos utilizando setfillstyle. Estas funciones
las declaraciones son las siguientes.

Declaración:

• void far establecerEstiloRelleno(int patrón, int color);

• void lejana establecercolor(int color);
• void lejos establecerColorFondo(int color);

Observaciones:

• setfillstyle establece el patrón de relleno actual y el color de relleno.

• setcolor establece el color actual de dibujo a color, que puede variar de 0 a
obtenermaxicolor.

• setbkcolor establece el fondo al color especificado por color.

El patrón de parámetro en setfillstyle es el siguiente:

Nombres Valor significa llenar con...

VACÍO 0 Color de fondo
RELLENO_SÓLIDO 1 Relleno sólido
RELLENAR_LÍNEA 2 ---
LTSLASH_FILL 3 ///
RELLENO_RAYADO 4 ///, líneas gruesas
BKSLASH_FILL 5 \\, líneas gruesas
LTBKSLASH_FILL 6 \\\
RELLENO_DE_TRAMA7 Tapa ligera
RELLENO CRUZADO 8 Cruce pesado
RELLENO_INTERCALADO
9 Intercalando líneas
10
RELLENO_PUNTOS_ANCHOSpuntos ampliamente espaciados

11 puntos estrechamente espaciados

CERRAR_PUNTO_RELLENO
USUARIO_LLENA 12 Patrón de relleno definido por el usuario

Aquí hay un programa de ejemplo con colores, píxeles, barra, limpiar dispositivo, etc.
stdlib.h se utiliza para la generación de números aleatorios. Tenemos una función random(no),
devuelve un número aleatorio entre 0 y no. El efecto es dibujando aleatoriamente
radio, círculos de color aleatorio con el mismo centro y píxeles aleatorios. kbhit()
la función (definida en conio.h) devuelve un valor distinto de cero cuando se presiona una tecla en
el teclado. Así que, el bucle continuará hasta que se presione una tecla.
 /*
aleatorio.c
algunos efectos gráficos utilizando números aleatorios.
ejemplo 1.2
por HarshaPerla, http://eharsha.tk
*/

#include "gráficos.h"
#include "conio.h"
#include "stdlib.h"

void main()
{
int gd, gm;
DETECT

inicializargráfico(&gd, &gm, "")

establecercolor(3);
setfillstyle(RELLENO_SÓLIDO,ROJO);
barra(50, 50, 590, 430);

setfillstyle(1, 14);
barra(100, 100, 540, 380);

mientras(!kbhit())
{
ponerpixel(random(439)+101,
aleatorio(279)+101,aleatorio(16));
setcolor(random(16));
círculo(320,240,aleatorio(100));
}
getch();
cerrargráfica();
}

En la siguiente parte del artículo, Ranjith K. H. explicará sobre cómo añadir un ratón a
tu aplicación.Lee la Parte II

Háblenos sobre este artículo: Este es el primer artículo de este tutorial. Estamos planeando
expándelo. Para continuar, necesitamos tus sugerencias. La siguiente parte del artículo será
dependiendo de los comentarios que publiques. Dinos qué parte del artículo necesita ser
explicado más, cómo se puede elaborar más el artículo y cómo te hizo sentir el artículo.
Haz clic aquí para publicar un comentarioo envíame un correo electrónico:[email protected]

->Programación de Ratón con Turbo C

http://electrosofts.com/cgraphics/

En GUI como Windows, el ratón es muy importante para la interacción del usuario. Pero en DOS,
el ratón solo aparecerá en algunos de los programas. Si estás escribiendo
juegos DOS o programas de gráficos, puedes agregar funcionalidad de ratón a tu
código. Aquí está cómo hacerlo.

Si eres un principiante en la programación gráfica de Turbo C, lee nuestro

introducción a los gráficos de Turbo C.

El mouse se puede utilizar en modo de texto así como en modo gráfico. Por lo general, es
utilizado en modo gráfico. Por lo tanto, primero debemos cambiar al modo gráfico. En
nuestro programa la función initgraph() es responsable de cambiar el modo de
text to graphics .DETECT es un macro definido en 'graphics.h'. Solicita
initgraph() para determinar automáticamente qué controlador gráfico cargar para
cambiar al modo de gráficos de la más alta resolución. La función initgraph() toma
tres parámetros, el controlador de gráficos, el modo de gráficos y la ruta al
archivo del controlador.

Una vez que el controlador ha sido cargado, initgraph() configura los valores numéricos de
el modo gráfico elegido en las variables gd y gm respectivamente. Aquí estamos
suponiendo que los archivos del controlador están en el directorio 'c:\tc\bgi'. Por lo tanto, la ruta
se pasó a initgraph() es 'c:\tc\bgi'.

Las diversas funciones del ratón se pueden acceder configurando el AX

regístrate con diferentes valores (número de servicio) y emitiendo el número de interrupción 51.
Las funciones se enumeran a continuación
Servicio de Interrupción Propósito

Restablecer el ratón y obtener estado

51 0 Llamar con AX = 0
Devoluciones: AX = FFFFh si el soporte del ratón está disponible
Ax = 0 Si el soporte para mouse no está disponible

Mostrar puntero del ratón

51 1 Llamar con AX = 1
Nada

Ocultar puntero del ratón

51 2 Llamada con AX = 2
Nada
Obtener la posición del mouse y el estado del botón
Llamada con AX = 3
BX = estado del botón del mouse
Significado del bit
0 botón no presionado
51 3
1 se presiona el botón izquierdo
2 se presiona el botón derecho
3 el botón central está presionado
CX = coordenada x
DX = coordenada y
Establecer la posición del puntero del ratón

Llamar con AX = 4
51 4 CX = coordenada x
coordenada y
Devoluciones: Nada

Establecer límites horizontales para el puntero

Llamada con AX = 7
51 7 CX = coordenada x mínima
DX = coordenada x máxima
Nada

Establecer límites verticales para el puntero

Llama con AX = 8
51 8 CX = coordenada y mínima
DX = coordenada y máxima
Devoluciones: Nada
Consideremos un programa que utiliza las funciones anteriores.
 #include<graphics.h>
#include<stdio.h>
#include<conio.h>
#include<dos.h>
unión REGS en, fuera;

int llamarRaton()
{
en.x.ax=1;
int86(51,&in,&out);
retornar 1;
}
void mouseposi(int &xpos,int &ypos,int &click)
{
3
int86(51,&in,&out);
click=fuera.x.bx;
xpos=out.x.cx;
ypos=out.x.dx;
}
int ocultarRaton()
{
2;
int86(51,&in,&out);
return 1;
}
void setposi(int &xpos,int &ypos)
{
in.x.ax=4;
in.x.cx=xpos;
in.x.dx=ypos;
int86(51,&in,&out);
}
int main()
{
int x,y,cl,a,b;
clrscr();
int g=DETECT,m;
initgraph(&g,&m,"c:\tc\bgi");
a=100;
b=400;
setposi(a,b);
llamarmouse();
hacer
{
 mouseposi(x,y,cl);
gotoxy(10,9);
printf("\n\tLa posición del ratón es: %d,%d",x,y);
Haz clic: %d
Presione cualquier tecla para ocultar el mouse
}mientras(!kbhit());
getch();
ocultar_mouse();
Presione cualquier tecla para salir
getch();
}

El programa anterior utiliza las siguientes funciones:

• llamargato( )
• mouseposi( )
• mousehide( )
• setposi( )

callmouse():- En esta función AX se establece en "1". Cuando se llama a esta función en

main() muestra el puntero del mouse. La posición del puntero se puede cambiar
usando el ratón.

mousehide():- En esta función, AX se establece en "2". Cuando se llama a esta función en

main() oculta el puntero del mouse. Esta función es útil al dibujar figuras.
primero se oculta el puntero del mouse, luego se dibuja la figura y nuevamente
se ha llamado al puntero del ratón.

mouseposi():- En esta función AX se establece en "3". Esta función devuelve el

posición del puntero del ratón. Contiene tres parámetros, que son
xpos, ypos, clic. xpos e ypos devuelven la posición de la coordenada x y y
ordena respectivamente. Click es la variable entera que devuelve los valores 1,2,3
correspondiente al botón presionado en el ratón y 0 para botones que no están
presionado. Si se presiona alguna tecla, kbhit devuelve un entero no cero; si no, devuelve cero.
 setposi():- En esta función AX se establece en "4". Esta función configura el mouse
puntero a posición específica. CX se ha cargado con la coordenada x del mouse
el puntero y DX se ha cargado con la coordenada y del puntero del mouse.

Consideremos otro programa

#include<graphics.h>
#include<stdio.h>
#include<conio.h>
#include<dos.h>
unión REGS dentro, fuera;

int llamarRaton()
{
in.x.ax=1;
int86(51,&in,&out);
regresar 1;
}
void restringirpunteromouse(int x1,int y1,int x2,int y2)
{
in.x.ax=7;
in.x.cx=x1;
in.x.dx=x2;
int86(51,&in,&out);
in.x.ax=8;
in.x.cx=y1;
in.x.dx=y2;
int86(51,&in,&out);
}
int main()
{
int x,y,cl,a,b;
clrscr();
int g=DETECT,m;
initgraph(&g,&m,"c:\tc\bgi");
rectángulo(100,100,550,400);
llamarRatón();
res restringir_ptrratón(100,100,550,400);
getch();
}

El programa anterior utiliza las siguientes funciones:

• Horizontal ( )
• Vertical( )
 Horizontal():- En esta función AX se establece en "7". Establece la barrera horizontal.
para el puntero que restringe el puntero del ratón a pasar ese límite. CX está siendo
cargado con la coordenada x mínima y Dx se ha cargado con la máxima
coordenada x.

Vertical(): - En esta función, AX se establece en "8". Establece la barrera vertical para

el puntero que restringe el puntero del mouse para pasar ese límite. CX ha sido cargado
con la coordenada y mínima y Dx está siendo cargado con la máxima y
ordenar.