Introduzione all'uso di PyQt
per realizzare semplici interfacce grafiche
per i nostri programmi Python

Cosa sono Qt e PyQt

[Da Wikipedia]
In programmazione, Qt è una libreria multipiattaforma per lo sviluppo di programmi con interfaccia grafica tramite l'uso di widget (congegni o elementi grafici). Qt, ampiamente utilizzato nell'ambiente desktop KDE per Linux, è stato sviluppato dall'azienda Qt Software (meglio conosciuta come Trolltech o Quasar Technologies)...
Qt usa il linguaggio C++ standard [...] ma esistono interfacce per Java, Python, C, Perl e PHP. Gira sulle piattaforme principali...
[Fine citazione]

PyQt è dunque l'interfaccia Python di Qt. Di fatto, PyQt è solo un wrapper verso le procedure Qt scritte in C++; questo si vede molto bene nella documentazione delle classi, che spesso non è stata neppure adattata a Python, ma conserva impostazione e soprattutto esempi presi dal Qt in C++ ; vedi per esempio la documentazione della classe QVBoxLayout WEB.

Impostazione

Dopo un brevissimo riepilogo di alcuni concetti generali, per il resto questa introduzione si dipanerà attraverso la presentazione e la discussione di alcuni esempi.
I sorgenti verranno copiati da questa pagina Web in un editor di testo (o in Idle), eventualmente modificati e lanciati in esecuzione.

Risorse

Il libro-bibbia Rapid GUI Programming with Python and Qt di Mark Summerfield -->PDF.
I testi degli esempi del libro suddetto -->ZIP.
Un tutorial il cui livello di complessità corrisponde più o meno al corso -->WEB.
Il class reference completo delle classi di PyQt -->WEB, disponibile anche off-line.
La documentazione di Qt, per esempio su -->WEB.

Non è chiaro se il libro di Summerfield sia di pubblico dominio oppure no; per un po' di tempo è stato scaricabile anche da Google, ma adesso non lo è più: vedi qui.

Curiosità

La parola widget origina dalla contrazione dei termini window e gadget.
Qt ha radici molto antiche; alcuni widget (vedi QLCDNumber, WEB) provengono addirittura dal Basic del Sinclair ZX Spectrum (1982: WEB).

Aspetti generali

Programmazione ad eventi (event-driven)

Qt / PyQt, come (credo) tutte le librerie per lo sviluppo di interfacce grafiche, si basa su un paradigma di programmazione ad eventi. Concepire i propri programmi per una modalità di funzionamento ad eventi rappresenta probabilmente una delle maggiori difficoltà concettuali che si incontrano per passare da una programmazione a linea di comando ad una programmazione controllata da una interfaccia grafica.


Programmazione sequenziale	Programmazione ad eventi
Mentre in un programma tradizionale l'esecuzione delle istruzioni segue percorsi fissi, che si ramificano soltanto in punti ben determinati predefiniti dal programmatore, nei programmi scritti utilizzando la tecnica a eventi il flusso del programma è largamente determinato dal verificarsi di eventi esterni. I programmi che utilizzano la programmazione a eventi (denominati spesso programmi event-driven) sono composti tipicamente da diversi brevi sotto-programmi, chiamati gestori degli eventi (event handlers) - che sono eseguiti in risposta agli eventi esterni.

Programmazione sequenziale

Programmazione ad eventi

Mentre in un programma tradizionale l'esecuzione delle istruzioni segue percorsi fissi, che si ramificano soltanto in punti ben determinati predefiniti dal programmatore, nei programmi scritti utilizzando la tecnica a eventi il flusso del programma è largamente determinato dal verificarsi di eventi esterni.
I programmi che utilizzano la programmazione a eventi (denominati spesso programmi event-driven) sono composti tipicamente da diversi brevi sotto-programmi, chiamati gestori degli eventi (event handlers) - che sono eseguiti in risposta agli eventi esterni.

OOP: Genitori, figli, proprietari e posseduti

La programmazione ad eventi si avvale in modo sostanziale dell'architettura offerta dalla programmazione ad oggetti.
Per seguire senza troppe difficoltà questa introduzione a PyQt, sarebbe bene quindi avere ben chiari i concetti base della OOP e in particolare i concetti di: classe, istanza, ereditarietà, metodo, proprietà.

È importante capire bene (e soprattutto non confondere) la relazione genitore-figlio relativa alle classi e quella proprietario-posseduto relativa agli oggetti istanziati. La documentazione usa il termine parent in entrambi i casi; nel secondo caso secondo me sarebbe preferibile utilizzare il termine owner e mi sforzerò di farlo.

Ciò detto, iniziamo!

Ricorda:

Le applicazioni basate su una dialog-box costituiscono una classe di applicazioni semplici ma versatili, che permettono di soddisfare una grande quantità di esigenze. La loro principale limitazione consiste nell'impossibilità di inserire un sistema di menù a tendina e quindi nel dover associare tutte le funzionalità a pulsanti ed altri widget inseribili in una dialog box.

Esempio 1: una finestra di dialogo vuota e un pulsante

Notare:

I moduli che si devono importare.
Il concetto di top-level widget.
La relazione di appartenenza tra istanze.
La necessità di risalire l'albero delle classi in cerca di documentazione (cfr. setGeometry).
I limiti della documentazione ufficiale di PyQt.

Ricorda:

Sebbene questa non sia una regola tassativa, tuttavia in genere ogni applicazione ha un solo widget top-level; nelle applicazioni basate su una dialog-box principale, è questa il top-level widget; ogni altro widget appartiene alla dialog-box principale o ad un suo altro widget precedentemente istanziato.
I widget posseduti da un altro widget sono disegnati (salvo qualche eccezione) all'interno del proprietario e lo seguono quando esso si sposta. Essi vengono distrutti quando si chiude il proprietario e disabilitati quando si disabilita il proprietario.
Sul posizionamento assoluto, vedere qui.

Esempio 2: lo scheletro di una applicazione a dialog-box

Notare:

L'esecuzione da linea di comando.
La restituzione dell'exit code.
Perché passare i parametri al costruttore dell'applicazione?.
Il passaggio dei parametri al costruttore della dialog.
L'esecuzione con un doppio click.
L'esecuzione senza console (detached).
Ma in caso di errore?.

Esempio 3: check box con allineamento verticale

#
# Check box con allineamento verticale.
#
import sys
from PyQt4.QtCore import *
from PyQt4.QtGui import *

#
    # Amicizia Label-Controlli.
    #

#
    # Definizione del layout.
    #
    #vlt=QVBoxLayout()
    #vlt.addWidget(ckbUno)
    #vlt.addWidget(ckbDue)
    #vlt.addWidget(ckbTre)
    #self.setLayout(vlt)

#
    # Connessione eventi-metodi (signals-slots).
    #

#
    # Operazioni che devono avvenire una sola
    # volta al lancio dell'applicazione.
    #
    self.show()

#
  # Procedure operative della dialog box principale.
  #

##########################
# Avvio dell'applicazione.
#
myApp=QApplication(sys.argv)
dbm=dBoxMain(sys.argv)
myApp.exec_()

Notare:

La sovrapposizione dei widget.
L'opportunità di definire un layout.
Il funzionamento del layout verticale.
I metodi addWidget e setLayout.
L'uso dell'ampersend [&].
L'indipendenza dei check box.

Esempio 4: radio button con allineamento orizzontale

