conundrum

Un recap sui progetti a cui sto lavorando al momento.

Clutter

Nei commenti al blog precendente mi si chiedeva di Clutter. Per chi non seguisse Planet GNOME (o per chi lo seguisse ma non avesse comunque la più pallida idea di cosa si tratti), Clutter è un toolkit che ho contribuito a realizzare più o meno da quando sono stato assunto alla OpenedHand (settimana più, settimana meno).

Clutter è un toolkit basato sulle stesse librerie usate per le GTK+ (GLib, GObject, Pango) ideato per scrivere applicazioni con un’interfaccia grafica mono-finestra - ad esempio: media box, personal video recorder, etc. - in ambienti (embedded e non) dotati di grafica accelerata (tramite OpenGL oppure OpenGL ES). Clutter fornisce un canvas, rappresentato dal singleton ClutterStage, e alcuni widget, chiamati ClutterActor. I widget forniti sono (volutamente, al momento) pochi: non solo perché siamo alla release 0.2.0, ma soprattutto perché vogliamo vedere di cosa necessitano gli sviluppatori prima di implementare ClutterActor nel modo sbagliato o del tutto inutili.

Hello, World - Come funziona Clutter? Ecco un semplice “hello, world” che sfrutta buona parte delle nuove API. È scritto in Python - avrei preferito scriverlo in Perl, ma conoscendo la quantità di pythonisti in “ascolto” ho scelto altrimenti; la versione in Perl è disponibile a richiesta. Se volete, potete scaricarla e farci quello che volete - è nel public domain, come dovrebbero essere tutti gli “hello world” di questo mondo. Se cliccate dopo il link, smonto il codice in blocchi per spiegare come funziona.

import sys
import clutter

Si parte importando i moduli, ovviamente. Il modulo clutter è fornito da pyclutter e supporta tutta la core library; non appena riuscirò ad avere un po’ di tempo, e a domare le interazioni tra Python, GObject e GStreamer, pyclutter fornirà anche i binding per le estensioni multimediali disponibili (al momento) in C.

class HelloClutter:
    def __init__ (self, message):
        self.stage = clutter.stage_get_default()
        self.stage.set_color(clutter.color_parse(‘DarkSlateGrey’))
        self.stage.set_size(800, 600)
        self.stage.connect(‘key-press-event’, clutter.main_quit)
        self.stage.connect(‘button-press-event’,
                           self.on_button_press_event)

Semplice classe per la nostra applicazione; inizializziamo tutto quando e cominciamo a creare lo stage principale su cui aggiungeremo i vari attori. Diamo una mano di “DarkSlateGrey” al palco, lo allarghiamo a 800 pixel per 600 e colleghiamo i due eventi che ci interessano: pressione di un tasto (a cui associamo l’uscita dal programma) e pressione di un pulsante del mouse (a cui associamo il metodo on_button_press_event).

        color = clutter.Color(0xff, 0xcc, 0xcc, 0xdd)

Creiamo un colore, dandogli i valori dei quattro canali (rosso, verde, blu e alpha per l’opacità). Questo è uno dei vari modi che Clutter mette a disposizione per creare un colore. In alternativa, si può usare una stringa di testo (come sopra) che, però, non cambierà il valore dell’opacità di default; si può usare un intero senza segno da 32 bit (packed) come 0xffccccdd; si può usare una conversione di colorspace da HLS a RGB.

        self.label = clutter.Label()
        self.label.set_font_name(‘Mono 32′)
        self.label.set_text(message)
        self.label.set_color(color)
        (label_width, label_height) = self.label.get_size()
        label_x = self.stage.get_width() - label_width - 50
        label_y = self.stage.get_height() - label_height
        self.label.set_position(label_x, label_y)
        self.stage.add(self.label)

Dopo il palco, creiamo il primo attore: una semplice etichetta di testo. Decidiamo il font e il contenuto e posizioniamo l’attore a cinquanta pixel dall’estremo in basso a destra dello stage. Le dimensioni dell’etichetta vengono ricalcolate quando impostiamo il font e il testo, così da garantirci sempre dei valori aggiornati. Usando Pango, abbiamo gratis il supporto per l’internazionalizzazione delle stringhe, dei glifi, dei paragrafi, dell’ellissi dei testi, degli spazi e delle legature.

        self.cursor = clutter.Rectangle()
        self.cursor.set_color(color)
        self.cursor.set_size(20, label_height)
        cursor_x = self.stage.get_width() - 50
        cursor_y = self.stage.get_height() - label_height
        self.cursor.set_position(cursor_x, cursor_y)
        self.stage.add(self.cursor)

