PyGTK/Smooth Animation with PyGTK/lang-es
| 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
Los eventos de PyGTK The PyGTK event queue is the means by which PyGTK events like mouse clicks, key presses and notifications are dispatched. The event queue is a list of events that need to be executed. Events can be generated by user input, or by other events such as an expose event generated by a window being resized.
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 es que si el número de milisegundos no es suficiente para todos los demás eventos que se procesarán entre los eventos del temporizador, puede morir de hambre la cola de eventos de tal manera que los acontecimientos, nunca va a suceder.
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
Threads
Yet another option for animation is to create a secondary thread which repeatedly calls queue_draw or some other function to update graphics.
This is how PyGame works, but in my experience the event queue tends to fill up leading to jerky animation and an unresponsive application.
Since the XO only has a single processor, multithreading adds additional overhead to the system, and you will have to deal with extra GTK and Python synchronization overhead as well.
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
The last method, and the only one I have found that is reliable enough for games, is to take over the PyGTK event loop. This is what SDL does internally, and is the pattern by which most Windows games operate as well.
The gtk.main() function supports being called recursively, and it has a gtk.main_iteration() function which processes a single event and returns. The final piece of the puzzle is gtk.events_pending(), which returns True if any events are pending.
This method is the most reliable, since you know that you will get all the available time, but also that all GTK events will be processed as soon as possible.
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
In the above examples, we have called self.queue_draw() to cause an event to be generated which will update the entire screen. In a real activity, you would just want to refresh whatever widget is animating.
However, another option is to just execute drawing commands (using cairo, gtk.Drawable, etc) in your main loop. There is no penalty to doing this, so you might want to consider it in game-like applications where rendering logic is mixed with update code.
Ejemplo del mundo real
Para un ejemplo que el juego escrito completamente en PyGTK usando estas tecnicas en la practica, ver la actividad ThreeDPong.