#
# Radio button con allineamento orizzontale.
#
import sys
from PyQt4.QtCore import *
from PyQt4.QtGui import *

#
    # Amicizia Label-Controlli.
    #

#
    # Definizione del layout.
    #
    hlt=QHBoxLayout()
    hlt.addWidget(rdbUno)
    hlt.addWidget(rdbDue)
    hlt.addWidget(rdbTre)
    self.setLayout(hlt)

#
    # Connessione eventi-metodi (signals-slots).
    #

#
    # Operazioni che devono avvenire una sola
    # volta al lancio dell'applicazione.
    #
    self.show()

#
  # Procedure operative della dialog box principale.
  #

##########################
# Avvio dell'applicazione.
#
myApp=QApplication(sys.argv)
dbm=dBoxMain(sys.argv)
myApp.exec_()

Notare:

Il funzionamento del layout orizzontale.
I metodi addWidget e setLayout.
La mutua esclusività dei radio button.

Ricorda:

Layout semplice

Creo i widget, che appartengono tutti alla dialog-box principale.
Inizializzo un layout senza proprietario.
Assegno i widget al layout con layoutName.addWidget(widgetName).
Assegno il layout alla dialog-box principale con self.setLayout(layoutName).

Esempio 5: doppio set di radio button (indipendenti)

#
# Doppio set di radio button (indipendenti).
#
import sys
from PyQt4.QtCore import *
from PyQt4.QtGui import *

#
    # Amicizia Label-Controlli.
    #

#
    # Definizione del layout.
    #
    vA=QVBoxLayout()
    vA.addWidget(rdbA1)
    vA.addWidget(rdbA2)
    vA.addWidget(rdbA3)
    #
    vB=QVBoxLayout()
    vB.addWidget(rdbB1)
    vB.addWidget(rdbB2)
    vB.addWidget(rdbB3)
    #
    hlt=QHBoxLayout()
    hlt.addLayout(vA)
    hlt.addLayout(vB)
    self.setLayout(hlt)

#
    # Connessione eventi-metodi (signals-slots).
    #

#
    # Operazioni che devono avvenire una sola
    # volta al lancio dell'applicazione.
    #
    self.show()

#
  # Procedure operative della dialog box principale.
  #

##########################
# Avvio dell'applicazione.
#
myApp=QApplication(sys.argv)
dbm=dBoxMain(sys.argv)
myApp.exec_()

#    #
#    # Raggruppamento.
#    #
#    grpA=QButtonGroup(self)
#    grpA.addButton(rdbA1)
#    grpA.addButton(rdbA2)
#    grpA.addButton(rdbA3)
#    #
#    grpB=QButtonGroup(self)
#    grpB.addButton(rdbB1)
#    grpB.addButton(rdbB2)
#    grpB.addButton(rdbB3)

Notare:

L'incastro dei layout verticale e orizzontale e il metodo addLayout.
L'oggetto di classe QButtonGroup che NON è un widget, ma bensì un contenitore astratto (senza alcun rendering grafico) per organizzare da un punto di vista logico dei gruppi di button (pulsanti, ovvero push button e radio button).
A differenza del widget QGroupBox (vedi sotto), l'oggetto QButtonGroup non consente di abilitare e disabilitare collettivamente i pulsanti che raggruppa.
L'oggetto QButtonGroup dà però la possibilità di associare i button senza rispettare alcuno schema legato alla disposizione grafica.

Ricorda:

Layout annidati (due in un terzo)

Creo i widget, che appartengono tutti alla dialog-box principale.
Inizializzo un primo layout senza proprietario.
Assegno alcuni widget al layout con layoutName.addWidget(widgetName).
Inizializzo un secondo layout senza proprietario.
Assegno altri widget al layout con layoutName.addWidget(widgetName).
Inizializzo un terzo layout senza proprietario.
Assegno i layout precedenti a questo terzo layout con terzoLayoutName.addLayout(layoutName).
Posso assegnare a questo terzo layout anche alcuni widget con terzoLayoutName.addWidget(widgetName).
Assegno il terzo layout alla dialog-box principale con self.setLayout(terzoLayoutName).

Esempio 6: doppio set di radio button indipendenti (approccio diverso)

#
# Doppio set di radio button indipendenti (approccio diverso).
#
import sys
from PyQt4.QtCore import *
from PyQt4.QtGui import *

#
    # Amicizia Label-Controlli.
    #

#
    # Definizione del layout.
    #
    vA=QVBoxLayout()
    vA.addWidget(rdbA1)
    vA.addWidget(rdbA2)
    vA.addWidget(rdbA3)
    gbxA.setLayout(vA)
    #
    vB=QVBoxLayout()
    vB.addWidget(rdbB1)
    vB.addWidget(rdbB2)
    vB.addWidget(rdbB3)
    gbxB.setLayout(vB)
    #
    hlt=QHBoxLayout()
    hlt.addWidget(gbxA)
    hlt.addWidget(gbxB)
    self.setLayout(hlt)

#
    # Connessione eventi-metodi (signals-slots).
    #

#
    # Operazioni che devono avvenire una sola
    # volta al lancio dell'applicazione.
    #
    self.show()

#
  # Procedure operative della dialog box principale.
  #

##########################
# Avvio dell'applicazione.
#
myApp=QApplication(sys.argv)
dbm=dBoxMain(sys.argv)
myApp.exec_()

Notare:

L'oggetto di classe QGroupBox, che è un widget con un suo rendering grafico; può essere abilitato e disabilitato, controllando in questo modo l'abilitazione dei pulsanti che contiene; può avere un titolo.
Notare il gioco delle appartenenze: gli oggetti di classe QGroupBox appartengono alla dialog, i radio button appartengo ai group box.
Notare anche il gioco dei layout, che adesso non ha bisogno del metodo addLayout.

Ricorda:

Layout con gruppi

Creo i gruppi QGroupBox, che appartengono alla dialog-box principale; ricordare che si tratta di widget!
Creo gli altri widget, che appartengono ai vari group box.
Per ogni group box:
1. inizializzo un layout senza proprietario;.
2. assegno i widget del gruppo al layout con layoutName.addWidget(widgetName);.
3. assegno il layout al gruppo con groupboxName.setLayout(layoutName).
Inizializzo un layout senza proprietario.
Assegno i gruppi al layout con layoutName.addWidget(groupboxName).
Assegno altri eventuali widget (fuori dai gruppi: questi widget appartengono alla dialog-box principale) al layout con layoutName.addWidget(widgetName).
Assegno quest'ultimo layout alla dialog-box principale con self.setLayout(layoutName).

Esempio 7: altra composizione di layout e prime funzionalità

#
# Altra composizione di layout e prime funzionalita'.
#
import sys
from PyQt4.QtCore import *
from PyQt4.QtGui import *

#################################
# Classe della dialog principale.
#
class dBoxMain(QDialog):
  def __init__(self,args):
  #
  # Costruttore della dialog principale.
  #
    QDialog.__init__(self)
    self.setWindowTitle(args[0])
    #
    # Costruzione dei widget.
    #
    gbxA=QGroupBox(self)
    btnUno=QPushButton(gbxA)
    btnUno.setText("Pulsante 1")
    btnDue=QPushButton(gbxA)
    btnDue.setText("Pulsante 2")
    btnTre=QPushButton(gbxA)
    btnTre.setText("Pulsante 3")
    btnTre.setEnabled(False)
    #
    gbxB=QGroupBox(self)
    btnQua=QPushButton(gbxB)
    btnQua.setText("Pulsante 4")
    btnCin=QPushButton(gbxB)
    btnCin.setText("Pulsante 5")
    #
    btnTog=QPushButton("Toggle",self)
    btnExt=QPushButton("Exit",self)

