Alcuni HowTo su questioni specifiche di PyQt

In questa pagina vengono descritte le soluzioni pratiche ad alcuni problemi specifici che si possono incontrare realizzando interfacce grafiche in PyQt per applicazioni sul modello DBA (Dialog-Box Application) oppure MWA (Main Window Application)

Intercettare il pulsantino [x] di chiusura della dialog-box principale di una DBA

Il pulsantino [x] in alto a destra nella dialog-box principale e il comando da tastiera "ALT-F4" generano entrambi lo stesso evento, gestito dalla procedura "closeEvent". Questa finisce col chiamare il metodo "reject" della classe QDialog. La via più semplice di gestire in modo personalizzato l'uscita da una applicazione (per esempio chiedendo conferma), magari predisponendo anche un pulsante dedicato, consiste nel ridefinire il metodo "reject" stesso (method overriding), collegandolo poi al pulsante dedicato.

Note:

Il pulsantino [x] della dialog-box genera lo stesso evento della combinazione di tasti "ALT-F4"; questo evento viene gestito dalla procedura "closeEvent", che a sua volta chiama la procedura "QDialog.reject".
Il tasto "ESC" chiama direttamente la procedura "QDialog.reject".
È possibile ridefinire la procedura "reject" per predisporre un percorso di uscita personalizzato e per collegarla anche a pulsanti o comandi specifici dell'applicazione.

Si noti anche il meccanismo con cui si riconosce quale dei pulsanti 1...5 è stato premuto.

Se si è interessati ad un controllo più preciso, che permetta per esempio di disabilitare del tutto il pulsantino [x] e il comando "ALT-F4", allora occorre ridefinire il gestore dell'evento "closeEvent". In questo caso è importante però tenere presente quanto segue:

se si decide di ignorare l'evento, allora si deve restare nell'applicazione;
se si vuole uscire dall'applicazione, allora non si può ignorare l'evento, altrimenti l'applicazione non verrà chiusa correttamente;
il tasto "ESC" chiama direttamente la procedura "QDialog.reject", quindi il suo comportamento non viene modificato se si ridefinisce il gestore "closeEvent"; occorre invece intervenire direttamente sul gestore "keyPressEvent".

from PyQt4.QtCore import *
from PyQt4.QtGui import *
#
class dBoxMain(QDialog):
  def __init__(self):
  #
  # Costruttore della dialog-box principale.
  #
    QDialog.__init__(self)
    self.setWindowTitle("Titolo")
    #
    # Costruzione dei widget.
    #
    btn1=QPushButton(self)
    btn1.setText("Bottone 1")
    btn2=QPushButton(self)
    btn2.setText("Bottone 2")
    btn3=QPushButton(self)
    btn3.setText("Bottone 3")
    btn4=QPushButton(self)
    btn4.setText("Bottone 4")
    btn5=QPushButton(self)
    btn5.setText("Bottone 5")
    btnU=QPushButton(self)
    btnU.setText("Uscita")
    #
    self.txtMsgs=QTextEdit(self)
    self.txtMsgs.setReadOnly(True)
    #
    # Definizione del layout.
    #
    grdMain=QGridLayout()
    grdMain.addWidget(btn1,0,0)
    grdMain.addWidget(btn2,1,0)
    grdMain.addWidget(btn3,2,0)
    grdMain.addWidget(btn4,3,0)
    grdMain.addWidget(btn5,4,0)
    grdMain.addWidget(btnU,5,0)
    #
    self.txtMsgs.setMinimumWidth(320)
    self.txtMsgs.setMinimumHeight(240)
    grdMain.addWidget(self.txtMsgs,0,1,6,1)
    #
    self.setLayout(grdMain)
    #
    # Connessione eventi-metodi (signals-slots).
    #
    self.connect(btn1,SIGNAL("clicked(bool)"),self.scriviMessaggio)
    self.connect(btn2,SIGNAL("clicked(bool)"),self.scriviMessaggio)
    self.connect(btn3,SIGNAL("clicked(bool)"),self.scriviMessaggio)
    self.connect(btn4,SIGNAL("clicked(bool)"),self.scriviMessaggio)
    self.connect(btn5,SIGNAL("clicked(bool)"),self.scriviMessaggio)
    self.connect(btnU,SIGNAL("clicked(bool)"),self.fineProgramma)
    #
    # Operazioni che devono avvenire una sola
    # volta al lancio dell'applicazione.
    #
    self.show()
  #
  # Procedure operative della dialog-box principale.
  #
  def closeEvent(self,e):
    #
    # Se si vogliono rendere inefficaci il pulsantino [x]
    # della dialog-box e il comando ALT-F4.
    #
    # e.ignore()
    #
    # Se si vogliono associare il pulsantino [x] della dialog-box
    # e il comando ALT-F4 alla procedura "fineProgramma", gia`
    # associata al pulsante di chiusura "btnU".
    # NB: se si decide di uscire (fineProgramma riporta True)
    # allora non si puo` ignorare l'evento; se si decide di
    # restare nel programma (fineProgramma riporta False)
    # allora occorre ignorare l'evento.
    #
    if not self.fineProgramma():
      e.ignore()
  #
  def keyPressEvent(self,e):
    #
    # Vogliamo disabilitare il tasto ESC.
    #
    # NB (http://pyqt.sourceforge.net/Docs/PyQt4/qwidget.html#keyPressEvent)
    # If you reimplement this handler, it is very important that you call the
    # base class implementation if you do not act upon the key.
    #
    if e.key()!=Qt.Key_Escape:
      QDialog.keyPressEvent(self,e)
  #
  def scriviMessaggio(self):
    #
    # Si riconosce quale pulsante e` stato premuto.
    #
    sender=self.sender()
    self.txtMsgs.append("Hai premuto il "+sender.text())
  #
  def fineProgramma(self):
    r=QMessageBox.question(self,"Chiedo conferma!","Sei sicuro?",
      QMessageBox.Yes | QMessageBox.No,QMessageBox.No)
    if r==QMessageBox.Yes:
      QDialog.reject(self)
    return r==QMessageBox.Yes
