Programmare con Linux Parte 4.

È il momento di realizzare il nostro primo programma a interfaccia grafica per GNU/Linux: un browser Web molto semplice e rapido, senza memorizzazione della cronologia e dunque comodo per la navigazione in incognito. Lo realizzeremo con Python utilizzando le librerie grafiche PyQt4 (installabili su un sistema Debian-like con il comando “sudo apt-get install python-qt4 pyqt4-dev-tools qt4-designer“). Si tratta della versione Python delle librerie Qt.

import sys
from PyQt4 import QtCore, QtGui, QtWebKit

Come nell’esempio precedente, le prime righe riguardano l’inclusione di librerie utili per il nostro programma.

Dichiariamo una “classe”, che rappresenterà la nostra finestra grafica. Una classe è l’insieme del codice necessario per un particolare oggetto (nel nostro caso la finestra del browser), e ci permetterà di utilizzare la finestra in modo comodo. La finestra viene costruita sulla base di un QMainWindow, un componente delle librerie PyQt che per l’appunto propone un modello di finestra grafica.

def __init__(self):

Ogni classe ha una funzione chiamata __init__. Questa è il “costruttore” della classe, ovvero la funzione che viene automaticamente chiamata ogni volta che qualcuno decide di realizzare un nuovo oggetto con la classe in questione. Nel nostro caso, questa funzione deve disegnare l’interfaccia grafica della finestra, così sarà poi possibile mostrarla.

QtGui.QMainWindow.__init__(self)

Prima di tutto, avviamo la funzione di costruzione di QMainWindow, così il grosso del lavoro verrà svolto dalle librerie Qt.

self.resize(800,600)

Dobbiamo dare una dimensione di partenza alla finestra: poi sarà comunque possibile ridimensionarla, ma cominciamo con una finestra grande 800×600 pixel.

self.centralwidget = QtGui.QWidget(self)
self.mainLayout = QtGui.QHBoxLayout(self.centralwidget)
self.mainLayout.setSpacing(0)
self.mainLayout.setMargin(1)

Ogni finestra deve avere un elemento centrale: lo chiamiamo mainLayout, ed è per l’appunto un “layout orizzontale” (QHBoxLayout). Un layout orizzontale è un oggetto grafico che contiene tutti gli altri oggetti e li dispone automaticamente sulla finestra in modo ordinato su una sola linea orizzontale. Questo primo Layout in realtà ci serve solo come contenitore generale, perché poi realizzeremo altri layout per disporre i vari elementi come vogliamo.

self.frame = QtGui.QFrame(self.centralwidget)
self.gridLayout = QtGui.QVBoxLayout(self.frame)
self.gridLayout.setMargin(0)
self.gridLayout.setSpacing(0)

Ci serve un layout verticale, per poter posizionare la barra degli strumenti. In poche parole, ciò che faremo sarà inserire questo layout verticale in una colonna del layout orizzontale generale. È in questo layout verticale che verranno inserite la barra degli strumenti e il visualizzatore HTML, una sopra l’altro.

self.horizontalLayout = QtGui.QHBoxLayout()
self.tb_url = QtGui.QLineEdit(self.frame)
self.bt_back = QtGui.QPushButton(self.frame)
self.bt_ahead = QtGui.QPushButton(self.frame)

La barra degli strumenti è anch’essa un semplice layout orizzontale: ogni colonna del livello verrà occupata da un pulsante (bt_back o bt_ahead) o dalla casella dell’indirizzo Web (tb_url).

self.bt_back.setIcon(QtGui.QIcon().fromTheme(“go-previous”))
self.bt_ahead.setIcon(QtGui.QIcon().fromTheme(“go-next”))

Costruiamo i due pulsanti necessari: uno per andare indietro nella cronologia temporanea, l’altro per andare avanti. Potremmo inserire un testo in ciascun pulsante, ma è meglio ricorrere a un’immagine, un’icona. E possiamo prelevarla direttamente dal set di immagini standard fornito dalle librerie Qt: basta indicare i loro nomi, go-previous e go-next.

self.connect(self.tb_url, QtCore.SIGNAL(“returnPressed()”), self.browse)
self.connect(self.bt_back, QtCore.SIGNAL(“clicked()”), self.html.back)
self.connect(self.bt_ahead, QtCore.SIGNAL(“clicked()”), self.html.forward)
self.connect(self.html, QtCore.SIGNAL(“urlChanged(const QUrl)”), self.url_changed)

Abbiamo inserito i vari elementi nella finestra. Però devono anche fare qualcosa: dovremo associare a ciascun elemento una specifica funzione. Questo si può fare collegando con la funzione connect il segnale emesso da uno degli elementi della finestra e le funzioni che costruiremo per le varie operazioni. Ad esempio, quando viene premuto il tasto Invio o Return sulla casella di testo dell’URL deve essere lanciata la funzione self.browse, che scriveremo. Quando vengono premuti i due pulsanti vengono lanciate direttamente le funzioni del QWebKit che si occupano di andare avanti o indietro nella cronologia temporanea. Infine, quando la pagina visualizzata dal QwebKit cambia, viene lanciata la funzione self.url_changed. Questo avviene tipicamente quando l’utente ha cliccato su un link.

self.default_url = “http://www.linux-magazine.it/”
self.tb_url.setText(self.default_url)
self.browse()

Per concludere la funzione iniziale della classe che stiamo scrivendo, impostiamo un URL di default, praticamente la nostra home page. Questo URL è impostato nella casella di testo apposita, e poi si può lanciare la funzione browser per ordinare la visualizzazione della pagina Web indicata nella casella di testo.

def browse(self):
url = self.tb_url.text() if self.tb_url.text() else self.default_url
self.html.load(QtCore.QUrl(url))
self.html.show()

if __name__ == “__main__”:

La classe browser è ora terminata, quindi possiamo procedere a scrivere il codice principale del programma (__main__).

app = QtGui.Qapplication(sys.argv)

Prima di tutto vogliamo creare una applicazione Qt, cioè un’app grafica tramite le librerie Qt, che gestiranno per noi la visualizzazione sullo schermo e i rapporti con il server grafico.

main = Browser()
main.show()

Poi, possiamo creare un oggetto che rappresenti la classe Browser definita poco fa: basta inventare un nuovo oggetto (che chiamiamo main) e associarlo alla classe. Da questo momento main sarà la finestra grafica della nostra applicazione, e possiamo farla apparire sullo schermo chiamando la sua funzione show. La funzione show non era stata manualmente definita nel codice che abbiamo presentato: questo perché faceva già parte del set di funzioni predefinite di QMainWindow, la libreria da cui la nostra classe Browser ha ereditato funzioni e attributi.

app.exec_()

Infine, ordiniamo il lancio (exec_()) dell’applicazione che abbiamo appena terminato di scrivere. Ci si può chiedere perché si usi la dicitura exec_ invece di exec. Il fatto è che fino alla versione 2 di Python, la parola exec era riservata e non poteva essere usata per le funzioni. È stato quindi necessario aggiungere un underscore per mantenere la compatibilità con Python 2.