PyGTK/Smooth Animation with PyGTK/lang-es

  For Developers

Traducción de PyGTK/Smooth_Animation_with_PyGTK	original
english | español   +/-	cambios

Esta página describe las diferentes formas de tener una animación suave en PyGTK, con varios pros y contras.

Vida de la batería

Es importante entender que agregando animaciones contstantes (por ejemplo animar el fondo) hara que la laptop no entre en modo de suspención y hara que la batería se consuma rápidamente, haciendo tu aplicación menos popular en el mundo real.

Así que solo debes usar actividades animadas cuando sean absolutamente necesario, y por la cantidad de tiempo mas corta posible.

Eventos PyGTK

La cola de eventos de PyGTK es el medio por el cual los eventos como clic de ratón, tecla precionada y notificaciones las envía PyGTK. Los eventos se encolan en una lista que necesitan ser ejecutados.

Los eventos pueden ser generados por interacción del usuario, o por otros eventos como puede ser el tamaño inicial de una ventana.

La aplicación tipica de PyGTK se ve de esta manera:

• Crea una ventana y widgets GTK.
• Conecta los eventos a las funciones.
• Llama a gtk.main().

La función gtk.main() simplemente procesa la cola de eventos, despachando eventos conectados a la funciones, hasta que gtk.main_quit() es llamada, al punto que regresa a la aplicacion exsitente. Nota que en las actividades de Sugar, gtk.main() es llamado por la actividad de sugar por un script al ser ejecutada.

Este sistema manejado por eventos es bueno para las aplicaciones de GUI las cuales tipicamente quieren estar en espera que un evento externo (como la acción de un usurario) ocurra. Pero para aplicaciones en tiempo real, generalmente quieres un poco de codigo ejecutandose todo el tiempo. Afortunadamente, existen diferentes maneras de alcanzar este tipo de procesos en Pygtk.

Eventos de Tiempo

Usando gobject.timeout_add(ms, fn) tu puedes hacer en PyGTK llamadas especifcas a la funcion cada N milisegundos. Esto suele ser el primer paso suave de acercamiento a la animación.

Un problema con el evento de reloj es que el reloj solo se inicia cuando retorna *después* de la función. De este modo si el reloj se establece hasta 30ms y la funcion se ejecuta despues de los 20ms, eso puede estar llamando 50ms despues del primer llamado. Por lo tanto, el ritmo o la sincronización se convierte un poco inconsistente a menos que en la función simpre se tome exactamente la misma cantidad de tiempo (y el costo de la funcion necesariamente este tomado encuenta en el tiempo de espera)

Un segundo problema esta en que si no se cuenta con los milisegundos suficientes para todos los eventos a ser procesdaso sobre el evento del reloj, puedes perder la secuencia de los eventos (o la cola de estos)de tal manera que no se ejecute ninguno. Esto puede causar que el programa tiemble, la GUI falla al momento de actualizar, entre otros problemas.

Nota. Cuando la animación este finalizada, tu puedes detener el evento de reloj para retornar False desde el encabezado de la función.

Ejemplo

 class MyActivity(Activity)
   def __init__(self):
     # Agrega unos 20fps (50ms) tiempo de animacion.
     gobject.timeout_add(50, self.timer_cb)
 
   def timer_cb(self):
     # Generando un evento de apertura
     self.queue_draw()
     return True

Eventos Idle

Usando gobject.idle_add(fn) puedes configurar funciones que se llamaran cada vez que PyGTK esta en espera, eso es cuando no hay otros eventos para procesar.

Esto puede mejorar con el tiempo desde que facilita que los eventos no se manejaran, y otros eventos como comandos y actualiaciones de la GUI se ejecutran antes que la función sea llamada.

El problema con esto que otros eventos (como movimientos del mouse) tomen prioridades sobre eventos en espera, o vice versa, el cual lleva a la animacion se retrase ya que los eventos externos o otros procesos retrazaran el proceso de animación.

Como los eventos del timer, puede parar el evento en espera de ser generados regresando un False de la función que lo maneja.

Ejemplo

 class MyActivity(Activity)
   def __init__(self):
     gobject.idle_add(50, self.idle_cb)
 
   def idle_cb(self):
     # Generate an expose event.
     self.queue_draw()
     return True

Hilos | SubProcesos

Apesar de todo, otra opcion para la animación es la creación de un hilo secundario o subproceso que repetidas veces llamará queue_draw o alguna otra funcion a actualizar los gráficos.

Esto es cuando se trabaja con PyGame, pero en mi experiencia el evento de hacer colas o encolar tiende a llenar hasta desbordar por completo la animacion y la aplicación deja de responder.

This is how PyGame works, but in my experience the event queue tends to fill up leading to jerky animation and an unresponsive application.

Donde el XO solamente tiene un solo procesador, multihilo agrega adicionalmente una sobrecarga al sistema y tendrías que lidiar con la carga extra de GTK Python y con los gastos generales de la sincronización.

Example

 # Do not forget this!  Without it, you will get random crashes.  It must be called before gtk.main().
 gtk.gdk.threads_init()
 
 class MyActivity(Activity)
   def __init__(self):
     thr = threading.Thread(target=self.mainloop)
     thr.start()
 
   def mainloop(self):
     while True:
       # Generate an expose event.
       self.queue_draw()
       # Allow the main thread to process for a while.
       time.sleep(10)

Tomando control del evento de bucle

El último método, y el único que he encontrado que es lo suficientemente confiable para los juegos, es hacerse cargo de el ciclo de eventos PyGTK. Esto es lo que SDL hace internamente, y es el patrón por el cual la mayoría de los juegos de Windows funcionan así.

La función gtk.main() soporta llamadas recursivas, y tiene una función gtk.main_iteration()con procesos de eventos simples y retornos. La pieza final del rompecabeza es gtk.events_pending(), que retorna Verdadero si existen eventos pendientes.

Este método es el mas seguro, ya que sabe que va a obtener todo el tiempo disponible, pero también que todos los eventos de GTK serán procesadas tan pronto como sea posible.

Ejemplo

 class MyActivity(Activity)
   def __init__(self):
     # Start up the main loop just after application initialization.
     self.timeout_add(20, self.mainloop)
 
   def mainloop(self):
     while True:
       # Process all pending events.
       while gtk.events_pending():
         gtk.main_iteration(False)
       # Generate an expose event (could just draw here as well).
       self.queue_draw()

Exponer eventos versus dibujo Inmediato

En el ejemplo anterior, se ha llamado a self.queue_draw() para generar un evento que provoca que se actualice toda la pantalla. Es una actividad real, solo que se desa actualizar cualquier widget o sección de la animación.

Sin embargo, otra opción es ejecutar los comandos del dibujo (usuando cairo, gtk.Drawable, etc) en el ciclo principal. Esto no es penalizado, así que sería bueno considerar en las aplicaciones como juegos donde se mezcla lógica de representación con el código de actualización.

Ejemplo del mundo real

Para un ejemplo que el juego escrito completamente en PyGTK usando estas tecnicas en la practica, ver la actividad ThreeDPong.