#
    # Amicizia Label-Controlli.
    #

#
    # Definizione del layout del gruppo A.
    #
    hA=QHBoxLayout()
    hA.addWidget(btnUno)
    hA.addWidget(btnDue)
    hA.addWidget(btnTre)
    gbxA.setLayout(hA)
    #
    # Definizione del layout del gruppo B.
    #
    hB=QHBoxLayout()
    hB.addStretch()
    hB.addWidget(btnQua)
    hB.addWidget(btnCin)
    gbxB.setLayout(hB)
    #
    # Definizione del layout della dialog box principale.
    #
    vlt=QVBoxLayout()
    vlt.addWidget(gbxA)
    vlt.addWidget(gbxB)
    vlt.addWidget(btnTog)
    vlt.addWidget(btnExt)
    self.setLayout(vlt)
    #
    # Connessione eventi-metodi (signals-slots).
    #
    self.connect(btnTog,SIGNAL("clicked(bool)"),self.toggle)
    self.connect(btnExt,SIGNAL("clicked(bool)"),self.reject)
    #btnTog.clicked[bool].connect(self.toggle)
    #btnExt.clicked[bool].connect(self.reject)
    #
    # Operazioni che devono avvenire una sola
    # volta al lancio dell'applicazione.
    #
    self.show()

#
  # Procedure operative della dialog box principale.
  #
  def toggle(self):
    gbxA.setEnabled(not gbxA.isEnabled())
#  def reject(self):
#    QDialog.reject(self)

##########################
# Avvio dell'applicazione.
#
myApp=QApplication(sys.argv)
dbm=dBoxMain(sys.argv)
myApp.exec_()

Notare:

Gioco delle appartenenze analogo al precedente.
Gioco del layout duale rispetto al precedente.
L'utilizzo del metodo addStretch.
C'è un errore!
La connessione eventi-metodi.
Il metodo statico QDialog.reject.
Il comportamento del pulsante 3.

Esempio 8: altri widget di uso comune; layout a griglia; altre funzionalità

#
# Altri widget di uso comune; layout a griglia; altre funzionalita'.
#
import sys
from PyQt4.QtCore import *
from PyQt4.QtGui import *

#################################
# Classe della dialog principale.
#
class dBoxMain(QDialog):
  def __init__(self,args):
  #
  # Costruttore della dialog principale.
  #
    QDialog.__init__(self)
    self.setWindowTitle(args[0])
    #
    # Costruzione dei widget: Label.
    #
    lblUno=QLabel("Prospetto acquisti",self)
    lblUno.setAlignment(Qt.AlignCenter)
    lblDue=QLabel("&Anno",self)
    lblTre=QLabel("&Quantit\u00e0",self) #'\u00e0' e' l'unicode x a'
    lblQua=QLabel("Costo &unitario",self)
    lblCin=QLabel("Costo totale",self)
    #
    self.lblSei=QLabel(self)
    self.lblSei.setText("[Anno 2001] - 2.50 \u20ac")
    #
    # Costruzione dei widget: Combo box.
    #
    self.cbxDue=QComboBox(self)
    self.cbxDue.addItems(["{0:d}".format(x) for x in range(2001,2011)])
    #
    # Costruzione dei widget: Spin box (per numeri interi).
    #
    self.sbxTre=QSpinBox(self)
    self.sbxTre.setRange(0,10)       #(min,max)
    self.sbxTre.setSingleStep(2)     #(step)
    self.sbxTre.setValue(5)          #(initVal)
    self.sbxTre.setPrefix("N.")
    #
    # Costruzione dei widget: Double spin box (per numeri reali).
    #
    self.dsxQua=QDoubleSpinBox(self)
    self.dsxQua.setRange(0.0,1.0)    #(min,max)
    self.dsxQua.setSingleStep(0.1)   #(step)
    self.dsxQua.setValue(0.5)        #(initVal)
    self.dsxQua.setSuffix(" \u20ac") #'\u20ac' e' l'unicode dell'euro
    #
    # Costruzione dei widget: Button.
    #
    btnUno=QPushButton("Calcola",self)
    btnDue=QPushButton(self)
    btnDue.setText("Fine")
    #
    # Amicizia Label-Controlli.
    #
    lblDue.setBuddy(self.cbxDue)
    lblTre.setBuddy(self.sbxTre)
    lblQua.setBuddy(self.dsxQua)
    #
    # Definizione del layout.
    #
    grd=QGridLayout()
    # gridlayoutName.addWidget(widgetName,row,col,rowspan,colspan)
    grd.addWidget(lblUno,0,0,1,2)
    grd.addWidget(lblDue,1,0)
    grd.addWidget(self.cbxDue,1,1)
    grd.addWidget(lblTre,2,0)
    grd.addWidget(self.sbxTre,2,1)
    grd.addWidget(lblQua,3,0)
    grd.addWidget(self.dsxQua,3,1)
    grd.addWidget(lblCin,4,0)
    grd.addWidget(self.lblSei,4,1)
    grd.addWidget(btnUno,5,0)
    grd.addWidget(btnDue,5,1)
    self.setLayout(grd)
    #
    # Connessione eventi-metodi (signals-slots).
    #
    self.connect(btnUno,SIGNAL("clicked(bool)"),self.docalc)
    self.connect(btnDue,SIGNAL("clicked(bool)"),self.reject)
    #
    # Operazioni che devono avvenire una sola
    # volta al lancio dell'applicazione.
    #
    self.show()

#
  # Procedure operative della dialog box principale.
  #
  def docalc(self):
    risnum=self.sbxTre.value()*self.dsxQua.value()
    risstr="[Anno {0}] - {1:.2f} \u20ac".format(self.cbxDue.currentText(),risnum)
    self.lblSei.setText(risstr)
  def reject(self):
    QDialog.reject(self)

##########################
# Avvio dell'applicazione.
#
myApp=QApplication(sys.argv)
dbm=dBoxMain(sys.argv)
myApp.exec_()

#    #
#    # Metodi aggiuntivi.
#    #
#    self.connect(self.cbxDue,SIGNAL("currentIndexChanged(int)"),self.docalc)
#    self.connect(self.sbxTre,SIGNAL("valueChanged(int)"),self.docalc)
#    self.connect(self.dsxQua,SIGNAL("valueChanged(double)"),self.docalc)

Notare:

I nuovi widget: label, combo box, spin box, button e alcuni dei loro metodi caratteristici.
L'amicizia label-controlli (metodo setBuddy).
Il layout a griglia.
La label come widget di output.
Altre connessioni eventi-metodi.

Ricorda:

Per assegnare i widget ad un layout a griglia la sintassi completa è gridlayoutName.addWidget(widgetName,row,col,rowspan,colspan).

Riassunto della puntata precedente

