Voy a explicar en esta entrada, como
intento enfocar el sistema de eventos en pyBta.
Imaginemos este programa:
#
-*- coding: ISO-8859-1 -*-
#!
/usr/local/bin/python
import
pyBta
from
pyBta import
controles
pyBta.iniciar(titulo="Prueba,
lectura
de
eventos",dimensiones=(200,200))
class
Formulario(controles.BtaFormulario):
def
__init__(self):
controles.BtaFormulario.__init__(self)
def
pre_iniciar(self):
self.medidas=200,200
self.panel=controles.BtaPanelCascada()
self.etiquetaHola=controles.BtaEtiquetaTextual("")
self.etiquetaHola.medidas=200,175
self.etiquetaHola.tama_fuente(30)
self.etiquetaHola.alinear=pyBta.ALINEAR_CENTRO,pyBta.ALINEAR_CENTRO
self.panel.poner(self.etiquetaHola)
self.botonHola=controles.BtaBotonTextual("pulsa
para
saludar")
self.botonHola.medidas=200,20
self.panel.poner(self.botonHola)
self.poner(self.panel)
return
True
def
post_iniciar(self):
pyBta.eventos.registrar_metodo("PULSANDO_SOBRE",self.botonHola,self.saludar)
return
True
def
saludar(self,evento):
self.etiquetaHola.etiqueta="Hola
Mundo."
formulario=Formulario()
pantalla=pyBta.BtaPantalla()
pantalla.poner(formulario)
pyBta.poner_pantalla(pantalla)
pyBta.ejecutar()
El programa muestra, un formulario,un
botón y una etiqueta. Cuando el usuario pulsa sobre el botón, la
etiqueta muestra el mensaje, hola mundo.
Para que esto funcione, PyBta necesita
de tres elementos fundamentales: un elemento a registrar, una función
que sirva de respuesta y una señal de evento válida para que la
función sea ejecutada en el momento requerido.
En este caso, el elemento a registrar
sería el objeto, self.botonSaludar, la función de respuesta sería,
self.saludar(self,evento) y la señal de evento requerida para
ejecutar la función, vendría dada por el módulo de eventos.
Para que pyBta responda a un
determinado evento, este tendrá que ser registrado dentro del
módulo, usando los tres elementos anteriores. El registro de un
evento, se puede ve en esta forma:
pyBta.eventos.registrar_metodo("PULSANDO_SOBRE",self.botonHola,self.saludar)
Como funciona:
Internamente, este módulo se basa en
un patrón Handler extendido. Este patrón se basa en tres elementos:
el constructor de eventos, el disparador y los n manejadores que sea
capaz de soportar el sistema.
La imagen anterior muestra, a grandes
rasgos, como funciona internamente el módulo de eventos.
Constructor de eventos: este
objeto es el encargado de gestionar el flujo de
eventos necesario, que después será enviado al disparador.
El disparador: este objeto es el
encargado de consumir el flujo de eventos
generado por el
constructor, para después, identificarlos uno a uno
y enviarlos a
sus manejadores correspondientes.
Los manejadores: Estos objetos
son los encargados de dar respuesta a los
eventos recibidos desde
el disparador. En pyBta, existe un
objeto manejador para cada
tipo de evento que la biblioteca
es capaz de generar.
PyBta mantiene estros tres elementos,
de manera interna al módulo y ofrece, mediante el objeto global
eventos, de una interfaz válida para la comunicación entre el
módulo y el exterior.
El módulo separa sus eventos en cinco
jerarquías diferentes. Estas jerarquías se encargan de agrupar los
distintos conjuntos de manejadores, según sea su ámbito.
Estas cinco jerarquías de manejadores
son:
Manejadores globales: estos son
los encargados de recibir los eventos
que son globales a toda
la biblioteca.
Manejadores generales:
estos son los encargados de mantener los eventos
que son visibles
desde la clase BtaElemento.
Manejadores
de control: Grupo de
manejadores encargados de mantener
eventos propios
a la biblioteca de
controles.
Manejadores
de escena: Grupo de manejadores
encargados de mantener
eventos propios del módulo escenas.
Manejadores de usuario: Grupo
de manejadores que se encargan de
mantener eventos
propios del usuario. Estos
manejadores, se generan y destruyen,
de manera manual.
De este modo, cada jerarquía es capaz
de contener el grupo de manejadores necesarios para mantener su
ámbito de eventos.
El módulo genera su flujo de eventos
de tres maneras diferentes. El encargado de este trabajo es el
objeto, constructorDeEventos.
La primera forma en la que pyBta genera
su flujo de eventos, es apoyándose de los eventos que ofrece la cola
de eventos de Pygame y estos son traducidos, mediante un grupo de
funciones, a eventos que pyBta puede entender, estos pertenecen al
ámbito de eventos globales.
A partir de ese primer flujo, entran en
juego los eventos de tipo conexión. Estos son generados mediante
unos objetos llamados, BtaConexion y pertenecen a la jerarquía de
eventos generales. Estos objetos, son depositados dentro del
constructorDeEventos y después, este los comprueba en tiempo de
ejecución.
La tercera forma en la que pyBta crea
su flujo de eventos, es mediante los llamados, envíos directos.
Esta forma de enviar señales al flujo
de eventos, se hace mediante el objeto eventos. Este tipo de eventos,
están relacionados con las jerarquías de control, de escenas y de
usuario.
Para enviar una señal al constructor,
se debe rellenar un diccionario con los valores requeridos por el
evento a llamar y después usar la función ,
pyBta.eventos.envio_directo(evento)
pasándole el diccionario creado.
Todas las señales generadas por el
objeto constructor, serán almacenadas dentro de el, mediante una
lista de señales. Periódicamente, el objeto disparador consume esa
lista de señales a eventos y la recorre mirando una a una cada
señal, para identificarla y enviarla a su manejador correspondiente.
Los manejadores se encargan del resto
del trabajo, mirando la señal recibida y buscando dentro de si
mismos, si tienen alguna respuesta asociada. De ser así, el
manejador emitirá esa respuesta y de no ser así, el manejador
desechará la señal.
En la próxima entrada explicaré los
eventos globales y generales que PyBta es capaz de generar.
Invito a cualquier persona a dar su
sana opinión. Yo me baso en esta idea, pero puedo estar equivocado, en modos o conceptos. Gracias.
No hay comentarios:
Publicar un comentario