En el anterior capítulo (como sencilla introducción) vimos que la estructura general de un programa en X Window se apoyaba en la selección de los eventos deseados por el cliente, y la detección y manipulación de los mismos en un bucle de eventos o mensajes:
Programa:
{
Inicialización();
SeleccionaEventos();
REPETIR Espera_EVENTO
{
Si llega PULSACION_DE_TECLADO:
{
Código que gestiona teclado;
}
Si llega PULSACION_DE_RATON:
{
Código que gestiona ratón;
}
Etc...
Resto_de_eventos: nada();
}
}
Lo primero que se va a comentar es la manera de seleccionar eventos, pues como veremos a continuación, no todos los eventos son recibidos por el programa cliente, sino que se reciben tan sólo los que éste especifica, y esto es una gran ventaja en el ámbito de la velocidad de procesamiento de los programas.
Durante la inicialización de nuestra aplicación y creación de la ventana principal de la misma es necesario indicarle al servidor qué tipo de eventos se desean recibir, pues puede interesarnos no recibir información de algún tipo de evento ocurrido, mientras que para nuestra aplicación otro periférico o evento software puede ser vital. Para la indicación de eventos deseados (también llamada "selección de eventos") al servidor X se utiliza la función XSelectInput y las llamadas "máscaras de eventos".
XSelectInput(display, window, event_mask) Display *display; Window window; long event_mask;Sobre los parámetros que se le pasan a esta función, el argumento display es la variable que conecta nuestro cliente con el servidor X (ya habitual en prácticamente todas las llamadas Xlib), la variable window es el idenficador de la ventana sobre la que deseamos seleccionar los eventos que se recibirán, y event_mask es una variable máscara (es decir, se utilizarán los diferentes bits de la misma como indicadores o flags, lo cual indica que al ser una variable de tipo long dispondremos de 32 posibles eventos distintos). Cada bit de esta variable event_mask se refiere a un evento concreto, de tal modo que si este bit se encuentra activado se estará pidiendo al servidor que informe al cliente de dicho evento, mientras que si se encuentra desactivado el servidor entiende que el cliente no desea recibir tal evento (con el consecuente ahorro de tiempo de procesamiento que esto supone).
Para hacer más fácil la selección de eventos existen cadenas o nombres simbólicos (definidos en X11/X.h) que identifican a los eventos para no tener que recordar el bit asociado a cada uno de ellos. Así, para indicarle al servidor que se desean recibir los eventos de pulsación de teclado y botón del mouse bastaría con activar estos 2 bits mediante el operador de concatenamiento OR (|):
Ejemplo:
XSelectInput( display, window, KeyPressMask | ButtonPressMask);Si no se utiliza esta función el servidor tiene indicado por defecto no pasarle ningún evento extra al cliente (simplemente los activados por defecto), por lo que es recomendable su utilización previa a la entrada al bucle de eventos.
Las posibles máscaras de eventos a utilizar se van a comentar a continuación, teniendo en cuenta que los nombres finalizados en Mask son los identificadores de máscaras de eventos a utilizar en la función XSelectInput, mientras que los que no tienen dicho sufijo se refieren al nombre del propio evento y que deberá ser gestionado dentro del bucle principal de la aplicación, el bucle de procesado de eventos.
ButtonPressMask: Nos avisa de pulsaciones del botón del mouse mediante un evento del tipo ButtonPress. Es decir, si seleccionamos el evento ButtonPressMask el servidor nos enviará los mensajes ButtonPress pertinentes a la ventana especificada.
ButtonReleaseMask: Máscara de evento referido a la liberación del botón del mouse, de tal modo que en caso de ser seleccionado se recibiría un evento del tipo ButtonRelease cada vez que el botón del ratón fuera liberado.
KeyPressMask: Esta máscara de evento indica al servidor de debe enviarnos todas las pulsaciones de teclado producidas en la ventana especificada, generando un evento KeyPress que podremos detectar en el bucle de mensajes. Como veremos, tras detectar este evento en el bucle de mensajes es posible obtener el código ASCII o scan code de esta tecla si así lo necesita nuestro programa, con funciones que comentaremos en su momento.
KeyReleaseMask: Similar a KeyPressMask, pero con el fin de que se nos indiquen las liberaciones de teclas mediante eventos KeyRelease.
KeymapStateMask: Permite la recepción de eventos tipo KeymapNotify relacionados con el mapa de teclado.
EnterWindowMask: Máscara que hace que el servidor nos avise cuando el usuario dé el foco principal a nuestra ventana, es decir, la haga la ventana activa, recibiendose un evento llamado EnterNotify, lo cual quiere decir que el puntero del mouse ha entrado en la ventana a la que se le informa del evento.
LeaveWindowMask: Similar a EnterWindowMask, pero que nos avisará mediante un mensaje LeaveNotify de que el usuario ha cambiado el foco (o que el puntero del ratón ha salido de dicha ventana) y que la ventana que recibe el mensaje no es la activa en ese momento.
ButtonMotionMask: Esta máscara hace que el servidor nos envie eventos relacionados con el movimiento del mouse cuando cualquier botón del mismo está pulsado (muy útil para gran cantidad de aplicaciones), recibiendo un evento MotionNotify, el mismo que se recibe ante cualquier movimiento del mouse. Esta máscara hace que este evento se genere mediante cualquier botón del mouse, mientras que las máscaras Button1MotionMask, Button2MotionMask, etc, hace que se genere ante el movimiento durante la pulsación del botón especificado (1, 2, etc.).
PointerMotionMask: Esta máscara hace que se reciba un evento MotionNotify cuando se produzca cualquier movimiento del puntero del ratón (sin necesitar que el botón sea pulsado, como en ButtonMotionMask).
PointerMotionHintMask: Permite que la notificación de eventos de movimiento (similares a PointerMotionMask) sea de forma no continua, a intervalos.
FocusChangeMask: Nos permitira recibir eventos FocusIn y FocusOut.
SubStructureNotifyMask: esta máscara le permitirá obtener los mismos eventos que StructureNotifyMask con la adición del evento CreateNotify.
SubStructureRedirectMask: Permite la recepción de los eventos MapRequest y ConfigureRequest y su tratamiento en el bucle de mensajes. Nótese que cuando algún evento no es seleccionado (y, por tanto, no se hace nada con él en el bucle de eventos), X Window realiza para tal evento las acciones genéricas por defecto (o nada, si así lo especificamos). Esta máscara, más concretamente, permite que si un sólo cliente (por ejemplo: el propio gestor de ventanas) ha seleccionado ésta sobre una ventana, las peticiones de otros clientes sobre las ventanas hijas de la ventana sobre la que se está aplicando el Mask no será realizado por el servidor (cosa que se realiza habitualmente) sino que éste enviará un mensaje a este cliente para que realice él las acciones pertinentes. Gracias a estos eventos existen los gestores de ventanas o window managers, que son quienes tienen la última palabra en en aspecto final y geometría de las ventanas en X Window.
VisibilityChangeMask: Permite recibir eventos del tipo VisibilityNotify, que indican cambios de visibilidad en la ventana a la que se informa.
ResizeRedirectMask: Esta máscara da acceso al evento de ResizeRequest, sobre el cambio de tamaño de la ventana sobre la que se especifica la selección del evento.
PropertyChangeMask: Al activar este bit se permite la recepción de eventos del tipo PropertyNotify, que indican cambios de valores asociados a una propiedad.
ColormapChangeMask: Esta máscara permite la recepción de eventos ColormapNotify, relacionados con el cambio del mapa de colores (ColorMap) por parte de cualquier aplicación. Este mensaje es importante en los modos gráficos con paleta, como por ejemplo de 16 colores o de 8 bits por pixel (256 colores).
En el cuadro 1 disponemos de un resumen de todas las máscaras de eventos y los mensajes que se generarán hacia nuestro bucle de mensajes al producirse estos.
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
EVENTOS MáSCARAS DE EVENTOS
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Eventos de teclado y ratón:
KeyPress -> KeyPressMask
KeyRelease -> KeyReleaseMask
KeymapNotify -> KeymapStateMask
ButtonPress -> ButtonPressMask
ButtonRelease -> ButtonReleaseMask
MotionNotify -> ButtonMotionMask
Button1MotionMask
Button2MotionMask
(etc.)
PointerMotionMask
PointerMotionHintMask
EnterNotify -> EnterWindowMask
LeaveNotify -> LeaveWindowMask
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Eventos relacionados con ventanas:
DestroyNotify
MapNotify
UnMapNotify
CirculateNotify
ReparentNotify
ConfigureNotify
GravityNotify -> StructureNotifyMask
CreateNotify
DestroyNotify
MapNotify
UnMapNotify
CirculateNotify
ReparentNotify
ConfigureNotify
GravityNotify -> SubStructureNotifyMask
MapRequest
ConfigureRequest-> SubStructureRedirectMask
VisibilityNotify-> VisibilityChangeMask
ResizeRequest -> ResizeRedirectMask
PropertyNotify -> PropertyChangeMask
FocusIn
FocusOut -> FocusChangeMask
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Eventos relacionados con gráficos:
Expose -> ExposureMask
ColormapNotify -> ColormapChangeMask
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Eventos siempre seleccionados:
MappingNotify
ClientMessage
SelectionNotify
SelectionClear
SelectionRequest
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Si el evento ocurrido no hubiera sido seleccionado por la ventana (no hemos pedido su recepción), este evento se propaga hasta la ventana madre y de ahi se continúa propagando hasta llegar a la ventana raíz (Root Window).
Si el evento estaba seleccionado, simplemente se comunica al cliente para que reaccione en consecuencia. A título de ejemplo, supongamos que hacemos un programa de dibujo con una ventana principal (donde se va a dibujar) y una subventana desde donde se seleccionan las formas gráficas a utilizar (línea, mano alzada, círculo, etc.). Si el usuario pulsara en cualquiera de estas opciones, el evento sería propagado hasta la ventana madre (si así lo hemos seleccionado) para que el propio cliente sea el que cambie el estilo de dibujo al seleccionado.
El mecanismo de propagación descrito tiene dos excepciones: la primera de ellas es el enfoque del teclado, y la segunda es la posesión del teclado y puntero pedida directamente por un programa cliente.
Este segundo proceso es conocido como captura del ratón o teclado (grab), y es establecido por cualquier programa cliente que necesita que todos los eventos producidos por estos dispositivos (se pueden capturar de forma conjunta o independiente) le sean notificados sólo a él. Podemos distinguir entre 2 tipos de capturas o grab: el grab activo (que se mantiene hasta que el cliente lo desactiva manualmente) o el pasivo, donde es el propio programa quien especifica cuando tendrá lugar la captura (ante la pulsación de un determinado botón o tecla), estado que se mantendrá hasta que se repita la misma pulsación.
La captura de ratón y teclado resulta muy útil en juegos y otros tipos de aplicaciones que requieren una atención especial a periféricos como el ratón o teclado.
Sobre los eventos de teclado, cabe decir que en cada instante hay una sóla ventana que recibe el enfoque del teclado (o foco), de tal modo que todos los eventos de teclado estarán siendo recibidos sólo por la ventana que recibe el foco y sus ventanas hijas. Este foco lo tiene por defecto la ventana raíz o Root Window (el escritorio), y es el gestor de ventanas el que suele modificarlo ante las peticiones del usuario. Un programa cliente puede modificar este enfoque mediante la función XSetInputFocus, que no vamos a necesitar en estos primeros capítulos.
Si, por ejemplo, el usuario pulsa una tecla y la aplicación seleccionó con XSelectInput() la recepción de eventos de teclado (KeyPressMask), al producirse la pulsación el servidor enviará al cliente un evento/mensaje llamado KeyPress, y una estructura de datos que contendrá información sobre el evento, en este caso, la tecla pulsada. En caso de que el cliente no seleccionara KeyPressMask, el evento simplemente es filtrado.
Cada evento requiere una información concreta (teclado=teclas, ratón=posiciones, botones, etc.), de modo que existen diferentes tipos de estructuras de eventos, de modo que X Window dispone de una estructura unión de todas que nos permitirá referirnos a la información de todos estos eventos mediante una sola struct llamada XEvent. Cuando se reciben los eventos, es posible retirarlos de la cola o bien leerlos sin retirarlos de dicha cola, todo ello mediante funciones como XNextEvent(), XMaskEvent(), WindowEvent(), XCheck() o XPeekEvent(), funciones que serán comentadas en la próxima entrega.
XDrawString(display, drawable, gc, x, y, string, length) Display *display; Drawable drawable; GC gc; int x, y; char *string; int length;Estos parámetros significan lo siguiente: Display es, como siempre, la comunicación entre el cliente y el servidor X; drawable es, de una forma sencilla, el lugar donde se dibujará; GC es el contexto gráfico a usar; length es la longitud de la cadena de texto a imprimir (se puede obtener con strlen()) y (X,Y) especifican las coordenadas de pixel donde se emplazará la esquina superior izquierda de la primera letra de la frase. Según se comenta en la documentación, cada imagen o carácter de la fuente es tratado como una máscara para una operación de rellenado en el drawable, de modo que como resultado de esa operación se obtenga una letra trazada en pantalla. El hecho de necesitar un GC (que podremos modificar como se verá más adelante), nos permitirá imprimir las letras con diferentes funciones, con varios estilos de rellenado con o sin clipping/recorte, etc.
Para poder utilizar esta función es necesario obtener primero todos sus parámetros. Para ello necesitaremos hacer uso de las funciones XLoadFont(), XCreateGC y XSetFont. El drawable será la propia ventana, es decir, el mismo manejador/identificador nos servirá.
Font XLoadFont(display, name) Display *display; char *name;Carga la fuente especificada y devuelve su respectivo identificador de fuente. El nombre de la fuente es cualquiera de los nombres estándar de X Window. Nosotros comenzaremos por utilizar la fuente de 9x15 u 8x16, cuyos nombres son "9x15" y "8x16", ya que estos son unos tamaños proporcionales a las fuentes de letras en consola.
Ejemplo: XLoadFont( display, "9x15" );Si queremos saber las fuentes disponibles en el sistema es posible utilizar la función XListFonts que requiere los siguientes parámetros.
char **XListFonts(display, pattern, maxnames, actual_count_return) Display *display; char *pattern; int maxnames; int *actual_count_return;Acepta la variable display, una cadena de búsqueda llamada pattern, como por ejemplo "9x*" (acabada en cero), de tal modo que se puedan especificar patrones de búsqueda (o simplemente "*", todas), maxnames, que es el número máximo de nombres que queremos que se nos devuelvan y actual_count_return, en donde se nos devolverá el número total de nombres de fuentes. No obstante esta función no la necesitaremos por el momento.
XSetFont(display, gc, font) Display *display; GC gc; Font font;Esta función pone la fuente especificada como fuente a utilizar en el GC especificado, aceptando para ello el display, el gc y la fuente (font) a utilizar. Este GC será creado con XCreateGC(), y no merece especial distinción (simplemente ver el ejemplo incluido más abajo).
Nota: para ver los diferentes mensajes de error que pueden generarse ante llamadas a estas funciones es recomendable la consulta de las páginas man de las diferentes funciones.
void main()
{
/* declaración de variables */
Display *display;
Window window;
GC gc;
Font font;
int pantalla;
unsigned long negro, blanco;
/* inicializaciones */
display = XOpenDisplay( NULL );
font = XLoadFont( display, "9x15" );
pantalla = DefaultScreen( display );
negro = BlackPixel( display, pantalla );
blanco = WhitePixel( display, pantalla );
window = XCreateSimpleWindow( etc, etc, etc,)
XSelectInput( etc, etc, etc );
XMapWindow( display, window );
/* VARIABLES GC y FONT */
gc = XCreateGC( display, window, 0, NULL );
XSetFont( display, gc, font );
/* resto del programa */
.. .. .. .. ..
/* en cualquier momento del mismo: */
XDrawString( display, window, gc, 100, 100, "Texto", 5 );
/* más codigo del programa */
.. .. .. .. ..
}
Lo que puede verse en el anterior código es que se necesita cargar un fuente y crear un GC que utilizará XDrawString para escribir en la ventana especificada.Por otra parte, conociendo esta función y teniendo a nuestro alcance la salida de texto en pantalla y el conocimiento (gracias a este y el siguiente artículo) de los eventos, ya será posible implementar programas elaborados de texto en X Window, creando un cursor virtual (2 variables CursorX, CursorY) y una función tipo printf() que utilice estas variables para hacer de la ventana gráfica algo similar a una ventana de texto, incrementando CursorX en AnchoFuente pixels para entrar en la siguiente celdilla, o CursorY en AltoFuente para pasar a la siguiente línea.
Figura 1: "Eventos y máscaras de eventos."
Santiago Romero