Qt è una libreria per realizzare GUI (interfacce grafiche).
Qt esiste per molte piattaforme: X11 (Linux con X Window), Mac OS X, MS Windows, piattaforme embedded (palmari e simili).
Qt è scritta in C++, ma esistono esistono interfacce per Java, Python, C, Perl e PHP.
PyQt è per l'appunto l'interfaccia Python per Qt e consiste di fatto solo un wrapper verso le procedure Qt scritte in C++, come appare chiaramente dalla documentazione.
Principalmente, [Py]Qt mette a disposizione un'ampia scelta di elementi grafici fondamentali, detti widget, che permettono all'utente di interagire con l'applicazione, mediante mouse e tastiera in un contesto grafico, nelle fasi di input dei dati, controllo dell'elaborazione ed output dei risultati (per un elenco dei principali widget disponibili vedere PDF).
[Py]Qt, come tutte le librerie GUI, funziona sulla base di un paradigma di programmazione ad eventi che a sua volta si avvale in modo sostanziale dell'architettura offerta dalla programmazione ad oggetti: i widget di [Py]Qt sono oggetti collegati tra di loro in una articolata gerarchia di classi (PDF).
L'impianto di una applicazione PyQt consiste nell'istanziare un widget principale (detto top-level widget, di solito - ma non necessariamente - una dialog-box o una finestra) e poi assegnargli una serie di altri widget, di cui il widget top-level diviene proprietario: tutti i metodi costruttori di widget in PyQt accettano infatti come ultimo parametro il riferimento ad un widget proprietario. Successivamente si definisce l'aspetto visivo della composizione dei widget e si stabiliscono le funzioni (metodi o anche slot) che devono essere eseguite quando sui widget vengono scatenati degli eventi (detti in linguaggio Qt signals).

Esempio 9: potenziometri e display LCD

#
# Potenziometri e display LCD.
#
import sys
from PyQt4.QtCore import *
from PyQt4.QtGui import *

MIN=20
MAX=80

#
    # Amicizia Label-Controlli.
    #

#
    # Definizione del layout.
    #
    hlt=QHBoxLayout()
    hlt.addWidget(self.rotPoten)
    hlt.addWidget(self.sldPoten)
    hlt.addWidget(self.lcdDispl)
    self.setLayout(hlt)
    #
    # Connessione eventi-metodi (signals-slots).
    #
    self.connect(self.rotPoten,SIGNAL("valueChanged(int)"),self.update1)
    self.connect(self.sldPoten,SIGNAL("valueChanged(int)"),self.update2)
    #
    # Operazioni che devono avvenire una sola
    # volta al lancio dell'applicazione.
    #
    self.show()

#
  # Procedure operative della dialog box principale.
  #
  def update1(self):
    val=self.rotPoten.value()
    self.sldPoten.setValue(val)
    self.lcdDispl.display("{0:2d}".format(val))
  def update2(self):
    val=self.sldPoten.value()
    self.rotPoten.setValue(val)
    self.lcdDispl.display("{0:2d}".format(val))
  def reject(self):
    QDialog.reject(self)

##########################
# Avvio dell'applicazione.
#
myApp=QApplication(sys.argv)
dbm=dBoxMain(sys.argv)
myApp.exec_()

Notare:

Il modo in cui i due potenziometri vengono sincronizzati.

Esempio 10: potenziometri e colori

#
# Potenziometri e colori.
#
import sys
from PyQt4.QtCore import *
from PyQt4.QtGui import *

#################################
# Classe della dialog principale.
#
class dBoxMain(QDialog):
 def __init__(self,args):
 #
 # Costruttore della dialog principale.
 #
 QDialog.__init__(self)
 self.setWindowTitle(args[0])
 #
 # Costruzione dei widget: RED.
 #
 self.diaRed=QDial(self)
 self.diaRed.setNotchesVisible(True)
 self.diaRed.setMinimum(0)
 self.diaRed.setMaximum(255)
 #
 lblRed=QLabel("&ROSSO",self)
 lblRed.setAlignment(Qt.AlignCenter)
 #
 self.sbxRed=QSpinBox(self)
 self.sbxRed.setRange(0,255)
 self.sbxRed.setSingleStep(1)
 self.sbxRed.setValue(0)
 #
 # Costruzione dei widget: GREEN.
 #
 self.diaGre=QDial(self)
 self.diaGre.setNotchesVisible(True)
 self.diaGre.setMinimum(0)
 self.diaGre.setMaximum(255)
 #
 lblGre=QLabel("&VERDE",self)
 lblGre.setAlignment(Qt.AlignCenter)
 #
 self.sbxGre=QSpinBox(self)
 self.sbxGre.setRange(0,255)
 self.sbxGre.setSingleStep(1)
 self.sbxGre.setValue(0)
 #
 # Costruzione dei widget: BLU.
 #
 self.diaBlu=QDial(self)
 self.diaBlu.setNotchesVisible(True)
 self.diaBlu.setMinimum(0)
 self.diaBlu.setMaximum(255)
 #
 lblBlu=QLabel("&BLU",self)
 lblBlu.setAlignment(Qt.AlignCenter)
 #
 self.sbxBlu=QSpinBox(self)
 self.sbxBlu.setRange(0,255)
 self.sbxBlu.setSingleStep(1)
 self.sbxBlu.setValue(0)
 #
 # Costruzione dei widget: quadrato di visualizzazione del colore.
 #
 self.lblDsp=QLabel(self)
 self.pixImg=QPixmap(120,120)
 self.pixImg.fill(QColor(0,0,0))
 self.lblDsp.setPixmap(self.pixImg)
 #
 # Amicizia Label-Controlli.
 #
 lblRed.setBuddy(self.sbxRed)
 lblGre.setBuddy(self.sbxGre)
 lblBlu.setBuddy(self.sbxBlu)
 #
 # Definizione del layout.
 #
 grd=QGridLayout()
 # gridlayoutName.addWidget(widgetName,row,col,rowspan,colspan)
 #
 grd.addWidget(lblRed,0,0)
 grd.addWidget(lblGre,0,1)
 grd.addWidget(lblBlu,0,2)
 #
 grd.addWidget(self.diaRed,1,0)
 grd.addWidget(self.diaGre,1,1)
 grd.addWidget(self.diaBlu,1,2)
 #
 grd.addWidget(self.sbxRed,2,0)
 grd.addWidget(self.sbxGre,2,1)
 grd.addWidget(self.sbxBlu,2,2)
 #
 grd.addWidget(self.lblDsp,0,3,3,1)
 self.setLayout(grd)
 #
 # Connessione eventi-metodi (signals-slots).
 #
 self.connect(self.diaRed,SIGNAL("valueChanged(int)"),self.update1)
 self.connect(self.diaGre,SIGNAL("valueChanged(int)"),self.update1)
 self.connect(self.diaBlu,SIGNAL("valueChanged(int)"),self.update1)
 self.connect(self.sbxRed,SIGNAL("valueChanged(int)"),self.update2)
 self.connect(self.sbxGre,SIGNAL("valueChanged(int)"),self.update2)
 self.connect(self.sbxBlu,SIGNAL("valueChanged(int)"),self.update2)
 #
 # Operazioni che devono avvenire una sola
 # volta al lancio dell'applicazione.
 #
 self.show()

#
  # Procedure operative della dialog box principale.
  #
  def update1(self):
    self.pixImg.fill(QColor(self.diaRed.value(),self.diaGre.value(),self.diaBlu.value()))
    self.lblDsp.setPixmap(self.pixImg)
    #
    val=self.diaRed.value()
    self.sbxRed.setValue(val)
    val=self.diaGre.value()
    self.sbxGre.setValue(val)
    val=self.diaBlu.value()
    self.sbxBlu.setValue(val)
  def update2(self):
    self.pixImg.fill(QColor(self.sbxRed.value(),self.sbxGre.value(),self.sbxBlu.value()))
    self.lblDsp.setPixmap(self.pixImg)
    #
    val=self.sbxRed.value()
    self.diaRed.setValue(val)
    val=self.sbxGre.value()
    self.diaGre.setValue(val)
    val=self.sbxBlu.value()
    self.diaBlu.setValue(val)
  def reject(self):
    QDialog.reject(self)

