Introducción
EuWinGUI, como Andrea Cini, su autor, explica, provee de una via muy simple para la creación de aplicaciones en Euphoria que usen la interfaz gráfica de usuario de Windows.
En comparación con otras librerías con el mismo fin disponibles para este lenguaje, no posee tantas características ni controles, puesto que la intención de su diseño es facilitar la creación de programas simples de manera sencilla y rápida, no estando orientado para desarrollos sofisticados.
Como útil añadido, se acompaña de un IDE programado con dicha librería (Designer.exw), que permite la creación visual de la interfaz gráfica, generando el código básico en Euphoria. No es tán dinámico como el entorno de desarrollo de Delphi, pero no resulta difícil hacerse con su manejo. En definitiva, es una herramienta que cumple adecuadamente con su papel.
Algo a destacar es su solidez y, sobre todo, su buena documentación (la mejor de entre todas las soluciones para Euphoria que he podido probar). Una vez que se estudia con detenimiento esta librería, uno descubre que tiene más posibilidades de lo que a primera vista pudiera parecer.
Por último hacer notar que, como es habitual en las soluciones
gratuitas, el autor no se hace responsable de posibles daños que
pudieran ser imputados a su uso.
Instalación
Los pasos a seguir son sencillos: se descomprime el fichero EuWinGUI.zip; se copia EuWinGUI.dll y el icono que se acompaña en ...Euphoria\Bin\, y las librerías EuWinGUI.ew y EWGuties.ew en ...Euphoria\Include\. Las carpetas EWG-Docs, EWG-Demos y EWG-Designer (que contienen, respectivamente, la documentación de la librería, un nutrido elenco de programas de demostración y el diseñador visual de la GUI), pueden trasladarse donde más convenga.
Una vez realizados los pasos anteriores, basta con insertar al principio de nuestros programas include EuWinGUI.ew o include EWGuties.ew para disponer de sus funcionalidades.
En caso de distribuir programas confeccionados por nosotros, es necesario
asegurarnos de incluir la librería EuWinGUI.dll.
Ejemplo de funcionamiento
Con EuWinGUI no es necesario conocer los intrincados mecanismos de la
API de Windows. Para interactuar con nuestro programa, basta con comprobar
los valores de dos variables globales (llamadas Event y EventOwner)
que informan, respectivamente, sobre el último evento detectado
y el control que lo generó. Lo veremos más claro con un ejemplo
(Button.exw, situado en la carpeta EWG-Demos):
include EuWinGUI.ew
atom button1
procedure EventLoop()
while True do
WaitEvent()
if Event = Click then
if EventOwner = button1 then
InfoMsg("Programmed in Euphoria with the EuWinGUI Library!!", "EuWinGUI")
end if
end if
end while
end procedure
procedure WinMain()
Window("EuWinGUI - The First Program", 100, 100, 290, 95)
button1 = Control(Button, "Info", 5, 10, 270, 50)
SetIcon("EuWinGUI.ICO")
EventLoop()
CloseApp(0)
end procedure
WinMain()
Examinemos el código.
- Con include añadimos la librería al programa.
- El átomo button1 sirve para almacenar el identificador del control creado, un simple botón. Si se necesitaran más controles habrían de añadirse más variables, una por cada control creado.
- El procedimiento EventLoop() es el corazón del sistema. Dentro de él se comprueba qué evento (o sea, qué acción generada por la interacción del usuario con la interfaz del programa) ha ocurrido en nuestra aplicación. Este procedimiento ha de ejecutarse completo, no debiendo usarse return para salir de él salvo cuando se desee finalizar la ejecución del programa.
- La sentencia while True do asegura que el código del bucle (que comprueba los eventos) se repita continuamente.
- El procedimiento WaitEvent() es uno de los más importantes de toda la librería. Su cometido es pasar el control del flujo del programa a Windows y no retornar hasta que ocurra uno de los eventos reconocidos. Cuando uno de estos eventos tiene lugar, pasa a la variable global Event el tipo de evento; y a la variable EventOwner el identificador del control que lo ha "disparado", devolviendo el control al programa.
- if Event = Click then comprueba si el evento ocurrido ha sido la pulsación del botón izquierdo del ratón.
- if EventOwner = button1 then comprueba si el evento registrado por WaitEvent() tuvo a button1 como origen. En caso afirmativo mostrará un mensaje usando el procedimiento InfoMsg().
- El bucle se repetirá hasta que se pulse el botón de cierre ("X") de la barra de título de la ventana principal, o, como ya se indicó antes, mediante la instrucción return.
- Dentro del procedimiento WinMain() se construye la interfaz del programa (la ventana principal, los controles dependientes de ella, etc...), se asignan valores específicos a los controles (si es preciso), y finalmente se invoca al procedimiento EventLoop() para ejecutar la comprobación de eventos.
- El procedimiento Window() es el primero en ser usado para crear la interfaz de la aplicación. Crea la ventana principal (y, en este caso, única) del programa, con el título deseado (en este caso: "EuWinGUI - The First Program"), la posición de la ventana (100, 100), y sus dimensiones (290 pixels de ancho y 95 de alto). No podrán añadirse controles hasta que se ejecute este procedimiento. Una vez se ha creado la ventana, el procedimiento almacena en la variable global WinHwnd el identificador de la misma. Esta variable puede ser usada posteriormente por las funciones y procedimientos EuWinGUI que necesiten este parámetro.
- La sentencia button1 = Control(Button, "Info", 5, 10, 270, 50) invoca a la función Control(). Esta función crea un nuevo control del tipo especificado, con un título determinado, y una posición (relativa al area cliente de la ventana principal) y unas dimensiones específicas, devolviendo el identificador del control creado.
- SetIcon() asigna el icono que aparecerá en la barra de título de la ventana principal. Si no se usa este procedimiento, el icono por defecto del programa será el de Euphoria.
- La sentencia EventLoop() llama a dicho procedimiento para comenzar el bucle de comprobación de eventos.
- CloseApp(0) cierra la aplicación una vez se ha abandonado el procedimiento EventLoop(), liberando todos los recursos creados por EuWinGUI durante la ejecución del programa. Si un programa se cierra sin llamar a este procedimiento (por ejemplo, mediante la invocación del comando de Euphoria abort()), los recursos usados por la aplicación quedarían sin liberar y, por lo tanto, no podrían ser reutilizados por el sistema, por lo que ha de tenerse especial cuidado en este punto. Si se pulsa el botón de cierre por defecto ("X") de la ventana principal y la variable global CloseEventEnabled contiene False (valor por defecto), EuWinGUI liberará automáticamente la memoria; pero si el valor es True y/o se añade una vía alternativa para cerrar la aplicación (por ejemplo, mediante un botón habilitado al efecto, como puede verse en la demo "TwoButtons.exw"), el procedimiento CloseApp() debe ser usado para finalizar el programa.
- Por último, la instrucción WinMain() inicia la
ejecución del programa.
Aplicaciones EuWinGUI con múltiples ventanas
Crear aplicaciones con múltiples ventanas en EuWinGUI es tan fácil como crear aplicaciones con una sola ventana, y no existen diferencias entre la manera en que se procesan los eventos producidos por los controles de diferentes ventanas con los de la ventana principal.
Para crear una ventana "hija" después de la ventana principal, se usa la función Control() con Dialog como tipo de control. La ventana se creará con el estilo actualmente seleccionado en la variable global WindowType, exactamente igual que cuando se crea la ventana principal con el procedimiento Window(), por lo que es posible crear ventanas "hijas" con diferentes estilos símplemente cambiando el valor de WindowType antes de llamar a la función Control() para crearlas.
El procedimiento SetParentWindow() se usa para indicar el "propietario" de los controles que se creen subsecuentemente con la función Control(), hasta que una nueva llamada a dicho procedimiento lo cambie.
Puesto que las ventanas creadas como Dialog son siempres "hijas" de la ventana principal, al solaparse ambas esta última puede quedar parcial o totalmente cubierta. Si se necesita crear una aplicación con múltiples ventanas que siempre deban estar completamente visibles si se activan, existe una técnica muy simple que solventa este problema con tres líneas de código, y que se mostrará más tarde.
Lo único que se debe recordar cuando se use Dialog es el hecho de que, a menos que la variable global CloseEventEnabled se fije a True, si el usuario pulsa en el botón de cierre por defecto de la ventana "hija" ("X"), toda la aplicación se cerrará como si se hubiera pulsado el mismo botón de la ventana principal. Para evitar esto, se pone a True la variable CloseEventEnabled y se procesa el evento Close para hacer invisible la ventana "hija" usando la función SetVisible().
Un repaso a los programas de demostración ayudará a clarificar
todo esto.
Operaciones en segundo plano
EuWinGUI proporciona un sistema para poder ejecutar operaciones en segundo plano mientras se espera a que el usuario genere algún evento, y evitando además que el programa quede "congelado" mientras terminan dichas operaciones. Esto se consigue con las rutinas IsEventWaiting() y ProcessEvent().
IsEventWaiting() comprueba la existencia de algún evento (ya sea de la librería o del sistema) pendiente de ser procesado y devuelve True en caso afirmativo. ProcessEvent(), por su lado, es una especie de clónico de WaitEvent() con una simple (pero importante) diferencia: WaitEvent() establece el valor de las variables globales Event, EventOwner y EventItem, y retorna SOLO si se reconoce algún evento de los recogidos en la librería EuWinGUI; ProcessEvent(), sin embargo, TAMBIÉN retorna aunque NO hayan eventos pendientes de procesar, en cuyo caso Event, EventOwner y EventItem se establecen a cero.
Veamos un ejemplo de funcionamiento. Para ello, modificaremos el programa
anteriormente descrito de la siguiente forma:
include EuWinGUI.ew
atom button1
function eventoSalida()
while IsEventWaiting() do -- si existen eventos por procesar ...
ProcessEvent() -- ... se capturan
if (Event = Key) and (EventItem = KEY_ESCAPE) then -- si pulsamos ESC ...
return True -- ... lo indicamos
end if
end while
return False -- la tecla pulsada no era ESC. No se abandonará el proceso.
end function
function procesoInterminable()
while True do -- bucle infinito que representa un proceso muy largo
if eventoSalida() then exit end if -- ***
end while
return True
end function
procedure EventLoop()
while True do
WaitEvent()
if Event = Click then
if EventOwner = button1 then
if procesoInterminable() then return end if
end if
end if
end while
end procedure
procedure WinMain()
Window("EuWinGUI - The First Program", 100, 100, 290, 95)
button1 = Control(Button, "Info", 5, 10, 270, 50)
SetIcon("EuWinGUI.ICO")
EventLoop()
CloseApp(0)
end procedure
WinMain()
El código se explica bastante bien por sí mismo. Cabe hacer
notar que, de eliminarse (o comentarse) la línea marcada con tres
asteriscos, al pulsar el botón (button1) el programa se "congelaría"
al quedar atrapado en un bucle infinito, no permitiendo cosas como, por
ejemplo, mover la ventana, ya que es necesario invocar a ProcessEvent()
para que de curso a los eventos propios del sistema.
En este punto alguien podría preguntarse por qué mantener
WaitEvent(),
si ProcessEvent() hace lo mismo. La respuesta es que WaitEvent()
es mucho más eficiente en los casos en que no existen estos tipos
de tareas pesadas, consumiendo poquísimos recursos, al contrario
de lo que ocurre con ProcessEvent(). De ahí que la solución
ideal sea la mostrada en el programa de ejemplo: usar ProcessEvent()
sólo dentro de las rutinas pesadas para dar salida a los eventos
producidos.
Sección gráfica
Las aplicaciones EuWinGUI pueden usar las mismas funciones gráficas de dos modos diferentes: dibujando directamente sobre la superficie de cualquier control, en cuyo caso primero ha de usarse SetDrawingControl() para indicar el control sobre el que se va a dibujar; o dibujando sobre un Memory Bitmap y, después, mostrándolo sobre un control Picture, en cuyo caso deberá usarse primero SetDrawingMB() para indicar sobre qué Memory Bitmap se va a dibujar.
El primer método es util para añadir elementos gráficos estáticos en los controles existentes. El inconveniente es que, cada vez que el sistema operativo tiene que redibujar la interfaz, estos elementos gráficos se borran, por lo que se ha habilitado SetDrawingProc(), el cual indicará el procedimiento que contendrá las instrucciones que permitirán redibujar los elementos gráficos estáticos cada vez que sea necesario.
Este método no es adecuado cuando el dibujo es muy complejo,
cambia con el tiempo o forma parte de una animación. En estos casos,
una solución más práctica es usar el segundo método
implementado por EuWinGUI, esto es, dibujar sobre un bitmap en memoria
(Memory Bitmap), y mostrarlo luego en un control. Puesto que el bitmap
es asignado a un control Picture, no se necesita una rutina que actualize
constantemente ya que esta tarea es automáticamente realizada por
el sistema operativo. Se puede crear un Memory Bitmap directamente en memoria
usando la función NewMB(), o puede ser un bitmap cargado
usando la función LoadPic(); en estos casos, el identificador
del nuevo bitmap, creado o cargado, puede usarse con SetDrawingMB()
para indicarlo como el bitmap activo actual sobre el que van a actuar las
funciones de dibujo, y pude ser asignado a un control de la clase Picture
usando el procedimiento SetPic(). Es posible copiar una porción
de un bitmap a otro usando el procedimiento CopyMB(); o directamente
sobre la superficie de un control usando CopyMBToControl(). Esta
última función es muy útil puesto que permite copiar
inmediatamente un bitmap sobre un Control sin esperar a que lo haga el
sistema operativo, evitando el parpadeo en juegos y animaciones.
Imprimiendo con EuWinGUI
EuWinGUI incluye un conjunto básico de instrucciones que puede ser usado en tiempo de ejecución por cualquier programa para obtener copias en papel de texto o gráficos, en una impresora física o virtual. La impresión se realiza de forma parecida a como se dibuja en un Memory Bitmap, con algunas diferencias que se detallan a continuación.
Antes de usar estas funciones, primero es necesario seleccionar una impresora (física o virtual), con el procedimiento SelectPrinter(), al cual se le pasa como argumento True o False: True para indicar que se va a usar la impresora determinada por defecto, y False para que se use el cuadro de diálogo que permite seleccionarla.
Una vez seleccionada la impresora, se debe usar NewDocument() para crear un documento de impresión. Esta función acepta un nombre de documento, que sólo servirá para identificarlo en la cola de impresión.
Un documento puede tener cualquier número de páginas. Cuando se crea un documento, se crea también una página, aunque se pueden añadir más usando NewPage(). Al usar este procedimiento, la página en uso se "cierra" y envía al buffer de memoria de la impresora, y se crea una nueva en blanco que será la que reciba ahora las instrucciones de confección de página.
Una página en blanco se asemeja a un Memory Bitmap en blanco, con una cierta anchura y altura en pixels (constantes para todas las páginas del mismo documento) que sólo dependen de la impresoa seleccionada y sus ajustes. Es posible conocer la anchura y altura de la página usando la función GetPageSize() y especificando en el argumento lo que queremos saber (X_DIM o Y_DIM). Esta función puede ser usada también para averiguar si se ha seleccionado una impresora, ya que, de no ser así, devolverá como valor de retorno 0 (cero).
Una vez se sepan las dimensiones de página, podemos comenzar a "dibujar" texto usando el procedimiento PrintString(), que funciona exactamente igual que DrawString() (usada para "dibujar" texto en un Memory Bitmap). Se pueden conocer las dimensiones en pixels de una cadena de texto usando la función GetPrinterStringSize() (similar a GetStringSize()) para, por ejemplo, centrarla, o determinar el interlineado, con unos simples cálculos.
Es posible establecer la fuente y el color a usar para imprimir una cadena de texto usando SetPrinterFont() y SetPrinterPenColor(). Las fuentes a usar deben ser creadas antes con la función NewFont(). Asimismo es posible imprimir Memory Bitmaps, o ficheros BMP cargados de disco, en una posición dada, usando PrintMB().
Una vez se han creado todas las páginas, el procedimiento StartPrinting() cierra el documento y lo envía a la impresora.
Es importante hacer notar que el tamaño final (en "puntos lógicos")
de una misma fuente varía dependiendo del dispositivo que se va
a usar y de sus parámetros: no solo cambia completamente de la pantalla
a la impresora, sino que también cambia de una impresora a otra
(o de una pantalla a otra, dependiendo del tema de escritorio utilizado).
Así, por ejemplo, mientras que la anchura de la pantalla es normalmente
de 1024 o 1280 pixels, la anchura de papel habitualmente utilizada puede
exceder fácilmente los 4000 puntos; por lo que ha de tenerse esto
en cuenta al dimensionar nuestras fuentes para impresión, si lo
que deseamos es que tengan un aspecto lo más parecido a como aparecen
en pantalla. Véase el programa de demostración "Printing.exw"
para estudiar un ejemplo práctico de todo lo anteriormente explicado.
La librería de utilidades EWGuties.ew
Contiene una serie de útiles funciones y procedimientos que permiten
hacer más fácil y rápida la creación de aplicaciones
EuWinGUI. Puesto que esta librería contiene al principio EuWinGUI.ew,
no es necesario incluir esta cuando se usa aquella.
Preguntas más frecuentes
Pregunta: ¿Por qué están solo disponibles los tipos de eventos más comunes?
Respuesta: Porque el autor intenta mantener la librería lo más pequeña y sencilla posible, reduciendo el número de controles al mínimo (existen otras librerías más potentes y pesadas, si se necesitan). Por la misma razón, EuWinGUI no implementa directamente atajos de teclado (aunque se pueden simular con facilidad). No obstante, se pueden añadir eventos adicionales usando procedimientos y funciones de bajo nivel, como TrapMessage(), Message() y GetTrappedMessage(), aunque se requiere un buen conocimiento de Windows para usarlos.
P: ¿Por qué están solo disponibles un limitado conjunto de controles?
R: Ya se explicó en la anterior pregunta. No obstante, controles como las barras de progreso, las listas desplegables, las barras de estado y otros, pueden ser simulados con los controles disponibles (como se puede comprobar en algunos de los programas de ejemplo que acompañan a la librería).
P: He creado un control PictureButton, pero no aparece nada en el ¿por qué?
R: Para que se muestre un dibujo o icono en el botón, dicha imagen (en formato BMP) ha de serle asignada con el procedimiento SetPicture().
P: He creado un control Picture o ClickPicture, pero no aparece nada en la ventana ¿por qué?
R: Picture y ClickPicture (al igual que los controles PictureButton y PicturePushButton), cuando se crean, están "vacios" inicialmente. Esto hace que sean, en principio, "invisibles", hasta que se les asigne una imagen BMP con SetPicture(). Hay que hacer notar que, independientemente de las dimensiones asignadas al crear estos controles, siempre se redimensionarán al tamaño de la imagen cargada, pudiéndose cambiar dicho tamaño usando SetDim(), lo que hará que dicha imagen se ajuste a las nuevas dimensiones. Señalar también que ClickPicture no responderá al evento Click hasta que no se cargue una imagen en él y se haga, así, "visible".
P: Uso una función EuWinGUI y, aunque el intérprete Euphoria no encuentra ningún error de sintaxis, no funciona ¿por qué?
R: Alguno de los argumentos usados no es válido. Es conveniente comprobar siempre la validez de los parámetros utilizados.
P: Intercepto el evento Click de un control Edit, pero, después de realizar las acciones deseadas, el control no recibe el foco y no puedo escribir sobre él ¿por qué?
R: Al interceptar el evento Click de un control Edit podemos "romper" el proceso normal de Windows y hacer que este pierda el foco. Así, para recuperarlo, una vez realizadas las acciones que dan lugar a esta pérdida de foco, usaremos el procedimiento Active().
P: Deseo usar una imagen de fondo para la ventana, así que uso un control ClickPicture que cubre todo el area cliente de la misma. Añado controles (como botones y cosas así) "sobre" la imagen pero no responden a los clicks del ratón ¿por qué?
R: En caso de que varios controles se solapen el evento Click es capturado preferentemente por el control ClickPicture. Para poner una imagen de fondo debe usarse el control Picture, que no responde a eventos.
P: He diseñado un programa EuWinGUI que inicia una aplicación externa usando las funciones system()/system_exec() de Euphoria, pero el interfaz de mi programa aparece borrado y no responde hasta que la aplicación externa finaliza, ¿qué puedo hacer?
R: system() y system_exec() rompen la función de redibujado automático normal de EuWinGUI. Para iniciar una aplicación externa debe usarse la función EuWinGUI RunApp(), que funciona igual pero con ciertas ventajas, como, por ejemplo, la de ejecutar directamente no sólo ficheros EXE, COM o BAT, sino cualquier fichero que tenga una extensión asociada a una aplicación; o, también, abrir directorios. El programa de demostración "Runner.exw" usa esta función para trabajar.
P: Hago click sobre un control del tipo List, pero no responde a este evento. ¿Cual es el problema?
R: Probablemente no se ha hecho click sobre un item del control. Si se hace click sobre una lista vacia o no se pulsa sobre uno de sus items, el sistema operativo no genera el evento Click. El motivo es que este evento del control List generalmente sólo sirve para saber si el índice de la lista ha cambiado, razón por la cual el evento Click se genera también si se cambia el índice usando las flechas del teclado.
P: He añadido dos grupos de botones de Radio, pero no funcionan como era de esperar: si hago click en uno de los botones de un grupo, todos los demás se desmarcan, incluso los del otro grupo ¿por qué?
R: Puesto que cada botón de Radio que se añada es un control hijo de la ventana, Windows los trata como si pertenecieran todos al mismo grupo. Si se necesita más de un grupo de botones de radio, debe usarse el control SimRadio, que no está controlado automáticamente por el sistema operativo, y procesaremos el evento Click para marcar y desmarcar los botones requeridos con el procedimiento SetCheck(). El programa de demostración "RadioGroups.exw" es un ejemplo de lo dicho.
P: Mi aplicación usa bastante el procedimiento SetPicture() para cargar imágenes en tiempo de ejecución. Funciona bien, pero, después de cierto número de cargas, deja de poder cambiarse las imágenes y al intentar cerrar el programa aparece el mensaje "out of memory error". ¿Qué ocurre?
R: El procedimiento SetPicture() carga una imagen bitmap en memoria, devolviendo el identificador de la imagen y almacenándolo en la variable global PictureHandle, y finalmente la asigna al control especificado. La memoria usada no vuelve a estar disponible hasta que finalice el programa o sea liberada con DeleteImage(). Si han de cambiarse imágenes en tiempo de ejecución, o cargar varias veces la misma imagen, lo apropiado sería utilizar la función LoadPic() para este menester, y usar SetPic() para asignarlo al control correspondiente, e ir borrando las imágenes que ya no se necesiten con DeleteImage().
P: Necesito crear una aplicación multiventana en la que estas estén siempre completamente visibles cuando estén activas. Pero la ventana principal, aunque esté activa, siempre se ve cubierta por las ventanas Dialog que se solapen con ella ¿cómo puedo conseguirlo?
R: No hay forma de que la ventana principal se vea por encima
de una Dialog, ya que esta última se crea como un control
hijo de la primera y el sistema operativo le da precedencia en la visualización.
Una técnica sencilla de solventar esto es crear (y no usar) la ventana
principal, y utilizar únicamente ventanas Dialog, ya que,
al tener la misma precedencia "visual", siempre se mostrarán completamente
visibles cuando se activen. El código siguiente consigue esto mismo:
WindowType = NoBorderWin
Window("",0,0,0,0)
WindowType = NoMaxWin
window1 = Control(Dialog, "Una ventana",....)
window2 = Control(Dialog, "Otra ventana",....).
SetParentWindow(window1)
control1 = Control(....)
SetParentWindow(window2)
control10 = Control(....)
Puede observarse que la ventana principal se crea sin bordes y con
anchura y altua cero (es decir, que la ventana está pero no puede
verse), y que se crean dos ventanas Dialog. Nótese que, aunque
no pueda verse, la ventana principal existe y, por tanto, puede interceptar
como siempre los eventos HotKey y Timer.
P: Deseo crear un Memory Bitmap para usarlo con un PictureButton. ¿Cual es la forma de usar UseTransparentPics para hacer su color de fondo transparente?
R: UseTransparentPics no tiene efecto con las imágenes creadas usando NewMB(), pero puede mostrarse un Memory Bitmap con un color de fondo "transparente" fijando el color de pluma igual que el color del botón (usando GetPixelColor() cuando el botón sea visible), y creando después el bitmap, cuyo "lienzo" tendrá el mismo color de fondo que el usado por el sistema operativo para dibujar los botones.
P: Intento imprimir el mismo documento por dos impresoras distintas, pero los resultados obtenidos son completamente diferentes en cuanto a dimensión de fuentes y líneas por página. ¿Alguna ayuda?
R: Cada impresora tiene unos ajustes y características distintas, por lo que el programador deberá utilizar la rutina de la librería EWGuties.ew GetFontLines(), que crea y devuelve el identificador de una fuente acorde con el nombre de familia y los atributos especificados que se usará como fuente de impresión con SetPrinterFont(), con lo que cada página impresa tendrá un número de líneas lo más cercano posible al valor deseado, para cualquier impresora que sea seleccionada para imprimir el documento.
Nota: Recuérdese que la aparicencia gráfica de
nuestras aplicaciones cambiará dependiendo de los parámetros
del sistema operativo del usuario. En particular, si programamos en un
sistema que usa Small Fonts y luego el usuario utiliza Large Fonts (o viceversa),
el aspecto de los controles que utilicen títulos (Buttons,
Texts,
Labels,
etc.) puede ser muy distinto debido a la diferencia en el tamaño
de la fuentes. Por eso es conveniente probar los programas en sistemas
que usen diferentes fuentes y tamaños.
Apéndice A: Variables globales EuWinGUI.
atom Event
almacena el último typo de evento registrado después de volver del procedimiento WaitEvent().
atom EventOwner
almacena el identificador del control que ha producido el último evento registrado después de volver del procedimiento WaitEvent().
atom EventItem
guarda un valor adicional asociado a ciertos tipos de eventos tras retornar del procedimiento WaitEvent(); por ejemplo, el código de caracter de la tecla pulsada cuando ocurre un evento Key.
atom UserTrap
se establece a True cada vez que un "mensaje atrapado" es pasado al procedimiento TrapMessage() por la librería, y ocasiona que se retorne de WaitEvent() para poder manejarlo.
atom WinHwnd
almacena el identificador de la ventana principal tras ser creada usando el procedimiento Window().
atom PictureHandle
guarda el identificador del último bitmap cargado después de una llamada al procedimiento SetPicture() (puede ser NULL si el procedimiento falló). El identificador de un bitmap puede ser utilizado con SetPicture() para cargarlo múltiple veces en el mismo o diferente control sin usar memoria adicional, o con DeleteImage() para liberar la memoria usada cuando el bitmap ya no se necesite.
atom CloseEventEnabled
inicialmente tiene el valor False. Si se establece a True antes de comenzar el bucle de eventos, permite generar el evento Close si el usuario hace click en el botón de cierre de la ventana, y, por tanto, realizar las acciones que se precisen antes de que la aplicación finalice (y hay que recordar terminar estas acciones con una llamada al procedimiento CloseApp() para liberar los recursos utilizados por EuWinGUI). También permite ocultar una ventana Dialog en aplicaciones multiventana.
atom UseTransparentPics
inicialmente tiene el valor False. Si se establece a True antes de usar el procedimiento SetPic(), permite usar el color del pixel superior izquierdo del bitmap cargado desde un fichero como "color transparente". De esta manera, todos los pixels de la imagen que tengan este color serán reemplazados por el color de superficie de la ventana, con lo que es posible cargar en los controles Picture, ClickPicture y PictureButton imágenes con un color de fondo "transparente". Esto no se aplica a los bitmap creados en memoria usando NewMB().
atom WinOnTop
inicialmente tiene el valor False. Establézcase a True antes de usar el procedimiento Window() si se necesita crear una ventana principal que siempre se encuentre en primer plano.
atom WindowType
inicialmente tiene el valor NoMaxWin. Úsese esta variable para establecer la apariencia (o estilo) de la ventana principal o de las ventanas Dialog. Ha de establecerse el valor requerido antes de usar los procedimientos Window() o la función Control(Dialog,....). Estos son los estilos disponibles:
NoMaxWin - por defecto; ventana con barra de título, botones minimizar y cerrar, y borde sólido.
NoMaxMinWin - ventana con barra de título, botón de cierre y borde sólido.
NoSysWin - ventana con barra de título, sin botones activos, y borde sólido.
NoTitleWin - ventana sin barra de título y borde sólido.
NoBorderWin - ventana plana sin borde ni barra de título.
Nota:
1 - las ventanas creadas con los estilos NoTitleWin o NoBorderWin, al no tener la barra de título, no pueden ser movidas por el usuario mediante el procedimiento habitual (aunque sí puede hacerse por programa).
2 - los programas que usan una ventana principal creada con un estilo que carezca de botón de cierre, DEBEN proveer de un método alternativo para finalizar su ejecución. La librería EWGuties.ew contiene un procedimiento (CloseAppOnEscape()) que permite hacer esto.
atom ShowFlag
inicialmente tiene el valor True. Por defecto, la ventana principal y todos sus controles son mostrados inmediatamente después de su creación. Si se establece a False antes de la creación de la ventana principal o cualquier control, es posible crearlos inicialmente ocultos. Para hacerlos visibles es necesario llamar al procedimiento SetVisible(). Por ejemplo, si una ventana usa muchos controles, el crear la interfaz podría llevar un poquito de tiempo, produciéndose un efecto de "parpadeo". Así pues, estableceremos esta variable a False antes del procedimiento Window(), y a True antes de la creación de los controles, haciéndose todo visible tras su construcción mediante una llamada a SetVisible(WinHwnd,True), y evitándose de ese modo el antiestético parpadeo.
atom MouseX, MouseY
almacena las coordenadas del puntero, relativas a la esquina superior izquierda del area cliente del control, tras la ocurrencia de un evento de ratón reconocido (o sea, Click, Release, RClick, RRelease y Move, si el control es la ventana principal o una ventana Dialog; o el evento Move, si se trata de cualquier otro control).
Nota: el evento Move, producido al mismo tiempo que se mantiene pulsado uno de los botones del ratón, se mantiene activo incluso cuando se superan los límites de la ventana. Así pues, deben controlarse los valores devueltos por este evento para asegurarse de que estén dentro de lo requerido.
atom Ticks
contiene el número de eventos Time generados y no procesados
mientras una caja de mensaje o diálogo de fichero se esté
mostrando, ya que el uso de estos (InfoMsg(), WarnMsg(),
AskMsg(),
FileDlg())
produce una "congelación" temporal de la aplicación, suspendiendo
la generación de eventos hasta que se cierren. Esto significa que,
si se usa el Timer, todos los eventos
Time generados mientras se
muestren estos cuadros y diálogos se perderían. Esta variable
global guarda los eventos Time generados y no procesados, permitiendo
a la aplicación actualizarse como sea necesario.
Apéndice B: Tipos de control EuWinGUI.
Dialog (ventana hija)
Button (botón con leyenda)
PushButton (botón con leyenda que puede mostrarse pulsado o no pulsado)
PictureButton (botón con imagen en vez de leyenda)
PicturePushButton (botón con imagen en vez de leyenda que puede mostrarse pulsado o no)
Edit (campo editable con desplazamiento de texto horizontal)
MultiEdit (campo editable multilinea con desplazamiento de texto horizontal)
SimEdit (campo editable con longitud de texto fija)
SimMultiEdit (campo editable multilinea con longitud de texto fija)
Check (caja de marcación automática con leyenda)
SimCheck (caja de marcación NO automática con leyenda)
Radio (botón de marcación automática con leyenda)
SimRadio (botón de marcación NO automática con leyenda)
Text (texto estático alineado a la izquierda)
FramedText (texto estático alineado a la izquierda y con borde)
Label (texto estático centrado)
ClickText (texto estático alineado a la izquierda pulsable)
ClickLabel (texto estático centrado pulsable)
Group (caja de agrupación no pulsable)
Picture (control que puede mostrar una imagen y que no es pulsable)
ClickPicture (control que puede mostrar una imagen y que sí es pulsable)
List (caja de lista)
SortedList (caja de lista ordenada)
SimMultiList (caja de lista horizontal multicolumna no desplazable)
SelectList (caja de lista que permite seleccionar múltiples lineas pulsando las tecla CTRL o SHIFT al tiempo que se hace click con el ratón)
SortedSelectList (versión ordenada de SelectList)
Apéndice C: Tipos de evento EuWinGUI.
Click
reconocido/generado por: todas las ventanas y controles EXCEPTO Group, Picture, Framed/Text y Label.
cuando: uno de los controles especificados es clickado con el botón izquierdo del ratón. Si el control es una ventana, el evento es generado cuando el botón es pulsado; en otro caso, cuando el botón es soltado.
Move
reconocido/generado por: todas las ventanas y controles EXCEPTO Group, Picture, Framed/Text y Label.
cuando: el puntero del ratón es movido por el area cliente de uno de los controles especificados que no esté cubierto por otros.
Release
reconocido/generado por: todas las ventanas.
cuando: el botón izquierdo del ratón es soltado después de haber sido pulsado sobre una ventana.
RClick
reconocido/generado por:todas las ventanas y controles EXCEPTO Group, Picture, Framed/Text y Label.
cuando: el botón derecho del ratón es pulsado sobre una ventana. Nota: la captura de este evento puede incidentalmente romper el manejo normal del mismo por Windows. Por ejemplo, interceptando el evento RClick de un campo Edit es posible que el menú contextual de Windows no se muestre. Así pues, hay que tener cuidado cuando se desee que el control propietario mantenga su comportamiento por defecto.
RRelease
reconocido/generado por:todas las ventanas y controles EXCEPTO Group, Picture, Framed/Text y Label.
cuando: el botón derecho del ratón es liberado después de haber sido pulsado sobre una ventana.
DClick
reconocido/generado por:List, SortedList y SimMultiList.
cuando: cuando se hace doble click con el botón izquierdo del ratón sobre uno de estos controles.
Key
reconocido/generado por:todas las ventanas y controles EXCEPTO Group, Click/Picture, Framed/Click/Text y Click/Label.
cuando: un control tiene el foco y se pulsa cualquier tecla. El código del caracter de la tecla pulsada se guarda en la variable global EventItem. Todas las teclas representables en pantalla y varias no representables pueden generar este evento (ver el Apéndice D).
HotKey
reconocido/generado por:todas las ventanas y controles EXCEPTO Group, Click/Picture, Framed/Click/Text y Click/Label.
cuando: cada vez que se pulse la tecla de tabulación cuando uno de estos controles tenga el foco.
Restore
reconocido/generado por:todas las ventanas.
cuando: cuando se restaure una ventana desde la barra de tareas.
Close
reconocido/generado por:todas las ventanas.
cuando: la variable global CloseEventEnabled esté establecida en True y el usuario pulse el botón de cierre de la ventana.
Time
reconocido/generado por:la ventana principal.
cuando: cada N milisegundos, según se haya establecido
mediante el procedimiento SetWinTimer(N).
Apéndice D: Otras constantes globales EuWinGUI.
True = 1
False = 0
Banderas (flags) a usar como parámetros de la función FileDlg()
Save
Open
Banderas a usar como parámetros de las funciones GetStringSize() y GetPrinterStringSize()
X_DIM (la anchura de la cadena de caracteres)
Y_DIM (la altura de la cadena de caracteres)
Estilos de ventana - a usar con la variable global WindowType
NoMaxWin
NoMaxMinWin
NoSysWin
NoTitleWin
NoBorderWin
Identificadores de fuente por defecto - a usar con los procedimientos SetFont() y SetPrinterFont()
FN_DEFAULT (fuente del sistema por defecto de anchura variable)
FN_FIXED (fuente del sistema por defecto de anchura fija)
Indentificadores de cursor por defecto - a usar con el procedimiento SerCurs()
CR_WE (flecha doble este-oeste)
CR_NS (doble flecha norte-sur)
CR_SIZE (flecha de cuatro direcciones)
CR_VARROW (flecha vertical)
CR_WAIT (reloj de arena)
CR_NULL (cursor invisible)
Colores - a usar con los procedimientos SetPenColor(), SetPrinterPenColor() y SetColor()
CL_WHITE (blanco, #FFFFFF)
CL_GRAY (gris, #C0C0C0)
CL_DKGRAY (gris oscuro, #808080)
CL_BLACK (negro, #000000)
CL_YELLOW (amarillo, #00FFFF)
CL_DKYELLOW (amarillo oscuro, #008080)
CL_RED (rojo, #0000FF)
CL_DKRED (rojo oscuro, #000080)
CL_GREEN (verde, #00FF00)
CL_DKGREEN (verde oscuro, #008000)
CL_CYAN (cian, #FFFF00)
CL_DKCYAN (cian oscuro, #808000)
CL_BLUE (azul, #FF0000)
CL_DKBLUE (azul oscuro, #800000)
CL_PURPLE (púrpura, #FF00FF)
CL_DKPURPLE (púrpura oscuro, #800080)
CL_DEFAULT (pseudocolor, para usar como argumento únicamente con el procedimiento SetColor(). Establece el color por defecto del sistema)
Códigos de teclado no imprimibles - a usar con el procedimiento IsKeyPressed() y el evento Key
KEY_ENTER
KEY_BACKSPACE
KEY_ESCAPE
KEY_DOWN
KEY_UP
KEY_LEFT
KEY_RIGHT
KEY_CLEAR
KEY_PAUSE
KEY_CAPSLOCK
KEY_PGUP
KEY_PGDN
KEY_END
KEY_HOME
KEY_INS
KEY_DEL
Apéndice E: Funciones y procedimientos EuWinGUI.
Activate(control)
ActivateText(control)
atom AskMsg(mensaje, título)
CloseApp(código de retorno)
atom Control(tipo de control, título, posición x, posición y, ancho, alto)
CopyMB(imagen de origen, posición x, posición y, ancho, alto, imagen de destino, posición xd, posición yd)
CopyMBToControl(imagen de origen, posición x, posición y, ancho, alto, control de destino, pos x, pos y)
DeleteImage(identificador)
DrawLine(inicio x, inicio y, final x, final y)
DrawMultiLine(líneas a dibujar)
DrawPoint(posición x, posición y)
DrawPolygon(puntos, bandera de relleno)
DrawString(posición x, posición y, texto)
sequence FileDlg(bandera, fichero por defecto, filtros)
atom GetCount(control)
sequence GetEditSel(control de edición)
atom GetIndex(control)
sequence GetItem(control)
atom GetListItemHeight(control)
atom GetPageSize(bandera de dimensión)
atom GetPixelColor(xpos, ypos)
atom GetPrinterStringSize(cadena, fuente, bandera de dimensión)
sequence GetSelec(control)
atom GetStringSize(control, cadena, fuente, bandera de dimensión)
sequence GetText(control)
sequence GetTrappedMessage()
InfoMsg(mensaje, título)
atom IsChecked(control)
atom IsEventWaiting()
atom IsKeyPressed(tecla)
ListAdd(control, item)
ListClear(control)
ListDel(control)
ListIns(control, item)
ListPut(control, item)
ListSeek(control, posición)
atom LoadCur(ruta del cursor)
atom LoadPic(ruta de la imagen)
atom Message(identificador de la ventana, mensaje, parámetro w, parámetro l, bandera de espera)
atom NewDocument(nombre del documento)
atom NewFont(nombre de la fuente, tamaño de la fuente, negrita, itálica, subrayada)
NewMB(ancho, alto)
NewPage()
PlaySnd(fichero de sonido WAV)
PrintMB(fuente de la imagen, posición x, posición y, ancho, alto)
PrintString(inicio x, inicio y, texto)
ProcessEvent()
RunApp(programa, parámetros)
integer ScreenHeight()
integer ScreenWidth()
SelectPrinter(bandera)
SetCheck(control, bandera)
SetColor(control, color del texto, color de fondo)
SetCur(identificador del cursor)
SetDim(control, nuevo ancho, nuevo alto)
SetDrawingControl(control)
SetDrawingMB(bitmap)
SetDrawingProc(control, identificador del procedimiento)
SetEditSel(control de edición, posición de inicio, posición de final)
SetEnable(control, bandera)
SetDrawingFont(fuente)
SetFixedFont(control)
SetFont(control, fuente)
SetIcon(ruta del icono)
SetListCWidth(control SimMultiList, ancho)
SetParentWindow(ventana)
SetPic(control, tipo de control, identificador de la imagen)
SetPicture(control, tipo de control, ruta de la imagen)
SetPenColor(color)
SetPenSize(ancho)
SetPos(control, nueva posición x, nueva posición y)
SetPrinterFont(fuente)
SetPrinterPenColor(color)
SetRefresh(control)
SetRepaintOn(control, bandera)
SetText(control, nuevo título)
SetVisible(control, bandera)
SetWinTimer(intervalo)
StartPrinting()
StopSnd()
TrapMessage(mensaje)
WaitEvent()
WarnMsg(mensaje, título)
Window(título, posición x, posición y, ancho,
alto)
Activate(control)
Establece el foco del teclado en el control especificado. Este procedimiento es especialmente útil para reactivar un control después de que la captura y el proceso de un evento cause que el control pierda el foco. Si se usa para activar un campo editable, cualquier texto presente en dicho campo NO será seleccionado.
[atom control] es el control a activar
ActivateText(control)
Actua igual que el anterior procedimiento, con la diferencia de que cual texto presente SI será seleccionado.
[atom control] es el control a activar
atom AskMsg(mensaje, título)
Muestra un diálogo estándar de consulta con el mensaje indicado, los botones Si/No, el título pasado y un icono de interrogación. Si el usuario pulsa el botón Si la función retorna el valor True, o False en caso contrario. Nota: la aplicación queda "congelada" (es decir, no responde a eventos) hasta que el diálogo se cierre.
[sequence mensaje] el mensaje a mostrar
[sequence caption] el título de la ventana de diálogo
CloseApp(código de salida)
Cierra la aplicación, emitiendo el código de salida indicado. Hay que usar siempre este procedimiento para finalizar cualquier aplicación EuWinGUI, a fin de que se liberen correctamente todos los recursos usados.
[atom código de salida] el código devuelto al sistema
cuando se cierra la aplicación
atom Control(tipo de control, título, posición x, posición y, ancho, alto)
Crea un control y devuelve su identificador. Se debe usar sólamente después de haberse utilizado la función Window(). Si no se puede crear el control, devuelve cero.
[atom tipo de control] es uno de los tipos de control soportados por la librería
[sequence título] es el texto asociado al control
[atom posición x, posición y] las coordenadas del control relativas a la ventana
[atom ancho, alto] la anchura y la altura del control en pixels
CopyMB(imagen de origen, posición x, posición y, ancho, alto, imagen de destino, posición xd, posición yd)
Copia un bitmap, entero o en parte, a la posición especificada. Es posible copiar sólamente una porción rectangular del bitmap origen especificando la coordenada superior izquierda de la misma, así como su altura y anchura. Tanto la imagen de origen como la de destino pueden ser Memory Bitmaps o imágenes cargadas desde un fichero.
[atom imagen de origen, imagen de destino] identificadores de las imágenes origen y destino
[atom posición x, posición y] las coordenadas de la imagen origen de la esquina superior izquierda del rectángulo que se va a copiar
[atom ancho, alto] dimensiones del rectángulo que se va a copiar
[atom posición xd, posición yd] las coordenadas de la
esquina superior izquierda de la imagen de destino donde se va a copiar
el rectángulo
CopyMBToControl(imagen de origen, posición x, posición y, ancho, alto, control de destino, pos x, pos y)
Copia un bitmap, entero o en parte, a la posición especificada. Es posible copiar sólamente una porción rectangular del bitmap origen especificando la coordenada superior izquierda de la misma, así como su altura y anchura. La imagen de origen puede ser un Memory Bitmap o una imagen cargada desde un fichero; y el control de destino puede ser cualquiera que esté visible. El efecto de este procedimiento no es persistente, y puede ser borrado por el sistema operativo cuando necesite refrescar la interfaz. La principal finalidad de este procedimiento es proveer un método de actualizar la apariencia de un control de forma inmediata y sin parpadeos, "dibujando" directamente la imagen sobre él (ver la "Sección gráfica").
[atom imagen de origen] identificador de la imagen de origen
[atom control de destino] identificador del control de destino donde se va a copiar
[atom posición x, posición y] las coordenadas de la imagen origen de la esquina superior izquierda del rectángulo que se va a copiar
[atom ancho, alto] dimensiones del rectángulo que se va a copiar
[atom posx, posy] las coordenadas de la esquina superior izquerda del
control de destino donde se va a copiar el rectángulo
DeleteImage(identificador)
Borra una imagen o Memory Bitmap previamente cargada pero que ya no se necesite, a fin de liberar memoria. Cada bitmap creado con la función NewMB(), cargado con LoadPic() o con el procedimiento SetPicture(), usa una cierta cantidad de memoria RAM que no se libera hasta que el programa finaliza. Si se van a utilizar muchas imágenes, es conveniente borrar las que ya no se necesiten para evitar el riesgo de que nos quedemos sin memoria. Una buena práctica es guardar en una variable sequence los identificadores de todas las imágenes creadas o cargadas (que se habrán ido tomando de la variable global PictureHandle en cada momento), para usar luego DeleteImage() con todas ellas.
[atom identificador] es el identificador de la imagen previamente creada
o cargada
DrawLine(inicio x, inicio y, final x, final y)
Dibuja una línea sobre el area cliente de la ventana o control indicado en la última llamada a SetDrawingControl(), o sobre el bitmap de memoria indicado en la última llamada a SetDrawingMB(), usando el color establecido por SetPenColor() y una anchura de línea determinada con SetPenSize(). Puesto que cualquier dibujo efectuado directamente sobre la superficie de una ventana o control es automáticamente borrado por el sistema operativo cuando refresca la interfaz, para hacerlo persistente debe ser emplazado dentro de un procedimiento de "repintado" (ver SetDrawingProc()).
[integer inicio x, inicio y] coordenadas donde comienza la línea (siendo la 0,0 correspondiente a la esquina superior izquierda)
[integer final x, final y] coordenadas donde termina la línea
DrawMultiLine(líneas a dibujar)
Una versión de la anterior rutina que permite dibujar varias
líneas (sean consecutivas o no) de una sola vez, ganando en velocidad.
"líneas a dibujar" es una secuencia que contiene secuencias de cuatro
elementos con las coordenadas de inicio y final de cada línea. Por
ejemplo:
DrawMultiLine({{10,10,20,20},{35,30,40,50},{100,20,100,50}}
es equivalente a
DrawLine(10,10,20,20)
DrawLine(35,30,40,50)
DrawLine(100,20,100,50)
pero se ejecuta mucho más rápidamente
[sequence líneas a dibujar] secuencia de secuencias de cuatro
elementos que almacenan las coordenadas inicial y final de cada línea
a dibujar
DrawPoint(posición x, posición y)
Dibuja un pixel sobre el area cliente de la ventana o control indicado en la última llamada a SetDrawingControl(), o sobre el bitmap de memoria indicado en la última llamada a SetDrawingMB(), usando el color establecido por SetPenColor(). Puesto que cualquier dibujo efectuado directamente sobre la superficie de una ventana o control es automáticamente borrado por el sistema operativo cuando refresca la interfaz, para hacerlo persistente debe ser emplazado dentro de un procedimiento de "repintado" (ver SetDrawingProc()).
[integer posición x, posición y] coordenadas del pixel
(siendo la 0,0 correspondiente a la esquina superior izquierda)
DrawPolygon(puntos, bandera de relleno)
Dibuja un polígono (es decir, una línea multisegmento cerrada) uniendo todos los puntos indicados en la secuencia pasada comp primer argumento, sobre el area cliente de la ventana o control indicado en la última llamada a SetDrawingControl(), usando el color establecido por SetPenColor() y una anchura de línea determinada con SetPenSize(). Si el segundo argumento es True, se rellena la figura con el mismo color. Puesto que cualquier dibujo efectuado directamente sobre la superficie de una ventana o control es automáticamente borrado por el sistema operativo cuando refresca la interfaz, para hacerlo persistente debe ser emplazado dentro de un procedimiento de "repintado" (ver SetDrawingProc()). En caso de diseños complejos que puedan llevar su tiempo el redibujarlos, lo más práctico sería confeccionarlos sobre un bitmap en memoria y copiarlo cada vez que se necesite desde ahí a la ventrana o control dentro del procedimiento SetDrawingProc() (esto mismo es aplicable para cualquier rutina de dibujado).
Hay que tener en cuenta que:
1) la secuencia de puntos debe ser una relación de números enteros (o sea, que no ha de contener secuencias anidadas), donde las coordenadas se introducirán de este modo: {x1, y1, x2, y2, x3, y3, ..., xn, yn), donde x1 es la coordenada horizontal de un punto e y1 la vertical;
2) el primer y último punto se conectarán automáticamente para cerrar la figura, por lo que no es necesario repetir las coordenadas del punto inicial;
3) el polígono puede rellenarse completamente sólo si ningún segmento intersecta a otro;
4) para dibujar un mísmo polígono (aparte el rellenado), una única llamada a DrawPolygon() es mucho más rápido que usar llamadas consecutivas a DrawLine().
Un ejemplo de uso:
DrawPolygon({10, 10, 50, 10, 50, 90, 10, 90}, True)
dibujará y rellenará un rectángulo cuyos puntos
tendrán las coordenadas (10, 50), (50, 10), (50, 90) y (10, 90).
[sequence puntos] secuencia de coordenadas de los puntos de la figura
[atom bandera de relleno] se establecerá a True cuando se desee
rellenar la figura, o a False cuando sólo se quiera dibujar el contorno
del polígono.
DrawString(posición x, posición y, texto)
Dibuja el texto pasado en el argumento en el area cliente de la ventana o control indicado en la última llamada a SetDrawingControl(), o sobre el bitmap de memoria indicado en la última llamada a SetDrawingMB(), usando el color establecido por SetPenColor() y la fuente determinada con SetDrawingFont(). Puesto que cualquier dibujo efectuado directamente sobre la superficie de una ventana o control es automáticamente borrado por el sistema operativo cuando refresca la interfaz, para hacerlo persistente debe ser emplazado dentro de un procedimiento de "repintado" (ver SetDrawingProc()). En caso de diseños complejos que puedan llevar su tiempo el redibujarlos, lo más práctico sería confeccionarlos sobre un bitmap en memoria y copiarlo cada vez que se necesite desde ahí a la ventrana o control dentro del procedimiento SetDrawingProc() (esto mismo es aplicable para cualquier rutina de dibujado).
[atom posición x, posición y] coordenadas donde se empieza a dibujar el texto (siendo la 0,0 correspondiente a la esquina superior izquierda)
[sequence text] es el texto a dibujar
sequence FileDlg(bandera, fichero por defecto, filtros)
Muestra un diálogo de fichero estándar "Abrir" o "Guardar como" (dependiendo del valor de la bandera) y devuelve la ruta completa del fichero seleccionado. La carpeta de inicio corresponde al directorio actual (que podrá ser cambiada, en caso necesario, con una llamada previa al comando de Euphoria chdir()). El argumento fichero por defecto puede contener el nombre y la extensión (NO la ruta) del fichero por defecto cuando se muestre el diálogo. El argumento filtros contiene la extensión por la que se filtrará el contenido del directorio. Se pueden indicar varias extensiones separándolas por líneas verticales, usando el formato siguiente:
"Descripción fichero 1|*.ex1|Descripción fichero 2|*.ex2|...|Descripción fichero n|*.exn", como en el ejemplo:
"Imágenes JPEG|*.JPG;*.JPEG|Todos los ficheros|*.*"
Nótese es uso del punto y coma para separar diferentes extensiones del mismo filtro. Si el argumento filtros es una cadena vacia ("") se mostrará el filtro por defecto "Todos los ficheros|*.*".
Como nota final, cuando se use el diálogo Guardar como, la función NO añadirá automáticamente la extensión de fichero en la ruta devuelta, aunque se seleccione un filtro. Además, la aplicación se "congelará" mientras no se cierre el cuadro de diálogo.
[atom bandera] puede ser Open (para un cuadro de diálogo Abrir) o Save (para un cuadro de diálogo Guardar como)
[sequence fichero por defecto] es el nombre de fichero por defecto
[sequence filtros] es la cadena de definición de filtros
atom GetCount(control)
Devuelve el número de ítems presentes en el control de tipo List especificado.
[atom control] es el control del tipo List a chequear
sequence GetEditSel(control de edición)
Devuelve una secuencia de dos elementos que almacena las posiciones de inicio y final del texto seleccionado en el control de edición especificado. Si no hay nada seleccionado, las dos posiciones devueltas tendrán el mismo valor, que corresponderá al del inductor. Hay que tener en cuenta que en los controles MultiEdit los caracteres de retorno de carro y nueva linea ("\r\n") TAMBIEN se contarán.
[atom control de edición] es el control del tipo Edit a chequear
atom GetIndex(control)
Devuelve el número del item actualmente seleccionado en un control del tipo List. Si no hay ningún item seleccionado, se devuelve -1. El primer item de una lista tiene el valor de posición 0 (cero).
[atom control] es el control del tipo Lista a chequear
sequence GetItem(control)
Devuelve la cadena de caracteres del item seleccionado en un control del tipo List. Es el equivalente de la función GetText(), usada para devolver el texto en otros tipos de controles.
[atom control] es el control del tipo Lista a chequear
atom GetListItemHeight(control)
Devuelve la altura en pixels de cada item (cadena de caracteres) de un control tipo List. Es util cuando se necesita conocer cuantas líneas son visibles al mismo tiempo (este dato se obtiene dividiendo la altura del control por el dato devuelto por esta función).
[atom control] es el identificador del control tipo List
atom GetPageSize(bandera de dimensión)
Devuelve el ancho y el alto de la página a imprimir, medido en pixels, conforme a lo seleccionado en los ajustes de la impresora.
[atom bandera de dimensión] será X_DIM cuando se
desee obtener la anchura, e Y_DIM para la altura
atom GetPixelColor(xpos, ypos)
Devuelve el color del pixel ubicado en las coordenadas xpos e ypos del control o del bitmap (o Memory Bitmap) seleccionado para recibir los comandos de dibujo con SetDrawingMB() o SetDrawingControl(). Sólo se puede obtener este dato si el pixel del control está visible en la pantalla. Si no puede obtenerse este dato, devolverá #FFFFFF.
[atom xpos, ypos] son las coordenadas del pixel a comprobar
atom GetPrinterStringSize(cadena, fuente, bandera de dimensión)
Devuelve la anchura o la altura, en pixels, de la candena de texto a imprimir sobre la impresora seleccionada, usando la fuente determinada, tal como hace GetStringSize(). La bandera de dimensión será X_DIM o Y_DIM si se desea obtener el ancho o el alto, respectivamente.
[sequence cadena] es la cadena de texto a "medir"
[atom fuente] es el identificador de la fuente a usar para obtener el valor deseado
[atom bandera de dimensión] será X_DIM o Y_DIM,
según se desee obtener el ancho o el alto de la cadena
sequence GetSelec(control)
Devuelve una secuencia de secuencias conteniendo los items seleccionados por un control SelecList o SortedSelecList. Es equivalente a la función GetItem() usada para devolver la cadena de texto seleccionada por un control de tipo List simple.
[atom control] es el control tipo SelecList o SortedSelecList
a comprobar
atom GetStringSize(control, cadena, fuente, bandera de dimensión)
Devuelve el ancho o alto, en pixels, de una cadena de texto, dibujada
en un determinado control usando la fuente establecida. La bandera de dimensión
será X_DIM o Y_DIM si se desea obtener el ancho o
el alto, respectivamente. Es útil para redimensionar un control
de acuerdo al tamaño del texto a mostrar, factor que puede variar
dependiendo de la fuente usada; o para comprobar si una determinada cadena
de texto cabe en un control (como en un List, para averiguar si se va a
poder ver entera); o para averiguar donde ha de ubicarse el texto que se
vaya a dibujar con DrawString(). Por ejemplo, es posible centrar
la cadena "Hola mundo", con la fuente por defecto, sobre un control Picture
con 200 pixels de ancho usando la siguiente instrucción:
DrawString((floor(200-GetStringSize(Picture01,"Hola mundo", FN_DEFAULT, X_DIM))/2),10,"Hola mundo")
[atom control] es el identificador del control
[sequence cadena] es la cadena de caracteres a "medir"
[atom font] es el identificador de la fuente a usar para obtener el valor deseado
[atom bandera de dimensión] será X_DIM o Y_DIM,
según se desee obtener el ancho o el alto de la cadena
sequence GetText(control)
Devuelve el texto de un control. Para obtener textos de un control List se debe usar GetItem().
[atom control] es el identificador del control
sequence GetTrappedMessage()
Esta función de bajo nivel está reservada para programadores
que tengan los suficientes conocimientos sobre programación a bajo
nivel de Windows. Establece la variable UserTrap a False y devuelve
una secuencia de cuatro elementos conteniendo la información (hwnd,
message, wParam, lParam) almacenada y asociada con el último mensaje
Windows "atrapado" (ver el procedimiento TrapMessage()) para ser
manejada convenientemente por el procedimiento EventLoop() y procesada
como se necesite, al igual que se hace con los demás eventos EuWinGUI.
InfoMsg(mensaje, título)
Muestra un cuadro de diálogo de información estándar con el mensaje y título pasados, y con el icono de información. Hasta que dicho cuadro no se cierre, la aplicación permanecerá "congelada".
[sequence mensaje] el mensaje a mostrar
[sequence título] el título de la ventana
atom IsChecked(control)
Devuelve True si el control tipo Check o Radio está marcado, o si el botón PushButton está activado.
[atom control] identificador del control tipo Check,
Radio
o PushButton a verificar
atom IsEventWaiting()
Devuelve True si existe algún evento pendiente de manejar, o
False en caso contrario. Se usa en conjunto con ProcessEvent() para
permitir realizar otras tareas mientras se espera a que ocurra algún
evento (ver Operaciones en segundo plano para más información).
atom IsKeyPressed(tecla)
Devuelve True si está pulsada la tecla indicada, o False si no. Por ejemplo, IsKeyPressed('A') devolverá True si la tecla 'A' está pulsada en el momento de ejecutar esta función.
[atom tecla] tecla a comprobar
ListAdd(control, item)
Añade un item de texto al control tipo List especificado. Si el control es de tipo SortedList, el nuevo item se emplaza en el orden adecuado; en otro caso, se añade al final de la lista.
[atom control] control de tipo List
[sequence item] es la cadena de texto a añadir a la lista
ListClear(control)
Borra todos los items de la lista
[atom control] es el control del tipo List a borrar
ListDel(control)
Borra el item seleccionado en el control de tipo List
[atom control] es el control de tipo List
ListIns(control, item)
Inserta el item de texto pasado como argumento en la posición del item seleccionado en el control de tipo Lista. Si se usa en un control de tipo SortedList, este pierde el orden
[atom control] es el control de tipo List
[sequence item] es la cadena de texto a insertar
ListPut(control, item)
Reemplaza el item seleccionado en la lista por el item pasado como argumento. Para evitar parpadeos del control durante el proceso de borrado e inserción, se debe usar el procedimiento SetReapintOn() antes y después de ejecutar este procedimiento. Si el control es del tipo SortedList, este pierde el orden
[atom control] es el control de tipo List
[sequence item] es la nueva cadena de texto
ListSeek(control, posición)
Selecciona el item situado en la posición indicada. Si la posición es -1, ningún item quedará seleccionado; mientras que si excede el número de items existentes, quedará seleccionado el último. Hay que recordar que el primer item de una lista tiene la posición 0 (cero).
[atom control] es el control de tipo List
[atom posición] es la posición del item a seleccionar
atom LoadCur(ruta del cursor)
Carga un fichero de cursor desde el disco y devuelve su identificador. Una vez cargado el cursor, su identificador puede ser usado para cambiar el tipo de puntero del ratón usando el procedimiento SetCur().
[sequence ruta del cursor] es la ruta completa del fichero de cursor
a cargar
atom LoadPic(ruta de la imagen)
Carga una imagen BMP desde el disco, devuelve su identificador y almacena el mismo identificador en la variable global PictureHandle. Sólo pueden cargarse imágenes BMP estándar, y no es necesario indicar la extensión. Esto significa que pueden cambiarse las extensiones de los ficheros BMP que se deseen cargar para evitar que el usuario de la apliación los reconozca. Obsérvese que cada vez que se invoque esta función, se utilizará una cantidad de memoria RAM igual al tamaño de la imagen cargada (aunque sea la misma); memoria que no se liberará hasta que finalice la aplicación, o bien se use el procedimiento DeleteImage().
[sequence ruta de la imagen] es la ruta completa del fichero BMP a cargar
atom Message(identificador de la ventana, mensaje, parámetro w, parámetro l, bandera de espera)
Esta función está reservada para programadores con un
buen nivel de conocimientos sobre programación de la API de Windows,
y debería ser ignorada por los usuarios casuales de esta librería.
NewDocument(nombre del documento)
Inicia un nuevo documento de impresión, creando una página en blanco. El nombre del documento es usado para identificarlo cuando se envie a la impresora.
Nota: cuando un documento de impresión se crea con esta función, no es posible crear otro hasta que el actual es cerrado y enviado a la impresora con el procedimiento StartPrinting().
[sequence nombre del documento] es el nombre que identifica al documento
atom NewFont(nombre de la fuente, tamaño de la fuente, negrita, itálica, subrayada)
Crea y carga un nuevo tipo de fuente para usarlo con los controles y procedimientos de dibujo de EuWinGUI, usando los parámetros pasados como argumentos, y devolviendo un identificador. Los procedimientos SetFont() y SetDrawingFont() puede usar este identificador para asignar la nueva fuente creada a cualquier control o para su uso con el procedimiento DrawString().
Nota: Si el sistema operativo no puede crear una fuente con los parámetros pasados, usará los más parecidos que tengan instalados. También hay que tener en cuenta que Windows tiende a evitar el uso de algunos tipos de fuentes "elaboradas" en ciertos controles.
Por ejemplo:
times1 = NewFont("Times New Roman", 16, True, False, False)
SetFont(Button01, times1)
crea una fuente del tipo "Times New Roman", de tamaño 16
y en negrita, y lo asigna al control Button01. Esta fuente se creará
exactamente con las características especificadas SOLO si estas
están presentes en el sistema donde corra el programa.
[sequence nombre de la fuente] nombre de la fuente a usar
[integer tamaño de la fuente] tamaño de la fuente a crear
[atom, negrita, itálica, subrayada] banderas que se establecerán
como True o False según el estilo deseado
atom NewMB(ancho, alto)
Crea un Memory Bitmap con las dimensiones especificadas, "relleno" con el color especificado con SetPenColor(), y devuelve un identificador. Un Memory Bitmap puede usarse exactamente igual que una imagen bitmap cargada desde un fichero. Puede asignarse en un control del tipo Picture mediante el procedimiento SetPic() (ver la Sección Gráfica).
[atom ancho, alto] el ancho y el alto del nuevo Memory Bitmap
NewPage()
Cierra la página actual del documento en curso y añade
una nueva página "en blanco". La página cerrada ya no podrá
modificarse, siendo la nueva página la que reciba ahora las instrucciones.
PlaySnd(fichero de sonido WAV)
Reproduce un fichero de sonido WAV. Para detener la reproducción se usará StopSnd(). Al iniciar la reproducción de un nuevo fichero de sonido, el que estuviera reproduciéndose en ese momento se detendría. Puesto que Windows sólo reproduce ficheros de sonido cargados en memoria, hay que evitar en lo posible los ficheros de gran tamaño. También hay que tener en cuenta que, si el fichero que se desea reproducir no existe, Windows emitirá el sonido de sistema correspondiente a "error".
[sequence wavefile] es la ruta completa del fichero WAV a reproducir
PrintMB(fuente de la imagen, posición x, posición y, ancho, alto)
Imprime, en su totalidad o en parte, el Memory Bitmap especificado en la página actual del documento de impresión en curso, en las coordenadas especificadas. Hay que tener en cuenta que algunas impresoras antiguas no admiten la impresión gráfica.
[atom fuente de la imagen] el identificador de la imagen a imprimir
[atom posición x, posición y] las coordenadas en la página del documento donde se imprimirá
[atom ancho, alto] el ancho y el alto en pixels de la imagen
PrintString(inicio x, inicio y, texto)
Imprime el texto especificado en la página actual del documento en curso, usando el color indicado con SetPrinterPenColor() y la fuente establecida con SetPrinterFont().
[atom inicio x, inicio y] las coordenadas donde se va a dibujar el texto
[sequence text] es el texto a dibujar
ProcessEvent()
Este procedimiento funciona igual que WaitEvent(), con la diferencia
de que retorna inmediatamente después de haber procesado todos los
eventos en espera. Mediante el uso de este procedimiento, una aplicación
EuWinGUI puede realizar otras tareas mientras espera a que ocurra algún
evento, aunque requiere un uso más intenso del microprocesador (ver
Operaciones
en segundo plano).
RunApp(programa, parámetros)
Inicia o abre el programa, fichero o directorio indicado, usando los parámetros deseados (si los hay). Los ficheros no ejecutables pueden abrirse directamente, pero sólo si su extensión está asociada con una aplicación ejecutable. Este procedimiento NO CAMBIA el directorio de trabajo del programa, por lo que, si fuera necesario cambiar de directorio, debe usarse el función de Euphoria chdir() antes de llamar a este procedimiento.
[sequence programa] es la ruta completa del programa o fichero a abrir
[sequence parámetros] son los parámetros a usar por el
programa que deseamos abrir
integer ScreenHeight()
Devuelve la altura de la resolución de pantalla actual, en pixels.
Esta función es útil para centrar verticalmente la ventana
en la pantalla.
integer ScreenWidth()
Devuelve la anchura de la resolución de pantalla actual, en pixels.
Útil para centrar horizontalmente la ventana.
SelectPrinter(bandera)
Selecciona una impresora para imprimir. Si el valor de la bandera es True queda seleccionada la impresora establecida por defecto en el sistema, con todos sus ajustes, y no se muestra el diálogo de impresora. Si es False, se muestra el cuádro de diálogo para que el usuario seleccione la impresora y los ajustes pertienentes. Hay que señalar que ninguna instrucción relacionada con la impresora funcionará hasta que se haya ejecutado este procedimiento.
[atom bandera] será True o False según queramos usar la
impresora por defecto o no
SetCheck(control, bandera)
Marca o desmarca el control tipo Check, Radio o PushButton.
[atom control] es el identificador de un control Check, Radio o PushButton
[atom bandera] será True para marcar, o False para desmarcar
SetColor(control, color del texto, color de fondo)
Cambia el color de caracter y de fondo del texto de un control tipo List, Text, Edit o Group. Puede especificarse el pseudocolor CL_DEFAULT para indicar el color por defecto establecido en el sistema. Hay que recordar que, en los controles Group, sólo se cambiarán los atributos del texto de la etiqueta, no de todo el control.
[atom control] es el identificador del control al que se le va a cambiar el color
[atom color del texto, color de fondo] son los colores de texto y fondo
a aplicar al control
SetCur(identificador del cursor)
Establece temporalmente uno de los cinco cursores estándar disponibles en Windows, o uno de los cargados con la función LoadCur(). "Temporalmente" significa que Windows restaurará automáticamente el cursor original cada vez que se mueva el ratón. Por esta razón, este procedimiento se usa normalmente cuando se capturan los eventos del ratón (Move, Click, Release, RClick, RRelease) de un control para cambiar el tipo de cursor constantemente.
[atom cursorshape] es uno de los cursores por defecto o el identificador
del cursor cargado desde un fichero
SetDim(control, nuevo ancho, nuevo alto)
Cambia las dimensiones de la ventana o control.
[atom control] es el identificador del control o ventana
[atom nuevo ancho, nuevo alto] son el nuevo ancho y alto del control
o ventana
SetDrawingControl(control)
Establece la ventana o control al que se van a dirigir las instrucciones de dibujo, hasta que una nueva llamada a este procedimiento o a SetDrawingMB() lo cambie. Inicialmente, es la ventana principal la que recibe estas instrucciones.
[atom control] es el identificador del control sobre el que se ejecutarán
las instrucciones de dibujo
SetDrawingMB(bitmap)
Establece el Memory Bitmap al que se van a dirigir las instrucciones de dibujo, hasta que una nueva llamada a este procedimiento o a SetDrawingControl() lo cambie.
[atom bitmap] es el identificador del Memory Bitmap o del bitmap cargado
desde un fichero sobre el que se ejecutarán las instrucciones de
dibujo
SetDrawingProc(control, identificador del procedimiento)
Este procedimiento permite dibujar directamente sobre la ventana o control indicado, cada vez que el sistema operativo necesita "redibujar" la interfaz, haciendo que nuestros "dibujos" sean persistentes. Puede indicarse un procedimiento para cada control; o uno para varios controles, en cuyo caso podremos usar la variable global EventOwner para averiguar la ventana que requiere ser redibujada por el sistema operativo.
El siguiente ejemplo:
procedure procedimientoRedibujado()
SetDrawingControl(Picture03)
SetPenColor(CL_WHILTE)
DrawMultiLine({{10,10,50,50}, {50,50,50,90}, {50,90,10,90}, {10,90,10,10}})
end procedure
SetDrawingProc(Picture03, routine_id("procedimientoRedibujado"))
crea y establece el procedimiento (sin argumentos) "procedimientoRedibujado()",
conteniendo las instrucciones necesarias para dibujar un cuadrado blanco
sobre el control Picture03, que se ejecutará automáticamente
cada vez que el control necesite ser redibujado por el sistema operativo.
Nota: es extremadamente importante incluir en estos procedimientos de redibujado SOLO llamadas a rutinas de dibujo. En caso de incluirse instrucciones que puedan causar que la ventana o control tengan que ser redibujadas por el sistema operativo, se entraría en un bucle sin fin. Por ejemplo, si se muestra un cuadro de diálogo o de mensaje dentro de este procedimiento, al mostrarse dicho cuadro podría solaparse sobre la ventana, lo que obligaría a Windows a redibujarla una vez se cerrara, entrando de esta manera en el mencionado bucle infinito. Por la misma razón, algunas funciones EuWinGUI que pueden originar dicha circunstancia son deshabilitadas y no tienen efecto en estas rutinas de redibujado.
[atom control] es el identificador del control sobre el que se establecerá la rutina de redibujado
[integer identificador del procedimiento] es el valor retornado por
la llamada a la función de Euphoria "routine_id()", usando
como argumento el identificador del procedimiento (sin argumentos) que
contiene las instrucciones de dibujo requeridas para ser ejecutadas por
EuWinGUI cada vez que la ventana o control necesite ser redibujado por
el sistema operativo
SetEditSel(control de edición, posición de inicio, posición de final)
Selecciona parte del texto de un control del tipo Edit, de acuerdo a las posiciones de inicio y final especificadas. Si la posición de inicio y de final es la misma, no se seleccionará nada, pero el cursor de texto se ubicará en la indicada como final. También puede usarse el valor -1 como parámetro de posición final para seleccionar la totalidad del texto. Hay que tener en cuenta que, en los controles MultiEdit, los caracteres de retorno de carro y nueva línea ("\r\n") que separan cada línea TAMBIÉN se cuentan.
[atom control de edición] es el control de tipo Edit
[atom posición de inicio, posición de final] posiciones
de inicio y final de la porción de texto a seleccionar
SetEnable(control, bandera)
Habilita o deshabilita el control especificado, dependiendo del valor de la bandera. Los controles deshabilitados no responden a eventos.
[atom control] es el identificador del control a habilitar o deshabilitar
[atom bandera] será True o False, según se quiera habilitar
o deshabilitar el control
SetDrawingFont(fuente)
Este procedimiento permite establecer la fuente que se usará con DrawString(). Dicha fuente habrá sido creada previamente con NewFont(), o será uno de los tipos por defecto.
[atom fuente] es el identificador de la fuente a usar
SetFixedFont(control)
Este procedimiento es equivalente a SetFont(control, FN_FIXED). Por defecto, los controles EuWinGUI usan la fuente variable estándar del sistema Windows. Este procedimiento permite reemplazar, para el control indicado, dicha fuente por la fija estándar del sistema, y es especialmente útil con los controles tipo List y Edit que necesiten mostrar texto "formateado".
[atom control] es el identificador del control al que se va a establecer
dicha fuente
SetFont(control, fuente)
Este procedimiento permite cambiar la fuente utilizada en el control especificado por otra creada previamente con la función NewFont() o por una de las establecidas por defecto.
[atom control] es el identificador del control al que se le va a cambiar la fuente
[atom fuente] es el identificador de la fuente a usar
SetIcon(ruta del icono)
Establece el icono de la ventana principal o de la última ventana establecida con el procedimiento SetParentWindow(). Por defecto se utilizará el icono estandar de Euphoria.
[sequence ruta del icono] es la ruta completa del fichero .ICO a cargar
SetListCWidth(control SimMultiList, ancho)
Establece la anchura, en pixels, de todas las columnas de un control SimMultiList, no teniendo efecto en otros tipos de control List. La anchura debe estar comprendida entre 1 y 65535 pixels. Cualquier valor que exceda estos límites se ajustarán (hacia arriba o hacia abajo) según sea necesario por la librería.
[atom control SimMultiList] es el identificador del control SimMultiList
[atom width] es el ancho deseado, en pixels, de todas las columnas del
control
SetParentWindow(ventana)
Establece la ventana (principal o hija) que será establecida como "padre" de todos los controles creados a partir de invocar este procedimiento, y hasta que se vuelva a utilizar para cambiar dicho "padre". Adviértase que las ventanas "hija" SIEMPRE tienen como "padre" a la ventana principal, independientemente de lo que se indique en este procedimiento.
[atom ventana] es el identificador de la ventana principal (WinHwnd)
o de la ventana "hija" que se va a usar como "padre" de los controles creados
tras la llamada a este procedimiento
SetPic(control, tipo de control, identificador de la imagen)
Asigna la imagen BMP (previamente cargada desde un fichero) o el Memory Bitmap (creado con NewMB()) a un control Picture, ClickPicture, PictureButton o PicturePushButton. Este procedimiento es especialmente útil cuando se carga un fichero BMP para usarse múltiples veces. A diferencia de SetPicture(), este procedimiento no usa memoria adicional para cada uso del BMP. El identificador de la imagen se guarda en la variable global PictureHandle después de la llamada a SetPicture() o a LoadPic(). Así, si se necesita asignar la misma imagen a múltiples controles, se puede ahorrar memoria utilizando la función LoadPic() para cargar la imagen desde un fichero en disco y entonces asignarla a dichos controles, usando el identificador devuelto por la función como tercer argumento de SetPic().
Ejemplo. Digamos que tenemos cuatro controles Picture y necesitamos
cargar la misma imagen (de 100 Kb). El código sería:
SetPicture(pic1, Picture, "imagen.bmp") SetPicture(pic2, Picture, "imagen.bmp") SetPicture(pic3, Picture, "imagen.bmp") SetPicture(pic4, Picture, "imagen.bmp")
El siguiente código hace lo mismo, pero, en vez de ocupar
400 Kb de RAM como el anterior, este sólo necesita 100 Kb puesto
que la imagen se carga una sola vez:
idImagen = LoadPic("imagen.bmp")
SetPic(pic1,Picture,idImagen)
SetPic(pic2,Picture,idImagen)
SetPic(pic3,Picture,idImagen)
SetPic(pic4,Picture,idImagen)
[atom control] es el identificador de un control Picture,
ClickPicture,
PictureButton
o PicturePushButton.
[atom tipo de control] es el tipo del control (Picture, ClickPicture, PictureButton o PicturePushButton).
[atom identificador de la imagen] es el identificador de la imagen previamente
cargada
SetPicture(control, tipo de control, ruta de la imagen)
Una llamada a este procedimiento es equivalente al código SetPic(control, tipo_de_control, LoadPic("ruta_de_la_imagen")). Carga y asigna al mismo tiempo una imagen BMP en un control Picture, ClickPicture, PictureButton o PicturePushButton, y guarda el identificador de la imagen en la variable global PictureHandle. Sólo se permiten imágenes BMP estándar, pero no es necesario indicar la extensión .BMP. Esto significa que se pueden renombrar los ficheros de imágenes con otras extensiones para, por ejemplo, "ocultarlos" al usuario. Adviértase que, cada vez que se utilice este procedimiento, se usará una cantidad de memoria RAM igual al tamaño del fichero de imagen cargado (aunque se cargue varias veces la misma imagen), y dejará de estar disponible hasta que finalice el programa. Si se va a hacer un uso repetido de las mismas imágenes, y para evitar que nos podamos quedar sin memoria, es preferible utilizar LoadPic() para cargar la imagen y SetPic() para asignarla a cada control cada vez que se necesite.
[atom control] es el identificador de un control Picture, ClickPicture, PictureButton o PicturePushButton.
[atom tipo de control] es el tipo del control (Picture, ClickPicture, PictureButton o PicturePushButton).
[sequence ruta de la imagen] es la ruta completa del fichero BMP a cargar
SetPenColor(color)
Establece el color que va a utilizarse en los procedimientos de dibujo. El color por defecto es el negro, pero puede usarse cualquier color. Los 16 colores básicos de Windows están predefinidos en EuWinGUI y pueden usarse como argumento en este procedimiento, pero es posible utilizar cualquier color que se necesite, usando la siguiente notación: #BBGGRR, donde BB representa el color azul, GG el verde y RR el rojo; siendo cada color un valor hexadecimal en el rango desde #00 a #FF (0 a 255) que indica la proporción de dicho color en la mezcla para crear el tono deseado. En caso de que el rango de colores soportado por el sistema sea inferior al representado, este elegirá automáticamente el más próximo de su paleta. Adviértase que es posible saber el color que se está utilizando dibujando, por ejemplo, un punto o una linea en un bitmap y usando la función GetPixelColor().
Por ejemplo, SetPenColor(CL_RED) establece el color rojo para ser utilizado en las rutinas de dibujo, mientras que SetPenColor(#E0E0E0) establece un color de una tonalidad gris clara.
[atom color] es el valor hexadecimal que define el color que va a ser
utilizado en los procedimientos de dibujo
SetPenSize(ancho)
Establece la anchura, en pixels, de las lineas que se van a dibujar con DrawLine(), DrawMultiLine() y DrawPolygon(). La anchura debe estar comprendida en 1 y 50, siendo 1 por defecto.
[atom width] es el ancho deseado de las lineas a dibujar
SetPos(control, nueva posición x, nueva posición y)
Mueve un control a una nueva posición sobre el area cliente de la ventana principal, o a la ventana principal con respecto a su posición en la pantalla.
[atom control] es el identificador del control o ventana a mover
[atom nueva_posicion_x, nueva_posicion_y] son las coordenadas x e y
de la nueva posición del control
SetPrinterFont(fuente)
Este procedimiento permite establecer la fuente a usar para imprimir en la página en curso de un documento de impresión
[atom font] es el identificador de la fuente a usar
SetPrinterPenColor(color)
Establece el color que se usará para imprimir los textos en la página en curso de un documento de impresión. Se le aplica lo mismo que a SetPenColor(). Obviamente, el color final usado en la impresión dependerá de las capacidades de la impresora.
[atom color] es el valor hexadecimal que define el color que va a ser
utilizado
SetRefresh(control)
Fuerza a Windows a refrescar (o sea, a redibujar) el control o ventana especificado. Si se usa dentro de un procedimiento utilizado con SetDrawingProc(), esta instrucción será ignorada por EuWinGUI, evitando así un bucle sin fin.
[atom control] es el identificador de la ventana o control a refrescar
SetRepaintOn(control, bandera)
Los controles son repintados automáticamente por Windows cada vez que se precisa, por ejemplo al cambiarle el título a un control. Algunas veces es útil evitar que Windows haga esto, por ejemplo cuando se añaden items a un control del tipo lista dado que, cada vez que se añade uno, Windows procede a su refresco, causando de esta manera cierto parpadeo, especialmente si se añaden muchos items de una vez. Estableciendo la bandera a False, el control indicado no se repintará hasta que se establezca a True, evitando de esta manera dicho parpadeo.
[atom control] es el identificador del control
[atom bandera] si es True se reactiva el repintado automático;
si es False, no se realiza dicho repintado
SetText(control, nuevo título)
Establece el texto o título de un control. Para añadir cadenas de texto a un control de tipo Lista habrán de usarse las funciones ListAdd() y ListIns(). Para añadir varias líneas de texto a un control MultiEdit habrán de utilizarse los caracteres "\r\n" (retorno de carro y nueva línea) separando cada línea (por ejemplo, SetText(medit1, "Línea 1\r\nLínea 2")).
[atom control] es el identificador del control
[sequence nuevo_título] es el nuevo título del control
SetVisible(control, bandera)
Hace que el control especificado sea visible o invisible, dependiendo del valor de la bandera. Los controles ocultos no responden a eventos.
[atom control] es el identificador del control
[atom bandera] será True si se desea hacer visible el control;
False, para ocultarlo.
SetWinTimer(intervalo)
Establece el timer de la ventana principal. Cuando se establece un intervalo, el evento Timer será generado por la ventana principal cada "intervalo" de milisegundos. Para detener el timer, establecer como intervalo 0.
[integer intervalo] es el intervalo en milisegundos entre cada evento
Timer
StartPrinting()
Cierra el documento de impresión y lo envía a la impresora
seleccionada. Una vez se use este procedimiento no podrán introducirse
cambios en el documento, y el único modo de detener la impresión
será manualmente (usando el diálogo de administración
de impresión).
StopSnd()
Detiene cualquier sonido que esté reproduciéndose en ese
momento.
TrapMessage(mensaje)
Este procedimiento está reservado para programadores que dominen la programación de Windows a bajo nivel. Sirve para "atrapar" mensajes específicos de Windows y forzar el retorno desde el procedimiento WaitEvent() cada vez que uno de tales mensajes es procesado por la librería, exactamente como se haría con los Eventos por defecto. Cada vez que se procesa un mensaje "atrapado", la variable global UserTrap se establece a True y el procedimiento WaitEvent() retorna. Es entonces posible, comprobando el valor de UserTrap dentro del procedimiento EventLoop(), rescatar todos los datos asociados con el mensaje "atrapado" (o sea, identificador, mensaje, wParam, lParam) usando la función GetTrappedMessage().
Notas importantes:
- es posible usar este procedimiento repetidas veces para "atrapar" diversos mensajes, pero hay que tener en cuenta que esto ralentizará progresivamente el programa.
- no es posible atrapar TODOS los mensajes; EuWinGUI necesita procesar algunos mensajes básicos y de bajo nivel para sus propios fines, y no permitirá al programador acceder a ellos para evitar posibles conflictos. En caso de que un mensaje no pueda ser "atrapado", la librería ignorará la instrucción del programa. Es labor del programador comprobar que dicha instrucción funcione.
- podría ocurrir que la "interferencia" de un mensaje crucial utilizado por Windows cause el fallo del programa.
- en ningún caso puede causarse un daño físico al equipo por "atrapar" el mensaje equivocado
[atom mensaje] es el mensaje Windows a "atrapar"
WaitEvent()
Inicia el procedimiento de manejo de eventos y espera a que el usuario
interactue de algún modo con la interfaz del programa. Una vez se
intercepta uno de los eventos soportados por la librería, se establece
la variable globar Event con el tipo de evento, y la variable global
EventOwner
con el identificador del control que recibe el evento, retornando.
WarnMsg(mensaje, título)
Muestra un diálogo de Aviso estándar con el mensaje y título indicados, y con el icono de exclamación. Nota: la aplicación se "congelará" (es decir, no procesará eventos) hasta que se cierre el cuadro de mensaje.
[sequence mensaje] es el mensaje a mostrar
[sequence caption] es el título de la ventana de diálogo
Window(título, posición x, posición y, ancho, alto)
Crea y muestra la ventana principal y asigna su identificador a la variable global WinHwnd. Es la primera función EuWinGUI a usar al crear la interfaz del programa. Si no se crea la ventana principal, WinHwnd se establecerá a cero. La apariencia (o estilo) de la ventana principal puede cambiarse (antes de usar este procedimiento) estableciendo el valor de las variables globales WindowType y WinOnTop.
[sequence título] es el título de la ventana
[atom posición x, posición y] son las coordenadas de la ventana con respecto a la pantalla
[atom ancho, alto] son la anchura y la altura (en pixels) de la ventana.
Apéndice F: Limitaciones del sistema operativo.
Los limites aplicables a los programas EuWinGUI por el sistema operativo son muy elásticos y dependen de la versión de Windows, los recursos y memoria RAM disponibles en el sistema donde corre la aplicación. No obstante, algunos controles están limitados en sus capacidades por Windows. Específicamente:
- las aplicaciones sobre Windows 95 no pueden tener más de 16.384 identificadores al mismo tiempo.
- los controles Sim/Multi/Edit pueden almacenar como máximo 32 Kb de texto, aunque puede ser menos dependiendo de la memoria disponible y, en el caso de los Edit Multiline, por el número de los separadores (retorno de carro + nueva línea) presentes en el texto (cada uno ocupa dos bytes).
- los controles List, SortedList y SimMultiList, pueden contener un
máximo de 32.767 items, aunque la longitud de cada uno sólo
está limitado por la memoria disponible.
(volver)