Altro attore: il “cursore” alto quanto l’etichetta di testo, largo venti pixel e posto nell’estremo in basso a destra del nostro stage. Ora non ci resta che animarlo, facendolo lampeggiare.

        self.timeline = clutter.Timeline(30, 25)
        self.timeline.set_loop(True)
        alpha = clutter.Alpha(self.timeline, clutter.ramp_func)
        self.behaviour = clutter.BehaviourOpacity(alpha, 0xdd, 0)
        self.behaviour.apply(self.cursor)

Per le animazioni ricorro ai “behaviour”, i comportamenti che accennavo all’inizio del post. Per prima cosa, creo una timeline, ovvero una linea che dia il computo del tempo; la voglio di trenta frame, con 25 frame al secondo, e la voglio in loop.

Come seconda cosa, creo un alpha. Un ClutterAlpha è un oggetto che lega una timeline a una funzione; ad ogni “tic” della timeline, invoca la funzione e ottiene un intero senza segno che è dipendente solo dal tempo. In pratica, ingegneristicamente parlando, è un generatore di forme d’onda (mi rendo conto solo ora, cercandolo, che Wikipedia italiana non ha una pagina sui generatori di forme d’onda; gli ingeneri sono peggio degli idraulici: quando servono non ci sono mai).

Infine, creo un behaviour, ovvero un oggetto che controlla una o più proprietà di un set di attori usando l’oggetto alpha; in questo caso, un ClutterBehaviourOpacity che controlla l’opacità degli attori.

    def on_button_press_event (self, stage, event):
        print “mouse button %d pressed at (%d, %d)” % \
              (event.button, event.x, event.y)

Questo è il callback del nostro evento, giusto per mostrare come ottenere i vari dettagli dall’oggetto event.

    def run (self):
        self.stage.show_all()
        self.timeline.start()
        clutter.main()

Il metodo run serve a:

• mostrare tutti gli attori sullo stage;
• avviare la timeline;
• avviare il main loop;

In questo senso, Clutter funziona esattamente come le GTK+: il main loop gira ed esegue il dispatch degli eventi da X all’applicazione.

def main (args):
    if args:
        message = args[0]
    else:
        message = ‘Hello, Clutter!’

    app = HelloClutter(message)
    app.run()
    return 0

if __name__ == ‘__main__’:
    sys.exit(main(sys.argv[1:]))

Qui c’è la solita ferramenta necessaria per i programmi Python. Per avviare, basta eseguire:

$ python hello-clutter.py "Ciao, mondo"

Where do we go from here? - La versione 0.1 di Clutter, rilasciata l’anno passato, ha gettato le fondamenta per gli attori di base, ed è stata sufficiente per realizzare OPT, un programma di presentazione usato da Ross Burton, da Jeff Waugh e dal sottoscritto al GUADEC di Vilanova. Per la version 0.2 abbiamo migliorato l’API, creato un renderer GL per Pango (riducendo l’utilizzo della memoria e aumentando la velocità e il supporto per l’internazionalizzazione) e aggiunto il supporto per i “comportamenti” (ClutterBehaviour) degli attori - ovvero un modo per animare i widget sul canvas. Purtroppo, a parte OPT non abbiamo notizia (al momento) di applicazioni che usino Clutter. Per questo ci farebbe piacere l’input della comunità, anche per sapere quali sono non solo i bug, ma anche le feature e le richieste che gli sviluppatori di applicazioni hanno; se voleste delle modifiche alle API per realizzare il prossimo rivale di MythTV (la cui interfaccia, diciamocela tutta, va bene a duemila geek, ma se la vedono gli utenti che hanno difficoltà a cambiare l’ora del videoregistratore abbiamo diecimila utenti che si buttano dalla finestra dall’orrore), oppure se avete dei bug da segnalare, basta aprire un ticket su Bugzilla.

continua…