##########################
# Avvio dell'applicazione.
#
myApp=QApplication(sys.argv)
dbm=dBoxMain(sys.argv)
myApp.exec_()

Notare:

L'uso di una label come contenitore per una immagine bitmap.
I metodi di collegamento tra dial e spin box.
La gestione base dei colori in PyQt (classe QColor).

Ricorda:

Qt e le immagini
Qt provides four classes for handling image data: QImage, QPixmap, QBitmap and QPicture. QImage is designed and optimized for I/O, and for direct pixel access and manipulation, while QPixmap is designed and optimized for showing images on screen. QBitmap is only a convenience class that inherits QPixmap, ensuring a depth of 1. Finally, the QPicture class is a paint device that records and replays QPainter commands.

Esempio 11: file open dialog-box, lettura e visualizzazione di immagini, dialog-box secondarie modali e non modali, message box

#
# File open dialog box, lettura e visualizzazione di immagini,
# dialog box secondarie modali e non modali, message box.
#
import sys
from PyQt4.QtCore import *
from PyQt4.QtGui import *

#
    # Amicizia Label-Controlli.
    #

#
    # Definizione del layout.
    #
    vlt=QVBoxLayout()
    vlt.addWidget(btnModale)
    vlt.addWidget(btnNonmod)
    vlt.addWidget(btnUscita)
    self.setLayout(vlt)
    #
    # Connessione eventi-metodi (signals-slots).
    #
    self.connect(btnModale,SIGNAL("clicked(bool)"),self.showmodale)
    self.connect(btnNonmod,SIGNAL("clicked(bool)"),self.shownonmod)
    self.connect(btnUscita,SIGNAL("clicked(bool)"),self.reject)
    #
    # Operazioni che devono avvenire una sola
    # volta al lancio dell'applicazione.
    #
    self.show()

#
  # Procedure operative della dialog box principale.
  #
  def loadimg(self):
    fName=QFileDialog.getOpenFileName(self,"Apri immagine",
      ".","File di immagine (*.bmp *.gif *.jpg *.png)")
    if fName:
      self.pixImg=QPixmap(fName)
      return True
    else:
      return False
  def showmodale(self):
    if self.loadimg():
      dlgViewer=QDialog(self)
      lblMap=QLabel(dlgViewer)
      #
      viewLay=QVBoxLayout()
      viewLay.addWidget(lblMap)
      dlgViewer.setLayout(viewLay)
      #
      lblMap.setPixmap(self.pixImg)
      dlgViewer.move(50,50)
      dlgViewer.exec_()
  def shownonmod(self):
    if self.loadimg():
      dlgViewer=QDialog(self)
      lblMap=QLabel(dlgViewer)
      #
      viewLay=QVBoxLayout()
      viewLay.addWidget(lblMap)
      dlgViewer.setLayout(viewLay)
      #
      lblMap.setPixmap(self.pixImg)
      dlgViewer.move(50,50)
      dlgViewer.show()
  def reject(self):
    r=QMessageBox.question(self,"Chiedo conferma!","Sei sicuro?",
      QMessageBox.Yes | QMessageBox.No,QMessageBox.No)
    if r==QMessageBox.Yes:
      QDialog.reject(self)

##########################
# Avvio dell'applicazione.
#
myApp=QApplication(sys.argv)
dbm=dBoxMain(sys.argv)
myApp.exec_()

Notare:

La dialog-box di acquisizione di un nome di file.
L'attivazione di una dialog-box secondaria, modale [lanciata con la funzione exec_] e non modale [funzione show]; queste in generale possono essere molto utili per l'input di dati o l'output di risultati.
Le dialog-box secondarie sono un'eccezione alla regola per cui i widget posseduti vengono disegnati all'interno del proprietario.
L'uso di una label per visualizzare un'immagine.
La message box di conferma dell'uscita, che viene attivata anche se si esce col pulsante [X].

Ricorda:

dialog-box speciali

Per il significato dei parametri delle file open/save dialog-box vedi qui. Si tratta di metodi statici; l'uso tipico è:

    fileName=QFileDialog.getOpenFileName(self,"Titolo",
      "Initial_dir","Tipi di file (*.ex1 *.ex2 *.ex2)")
    if fileName:
      utilizza_il_nome_del_file
    else:
      NON_utilizza_il_nome_del_file

    fileName=QFileDialog.getSaveFileName(self,"Titolo",
      "Initial_dir","Tipi di file (*.ex1 *.ex2 *.ex2)")
    if fileName:
      utilizza_il_nome_del_file
    else:
      NON_utilizza_il_nome_del_file

Per il significato dei parametri della message box vedi qui. Si tratta di un metodo statico; l'uso tipico è:

    r=QMessageBox.question(self,"Titolo",
      "Prompt",QMessageBox.Yes | QMessageBox.No,
      QMessageBox.No)
    if r==QMessageBox.Yes:
      fai_qualcosa
    else:
      fai_qualcosaltro_o_niente

Alcue dialog-box specializzate

QColorDialog
QErrorMessage
QFileDialog
QFontDialog
QInputDialog
QMessageBox
QPageSetupDialog
QPrintPreviewDialog
QProgressDialog

dialog-box secondarie

In generale, le dialog-box secondarie si usano molto per realizzare moduli (form) con cui acquisire dall'utente dati, scelte, impostazioni. In quest'ottica, si distinguono tre tipologie di dialog-box: dumb dialog box, standard dialog-box e smart dialog-box.
Le dumb dialog-box sono dialog-box secondarie i cui widget sono inizializzati direttamente, uno per uno, dall'oggetto chiamante e sono poi riletti allo stesso modo quando la dialog-box viene confermata. All'interno di una dumb dialog-box è possibile effettuare una validazione a livello di widget, ma non a livello di form. Le dumb dialog-box sono normalmente modali e dotate di pulsanti di convalida finale per accettazione (per esempio, pulsante OK) o rifiuto (per esempio, un pulsante Cancel).
Nelle standard dialog-box esistono metodi per inizializzare e rileggere i valori dei vari widget, senza dover accedere direttamente agli stessi; questi metodi sono chiamati per iniziativa dell'oggetto chiamante, che passa loro dei parametri opportuni. È possibile effettuare una validazione a livello di form, oltre che a livello di widget. Le standard dialog-box possono essere modali (più spesso) ma anche non modali (nel qual caso saranno dotate di un pulsante con funzione di Apply).
In una smart dialog-box i valori dei widget vengono inizializzati e riletti dalla dialog stessa, in relazione ad una apposita struttura-dati i cui riferimenti vengono passati al suo costruttore. È possibile effettuare una validazione sia a livello di form, sia a livello di widget. Le smart dialog-box sono di solito non modali, con un pulsante di Apply. Spesso sono anche live, a significare che le modifiche ai valori dei widget, determinate dall'interazione con l'utente, si riflettono immediatamente nelle strutture-dati associate, rendendo inutile il comando di convalida.

Esempio 12: lettura e visualizzazione di file di testo e HTML

#
# Lettura e visualizzazione di file di testo e HTML.
#
import sys
from PyQt4.QtCore import *
from PyQt4.QtGui import *

#
    # Amicizia Label-Controlli.
    #

