| Plataforma: | DOS32 |
| Sintaxis: | include graphics.e ellipse(i1, i2, s1, s2) |
| Descripción: | Dibuja una elipse con color 'i1' en una pantalla
de gráficos de píxel. La elipse
cabrá cuidadosamente dentro del rectángulo definido por
los puntos diagonales 's1' {x1, y1} y 's2' {x2, y2}. Si el rectángulo
es una cuadrado, entonces la elipse será un círculo. Rellena
la elipse cuando 'i2' vale 1. No la rellena cuando 'i2' vale 0. |
| Ejemplo: | |
ellipse(MAGENTA, 0, {10, 10}, {20, 20})
-- Debería hacer un círculo magenta bien ajustado
-- dentro del cuadrado:
-- {10, 10}, {10, 20}, {20, 20}, {20, 10}.
| |
| Programa de ejemplo: | demo\dos32\sb.ex |
| Ver también: | polygon, draw_line |
| Sintaxis: | i = equal(x1, x2) |
| Descripción: | Compara dos objetos Euphoria para determinar si
son iguales. Devuelve 1 (verdadero) si son iguales, 0 si son distintos. |
| Comentarios: | Es equivalente a la expresión: compare(x1, x2) = 0. |
| Ejemplo 1: | |
if equal(PI, 3.14) then
puts(1, "déme un mejor valor de PI!\n")
end if | |
| Ejemplo 2: | |
if equal(name, "Jorge") or equal(name, "JORGE") then
puts(1, "el nombre es Jorge\n")
end if
| |
| Ver también: | compare, operador equals (=) |
| Sintaxis: | i = find(x, s) |
| Descripción: | Busca 'x' como elemento de 's'. Si lo encuentra,
devuelve el índice del primer elemento de 's' que coincida, sino
devuelve 0. |
| Ejemplo 1: | |
ubicacion = find(11, {5, 8, 11, 2, 3})
-- ubicacion se establece en 3 | |
| Ejemplo 2: | |
nombres = {"Alfredo", "Pedro", "Juan", "María", ""}
ubicacion = find("María", nombres)
-- ubicacion se establece en 4
| |
| Ver también: | match, compare |
| Sintaxis: | include machine.e a1 = float32_to_atom(s) |
| Descripción: | Convierte una secuencia de 4 bytes en un átomo.
Esos 4 bytes tienen que contener el formato IEEE de punto flotante de
32 bits. |
| Comentarios: | Cualquier número IEEE de punto flotante de 32 bits se puede convertir en un átomo. |
| Ejemplo: | |
f = repeat(0, 4)
fn = open("numeros.dat", "rb") -- lee en binario
f[1] = getc(fn)
f[2] = getc(fn)
f[3] = getc(fn)
f[4] = getc(fn)
a = float32_to_atom(f)
| |
| Ver también: | float64_to_atom, atom_to_float32 |
| Sintaxis: | include machine.e a1 = float64_to_atom(s) |
| Descripción: | Convierte una secuencia de 8 bytes en un átomo.
Esos 8 bytes tienen que contener el formato IEEE de punto flotante de
64 bits. |
| Comentarios: | Cualquier número IEEE de punto flotante de 64 bits se puede convertir en un átomo. |
| Ejemplo: | |
f = repeat(0, 8)
fn = open("numeros.dat", "rb") -- lee en binario
for i = 1 to 8 do
f[i] = getc(fn)
end for
a = float64_to_atom(f)
| |
| Ver también: | float32_to_atom, atom_to_float64 |
| Sintaxis: | x2 = floor(x1) |
| Descripción: | Devuelve el mayor entero menor o igual que 'x1' (Redenodea hacia abajo un entero). |
| Comentarios: | Esta función se puede aplicar a un átomo o a todos los elementos de una secuencia. |
| Ejemplo: | |
y = floor({0.5, -1.6, 9.99, 100})
-- y es {0, -2, 9, 100}
| |
| Ver también: | remainder |
| Sintaxis: | include file.e flush(fn) |
| Descripción: | Al escribir datos a un fichero, normalmente Euphoria
almacena los datos en un búfer de memoria hasta se acumule una
porción lo suficientemente grande. Esta gran porción se
puede escribir en el disco de forma muy eficiente. A veces, puede querer
forzar (o descargar) todos los datos inmediatamente, aún cuando
el búfer de memoria no esté lleno. Para hacer esto, tiene
que llamar a flush(fn),
donde 'fn' es el número de fichero de un fichero abierto para escritura
o agregado. |
| Comentarios: | Cuando el fichero está cerrado, (ver close()),
todos los datos en el búfer se descargan. Cuando termina un programa,
todos los ficheros abiertos se descargan y se cierran automáticamente.
Use flush() cuando otro proceso necesite ver todos los datos escritos hasta ahora, pero sin que esté listo para cerrar el fichero aún. |
| Ejemplo: | |
f = open("logfile", "w")
puts(f, "Record#1\n")
puts(1, "Presione ENTER cuando esté listo\n")
flush(f) -- Esto fuerza a "Record #1" into "logfile" on disk.
-- Sin esto, "logfile" aparecerá teniendo
-- 0 caracteres cuando detengamos la entrada de teclado.
s = gets(0) -- espera una entrada por teclado
| |
| Ver también: | close, lock_file |
| Sintaxis: | include machine.e free(a) |
| Descripción: | Libera un bloque de memoria previamente asignado
al especificar la dirección del comienzo del bloque, es decir,
la dirección que devolvió allocate().
|
| Comentarios: | Use free()
para reciclar bloques de memoria durante la ejecución. Esto reducirá
la posibilidad de quedarse sin memoria o de provocar un excesivo intercambio
de memoria virtual a disco. No referencie un bloque de memoria que ya
fue liberado. Cuando su programa termina, toda la memoria asignada se
devolverá al sistema.
No use free() para desasignar memoria que fue asignada usando allocate_low(). Use free_low() para este fin. |
| Programa de ejemplo: | demo\callmach.ex |
| Ver también: | allocate, free_low |
| Plataforma: | WIN32, Linux, FreeBSD |
| Sintaxis: | include dll.e free_console() |
| Descripción: | Libera (borra) cualquier ventana de consola asociada a su programa. |
| Comentarios: | Euphoria creará una ventana de consola de
texto para su programa la primera vez que
el programa escriba algo en pantalla, lea algo desde el teclado o cualquier
situación que necesite una consola (similar a la ventana del Indicador
de DOS). En WIN32 esta ventana
desaparecerá automáticamente cuando termine el programa,
pero puede llamar a free_console()
para hacerla desaparecer más pronto. En Linux
o FreeBSD, la consola de
modo de texto está siempre, pero una ventana xterm desaparecerá
después que Euphoria muestre el indicador "Presionar Enter" al
final de la ejecución.
En Linux o FreeBSD, free_console() establecerá los parámetros nuevamente como normales, deshaciendo los efectos que curses tiene en pantalla. En una ventana xterm de Linux o FreeBSD, una llamada a free_console(), sin ninguna impresión en pantalla o lectura del teclado, eliminará el indicador "Presionar Enter" que normalmente emite Euphoria al final de la ejecución. Después de liberar la ventana de consola, puede crear una nueva ventana de consola imprimiendo alguna cosa en pantalla, o simplemente llamando a clear_screen(), position() o cualquier otra rutina que necesite una consola. Cuando usa la utilidad de trazado, o cuando el programa tiene un error, Euphoria creará automáticamente una venta de consola para mostrar la información de trazado, mensajes de error, etc. Hay una rutina de la API de WIN32, FreeConsole() que hace algo similar a free_console(). Debería usar free_console(), porque le permite al intérprete saber si no existe más una consola. |
| Ver también: | clear_screen, platform.doc |
| Plataforma: | DOS32 |
| Sintaxis: | include machine.e free_low(i) |
| Descripción: | Libera un bloque de memoria convencional previamente
asignado al especificar la dirección del comienzo del bloque, es
decir, la dirección que devolvió allocate_low().
|
| Comentarios: | Use free_low()
para reciclar bloques de memoria convencional durante la ejecución.
Esto reducirá la posibilidad de quedarse sin memoria convencional.
No referencie un bloque de memoria que ya fue liberado. Cuando su programa
termina, toda la memoria asignada se devolverá al sistema.
No use free_low() para desasignar memoria que fue asignada usando allocate(). Use free() para este fin. |
| Programa de ejemplo: | demo\dos32\dosint.ex |
| Ver también: | allocate_low, dos_interrupt, free |
| Sintaxis: | include get.e s = get(fn) |
| Descripción: | Ingresa, desde el fichero 'fn', una cadena de caracteres
humanamente legible representando un objeto Euphoria. Convierte la cadena
en el valor numérico de ese objeto. 's' será una secuencia
de 2 elementos: {estado de error, valor}. Los códigos de
error son: |
GET_SUCCESS -- el objeto se leyó existosamente
GET_EOF -- fin de fichero antes que se lea el objeto
GET_FAIL -- el objeto no es correcto sintacticamente
| |
get()
puede leer objetos Euphoria arbitrariamente complicados. Podría
tener un secuencia larga de valores entre llaves, separados por comas,
por ejemplo: {23, {49, 57}, 0.5, -1, 99, 'A', "Juan"}. Una
sola llamada a get() leerá secuencia entera y devolverá
su valor como resultado.
Cada llamada a get() inicia donde quedó la llamada previa. Por ejemplo, se debería necesitar una serie de 5 llamadas a get() para leer: 99 5.2 {1,2,3} "Hola" -1 En la sexta llamada a get() y cualquier otra siguiente, vería el código de estado GET_EOF. Si tiene algo como: {1, 2, xxx} en el flujo de entrada vería el código de error GET_FAIL, porque xxx no es un objeto Euphoria. Si tiene varios objetos "de alto nivel" en el flujo de entrada, tiene que separarlos unos de otros mediante uno o más caracteres "separadores" (blanco, tabulador, \r o \n). Los separadores no son necesarios dentro de un objeto de alto nivel. Una llamada a get() leerá un objeto completo de alto nivel, más un caracter adicional (separador). | |
| Comentarios: | La combinación de print()
y get() se puede usar para
guardar un objeto Euphoria en el disco y luego volver a leerlo. Esta técnica
se puede usar para implementar una base de datos de una o más secuencias
Euphoria grandes almacenadas en ficheros del disco. Las secuencias se
pueden leer a memoria, actualizar y escribir nuevamente al disco después
que cada serie de transacciones se complete. Recuerde escribir un caracter
"separador" (usando puts())
después de cada llamada a print().
El valor devuelto carece de significado, salvo que obtenga el estado GET_SUCCESS. |
| Ejemplo: | Suponga que el programa le pide al usuario ingresar un número desde el teclado. |
-- Si el usuario escribe 77.5, get(0) devolverá:
{GET_SUCCESS, 77.5}
-- por cuanto gets(0) devolverá:
"77.5\n"
| |
| Programa de ejemplo: | demo\mydata.ex |
| Ver también: | print, value, gets, getc, prompt_number, prompt_string |
| Plataforma: | DOS32 |
| Sintaxis: | include image.e i = get_active_page() |
| Descripción: | Algunos modos gráficos en la mayoría
de las tarjets de video, tienen varias páginas de memoria. Esto
le permite escribir la salida de pantalla en una página, mientras
muestra otra diferente. get_active_page()
devuelve el número de página actual que se está enviando
a la pantalla. |
| Comentarios: | Las páginas activa y mostrada son 0 por defecto.
video_config()
le dirá cuantas páginas están disponibles en el actual
modo gráfico. |
| Ver también: | set_active_page, get_display_page, video_config |
| Plataforma: | DOS32 |
| Sintaxis: | include image.e s = get_all_palette() |
| Descripción: | Devuelve las intensidades de color para el conjunto
completo de colores del actual modo gráfico. 's' es una secuencia
de la forma:
{{r,g,b}, {r,g,b}, ..., {r,g,b}} Cada elemento especifica una intensidad de color {red, green, blue} para el número de color correspondiente, comenzando con el número de color 0. Los valores para rojo, verde y azul estarán en el rango de 0 a 63. |
| Comentarios: | Esta función se debería usar para
obtener los valores de la paleta que necesita save_bitmap().
Recuerde multiplicar esos valores por 4 antes de llamar a save_bitmap(),
ya que save_bitmap()
espera valores en el rango de 0 a 255. |
| Ver también: | palette, all_palette, read_bitmap, save_bitmap, save_screen |
| Sintaxis: | include get.e s = get_bytes(fn, i) |
| Descripción: | Lee los próximos 'i' bytes desde el fichero
número 'fn'. Devuelve los bytes como una secuencia. La secuencia
será de longitud 'i', salvo cuando haya menos de los 'i' bytes
restantes a leer dentro del fichero. |
| Comentarios: | Cuando i > 0 y length(s)
< i, usted sabe que se alcanzó el fin del fichero. Eventualmente,
se devolverá una secuencia vacía
en 's'.
Esta función se usa normalmente con ficheros abiertos en modo binario "rb". Esto evita la situación confusa en el modo de texto donde DOS convierte el par CR LF a LF. |
| Ejemplo: | |
include get.e
integer fn
fn = open("temp", "rb") -- un fichero existente
sequence whole_file
whole_file = {}
sequence chunk
while 1 do
chunk = get_bytes(fn, 100) -- lee 100 bytes por vez
whole_file &= chunk -- chunk debería estar vacío, ok
if length(chunk) < 100 then
exit
end if
end while
close(fn)
? length(whole_file) -- debería coincidir el tamaño DIR de "temp"
| |
| Ver también: | getc, gets |
| Plataforma: | DOS32 |
| Sintaxis: | include image.e i = get_display_page() |
| Descripción: | Algunos modos gráficos en la mayoría
de las tarjets de video, tienen varias páginas de memoria. Esto
le permite escribir la salida de pantalla en una página, mientras
muestra otra diferente. get_display_page()
devuelve el número de página actual que se está mostrando
en el monitor. |
| Comentarios: | Las páginas activa y mostrada son 0 por defecto. video_config() le dirá cuantas páginas están disponibles en el actual modo gráfico. |
| Ver también: | set_display_page, get_active_page, video_config |
| Sintaxis: | i = get_key() |
| Descripción: | Devuelve la tecla que presionó el usuario,
sin esperar. Devuelve -1, si no se presionó ninguna tecla. Devuelve
los códigos especiales de las teclas de función, flechas
del cursor, etc. |
| Comentarios: | El sistema operativo puede mantener en el búfer
del teclado, una pequeña cantidad de tecleos. get_key()
devolverá el siguiente del búfer, o -1 si el búfer
está vacío.
Ejecute el programa key.bat para ver que código de tecla se genera para cada tecla de su teclado. |
| Ver también: | wait_key, getc |
| Plataforma: | DOS32, Linux |
| Sintaxis: | include mouse.e x1 = get_mouse() |
| Descripción: | Devuelve el último evento del ratón,
en la forma: {evento, x, y} o devuelve -1 si no ha habido ningún
evento del ratón, desde la última vez que se invocó
a get_mouse().
Las constntes definidas en mouse.e para los posibles eventos del ratón son: |
global constant MOVE = 1,
LEFT_DOWN = 2,
LEFT_UP = 4,
RIGHT_DOWN = 8,
RIGHT_UP = 16,
MIDDLE_DOWN = 32,
MIDDLE_UP = 64
| |
x e y son las coordenadas del puntero del ratón
en el momento en que ocurrió el evento. get_mouse()
inmediatamente devuelve tanto -1 como un evento del ratón. No espera
que ocurra un evento. Usted tiene que consultarlo bastante frecuentemente
para evitar perder algún evento. Al ocurrir el evento siguiente,
el evento actual se pierde, si no lo leyó. En la práctica,
no es difícil capturar la mayoría de los eventos. Perder
un evento MOVE, generalmente no están serio, ya que el siguiente
MOVE le dirá donde está el puntero del ratón.
A veces se informan varios eventos. Por ejemplo, si el ratón se está moviendo cuando se presiona el botón izquierdo, get_mouse() informará el valor de los eventos LEFT_DOWN+MOVE, es decir 2+1 o 3. Por esta razón, debería consultar un evento en particular usando and_bits(). Vea los ejemplos de más abajo. | |
| Comentarios: | En los modos de gráficos
de píxel que son de 320 píxeles de ancho, necesita
dividir el valor 'x' por 2 para conseguir la posición correcta
en pantalla (una característica extraña del DOS).
En los modos de texto de DOS32 necesita escalar las coordenadas x e y, para obtener las posiciones de línea y columna. En Linux, este escalamiento no se necesita - x e y corresponden a la línea y columna de la pantalla, donde (1,1) es la esquina superior izquierda. En DOS32, necesita un controlador de ratón DOS para usar esta rutina. En Linux, el servidor GPM tiene que estar corriendo. En Linux, los eventos de movimiento del ratón no se informan en una ventana xterm, solo en la consola de texto. LEFT_UP, RIGHT_UP y MIDDLE_UP no se distinguen unos de otros. Puede usar get_mouse() en la mayoría de los modos de texto y gráficos de píxel. La primera llamada que haga a get_mouse() activará el puntero del ratón o un caracter resaltado. El DOS generalmente no soporta el uso del ratón en los modos gráficos SVGA (más allá de 640x480 píxeles). Esta restricción se quitó en Windows 95 (DOS 7.0). Graeme Burke, Peter Blue y otros, han contribuido con rutinas de ratón que salvan los problemas de usar el ratón en SVGA. Vea la página web "Archivo" de Euphoria. Las coordenadas x, y devueltas pueden ser aquellas of the very tip of the mouse pointer o podrían referirse al píxel apuntado por el puntero del ratón. Probar si se está intentando leer un píxel usando get_pixel(). En su lugar, puede tener que leer x-1, y-1. |
| Ejemplo 1: | un valor de retorno de: |
{2, 100, 50}
| |
indicaría que se presionó el botón
izquierdo cuando el puntero del ratón estaba en la posición
x=100, y=50 de la pantalla. |
|
| Ejemplo 2: | Para probar LEFT_DOWN, escriba algo así: |
object event
while 1 do
event = get_mouse()
if sequence(event) then
if and_bits(event[1], LEFT_DOWN) then
-- se presionó el botón izquierdo
exit
end if
end if
end while
| |
| Ver también: | mouse_events, mouse_pointer, and_bits |
| Plataforma: | DOS32 |
| Sintaxis: | x = get_pixel(s) |
| Descripción: | Cuando 's' es una coordenada de pantalla de 2 elementos
{x, y}, get_pixel() devuelve
el color (un entero pequeño) del píxel en la pantalla de
gráficos de píxel en ese punto.
Cuando 's' es una secuencia de 3 elementos de la forma: {x, y, n}, get_pixel() devuelve una secuencia de 'n' colores para los puntos que comienzan en {x, y} y siguen a la derecha {x+1, y}, {x+2, y}, etc. Los puntos fuera de la pantalla tienen valores de color impredecibles. |
| Comentarios: | Cuando 'n' está especificado, se usa un algoritmo
muy veloz para leer los colores del píxel en pantalla. Es mucho
más rápido llamar a get_pixel()
una vez, especificando un valor grande para 'n', que llamarlo muchas veces
leyendo un color de píxel por vez. |
| Ejemplo: | |
object x
x = get_pixel({30,40})
-- x se establece al valor de color del punto x=30, y=40
x = get_pixel({30,40,100})
-- x se establece a una secuencia de 100 valores enteros, representando
-- los colores que empiezan en {30,40} y siguen hacia la derecha
| |
| Ver también: | pixel, graphics_mode, get_position |
| Sintaxis: | include graphics.e s = get_position() |
| Descripción: | Devuelve la línea y columna actuales de la
posición del cursor, como una secuencia de 2 elementos {línea,
columna}. |
| Comentarios: | get_position()
trabaja tanto en los modos de texto como los de
gráficos de píxel. En los modos
gráficos de píxel no se muestra el cursor, pero get_position()
devolverá la línea y la columna donde se mostrará
el próximo caracter.
El sistema de coordenadas para mostrar texto es diferente que el que se usa para mostrar píxeles. Los píxeles se muestran de modo tal que el superior izquierdo (x=0,y=0) y la primera coordenada controla la ubicación horizontal izquierda-derecha. En los modos de gráficos de píxel, se pueden mostrar tanto texto como píxeles. get_position() devuelve la línea y columna actuales para el texto que se está mostrando, no los píxeles que puede dibujar. No existe la rutina que obtiene la posición actual del píxel. |
| Ver también: | position, get_pixel |
| Plataforma: | DOS32, Linux, FreeBSD |
| Sintaxis: | include image.e s = get_screen_char(i1, i2) |
| Descripción: | Devuelve una secuencia 's' de 2 elementos, de la
forma {código ASCII, atributos} para el caracter en pantalla
de la línea 'i1', columna 'i2'. 's' está compuesto por dos
átomos. El primero es el código ASCII del caracter y el
segundo contiene los colores de frente y fondo del caracter y, posiblemente
otra información describiendo la apariencia del caracter en pantalla. |
| Comentarios: | Con get_screen_char()
y put_screen_char()
puede guardar y recuperar un caracter de la pantalla, junto con sus atributos. |
| Ejemplo: | |
-- lee el caracter y atributos de la esquina superior izquierda
s = get_screen_char(1,1)
-- almacena el caracter y atributos de la línea 25, columna 10
put_screen_char(25, 10, {s})
| |
| Ver también: | put_screen_char, save_text_image |
| Plataforma: | DOS32 |
| Sintaxis: | include machine.e s = get_vector(i) |
| Descripción: | Devuelve la dirección lejana (far) de modo
protegido actual del manejador de interrupción número 'i'.
's' será una secuencia de 2 elementos: {segmento de 16 bits,
offset de 32 bits}. |
| Ejemplo: | |
s = get_vector(#1C)
-- s tendrá la dirección lejana (far) del manejar de la interrupción del
-- timer, por ejemplo: {59, 808}
| |
| Programa de ejemplo: | demo\dos32\hardint.ex |
| Ver también: | set_vector, lock_memory |
| Sintaxis: | i = getc(fn) |
| Descripción: | Obtiene el siguiente caracter (byte) desde un fichero
o dispositivo 'fn'. El caracter tendrá un valor entre 0 y 255.
Al final del fichero se devuelve -1. |
| Comentarios: | Con getc(),
se usa un búfer a la salida del fichero, es decir, getc()
no va al disco por cada caracter. En su lugar, un gran bloque de caracteres
se leerán de una vez y se traerán uno por uno desde el búfer
de memoria.
Cuando getc() lee desde el teclado, no verá ningún caracter hasta que se presione Enter. Tenga en cuenta que el usuario puede escribir Ctrl+Z, que el sistema operativo interpreta como "fin de fichero". Se devolverá -1. |
| Ver también: | gets, get_key, wait_key, open |
| Sintaxis: | x = getenv(s) |
| Descripción: | Devuelve el valor de una variable del entorno. Si la variable está indefinida, devuelve -1. |
| Comentarios: | Debido a que se podrían devolver tanto una
secuencia como un átomo (-1), probablemente debería asignar
el resultado a una variable declarada como objeto. |
| Ejemplo: | |
e = getenv("EUDIR")
-- e será "C:\EUPHORIA" -- o tal vez D:, E: etc.
| |
| Ver también: | command_line |
| Sintaxis: | x = gets(fn) |
| Descripción: | Obtiene la próxima secuencia (una línea,
incluyendo '\n') de caracteres desde un fichero o dispositivo 'fn'. Los
caracteres tendrán valores entre 0 y 255. Al final del fichero
se devuelve el átomo -1. |
| Comentarios: | Debido a que se puede devolver tanto una secuencia
como un átomo (-1), probablemente debería asignar el resultado
a una variable declarada como objeto.
Después de leer una línea de texto desde el teclado, comúnmente debería emitir un caracter '\n', por ejemplo puts(l, '\n'), antes de imprimir alguna cosa. Solamente en la última línea de la pantalla el sistema operativo hace un desplazamiento de pantalla y avanza a la siguiente línea. La última línea de un fichero no debería terminar con el caracter '\n' (nueva línea). Al leer desde el teclado, el usuario puede escribir Ctrl+Z, que el sistema operativo interpreta como "fin de fichero". Se devolverá -1. En los modos SVGA, DOS puede establecer erróneamente la posición del cursor, después de llamar a gets(0) para leer el teclado. Debería establecerlo usando position(). |
| Ejemplo 1: | |
sequence buffer
object line
integer fn
-- lee un fichero de texto a una secuencia
fn = open("mifichero.txt", "r")
if fn = -1 then
puts(1, "No se puede abrir mifichero.txt\n")
abort(1)
end if
buffer = {}
while 1 do
line = gets(fn)
if atom(line) then
exit -- al final del fichero se devuelve -1
end if
buffer = append(buffer, line)
end while
| |
| Ejemplo 2: | |
object line puts(1, "¿Cual es tu nombre?\n") line = gets(0) -- lee la entrada estándar (teclado) line = line[1..length(line)-1] -- elimina el caracter \n del final puts(1, '\n') -- necesario puts(1, line & " es un bonito nombre.\n") | |
| Ver también: | getc, puts, open |
| Plataforma: | DOS32 |
| Sintaxis: | include graphics.e i1 = graphics_mode(i2) |
| Descripción: | Selecciona el modo gráfico 'i2'. Ver la lista
de modos gráficos válidos en graphics.e.
Si la operación resulta exitosa, 'i1' valdrá 0, en caso
contrario 'i1' valdrá 1. |
| Comentarios: | A algunos modos se los llama modos
de texto porque le permiten solamente mostrar texto. A los otros
modos se los llama modos de gráficos de píxel
porque pueden mostrar píxeles, líneas, elipses, así
como texto.
Como facilidad para sus usuarios, es buena idea regresar del modo de gráficos de píxel al modo de texto antes de terminar el programa. Puede hacer esto con graphics_mode(-1). Si un programa de gráficos de píxel deja su pantalla hecha un desorden, puede limpiarla con el comando CLS de DOS, o ejecutando ex o ed. Bajo ciertas condiciones, algunas tarjetas gráficas serán incapaces de entrar en algunos modos SVGA. No siempre puede decir desde el valor de 'i1', que la configuración del modo gráfico fue existosa. En las plataformas WIN32 y Linux/FreeBSD, graphics_mode() asignará una consola de modo texto plano si no existe ninguna aún. Devolverá 0, sin importar el valor pasado como 'i2'. |
| Ejemplo: | |
if graphics_mode(18) then
puts(SCREEN, "se necesitan gráficos VGA!\n")
abort(1)
end if
draw_line(BLUE, {{0,0}, {50,50}})
| |
| Ver también: | text_rows, video_config |