#
# Avvio dell'applicazione.
#
myApp=QApplication([])
dbm=dBoxMain()
myApp.exec_()

Note:

Il pulsantino [x] della dialog-box genera lo stesso evento della combinazione di tasti "ALT-F4"; questo evento viene gestito dalla procedura "closeEvent", che a sua volta chiama la procedura "QDialog.reject".
Il gestore dell'evento "closeEvent" può essere ridefinito rispetto al default e allora diventa a tutti gli effetti un metodo operativo della dialog-box principale.
È possibile imporre di ignorare l'evento e quindi rendere inefficaci il pulsantino [x] e il comando "ALT-F4", oppure modificarne il comportamento; nel primo caso si potrà uscire dall'applicazione solo col comando dedicato previsto dal programmatore.
Il tasto "ESC" non viene influenzato dall'intervento su "closeEvent", quindi per disabilitarlo si ridefinisce il gestore "keyPressEvent" in modo da filtrarlo lasciando però inalterata l'operatività di tutti gli altri tasti.

Gestione del tasto ESC e dei tasti funzione in una applicazione DBA

from PyQt4.QtCore import *
from PyQt4.QtGui import *
#
class dBoxMain(QDialog):
  def __init__(self):
  #
  # Costruttore della dialog-box principale.
  #
    QDialog.__init__(self)
    self.setWindowTitle("Titolo")
    #
    # Costruzione dei widget.
    #
    btnF01=QPushButton(self)
    btnF01.setText("F1")
    btnF02=QPushButton(self)
    btnF02.setText("F2")
    btnF03=QPushButton(self)
    btnF03.setText("F3")
    btnF04=QPushButton(self)
    btnF04.setText("F4")
    btnF05=QPushButton(self)
    btnF05.setText("F5")
    btnF10=QPushButton(self)
    btnF10.setText("F10 = Uscita (va bene anche ESC)")
    #
    self.txtMsgs=QTextEdit(self)
    self.txtMsgs.setReadOnly(True)
    #
    # Definizione del layout.
    #
    grdMain=QGridLayout()
    grdMain.addWidget(btnF01,0,0)
    grdMain.addWidget(btnF02,1,0)
    grdMain.addWidget(btnF03,2,0)
    grdMain.addWidget(btnF04,3,0)
    grdMain.addWidget(btnF05,4,0)
    grdMain.addWidget(btnF10,5,0,1,2)
    #
    self.txtMsgs.setMinimumWidth(320)
    self.txtMsgs.setMinimumHeight(240)
    grdMain.addWidget(self.txtMsgs,0,1,5,1)
    #
    self.setLayout(grdMain)
    #
    # Connessione eventi-metodi (signals-slots).
    #
    self.connect(btnF01,SIGNAL("clicked(bool)"),self.scriviMessaggio)
    self.connect(btnF02,SIGNAL("clicked(bool)"),self.scriviMessaggio)
    self.connect(btnF03,SIGNAL("clicked(bool)"),self.scriviMessaggio)
    self.connect(btnF04,SIGNAL("clicked(bool)"),self.scriviMessaggio)
    self.connect(btnF05,SIGNAL("clicked(bool)"),self.scriviMessaggio)
    self.connect(btnF10,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 keyPressEvent(self,e):
    #
    # Gestione della tastiera; per i codici vedi:
    # http://jay-notes.blogspot.it/2007/05/qtkey.html
    #
    # NB (http://pyqt.sourceforge.net/Docs/PyQt4/qwidget.html#keyPressEvent)
    # If you reimplement this handler, it is very important that you call the
    # base class implementation if you do not act upon the key.
    #
    # NB l'intervento esplicito sul tasto ESC e` pleonastico, perche'
    # il tasto ESC determinerebbe in ogni caso l'uscita dall'applicazione.
    #
    eventKey=e.key()
    if eventKey==Qt.Key_Escape or eventKey==Qt.Key_F10:
      self.reject()
    elif eventKey>=Qt.Key_F1 and eventKey<=Qt.Key_F5:
      self.scriviMessaggio(eventKey-Qt.Key_F1+1)
    elif eventKey>Qt.Key_F5 and eventKey<=Qt.Key_F12:
      self.txtMsgs.append("Premuto tasto funzione F"+str(eventKey-Qt.Key_F1+1))
    else:
      self.txtMsgs.append("Premuto tasto codice ASCII: "+str(eventKey))
  #
  def scriviMessaggio(self,bttn):
    #
    # Si cerca di riconoscere da dove e` scaturita l'azione.
    #
    sender=self.sender()
    if sender is not None:
      # Si e` premuto il pulsante con il mouse (o TAB + SPACE)
      self.txtMsgs.append("Premuto pulsante "+sender.text()+" (col mouse o TAB/SPACE)")
    else:
      # Si e` premuto il tasto funzione corrispondente
      self.txtMsgs.append("Premuto pulsante F"+str(bttn)+" (col tasto funzione)")
  #
  def reject(self):
    QDialog.reject(self)
#
# Avvio dell'applicazione.
#
myApp=QApplication([])
dbm=dBoxMain()
myApp.exec_()

Note:

Viene intercettato e ridefinito il gestore "keyPressEvent" dell'evento generato dalla pressione di un tasto fisico.
Se non tutti i possibili tasti vengono gestiti dal nuovo gestore "keyPressEvent", allora occorre richiamare il gestore originale "QDialog.keyPressEvent(self,e)"; vedere qui, dove si legge "If you reimplement this handler, it is very important that you call the base class implementation if you do not act upon the key".
L'intervento esplicito sul tasto "ESC" è pleonastico, perché il tasto "ESC" determinerebbe in ogni caso l'uscita dall'applicazione.
L'elenco completo dei codici intercettabili è visualizzabile qui.
Si noti il dispositivo con cui si distingue tra pressione del pulsante col mouse o "TAB + SPACE" e pressione del tasto funzione corrispondente.

Status line di una applicazione MWA con due campi agli estremi opposti

import urllib.request
from PyQt4.QtCore import *
from PyQt4.QtGui import *
#
class winMain(QMainWindow):
  def __init__(self):
  #
  # Costruttore della finestra principale.
  #
    QMainWindow.__init__(self)
    self.setWindowTitle("IL PRESIDENTE")
    #
    # Costruzione della status bar.
    #
    sBar=self.statusBar()
    #
    lblStsL=QLabel("Repubblica Italiana",sBar)
    lblStsL.setAlignment(Qt.AlignLeft)
    lblStsR=QLabel("Sesto Fiorentino (FI), giugno 2015",sBar)
    lblStsR.setAlignment(Qt.AlignRight)
    #
    sBar.addWidget(lblStsL,0)
    sBar.addPermanentWidget(lblStsR,0)
    #
    # Costruzione del central widget.
    #
    self.lblImage=QLabel()
    self.lblImage.setAlignment(Qt.AlignCenter)
    self.setCentralWidget(self.lblImage)
    #
    # Si riempie il central widget con una
    # immagine presa direttamente da Internet.
    #
    pixmap=QPixmap()
    url="http://www.repstatic.it/content/nazionale/img/2015/01/28/220734294-3c65732a-b424-4acc-8185-4593fff414a8.jpg"
    pixmap.loadFromData(urllib.request.urlopen(url).read())
    self.lblImage.setPixmap(pixmap)
    #
    # Operazioni che devono avvenire una sola
    # volta al lancio dell'applicazione.
    #
    self.show()
#
# Avvio dell'applicazione.
#
myApp=QApplication([])
wnm=winMain()
myApp.exec_()

Note:

La label a sinistra viene inserita con "statusBar.addWidget".
La label a destra viene inserita invece con "statusBar.addPermanentWidget".
Si noti il meccanismo per mezzo del quale l'immagine da visualizzare nel central widget viene prelevata direttamente dal Web in tempo reale (naturalmente necessita di una connessione a Internet).

Trasformare una DBA in una MWA "kiosk-mode"

Prima

Dopo

from PyQt4.QtCore import *
from PyQt4.QtGui import *
#
class dBoxMain(QDialog):
  def __init__(self,owner):
  #
  # Costruttore della dialog-box principale.
  #
    QDialog.__init__(self,owner)
    self.mainWin=owner
    self.setWindowTitle("Titolo")
    #
    # Costruzione dei widget.
    #
    btn1=QPushButton(self)
    btn1.setText("Bottone 1")
    btn2=QPushButton(self)
    btn2.setText("Bottone 2")
    btn3=QPushButton(self)
    btn3.setText("Bottone 3")
    btn4=QPushButton(self)
    btn4.setText("Bottone 4")
    btn5=QPushButton(self)
    btn5.setText("Bottone 5")
    btnU=QPushButton(self)
    btnU.setText("Uscita")
    #
    self.txtMsgs=QTextEdit(self)
    self.txtMsgs.setReadOnly(True)
    #
    # Definizione del layout.
    #
    grdMain=QGridLayout()
    grdMain.addWidget(btn1,0,0)
    grdMain.addWidget(btn2,1,0)
    grdMain.addWidget(btn3,2,0)
    grdMain.addWidget(btn4,3,0)
    grdMain.addWidget(btn5,4,0)
    grdMain.addWidget(btnU,5,0)
    #
    self.txtMsgs.setMinimumWidth(320)
    self.txtMsgs.setMinimumHeight(240)
    grdMain.addWidget(self.txtMsgs,0,1,6,1)
    #
    self.setLayout(grdMain)
    #
    # Connessione eventi-metodi (signals-slots).
    #
    self.connect(btn1,SIGNAL("clicked(bool)"),self.scriviMessaggio)
    self.connect(btn2,SIGNAL("clicked(bool)"),self.scriviMessaggio)
    self.connect(btn3,SIGNAL("clicked(bool)"),self.scriviMessaggio)
    self.connect(btn4,SIGNAL("clicked(bool)"),self.scriviMessaggio)
    self.connect(btn5,SIGNAL("clicked(bool)"),self.scriviMessaggio)
    self.connect(btnU,SIGNAL("clicked(bool)"),self.reject)
    #
    # Operazioni che devono avvenire una sola
    # volta al lancio dell'applicazione.
    #
    pass
  #
  # Procedure operative della dialog-box principale.
  #
  def scriviMessaggio(self):
    #
    # Si riconosce quale pulsante e` stato premuto.
    #
    sender=self.sender()
    self.txtMsgs.append("Hai premuto il "+sender.text())
  #
  def reject(self):
    self.mainWin.deleteLater()
    QDialog.reject(self)
#
class winMain(QMainWindow):
  def __init__(self):
  #
  # Costruttore della finestra principale.
  #
    QMainWindow.__init__(self)
    self.setWindowTitle("")
    #
    # Costruzione della dialog-box principale
    # come central widget di questa finestra.
    #
    self.dlgMain=dBoxMain(self)
    self.dlgMain.setFixedWidth(self.dlgMain.sizeHint().width())
    self.dlgMain.setFixedHeight(self.dlgMain.sizeHint().height())
    self.setCentralWidget(self.dlgMain)
    #
    # Operazioni che devono avvenire una sola
    # volta al lancio dell'applicazione.
    #
    self.showFullScreen()
    self.dlgMain.exec_()
#
# Avvio dell'applicazione.
#
myApp=QApplication([])
wnm=winMain()
myApp.exec_()

Con sfondo

import urllib.request
from PyQt4.QtCore import *
from PyQt4.QtGui import *
#
class dBoxMain(QDialog):
  def __init__(self,owner):
  #
  # Costruttore della dialog-box principale.
  #
    QDialog.__init__(self,owner)
    self.mainWin=owner
    self.setWindowTitle("Titolo")
    #
    # Costruzione dei widget.
    #
    btn1=QPushButton(self)
    btn1.setText("Bottone 1")
    btn2=QPushButton(self)
    btn2.setText("Bottone 2")
    btn3=QPushButton(self)
    btn3.setText("Bottone 3")
    btn4=QPushButton(self)
    btn4.setText("Bottone 4")
    btn5=QPushButton(self)
    btn5.setText("Bottone 5")
    btnU=QPushButton(self)
    btnU.setText("Uscita")
    #
    self.txtMsgs=QTextEdit(self)
    self.txtMsgs.setReadOnly(True)
    #
    # Definizione del layout.
    #
    grdMain=QGridLayout()
    grdMain.addWidget(btn1,0,0)
    grdMain.addWidget(btn2,1,0)
    grdMain.addWidget(btn3,2,0)
    grdMain.addWidget(btn4,3,0)
    grdMain.addWidget(btn5,4,0)
    grdMain.addWidget(btnU,5,0)
    #
    self.txtMsgs.setMinimumWidth(320)
    self.txtMsgs.setMinimumHeight(240)
    grdMain.addWidget(self.txtMsgs,0,1,6,1)
    #
    self.setLayout(grdMain)
    #
    # Connessione eventi-metodi (signals-slots).
    #
    self.connect(btn1,SIGNAL("clicked(bool)"),self.scriviMessaggio)
    self.connect(btn2,SIGNAL("clicked(bool)"),self.scriviMessaggio)
    self.connect(btn3,SIGNAL("clicked(bool)"),self.scriviMessaggio)
    self.connect(btn4,SIGNAL("clicked(bool)"),self.scriviMessaggio)
    self.connect(btn5,SIGNAL("clicked(bool)"),self.scriviMessaggio)
    self.connect(btnU,SIGNAL("clicked(bool)"),self.reject)
    #
    # Operazioni che devono avvenire una sola
    # volta al lancio dell'applicazione.
    #
    pass
  #
  # Procedure operative della dialog-box principale.
  #
  def scriviMessaggio(self):
    #
    # Si riconosce quale pulsante e` stato premuto.
    #
    sender=self.sender()
    self.txtMsgs.append("Hai premuto il "+sender.text())
  #
  def reject(self):
    self.mainWin.deleteLater()
    QDialog.reject(self)
#
class winMain(QMainWindow):
  def __init__(self):
  #
  # Costruttore della finestra principale.
  #
    QMainWindow.__init__(self)
    self.setWindowTitle("")
    #
    # Costruzione della dialog-box principale
    # come central widget di questa finestra.
    #
    self.dlgMain=dBoxMain(self)
    self.dlgMain.setFixedWidth(self.dlgMain.sizeHint().width())
    self.dlgMain.setFixedHeight(self.dlgMain.sizeHint().height())
    self.setCentralWidget(self.dlgMain)
    #
    # Impostazione dello sfondo (con una immagine presa dal Web).
    #
    pixmap=QPixmap()
    url="http://orig06.deviantart.net/bdcf/f/2008/238/c/4/seamless_brick_texture_by_paradise_awaits.jpg"
    pixmap.loadFromData(urllib.request.urlopen(url).read())
    #
    palette=QPalette()
  # palette.setBrush(QPalette.Background,QBrush(QPixmap("filename.ext")))
    palette.setBrush(QPalette.Background,QBrush(pixmap))
    self.setPalette(palette)
    #
    # Operazioni che devono avvenire una sola
    # volta al lancio dell'applicazione.
    #
    self.showFullScreen()
    self.dlgMain.exec_()
#
# Avvio dell'applicazione.
#
myApp=QApplication([])
wnm=winMain()
myApp.exec_()

Note:

All'avvio dell'applicazione, viene istanziata la finestra principale anziché la dialog-box principale.
La dialog-box principale viene costruita dalla finestra principale e poi ne diviene la central widget; se ne fissano anche le dimensioni ottimali.
Al costruttore della dialog-box principale viene passato un riferimento all'owner (ovvero alla finestra principale); questo viene anche memorizzato come proprietà della stessa dialog-box principale.
Al termine della costruzione, la dialog-box principale NON viene visualizzata.
Dopo aver costruito la dialog-box principale, il costruttore della finestra principale provvede a mostrare se stessa a schermo intero e a mandare in esecuzione modale la dialog-box principale.
Alla chiusura della dialog-box principale, si predispone anche la successiva chiusura della finestra principale.
Si osservi la versione con sfondo riempito di una immagine "tileable texture" presa direttamente dal Web (è necessario disporre di una connessione ad Internet).

Ritorna alla pagina indice

Daniele Andreuccetti, IFAC-CNR, giugno 2015