#
    # Definizione del layout.
    #
    grd=QGridLayout()
    # gridlayoutName.addWidget(widgetName,row,col,rowspan,colspan)
    grd.addWidget(self.btnApri,0,0)
    grd.addWidget(self.ckbHtml,0,1)
    grd.addWidget(btnExit,0,2)
    # grd.setColumnStretch(3,10)
    grd.addWidget(self.txtDisplay,1,0,1,3)
    self.setLayout(grd)
    # self.resize(600,500)
    #
    # Connessione eventi-metodi (signals-slots).
    #
    self.connect(self.btnApri,SIGNAL("clicked(bool)"),self.doview)
    self.connect(btnExit,SIGNAL("clicked(bool)"),self.reject)
    self.connect(self.ckbHtml,SIGNAL("stateChanged(int)"),self.switchmode)
    #
    # Operazioni che devono avvenire una sola
    # volta al lancio dell'applicazione.
    #
    self.show()

#
  # Procedure operative della dialog box principale.
  #
  def switchmode(self):
    if self.ckbHtml.isChecked():
      self.btnApri.setText(" Apri (come HTML) ")
    else:
      self.btnApri.setText(" Apri (come testo) ")
  def doview(self):
    self.txtDisplay.clear()
    fName=QFileDialog.getOpenFileName(self,"Apri file",
      ".","File di testo (*.txt *.prn)\nFile HTML (*.htm *.html)")
    if fName:
      with open(fName,"rt") as fp:
        tutto=fp.read()
        if self.ckbHtml.isChecked():
          self.txtDisplay.setHtml(tutto)
        else:
          self.txtDisplay.setPlainText(tutto)

##########################
# Avvio dell'applicazione.
#
myApp=QApplication(sys.argv)
dbm=dBoxMain(sys.argv)
myApp.exec_()

Notare:

La versatilità del widget QTextEdit.
La modifica dinamica dell'etichetta sul pulsante.
Il metodo resize della dialog-box principale.
Il metodo setColumnStretch per i layout a griglia.
Attenzione: in modalità HTML le immagini vengono caricate solo se si trovano nella cartella del programma!

Ricorda:

Il widget QTextEdit può essere utilizzato anche per l'input e l'editing di testo. Per l'input e l'editing di testo su linea singola esiste anche il widget QLineEdit.

Esempio 13: visualizzazione di un grafico Pyplot

#
# Visualizzazione di un grafico Pyplot.
#
import sys
from matplotlib import pyplot
from PyQt4.QtCore import *
from PyQt4.QtGui import *

#
    # Amicizia Label-Controlli.
    #

#
    # Definizione del layout.
    #
    vlt=QVBoxLayout()
    vlt.addWidget(btnApri)
    vlt.addWidget(btnFine)
    self.setLayout(vlt)
    #
    # Connessione eventi-metodi (signals-slots).
    #
    self.connect(btnApri,SIGNAL("clicked(bool)"),self.showgraph)
    self.connect(btnFine,SIGNAL("clicked(bool)"),self.reject)
    #
    # Operazioni che devono avvenire una sola
    # volta al lancio dell'applicazione.
    #
    self.show()

#
  # Procedure operative della dialog box principale.
  #
  def showgraph(self):
    fName=QFileDialog.getOpenFileName(self,"Apri dati",
      ".","File di testo (*.txt *.prn *.csv)")
    if fName:
      x=[]
      y=[]
      with open(fName,"rt") as fp:
        for s in fp.readlines():
          (xx,yy)=s.split(',')
          x.append(xx)
          y.append(yy)
      pyplot.figure(1)
      pyplot.subplot(111)
      pyplot.plot(x,y,linewidth=2.0)
      pyplot.title("GRAFICO SEGNALE")
      pyplot.xlabel('Tempo [s]')
      pyplot.ylabel('Ampiezza [V]')
      pyplot.grid(True)
      pyplot.show()

##########################
# Avvio dell'applicazione.
#
myApp=QApplication(sys.argv)
dbm=dBoxMain(sys.argv)
myApp.exec_()

Notare:

Posso chiudere indifferentemente prima il grafico o prima la dialog-box dell'applicazione.
Posso chiudere il grafico e farne un'altro.
NON posso lanciare un altro grafico prima di aver chiuso quello attivo!

Esempio 14: visualizzazione di un grafico Pyplot con blocco e sblocco

#
# Visualizzazione di un grafico Pyplot con blocco e sblocco.
#
import sys
from matplotlib import pyplot
from PyQt4.QtCore import *
from PyQt4.QtGui import *

def riabilita_pulsanti(evt):
#
# Ripristina lo stato di abilitazione del
# gruppo di pulsanti della dialog principale.
#
  dbm.gbxA.setEnabled(True)

#
    # Amicizia Label-Controlli.
    #

#
    # Definizione del layout.
    #
    hlt=QHBoxLayout()
    hlt.addWidget(btnApri)
    hlt.addWidget(btnFine)
    self.gbxA.setLayout(hlt)
    vlt=QVBoxLayout()
    vlt.addWidget(self.gbxA)
    self.setLayout(vlt)
    #
    # Connessione eventi-metodi (signals-slots).
    #
    self.connect(btnApri,SIGNAL("clicked(bool)"),self.showgraph)
    self.connect(btnFine,SIGNAL("clicked(bool)"),self.reject)
    #
    # Operazioni che devono avvenire una sola
    # volta al lancio dell'applicazione.
    #
    self.show()

#
  # Procedure operative della dialog box principale.
  #
  def showgraph(self):
    fName=QFileDialog.getOpenFileName(self,
      "Apri dati",".","File di testo (*.txt *.prn *.csv)")
    if fName:
      x=[]
      y=[]
      with open(fName,"rt") as fp:
        for s in fp.readlines():
          (xx,yy)=s.split(',')
          x.append(xx)
          y.append(yy)
      fig=pyplot.figure(1)
      fig.canvas.mpl_connect("close_event",riabilita_pulsanti)
      pyplot.subplot(111)
      pyplot.plot(x,y,linewidth=2.0)
      pyplot.title("GRAFICO SEGNALE")
      pyplot.xlabel('Tempo [s]')
      pyplot.ylabel('Ampiezza [V]')
      pyplot.grid(True)
      self.gbxA.setEnabled(False)
      pyplot.show()

##########################
# Avvio dell'applicazione.
#
myApp=QApplication(sys.argv)
dbm=dBoxMain(sys.argv)
myApp.exec_()

Notare:

La disabilitazione di gruppo.
Il codice esterno alla dialog-box principale.

Esempio 15: visualizzazione di due grafici in due figure Pyplot con blocco e sblocco

#
# Visualizzazione di due grafici in due figure Pyplot con blocco e sblocco.
#
import sys
from matplotlib import pyplot
from PyQt4.QtCore import *
from PyQt4.QtGui import *

def riabilita_pulsanti(evt):
#
# Ripristina lo stato di abilitazione del
# gruppo di pulsanti della dialog principale.
#
  dbm.nfig=dbm.nfig-1
  dbm.lblNum.setText("Lette {0:1d} immagini".format(dbm.nfig))
  if dbm.nfig==0:
    dbm.btnApri.setEnabled(True)

#################################
# Classe della dialog principale.
#
class dBoxMain(QDialog):
  def __init__(self,args):
  #
  # Costruttore della dialog principale.
  #
    QDialog.__init__(self)
    self.setWindowTitle(args[0])
    self.nfig=0
    #
    # Costruzione dei widget.
    #
    self.btnApri=QPushButton("Apri",self)
    btnFine=QPushButton("Fine",self)
    self.lblNum=QLabel("Lette 0 immagini",self)

