Python e MVC, una storia tutta da scrivere (Prima parte)

Sistemato il modello, concentriamoci sulla sua rappresentazione e prendiamo in esame l’implementazione realizzata senza l’utilizzo di Glade (fra breve vi spiegherò il motivo), presente nel file view.py:

from gtkmvc.view import View

import gtk

class MyViewNoGlade (View):

def __init__(self, ctrl):

# Qui l’interfaccia non viene costruita partendo

# da un file glade. La registrazione viene ritardata

# e i widget verranno aggiunti a mano

# successivamente.

View.__init__(self, ctrl, register=False)

# Ecco i widget utilizzati:

w = gtk.Window()

h = gtk.VBox()

l = gtk.Label()

b = gtk.Button("Press")

h.pack_start(l)

h.pack_end(b)

w.add(h)

w.show_all()

# Aggiungiamo tutti i widget che ci interessano,

# assegnando loro un nome. Supponiamo che sia

# necessario accedere solo alla finestra principale,

# all’etichetta e al pulsante. I widget vengono

# aggiunti come in una mappa:

self[‘main_window’] = w

self[‘label’] = l

self[‘button’] = b

# Ora possiamo procedere alla registrazione

# della vista. Ciò consente al controller di

# configurare tutte le connessioni dei segnali

# e le altre operazioni:

ctrl.register_view(self)

return

pass # end of class

Ho pensato di tradurre i commenti embedded originali in modo da facilitare la comprensione del codice, già molto semplice di suo.

Definita l’interfaccia, non resta che curarne il collegamento con il modello. A tale scopo, nel file ctrl.py viene definita una nuova classe, MyController, che contiene i collegamenti sia alla vista che al modello e ne gestisce la sincronizzazione:

from gtkmvc import Controller

import gtk

class MyController (Controller):

def __init__(self, model):

Controller.__init__(self, model)

# Il controller osserva le proprietà

# presenti nel modello:

return

def register_view(self, view):

"""

Questo metodo viene richiamato dalla vista,

una volta pronta alla registrazione. Qui

colleghiamo il clic del pulsante al metodo

al quale desideriamo far gestire la risposta.

Lo stesso discorso vale per il segnale di

‘distruzione’ della finestra principale.

"""

Controller.register_view(self, view)

# collega i segnali:

self.view[‘main_window’].connect(‘destroy’, gtk.main_quit)

self.view[‘button’].connect(‘clicked’, self.on_button_clicked)

# inizializza il testo dell’etichetta:

self.view[’label’].set_text("%d" % self.model.counter)

return

# qui inseriamo i gestori dei segnali:

def on_button_clicked(self, button):

self.model.counter += 1 # modifica il modello

return

# e qui i metodi di notifica delle

# modifiche alle proprietà

# osservabili del modello:

def property_counter_value_change(self, model, old, new):

self.view[‘label’].set_text("%d" % new)

print "Property ‘counter’ changed value from %d to %d" % (old, new)

return

pass # end of class

Penso che i commenti embedded e la documentazione allegata possano chiarire anche i punti più oscuri del codice illustrato. Ho preferito utilizzare l’esempio no-Glade per un motivo di completezza, in modo da mostrarvi ogni piccolo aspetto implementativo.

Ci fermiamo qui, almeno per ora. Nella prossima puntata vi mostrerò una piccola applicazione d’esempio, completa e funzionante, sviluppata proprio con questo fantastico framework.

Riferimenti

Page 2 of 3 | Previous page | Next page