#
    # Amicizia Label-Controlli.
    #

#
    # Definizione del layout.
    #
    hlt=QHBoxLayout()
    hlt.addWidget(self.btnApri)
    hlt.addWidget(btnFine)
    hlt.addWidget(self.lblNum)
    self.setLayout(hlt)
    #
    # Connessione eventi-metodi (signals-slots).
    #
    self.connect(self.btnApri,SIGNAL("clicked(bool)"),self.showgraph)
    self.connect(btnFine,SIGNAL("clicked(bool)"),self.reject)
    #
    # Operazioni che devono avvenire una sola
    # volta al lancio dell'applicazione.
    #
    self.show()

#
  # Procedure operative della dialog box principale.
  #
  def showgraph(self):
    fName=QFileDialog.getOpenFileName(self,
      "Apri dati",".","File di testo (*.txt *.prn *.csv)")
    if fName:
      self.nfig=self.nfig+1
      self.lblNum.setText("Lette {0:1d} immagini".format(self.nfig))
      x=[]
      y=[]
      with open(fName,"rt") as fp:
        for s in fp.readlines():
          (xx,yy)=s.split(',')
          x.append(xx)
          y.append(yy)
      fig=pyplot.figure(self.nfig)
      fig.canvas.mpl_connect("close_event",riabilita_pulsanti)
      pyplot.subplot(111)
      pyplot.plot(x,y,linewidth=2.0)
      pyplot.title("GRAFICO SEGNALE")
      pyplot.xlabel('Tempo [s]')
      pyplot.ylabel('Ampiezza [V]')
      pyplot.grid(True)
      if self.nfig==2:
        self.btnApri.setEnabled(False)
        pyplot.show()

##########################
# Avvio dell'applicazione.
#
myApp=QApplication(sys.argv)
dbm=dBoxMain(sys.argv)
myApp.exec_()

Notare:

L'utilizzo di una proprietà della dialog-box principale a mo' di variabile globale dell'applicazione, per tenere traccia del numero di immagini preparate.
L'indirizzamento dell'evento di chiusura di entrambe le finestre dei grafici alla stessa funzione esterna.

Esempio 16: visualizzazione di un grafico Pyplot in una dialog-box PyQt

#
# Visualizzazione di un grafico Pyplot
# in una dialog-box PyQt secondaria.
#
import sys
from matplotlib import pyplot
from matplotlib.backends.backend_qt4agg import FigureCanvasQTAgg
from matplotlib.backends.backend_qt4agg import NavigationToolbar2QT
from PyQt4.QtCore import *
from PyQt4.QtGui import *

#
    # Amicizia Label-Controlli.
    #

#
  # Procedure operative della dialog box principale.
  #
  def showgraph(self):
    fName=QFileDialog.getOpenFileName(self,"Apri dati",
      ".","File di testo (*.txt *.prn *.csv)")
    if fName:
      #
      # Preparo il grafico come "figure"
      # pyplot, in base ai dati del file.
      #
      x=[]
      y=[]
      with open(fName,"rt") as fp:
        for s in fp.readlines():
          (xx,yy)=s.split(',')
          x.append(xx)
          y.append(yy)
      pyFig=pyplot.figure()
      pyplot.subplot(111)
      pyplot.plot(x,y,linewidth=2.0)
      pyplot.title("GRAFICO SEGNALE")
      pyplot.xlabel('Tempo [s]')
      pyplot.ylabel('Ampiezza [V]')
      pyplot.grid(True)
      #
      # Costruisco una dialog-box secondaria.
      #
      dlgViewer=QDialog(self)
      #
      # Costruisco l'oggetto di interfaccia
      # PyQt - Matplotlib, passandogli la
      # figura pyplot da mostrare; la proprieta'
      # di questo oggetto viene assegnata alla
      # dialog-box che deve contenerlo.
      #
      mplGraf=FigureCanvasQTAgg(pyFig)
      mplGraf.setParent(dlgViewer)
      #
      # Costruisco anche la tool-bar di
      # controllo di Matplotlib. "False"
      # come ultimo parametro permette
      # di eliminare la finestrina delle
      # coordinate variabili; la proprieta'
      # di questo oggetto viene assegnata
      # alla dialog-box che deve contenerlo.
      #
      ntbGraf=NavigationToolbar2QT(mplGraf,dlgViewer,False)
      #
      # Inserisco i due oggetti Matplotlib nella
      # dialog-box, utilizzando un layout verticale,
      # con la tool-bar SOPRA il grafico.
      #
      viewLay=QVBoxLayout()
      viewLay.addWidget(ntbGraf)
      viewLay.addWidget(mplGraf)
      dlgViewer.setLayout(viewLay)
      #
      # Visualizzo la dialog-box secondaria
      # ed in essa il grafico desiderato.
      #
      dlgViewer.move(20,20)
      dlgViewer.exec_()

##########################
# Avvio dell'applicazione.
#
myApp=QApplication(sys.argv)
dbm=dBoxMain(sys.argv)
myApp.exec_()

Notare:

Nella procedura showgraph si costruisce il grafico esattamente come nell'esempio 13, ma alla figura pyplot così ottenuta viene assegnato un riferimento esplicito (pyFig) e non viene chiamato il metodo pyplot.show; inoltre non è opportuno assegnare esplicitamente un numero alla figura (come argomento della funzione pyplot.figure) per evitare la sovrapposizione in caso di costruzione di più figure.
Si istanziano direttamente due oggetti che ereditano sia dal mondo Matplotlib, sia dal mondo PyQt: FigureCanvasQTAgg e NavigationToolbar2QTAgg. Nell'esempio 16b viene invece definita e poi istanziata una classe Qt4MplCanvas figlia della FigureCanvasQTAgg: questo approccio è utile se se ne vogliono modificare molte proprietà.
Entrambi gli oggeti di cui sopra vengono inseriti in una dialog-box secondaria.
Al primo di questi oggetti viene passato il riferimento alla figura pyplot precedentemente costruita (pyFig). Poiché il costruttore di questo oggetto non ammette invece di specificare anche un proprietario, l'oggetto viene esplicitamente assegnato alla dialog-box in cui verrà inserito per mezzo del metodo setParent (nel caso dell'esempio 16b, questo avviene nel costruttore della classe derivata Qt4MplCanvas). Tutto questo per altro non sarebbe strettamente necessario, in quanto la stessa operazione di apparentamento verrebbe comunque effettuata dal layout manager in modo automatico.
La dialog-box secondaria viene attivata in modalità modale (metodo exec_). Se volessimo attivarla in modalità non modale (metodo show), occorrerebbe prevedere esplicitamente la chiusura e distruzione della dialog-box secondaria all'uscita del programma. L'esempio 16c illustra questa possibilità, gestendo anche una lista di dialog-box secondarie con relative figure pyplot, in modo da consentire di visualizzare più grafici contemporaneamente.
L'esempio 16d presenta un approccio diverso, in cui non si apre una dialog-box secondaria, ma invece si inserisce il grafico pyplot direttamente in un QFrame a sua volta inserito nella dialog-box principale.

Esempio 17: lo scheletro di una applicazione a finestra (window)

#
# Lo scheletro di una applicazione a finestra (window).
#
import sys
from PyQt4.QtCore import *
from PyQt4.QtGui import *

#
    # Definizione del menu' e associazione con le relative azioni.
    #

#
    # Costruzione della status bar.
    #

#
    # Costruzione del central widget.
    #

#
    # Costruzione degli altri widget.
    #

#
    # Amicizia Label-Controlli.
    #

#
    # Definizione del layout.
    #

#
    # Connessione eventi-metodi (signals-slots).
    #

#
    # Operazioni che devono avvenire una sola
    # volta al lancio dell'applicazione.
    #
    self.show()

#
  # Procedure operative della finestra principale.
  #

##########################
# Avvio dell'applicazione.
#
myApp=QApplication(sys.argv)
wnm=winMain(sys.argv)
myApp.exec_()

Notare:

La struttura un po' diversa.
La finestra ha sempre un central widget.

Esempio 18: operazioni su immagini (esempio di applicazione a finestra e menù)

#
# Operazioni su immagini (esempio di applicazione a finestra e menu').
#
import sys
from PyQt4.QtCore import *
from PyQt4.QtGui import *

###################################
# Classe della finestra principale.
#
class winMain(QMainWindow):
  def __init__(self,args):
  #
  # Costruttore della finestra principale.
  #
    QMainWindow.__init__(self)
    self.setWindowTitle(args[0])
    self.wrkImg=QImage()
    #
    # Definizione delle azioni e associazione con i relativi metodi.
    #
    fileOpenAction=QAction("&Apri",self)
    fileOpenAction.setStatusTip("Apri un file di immagine")
    self.connect(fileOpenAction,SIGNAL("triggered(bool)"),self.aprifile)
    #
    fileQuitAction=QAction("&Esci",self)
    fileQuitAction.setStatusTip("Chiudi il programma")
    self.connect(fileQuitAction,SIGNAL("triggered(bool)"),self.close)
    #
    editFlipHAction=QAction("Flip&H",self)
    editFlipHAction.setStatusTip("Ribalta orizzontalmente")
    self.connect(editFlipHAction,SIGNAL("triggered(bool)"),self.fliphoriz)
    #
    editFlipVAction=QAction("Flip&V",self)
    editFlipVAction.setStatusTip("Ribalta verticalmente")
    self.connect(editFlipVAction,SIGNAL("triggered(bool)"),self.flipvert)
    #
    editInvertAction=QAction("&Invert",self)
    editInvertAction.setStatusTip("Inverti")
    self.connect(editInvertAction,SIGNAL("triggered(bool)"),self.invertcolor)
    #
    # Definizione del menu' e associazione con le relative azioni.
    #
    mBar=self.menuBar()
    fileMnu=mBar.addMenu("&File")
    fileMnu.addAction(fileOpenAction)
    fileMnu.addAction(fileQuitAction)
    editMnu=mBar.addMenu("&Edit")
    editMnu.addAction(editInvertAction)
    #
    flipMnu=editMnu.addMenu("&Flip")
    flipMnu.addAction(editFlipHAction)
    flipMnu.addAction(editFlipVAction)
    #
    # Costruzione della status bar.
    #
    self.sBar=self.statusBar()
    self.sBar.showMessage("Sono pronto/a")
    #
    # Costruzione del central widget.
    #
    self.lblImage=QLabel()
    self.lblImage.setMinimumSize(200,200)
    self.lblImage.setAlignment(Qt.AlignCenter)
    self.setCentralWidget(self.lblImage)
    self.lblImage.setPixmap(QPixmap("splash.gif"))
    #
    # Costruzione degli altri widget.
    #

#
    # Amicizia Label-Controlli.
    #

#
    # Definizione del layout.
    #

#
    # Connessione eventi-metodi (signals-slots).
    #

#
    # Operazioni che devono avvenire una sola
    # volta al lancio dell'applicazione.
    #
    self.resize(600,450)
    self.show()

#
  # Procedure operative della finestra principale.
  #
  def showimage(self):
      self.lblImage.setPixmap(QPixmap.fromImage(self.wrkImg))
  def aprifile(self):
    fName=QFileDialog.getOpenFileName(self,"Apri immagine",
      ".","File di immagine (*.bmp *.gif *.jpg *.png)")
    if fName:
      self.wrkImg=QImage(fName)
      self.showimage()
      self.sBar.showMessage("Immagine caricata")
  def fliphoriz(self):
    self.wrkImg=self.wrkImg.mirrored(True,False)
    self.showimage()
    self.sBar.showMessage("Immagine specchiata orizzontalmente")
  def flipvert(self):
    self.wrkImg=self.wrkImg.mirrored(False,True)
    self.showimage()
    self.sBar.showMessage("Immagine specchiata verticalmente")
  def invertcolor(self):
    self.wrkImg.invertPixels()
    self.showimage()
    self.sBar.showMessage("Colori invertiti")

##########################
# Avvio dell'applicazione.
#
myApp=QApplication(sys.argv)
wnm=winMain(sys.argv)
myApp.exec_()

Notare:

La finestra ha sempre un central widget.
Il concetto di azione in collegamento col menù.
Posso usare il central widget per uno splash-screen iniziale.
Le operazioni built-in sulle immagini.

Che altro ancora?

Line editor.
Liste.
Scroll bar.
Parser HTML e XML.
Widget multimediali.
Supporto ai database.
.....

Ritorna alla pagina indice

Daniele Andreuccetti, IFAC-CNR, giugno 2015

Introduzione all'uso di PyQtper realizzare semplici interfacce graficheper i nostri programmi Python

Cosa sono Qt e PyQt

Impostazione

Risorse

Curiosità

Aspetti generali

Programmazione ad eventi (event-driven)

OOP: Genitori, figli, proprietari e posseduti

Ciò detto, iniziamo!

Ricorda:

Esempio 1: una finestra di dialogo vuota e un pulsante

Notare:

Ricorda:

Esempio 2: lo scheletro di una applicazione a dialog-box

Notare:

Esempio 3: check box con allineamento verticale

Notare:

Esempio 4: radio button con allineamento orizzontale

Notare:

Ricorda:

Esempio 5: doppio set di radio button (indipendenti)

Notare:

Ricorda:

Esempio 6: doppio set di radio button indipendenti (approccio diverso)

Notare:

Ricorda:

Esempio 7: altra composizione di layout e prime funzionalità

Notare:

Esempio 8: altri widget di uso comune; layout a griglia; altre funzionalità

Notare:

Ricorda:

Riassunto della puntata precedente

Esempio 9: potenziometri e display LCD

Notare:

Esempio 10: potenziometri e colori

Notare:

Ricorda:

Esempio 11: file open dialog-box, lettura e visualizzazione di immagini, dialog-box secondarie modali e non modali, message box

Notare:

Ricorda:

Esempio 12: lettura e visualizzazione di file di testo e HTML

Notare:

Ricorda:

Esempio 13: visualizzazione di un grafico Pyplot

Notare:

Esempio 14: visualizzazione di un grafico Pyplot con blocco e sblocco

Notare:

Esempio 15: visualizzazione di due grafici in due figure Pyplot con blocco e sblocco

Notare:

Esempio 16: visualizzazione di un grafico Pyplot in una dialog-box PyQt

Notare:

Esempio 17: lo scheletro di una applicazione a finestra (window)

Notare:

Esempio 18: operazioni su immagini (esempio di applicazione a finestra e menù)

Notare:

Che altro ancora?

Introduzione all'uso di PyQt
per realizzare semplici interfacce grafiche
per i nostri programmi Python