1.95 MB - Qt 5 QB La Mailing List è attiva!

Qt 5 Quanto Basta
La guida all'uso della libreria grafica Qt 5, in italiano
Gianbattista Gualeni
Volume 01: Da “Hello World!” ad una applicazione e oltre.
Copyright © 2014 Gianbattista Gualeni
Seconda Edizione, Maggio 2014
Tutti i diritti sono riservati. Ai sensi delle convenzioni internazionali sul diritto d'autore, senza il
permesso scritto dell'autore, è vietata ogni riproduzione, anche parziale, del presente libro.
Contenuto depositato presso gli organi competenti.
ISBN: 978-88-909016-0-7
Per informazioni:
e-mail: [email protected]
web: www.gianbattistagualeni.it/qt5qb/
Qt© è un marchio registrato di Digia Plc e/o sue sussidiarie (http://qt.digia.com).
I prodotti e i marchi citati appartengono ai rispettivi proprietari.
Indice generale
Prefazione...........................................................................................................................................7
Glossario.............................................................................................................................................8
Introduzione........................................................................................................................................9
Come nasce questo libro..................................................................................................................9
Perché la scelta di Qt come libreria di sviluppo............................................................................10
Ubuntu ovvero la scelta della distribuzione Linux........................................................................11
Come finì la storia..........................................................................................................................11
1 Prerequisiti: libreria, editor e compilatore.....................................................................................13
1.1 Prima di iniziare.......................................................................................................................13
1.2 La licenza duale.......................................................................................................................13
1.3 Componenti del sistema...........................................................................................................14
1.4 Scaricare la libreria Qt 5.0.2....................................................................................................14
1.5 Configurazione del sistema Linux...........................................................................................16
1.6 Configurazione del sistema Windows......................................................................................22
2 Hello World! Creare il primo applicativo......................................................................................34
2.1 Analisi dei file che compongono il progetto............................................................................34
2.2 Compilare il progetto...............................................................................................................40
2.3 Compilazione ed esecuzione di un applicativo........................................................................43
2.4 QDebug: inserire un messaggio trace......................................................................................45
2.5 Altri file che possono far parte del progetto............................................................................46
2.6 Rimuovere un file dal progetto................................................................................................48
3 Distribuire l'applicativo.................................................................................................................49
3.1 Distribuire un applicativo per Linux........................................................................................49
3.2 Distribuire un applicativo per Windows..................................................................................58
4 Un visualizzatore immagini con QGraphicsView.........................................................................68
4.1 Creare l'applicazione di base....................................................................................................68
4.2 QAction e l'interazione con l'utente.........................................................................................69
4.3 QGraphicsView per visualizzare le immagini.........................................................................77
4.4 Selezionare la cartella e caricare le immagini.........................................................................82
4.5 Completare le azioni per sfogliare le immagini.......................................................................88
4.6 Gestire lo zoom........................................................................................................................89
4.7 Risultato finale.........................................................................................................................93
5 Completare il visualizzatore di immagini......................................................................................94
5.1 La versione dell'applicazione...................................................................................................94
5.2 QSettings per salvare la configurazione................................................................................103
5.3 QMessageBox::question() per chiedere conferma prima di chiudere...................................108
5.4 Impostare il colore dello sfondo.............................................................................................111
5.5 QStatusBar: informazioni sulla barra di stato........................................................................117
5.6 Gestire l'attesa durante il caricamento delle immagini..........................................................127
5.7 Finestra con le informazioni dell'immagine...........................................................................130
5.8 Distribuire Visualizzatore Immagini 1.0................................................................................151
6 Creare una libreria con Qt...........................................................................................................155
6.1 Classificazione delle librerie..................................................................................................155
6.2 Cap6ElaIm: creare una libreria statica...................................................................................156
6.3 D-pointer per fare una vera libreria.......................................................................................161
6.4 Come si usa una libreria statica.............................................................................................172
6.5 Creare una libreria dinamica..................................................................................................183
6.6 Usare una libreria dinamica...................................................................................................187
6.7 Controllare il contenuto di una libreria..................................................................................191
6.8 La compatibilità binaria.........................................................................................................194
7 Argomenti avanzati......................................................................................................................196
7.1 Mostrare una gif animata durante l'attesa..............................................................................196
7.2 Formati immagine supportati.................................................................................................215
7.3 Controllare la posizione del mouse tramite le frecce.............................................................218
Alla mia famiglia e a tutti gli amici che mi hanno so(u)pportato in questa fantastica avventura!
Gianbattista 15 Gennaio 2014
It's my life, It's now or never, I ain't gonna live forever, I just want to live while I'm alive …
Bon Jovi
Prefazione
Penso di essere stato il primo o forse, se non proprio il primo, tra i primissimi ad acquistare la
prima edizione del libro Qt5 Quanto Basta di Gianbattista Gualeni.
Quando mi è stato chiesto di scrivere la prefazione a questo libro, ho accettato con piacere, in
quanto in diversi anni di attività (e di letture) mi è capitato raramente di incontrare un autore che
con passione, talento e spirito di condivisione mette a disposizione di tutti quanto ha imparato
autonomamente.
Essere un buon software designer, oggi come sempre, richiede contemporaneamente una
capacità creativa ed una padronanza delle tecniche e degli strumenti disponibili. Su questa base è
possibile asserire che l’ambiente di sviluppo Qt rappresenta una perfetta sintesi di ispirazione
creativa e tecnica di programmazione.
Fatta questa premessa è quindi intuibile comprendere l’abilità dell’autore che ha saputo
trasmettere, con passione, la semplicità, la potenza e non ultimo l’eleganza, del codice sorgente
scritto impiegando questo toolkit.
Le pagine di questo libro scorrono piacevolmente presentando una sequenza fitta di
informazioni preziose per chi vuol scrivere buon codice sorgente multi-piattaforma. Esso è
fondamentale per tutti coloro che si avvicinano a Qt per la prima volta, ma è anche utile a chi Qt lo
conosce già; posso confermare infatti che, pur seguendo l’evoluzione di questo toolkit sin dal
lontano 2003, ho trovato nel libro informazioni utili, stimoli per migliorare e punti di vista
interessanti.
Lo stile impiegato dall’autore mette il lettore a proprio agio fornendo con precisione, sin dalle
battute iniziali, tutte le informazioni necessarie per poter mettere in pratica i concetti esposti; il
lettore viene così accompagnato “per mano” nella realizzazione di applicazioni dalle “GUI” evolute
ed allo stato dell’arte.
Termino quest’introduzione del libro con, permettetemi, una nota di orgoglio in quanto
finalmente, grazie a Gianbattista Gualeni, è disponibile un libro in lingua italiana sulle famose
“librerie Qt”.
Paolo Sereno, Torino, 20 Maggio 2014
Glossario
In questa sezione cerchiamo di dare una rapida definizione ad alcuni termini o acronimi che
verranno usati con una certa disinvoltura all'interno del testo.
Bash: “Bourne Again Shell” è uno dei tanti programmi che comunicano con il sistema operativo
usando la “command line interface”. In realtà in Ubuntu non si usa la bash ma un applicativo che si
chiama Gterminal (dove la prima G sta per GNOME). In italiano viene spesso chiamata Terminale.
Compilatore: lo scopo del compilatore è quello di convertire del codice scritto in un linguaggio
ad alto livello, contenuto in un file di testo, in un file binario contente del codice Assembly, in modo
che possa essere interpretato dal processore.
DLL: ovvero “Dynamic Link Library” è un file che contiene parte del codice, organizzato come
una libreria di funzioni o di risorse, che viene collegato all'eseguibile mentre è in esecuzione.
GNOME: E' uno dei possibili desktop grafici usati nelle distribuzioni Linux. La versione di
Ubuntu che uso si appoggia ad un desktop GNOME.
GNU: è un progetto per lo sviluppo cooperativo di software libero, lanciato da Richard Stallman
nel 1983. Oltre ad essere probabilmente la prima volta che si è formulato, con tanto di licenza e basi
legali, il concetto di software libero, ha prodotto risultati notevoli, tra cui il compilatore GCC.
GPL: “GNU Pulic License”, è un altro risultato eclatante del progetto GNU ed è la base del
concetto di Open Source. Si tratta di una licenza che pur proteggendo il diritto d'autore di chi ha
creato il codice, prevede la diffusione del codice sorgente dell'applicativo o della libreria, affinché
chi riceve il lavoro possa, a patto di rispettare alcune condizioni, modificarlo, correggerlo,
migliorarlo, senza richiedere un consenso esplicito dell'autore.
LGPL: “Lesser GNU Public License”. Questa licenza sovviene a uno dei limiti più grandi della
GPL, che impediva di usare codice Open Source all'interno di progetti che a loro volta non fossero
Open Source.
Linker: è un applicativo che prende il risultato del compilatore e lo impacchetta in un
eseguibile.
Linux: è un sistema operativo, simile a Unix, ma libero, sviluppato nei primi anni '90 da Linus
Torvalds. Attualmente è molto molto popolare dato che viene usato in tutti i telefoni Android. La
sua diffusione in ambiente Desktop invece non è mai riuscita a scalfire la supremazia di Windows.
Plug-in: con questo termine si intendono delle librerie di funzioni che possono essere innestate
in un applicativo al fine di espandere le sue funzionalità. Tecnicamente sono delle librerie a
collegamento dinamico, con alcune funzionalità aggiuntive.
SDK: “software development kit”, è una collezione di esempi, librerie software e
documentazione, che assieme formano un Kit per lo sviluppo di applicazioni software.
SO: ovvero “Shared Object” è l'estensione usata per identificare le librerie a caricamento
dinamico nel mondo Linux.
Ubuntu: si tratta di una distribuzione di Linux, basata su Debian e Gnome. Viene manutenuta e
sviluppata principalmente da Canonical, che è una azienda fondata da Mark Shuttleworth, un
giovane imprenditore sudafricano.
Widget: si usa per indicare un elemento riusabile in una interfaccia grafica. Pulsanti, caselle di
testo, barre di scorrimento, finestre per visualizzare immagini, sono tutti Widget. In alcune librerie
sono chiamati anche Controlli.
Introduzione
In questo breve capitolo, passeremo in rassegna, gli eventi che negli ultimi 5 anni, mi hanno
portato a scegliere Qt come libreria per lo sviluppo delle mie applicazioni, sia per Linux che per
Windows.
Come nasce questo libro
Nel 2008 mi occupavo di telecamere per applicazioni di visione industriale. Per intenderci, sono
telecamere che controllano la conformità di una lavorazione meccanica o di un astuccio per
medicinali.
In queste applicazioni c'era sempre un pannello operatore che veniva usato per controllare la
macchina o la linea di produzione. Dietro di esso c'era quasi sempre un computer industriale con un
sistema operativo Windows 2000 o Windows XP.
Sicuramente saprete che le applicazioni industriali hanno in genere un approccio molto
conservativo, e che sono sistemi pensati per garantire la produttività della macchina o della linea per
un minimo di 10 anni. Nel 2008 Windows 2000 era vicino ai 10 anni di vita, e non veniva più usato
per i nuovi progetti, mentre Windows XP era considerato il sistema operativo ideale per i nuovi
sviluppi, dato che aveva iniziato a diffondersi a partire dal 2003.
Torniamo noi, il 2008 è l'anno del fallimento della banca Lehman Brothers, l'anno in cui la
finanza anglosassone è scesa dalla cattedra e ci ha trascinato nella più grande crisi economica di
sempre. Ma il 2008 è anche l'anno in cui ha cominciato a diffondersi Windows Vista e si è
cominciato a capire che non sarebbe stato un sistema adatto per applicazioni industriali, per una
serie di motivi, tra cui la necessità di processori più potenti, di schede grafiche aggiornate, di
memoria RAM superiore a 1 GB e almeno 100 GB di spazio su disco.
Queste erano richieste impegnative già per i sistemi desktop, figuratevi per i sistemi industriali,
dove le CPU erano spesso depotenziate per poter funzionare senza ventole, la memoria RAM era
quasi sempre da 256 MB (a volte da 512 MB), e il disco fisso veniva sostituito da una memoria
flash da 4 GB con scrittura bloccata per aumentarne al massimo l'affidabilità. Installare Windows
Vista significava passare a sistemi con ventola di raffreddamento. Ve lo immaginate cosa si sarebbe
potuto formare dentro un PC, a causa della ventola, dopo dieci anni di funzionamento? Sareste
riusciti ad accettare quel livello di sporcizia su una macchina dedita al confezionamento di farmaci?
O su una linea di produzione di biscotti?
Era chiaro a tutti che stava per arrivare un grosso problema. Nel momento in cui Microsoft
avesse deciso di chiudere la vendita di Windows XP e Windows 2000, le opzioni erano due: o
installare copie pirata o passare ad un altro sistema operativo, meno esoso nei requisiti, e più stabile
nel tempo: Linux.
Cavoli, Linux! Quando i clienti mi cominciarono a parlare di questi progetti, rimasi spiazzato.
Avevo molti amici che lo conoscevano, lo usavano, ci “smanettavano”, ma io non ero mai andato
oltre la simpatia per il sistema operativo creato da Linus Torvalds nel 1991. Al tempo avevo giusto
provato ad installarlo su una macchina virtuale, ma poi, di fronte all'interfaccia a linea di comando,
avevo lasciato perdere.
E poi, si fa alla svelta a dire Linux, ma c'è il Kernel, c'è la distribuzione, c'è il file system, c'è il
desktop, c'è la shell di comando, c'è il gestore dei pacchetti di installazione... A differenza di
Windows, dove nel bene e nel male tutte queste opzioni sono già state valutate e tutte le scelte sono
state fatte, quando ci si approccia al mondo Linux il numero di possibili combinazioni è così alto da
far spavento.
Il risultato fu che coloro che non poterono passare ad un PC più potente a causa dei problemi
con le ventole iniziarono a progettare la migrazione della loro applicazione verso Linux. Gli altri si
misero in una sorta di limbo in attesa che Microsoft mandasse loro un segnale di speranza. A tal
proposito si narra che Michael Dell in persona, il titolare di Dell Computers, partì da Austin, in
Texas, in sella al suo cavallo nero, con cappello bianco a falda larga, il fucile Winchester e nella
fondina una pistola Colt (forse sto un poco esagerando…) e arrivò fino a Redmond, nello stato di
Washington, dopo 2150 miglia di viaggio. Suonò al campanello di Steve Ballmer, che al tempo era
l'amministratore delegato di Microsoft, e lo implorò di permettergli di continuare a vendere PC con
installato Windows XP. Alla fine trovarono un accordo e fu concesso a Dell, e poi a tutti gli altri
costruttori di computer, di installare Windows Vista e Windows XP contemporaneamente, lasciando
poi che il cliente decidesse, al primo avvio, quale dei due sistemi operativi usare. Il povero Steve
Ballmer si arrese all'evidenza quando realizzò che il 99,9% dei clienti preferiva Windows XP. I miei
clienti tirarono un sospiro di sollievo.
Ma a questo punto vi chiederete: cosa c'entra questo con la libreria Qt? La risposta è semplice:
queste sono le condizioni al contorno quando decisi di iniziare a studiare la libreria grafica Qt.
Dovete sapere che al tempo io curavo lo sviluppo dell'SDK per le telecamere industriali. Per
intenderci, l'SDK è una collezione di documenti, esempi, manuali, e librerie software che servono al
cliente per collegare la telecamera alla sua applicazione. Per fare un SDK serve una buona
conoscenza delle applicazioni, dei tool di sviluppo e del sistema operativo. Il nostro SDK non era
eccezionale, ma si difendeva, solo che era pensato per funzionare solo con Windows XP. Sviluppare
un nuovo SDK per Linux voleva dire studiare il sistema operativo, studiare i tool di sviluppo e
studiare le applicazioni, il tutto per piattaforme a 32-bit o a 64-bit e probabilmente per più di una
distribuzione. Capite che il problema non ammetteva una soluzione semplice. Più entravo nel
mondo Linux e più mi rendevo conto della complessità di un SDK adatto.
E fu a questo punto che inciampai nelle librerie multi-piattaforma e in Qt. In realtà la mia prima
scelta fu WxWidget, dato che al tempo Qt non permetteva di sviluppare con la licenza LGPL,
ovvero quella licenza che permette di rilasciare il proprio lavoro in forma chiusa, e in azienda non
mi avrebbero autorizzato a rilasciare l'SDK in formato Open Source o GPL. La fortuna volle che nel
2008 Nokia acquistò l'azienda proprietaria di Qt e nel 2009 rilasciò la libreria in formato LGPL. A
questo punto passai definitivamente a Qt.
Perché la scelta di Qt come libreria di sviluppo
L'ontologia di una libreria multi-piattaforma è che lo stesso codice sorgente possa essere
convertito in un applicativo su più di un sistema operativo. Nel caso di Qt, è possibile scrivere un
applicativo e compilarlo per Windows, per Linux, per Mac (da poco anche per iPhone, iPad e
dispositivi Android, ma questo potrebbe essere l'argomento di un prossimo libro).
Questo era perfetto per le nostre esigenze. Una volta che tutto il nostro SDK fosse stato
convertito in Qt, avremmo potuto manutenere un solo progetto e compilarlo sia per Windows che
per Linux. Inoltre Qt era disponibile come LGPL, quindi anche i nostri clienti avrebbero potuto
sviluppare i loro applicativi in Linux, senza investire 3/4000 € in un ambiente di sviluppo. E anche
per noi era fantastico, perché avremmo potuto fare delle demo o delle presentazioni ai clienti senza
problemi di licenza.
Inoltre, a seguito dell'acquisizione da parte di Nokia, venne posto grande impegno per rendere i
tool di sviluppo più facili da usare. Furono create delle distribuzioni che a fianco della libreria
contenevano anche Qt Creator e tutti gli applicativi di supporto (ad esempio per il multilingua). Per
farla breve, anche per gli utenti Linux si poteva installare il tutto senza bisogno di aprire il terminale
e digitare: “sudo apt-get install”. Bastava scaricare un file da internet ed eseguirlo facendo
doppio click.
Ubuntu ovvero la scelta della distribuzione Linux
Bene, dopo aver chiarito come è stata scelta la libreria Qt, vorrei spendere due parole su come
sono finito ad usare la distribuzione Linux Ubuntu.
Essendo digiuno in materia iniziai ad intervistare amici, clienti, e colleghi. Il responso fu
unanime: la distribuzione più adatta, secondo loro, era Debian. Tutti mi indicarono quella come la
distribuzione migliore per un uso professionale. Pertanto iniziai a studiare tutti gli aspetti, a
scaricarmi e a masterizzare i cinque DVD necessari e a capire come avrei potuto installarla sul PC
portatile che l'azienda mi aveva messo a disposizione, a fianco dell'installazione di Windows XP.
Pertanto, nell'estate del 2008, durante le vacanze estive, a casa, con quaranta gradi all'ombra
iniziai ad installare Debian. Non si trattava di un sacrificio straordinario, dato che non ho mai amato
le vacanze di Agosto. Con tutta l'Italia ferma, qualsiasi vacanza è molto più costosa e qualsiasi
località troppo affollata per essere un'esperienza rilassante. Ma non pensavo nemmeno che
diventasse una operazione tanto complicata da portarmi via tutta la vacanza. Tra l'altro, per la prima
volta, la mia azienda mi obbligò a fare quattro settimane di ferie ad Agosto.
Ebbene, dopo aver provato tre volte ad installare una distribuzione Debian (mi sembra si
chiamasse Lenny), e non essere riuscito a far ripartire il portatile alla fine dell'installazione,
disperato cominciai a cercare su internet una via di uscita. E fu in quel frangente che mi imbattei in
Ubuntu.
Fu una sorta di folgorazione, fu come vedere l'arcobaleno dopo essere stato nel bosco sotto un
temporale che sembrava non finire mai. Nello slogan di Ubuntu: “Linux per esseri umani” colsi
l'attenzione per il grido di dolore che si sollevava da tutti coloro che come me, avevano provato ad
installare Linux e avevano rinunciato. Subito, mi comperai una chiavetta USB da 8 GB, su cui
installai la distribuzione in formato Live, ovvero in modo che potesse funzionare senza installare
alcunché sul computer, e iniziai ad usare Linux.
Insomma, alla fine dell'estate del 2008 ero pronto per sviluppare un SDK multi piattaforma,
usando Qt, Ubuntu e Windows XP.
Come finì la storia
Microsoft fece un passo indietro autorizzando i clienti al downgrade, ovvero a comperare
Windows Vista e poi convertirlo in Windows XP, dando alle aziende altri cinque anni per adeguarsi,
mentre dichiarava che il nuovo Windows 7, che venne rilasciato a fine 2009, avrebbe fatto tesoro
delle critiche degli utenti.
La crisi colpì duramente l'azienda per cui lavoravo e, dopo un primo tentativo di recupero nel
2010, nel 2011 arrivò il cosiddetto “double deep”, vale a dire la seconda recessione, e alla fine del
2011, mi ritrovai in cassa integrazione. Nel 2012 cambiai lavoro e passai a fare altro.
Alla fine l'azienda per cui lavoravo non sviluppò l'SDK multi-piattaforma.
Nel frattempo la distribuzione Ubuntu perse la sua spinta dirompente e non divenne mai un
sistema operativo in grado di impensierire Windows, mentre nel mondo Linux la distribuzione
Linux Mint, a partire dal 2011, la soppiantò in termini di popolarità (stando alle statistiche
pubblicate dal sito www.distrowatch.com, anche se l'argomento è fonte di accesissime discussioni
in cui non voglio entrare).
Anche Nokia, che era proprietaria della libreria Qt, non se la passò bene. L'arrivo di Apple nel
mercato della telefonia, con il suo iPhone e le sue app, la colse impreparata, o forse addormentata
sugli allori della sua mostruosa quota di mercato. Quando poi all'orizzonte comparve Android,
Nokia cercò di reagire rimpiazzando il suo sistema operativo Simbian, che ormai era troppo
vecchio, con MeeGo, ma era troppo tardi. Gli sviluppatori deridevano Nokia giocando sul nome
MeeGo e chiamandolo Mee Gone, per indicare qualcosa del tipo: “io, me ne sono andato”. Alla
fine, nel 2010, Nokia annunciò un accordo con Microsoft, in base al quale la nuova linea di telefoni
Lumia presto avrebbe avuto come sistema operativo Windows Phone 8. A quel punto era chiaro a
tutti gli sviluppatori e gli appassionati che come me usavano Qt, che la libreria non era più un
prodotto strategico per Nokia.
Poteva finire male, con Qt relegato al rango di prodotto morente, con pochi nuovi sviluppi,
qualche rilascio di manutenzione, portato avanti da sviluppatori demotivati. Sembrava abbastanza
improbabile che la tanto annunciata versione 5.0, che stava accumulando quasi un anno di ritardo,
potesse mai vedere la luce.
Invece non finì così! Nel 2012 Qt venne venduto a Digia e moltissimi sviluppatori lasciarono
Nokia. Iniziò un pesantissimo lavoro di migrazione di tutta la documentazione e di tutti i server
verso il nuovo dominio (qt.digia.com).
Il 19 Dicembre 2012 la versione 5.0 venne finalmente rilasciata.
1 Prerequisiti: libreria, editor e compilatore
In questo capitolo vedremo quali sono gli elementi essenziali, dove reperirli e come installarli.
Per essere sicuri del risultato finale, il tutto verrà provato sia per Linux che Windows. Inoltre
verranno descritte le differenze tra licenza commerciale e licenza LGPL.
1.1 Prima di iniziare
Questo libro vuole essere una guida che, attraversando i componenti principali della libreria, vi
renderà in grado di sviluppare applicazioni e librerie con Qt, sia per Windows che per Linux. Gli
esempi non verranno testati con un Mac, ma data l'attenzione posta da Digia per la qualità della
libreria, dato che Mac Os ha un kernel molto simile a Linux e dato che verificheremo direttamente
come la stessa applicazione possa essere compilata sia per Linux che per Windows, non ho alcun
dubbio sul fatto che il libro sia adatto anche per utenti Mac.
Detto questo, abbiate pazienza se gli esempi di codice e le schermate sono state fatte
principalmente usando Qt in Ubuntu. Non voglio fare evangelizzazione a favore di Ubuntu, ma
trovo molto più comodo lavorare in Linux che in Windows 7. Il vantaggio principale è la velocità di
avvio del sistema. Ho degli amici che accendono il computer la mattina, vanno a fare colazione, e
poi lo lasciano acceso tutto il giorno. Non è il mio caso. Il mio nuovo portatile, pur essendo scarsino
come processore, grazie a Ubuntu e ad un disco allo stato solido fa il boot in soli 16 secondi. Se mi
servono dei test con Windows 7, posso usare una macchina virtuale, riavviarla in pochi secondi e
ricongelarla. Addirittura a volte ho l'impressione che Windows 7 giri meglio in una macchina
virtuale lanciata da Linux, che non nel caso nativo.
1.2 La licenza duale
Uno degli aspetti fondamentali di Qt è la disponibilità di una forma duale di licenza, ovvero di
una commerciale e di una “Open Source” LGPL.
La licenza commerciale, che è a tutti gli effetti una licenza di sviluppo, prevede l'acquisto della
libreria, esattamente come si fa con Microsoft Visual Studio, e nessun'altra spesa per rilasciare le
applicazioni. Questa è obbligatoria nel caso di applicazioni “embedded” o nel caso in cui si voglia
rilasciare un'applicazione in forma monolitica, ovvero senza mostrare la presenza della libreria Qt.
Inoltre comprende il supporto tecnico da parte di Digia.
La licenza LGPL non prevede alcun supporto e alcuna garanzia, e nemmeno un costo.
Nel caso in cui ci si avvalga della licenza Open Source, è possibile usare la libreria per fare
qualsiasi cosa, compreso la creazione di applicativi con codice sorgente chiuso e commercializzarli
a patto che:
•
Sia ben chiaro all'utente finale, tramite l'uso del logo di Qt, che si sta utilizzando la
libreria.
•
Le DLL (Dynamic Link Libraries) o gli SO (Shared Objects) siano visibili e
sostituibili dall'utente, che in questo modo mantiene il diritto di poter modificare il
codice, relativamente alla parte di libreria Qt.
In entrambi i casi le librerie sono identiche, identica la qualità dei test che vengono fatti e
identici i tool che fanno parte della libreria. Cambia solo quanto si spende e che cosa si può fare o
non fare con la libreria.
Concludendo, possiamo dire che la licenza LGPL è perfetta per lo studio della libreria, o per fare
piccole applicazioni. Per le aziende che sviluppano prodotti basati su Qt è più adatta la versione
commerciale in quanto possono accedere a vari livelli di supporto, richiedere corsi di formazione,
etc. Se poi l'applicazione è destinata ad alcuni settori specifici, come il biomedicale, l'uso di
software open source non è ammesso per motivi di sicurezza. Ve lo immaginate un infermiere che
cambia una DLL in un apparato per la dialisi? In questi casi la licenza commerciale è l'unica
opzione.
Prima che nel 2009 venisse introdotta la licenza LGPL, era possibile solo lo sviluppo di
applicazioni Open Source, cioè il codice dell'applicazione doveva essere distribuito, aperto e
modificabile, dall'utente.
1.3 Componenti del sistema
Per sviluppare con Qt servono tre componenti base: la libreria Qt, Qt Creator e un compilatore.
La libreria è la parte più corposa e nel caso di Linux occupa circa 500 MB di disco fisso,
distribuiti in 21.000 file. Contiene: gli SO (“Shared Objects”) o le DLL (“Dynamic Link
Libraries”) nel caso di Windows, gli “header file” (ovvero i file .h, per intenderci) che descrivono il
contenuto delle librerie, gli esempi e tutta la documentazione necessaria. Per dare un'idea della
complessità, basti pensare che la cartella della documentazione contiene più di 7.000 file e occupa
circa 250 MB.
Qt Creator è l'applicativo che si usa per creare un progetto, scrivere il codice, interrogare la
documentazione, costruire l'interfaccia utente, invocare il compilatore per generare l'eseguibile, ed
eseguire il proprio applicativo in modalità debug.
Il compilatore è l'unica parte esterna a Qt. Nel caso Linux si usa il GNU C++ Compiler, detto
anche g++; nel caso di Windows tipicamente si usa sia il compilatore di Visual Studio che MinGW.
Se avete provato a sviluppare con Microsoft Visual Studio, questa architettura basata su tre
elementi vi suonerà strana, ma è solo perché l'ambiente di programmazione nasconde la struttura. In
realtà il framework .NET è la libreria, Visual Studio equivale a Qt Creator e il compilatore si
chiama “cl.exe” e si trova nella cartella “Visual Studio\VC\bin”.
A questo punto siamo pronti per scaricare la libreria da Internet.
1.4 Scaricare la libreria Qt 5.0.2
La libreria usata per la stesura del libro è la versione 5.0.2, rilasciata il 10 Aprile 2013.
Utilizzare esattamente questa versione di libreria è essenziale perché tutti gli esempi funzionino al
100% e non ci siano intoppi. Naturalmente non mi aspetto dei cambiamenti straordinari passando a
versioni successive, ma per il momento il consiglio è: “Usate la 5.0.2!”
La prima operazione da fare è andare sul sito qt.digia.com, cercare il link a qt-proiect.org, aprire la
pagina, cercare download e arrivare alla pagina con i link delle varie distribuzioni.
Fig. 1.1: Cercare la sezione Qt Project
A questo punto vi verrà proposta la versione corrente della libreria, che non sarà più la 5.0.2, ma
probabilmente una molto più avanzata. Cercate la sezione “Older Versions” e passate all'archivio.
Fig. 1.2: Cercare la sezione relativa alle versioni precedenti
Una volta entrati nell'archivio si deve aprire la pagina relativa alla versione 5.0
Fig. 1.3: Cercare la cartella relativa alla versione 5.0
Poi selezionare la cartella relativa alla versione 5.0.2
Fig. 1.4: Selezionare la cartella 5.0.2
E per finire, selezionare il file più adatto alla piattaforma che stiamo usando.
Fig. 1.5: Selezionare il pacchetto adatto alla piattaforma e alla
configurazione in uso
1.5 Configurazione del sistema Linux
In questo paragrafo verranno illustrati tutti i passi necessari ad installare libreria, compilatore, e
ambiente di sviluppo, fino a creare una prima applicazione per verificare che l'installazione sia
corretta.
La distribuzione Linux usata durante la revisione finale del libro è Ubuntu 12.10 Quantal
Quetzal a 64-bit. La libreria installata è la versione 5.0.2 a 64-bit, rilasciata il 10 Aprile 2013,
mentre il compilatore usato è g++, versione 4.7.2. Per quanto riguarda Qt Creator, si è optato per la
versione 2.7.0 resa pubblica il 21 Marzo 2013.
Ricordate che per scaricare il tutto e poterlo installare servono circa 2 GB di spazio libero sulla
partizione di sistema (root).
1.5.1
Installazione del compilatore
Il compilatore da usare è GNU C++ Compiler, conosciuto anche come g++. Lo si può installare
usando il comando:
sudo apt-get install g++
Oppure, se come me siete un poco pigri, non vi ricordate la sintassi esatta o semplicemente
preferite l'interfaccia grafica, potete usare Ubuntu Software Center, cercare g++ nella lista dei
programmi e controllare che non sia già installato, cosa altamente probabile, altrimenti installarlo.
Attenzione a non fare confusione tra gcc che è il compilatore C e g++ che è il compilatore C++.
Fig. 1.6: Installazione del compilatore C++ in Linux
Fig. 1.7: Compilatore C++ Installato
Oltre al compilatore, sono necessarie anche le librerie OpenGL. Per installarle stavolta l'unica
opzione è il terminale di comando, dove per installare libgl-dev e libglu-dev dobbiamo
digitare:
sudo apt-get install libgl-dev libglu-dev
1.5.2
Installazione della libreria Qt
Supponendo di avere già un computer con Ubuntu e un browser, e aver seguito le istruzioni del
paragrafo 1.4 su dove trovare la libreria, scarichiamo il file
qt-linux-opensource-5.0.2-x86_64-offline.run
Fig. 1.8: File da scaricare per Linux a 64 Bit
Dato che questa versione contiene anche Qt Creator 2.7.0, non serve altro.
Recuperiamo il file qt-linux-opensource-5.0.2-x86_64-offline.run dalla cartella in
cui è stato scaricato e facendo click con il tasto destro rendiamolo eseguibile cliccando sul flag
“Consentire l'esecuzione del file come programma”.
Fig. 1.9: Rendere l'installer eseguibile
Ora facendo doppio click sul file inizia l'installazione.
Impostare il flag “Esecuzione” equivale ad usare il comando “change mode” tramite il
terminale. Personalmente lo trovo più facile da ricordare che non digitare la sequenza:
chmod u+x
qt-linux-opensource-5.0.2-x86_64-offline.run
Fig. 1.10: Schermata iniziale dell'installazione di Qt
5.0.2 su Linux
Fig. 1.11: Schermata finale dell'installazione di Qt
5.0.2 su Linux
1.5.3
Verificare che l'installazione sia completa
Alla fine del processo di installazione aprite Qt Creator; per controllare che tutto funzioni è
sufficiente selezionare “File”, “New File or Project” e, nella finestra di dialogo che appare, nella
prima colonna selezionate “Applications”, nella seconda colonna “Qt Gui Application”, e premete il
pulsante “Choose”.
Procedete
inserendo
il
nome
dell'applicazione
che
volete
creare,
ad
esempio
TestInstallazione, ed impostate la cartella di lavoro. Premete “Next” quando appare la
schermata relativa alla sezione del kit di compilazione, selezionate “Next” alla schermata “Class
Information”, e poi “Finish” nella schermata “Project Management”.
In pochi secondi ci si ritrova in Qt Creator con il progetto creato, pronto per essere compilato ed
eseguito.
Fig. 1.12: Creare un'applicazione per testare l'installazione
Fig. 1.13: Impostare nome progetto e cartella
Fig. 1.14: Selezione della configurazione di compilazione
Fig. 1.15: Generazione della classe principale
Fig. 1.16: Impostazione del controllo di gestione
Per verificare che l'applicativo si possa compilare ed eseguire, selezionate il menù “Build”,
“Run” (o premere Ctrl+R).
Se tutto funziona, vedrete comparire una finestra vuota che si chiama MainWindow.
Fig 1.17: Finestra vuota per l'applicazione
di test in Linux
1.6 Configurazione del sistema Windows
In questo paragrafo verranno illustrati tutti i passi necessari ad installare la libreria e il
compilatore Visual Studio 2012 Express, fino a creare una prima applicazione per verificare che
l'installazione sia corretta.
Visual Studio Express è la versione prova per 30 gg del blasonato Visual Studio ed è disponibile
sul sito di Microsoft. Passati i 30 gg è possibile registrarsi sul sito di Microsoft ed estendere
gratuitamente e senza limiti la licenza. Questa formula vale per tutte le versioni di Visual Studio,
compresa la versione 2012.
L'installazione richiede circa 5 GB per Visual Studio e circa 1.6 GB per la libreria Qt.
La libreria viene distribuita nella versione compilata con: MinGW, Visual Studio 2010 a 32-bit,
Visual Studio 2012 a 64-bit. Dato che il mio sistema operativo è Windows 7 a 64-bit, sarebbe uno
spreco installare una libreria compilata a 32-bit, pertanto ho scelto di lavorare con Visual Studio
Express 2012.
E poi personalmente credo che la piattaforma a 32-bit vada archiviata come un retaggio del
secolo scorso, dato che sono passati ormai più di 10 anni dal rilascio del primo processore AMD a
64-bit. Ormai tutti i processori in commercio sono in grado di funzionare a 64-bit e, poveretti, molti
di loro si ritrovano a vivere una vita non loro, limitata, a 32-bit, mentre potrebbero girare a 64-bit. I
loro sistemi operativi non li valorizzano.
Spesso sui computer portatili viene installato Windows 7 a 32-bit, perché in questo modo il
processore consuma meno e la batteria dura di più. Non ho esperienze dirette di Windows 8, ma
voglio dire basta, voglio ascoltare la frustrazione del mio Core i5 e liberare la sua potenza,
permettendogli di lavorare a 64-bit, consentendogli di indirizzare file più grandi di 4 GB e memorie
RAM superiori a 4 GB.
Per inciso, l'architettura a 64-bit attuale si chiama AMD64 a seguito del prevalere della
soluzione AMD sulla soluzione Intel, che era stata denominata IA64 e venne implementata per la
prima volta con il processore Itanium nel 2002. Il passaggio alla nuova architettura fu ritenuto
troppo oneroso dal mercato e fu preferita l'architettura AMD, i cui primi processori vennero
rilasciati nel 2003 (Athlon 64 e Opteron 64). Abbastanza rapidamente, nel 2004, Intel inserì nei suoi
processori le estensioni EM64T e rese le famiglie Xeon (processori per server) e Pentium 4
(processori per desktop) compatibili con i sistemi operativi a 64-bit. La prima versione di Windows
XP a 64-bit venne pubblicata nell'Aprile 2005.
La versione di Windows usata durante la revisione finale del libro è Windows 7 64-bit. La
libreria installata è la versione 5.0.2 a 64-bit, rilasciata il 10 Aprile 2013, mentre il compilatore
usato è Visual Studio 2012, che è in grado di compilare sia a 32-bit che a 64-bit. Per quanto
riguarda Qt Creator, si è optato per la versione 2.7.0 resa pubblica il 21 Marzo 2013 e distribuita
con la libreria 5.0.2.
1.6.1
Installazione di Visual Studio Express 2012
La prima cosa da fare è scaricare Visual Studio 2012 Express andando sul sito di Microsoft
www.microsoft.com/visualstudio/ita/downloads e selezionando Visual Studio Express 2012. A
questo punto si passa ad una pagina che chiede quale versione di Visual Studio si vuole installare.
Selezionare la versione per Windows Desktop. Cliccando sull'immagine del CD è possibile
scaricare un file in formato ISO che contiene l'installazione.
Fig. 1.18: Selezionare l'immagine del CD per scaricare il file ISO con
l'installazione di Visual Studio Express 2012
Il file, una volta scaricato si chiama VS2012_WDX_ITA.iso ed ha una dimensione di 622 MB.
Per poterlo usare lo si deve masterizzare su un CD, oppure montare come CD virtuale usando un
apposito programma. Nella mia installazione ho utilizzato il programma “free-ware” “Virtual Clone
Drive”, prodotto da slysoft (www.slysoft.com). Dopo aver installato Virtual Clone Drive, basta fare
doppio click sul file VS2012_WDX_ITA.iso e nella schermata che appare selezionare “Open folder
to view files”. A questo punto, doppio click su “wdexpress_full” e l'installazione inizia.
Fig. 1.19: Apertura del file VS2012_WDX_ITA.iso
Fig. 1.20: Programma di installazione di Visual Studio 2012
Express
Dopo qualche secondo, credo dovuto alla macchina virtuale del framework .NET, comparirà una
schermata in cui si devono accettare tutte le condizioni di licenza chieste da Microsoft e poi far
partire l'installazione vera e propria premendo “INSTALLA”.
Preparatevi al fatto che l'operazione non sarà veloce. Solo per far uscire la finestra iniziale ci
vogliono 25 secondi, figuratevi quanti minuti servono per installare il tutto. Ascoltate il mio
consiglio, portate fuori il cane a fare i suoi bisogni, bevetevi un caffè al bar, leggetevi la Gazzetta e
quando tornate l'installazione potrebbe essere finita. Non pensate di poter usare il computer nel
frattempo. Nonostante i 4 processori siano assolutamente disoccupati, il computer è comunque
inutilizzabile.
Fig. 1.21: Schermata iniziale dell'installazione di Visual
Studio 2012 Express
Fig. 1.22: Installazione di Visual Studio 2012
Express in corso
1.6.2
Installazione della libreria Qt
Se avete seguito le istruzioni del paragrafo 1.4 su come scaricare la libreria, ora non resta che
scaricare il file:
qt-windows-opensource-5.0.2-msvc2012_64-x64-offline.exe
Dato che questa versione contiene anche la versione 2.7.0 di Qt Creator, non è necessario
scaricare a parte Qt Creator.
Fig. 1.23: File da scaricare per Windows
Fare doppio click sul file qt-windows-opensource-5.0.2-msvc2012_64-x64-offline.exe appena
scaricato e seguire la procedura di installazione. Premere “Next” nella schermata iniziale, premere
“Next” nella schermata che permette di selezionare la cartella di destinazione dell'installazione e
premere “Next” nella schermata che permette di selezionare quali componenti installare. A questo
punto basta attendere pochi minuti e l'installazione è completa.
Fig. 1.24: Schermata iniziale dell'installazione in
Windows 7
Fig. 1.25: Selezione della cartella di destinazione in
Windows 7
Fig. 1.26: Selezione dei componenti da installare
Fig. 1.27: Installazione in corso
Fig. 1.28: Installazione completata
1.6.3
Controllare che il tutto funzioni
Dato che prima è stato installato il compilatore e poi la libreria Qt, tutte le operazioni di
configurazione del sistema sono già state fatte e non dovrebbero esserci problemi. Verificarlo è
molto semplice, basta aprire Qt Creator, cercando nell'elenco dei programmi di Windows la cartella
Qt 5.0.2. Una volta aperto il programma selezionare la voce di menu “File”, “New File or Project”
e nella finestra di dialogo che appare, nella prima colonna selezionare “Applications”, nella seconda
colonna selezionare “Qt Gui Application”, e premere il pulsante “Choose”.
Procedere inserendo il nome dell'applicazione, ad esempio TestInstallazioneW7, ed
impostando la cartella di lavoro. Premere “Next” quando appare la schermata relativa alla sezione
del kit di compilazione, premere “Next” alla schermata “Class Information”, premere “Finish”
quando chiede di selezionare un controllo di versione nella schermata “Project Management”. In
pochi secondi ci si ritrova in Qt Creator con il progetto completato, pronto per essere compilato ed
eseguito.
Fig. 1.29: Posizione di Qt
Creator
Fig. 1.30: Creare una nuova applicazione
Fig. 1.31: Impostazione nome progetto e cartella di lavoro
Fig. 1.32: Impostazione del kit di compilazione
Fig. 1.33: Definizione della classe principale del
progetto
Fig. 1.34: Selezione del controllo di versione
Fig. 1.35: Il progetto di prova viene visualizzato in Qt Creator
Non resta altro che verificare che l'applicativo si possa compilare ed eseguire. Selezionare il
menù “Build”, “Run” (o premere Ctrl+R) e se tutto funziona vedrete comparire una finestra vuota
che si chiama MainWindow
Fig. 1.36: Ecco come appare la form
principale in Windows 7
2 Hello World! Creare il primo applicativo
In questo capitolo vedremo gli elementi necessari a creare il classico Hello World! Prestate
molta attenzione, perché si deve mettere il punto esclamativo alla fine, altrimenti non è un Hello
World! valido.
Questa, sarà anche l'occasione per vedere bene, quali sono i componenti di un progetto, e quali
fasi si devono attraversare per passare dal codice, all'eseguibile.
2.1 Analisi dei file che compongono il progetto
Per capire dove si deve agire per creare il messaggio Hello World! è bene fare una disamina
dettagliata di come viene costruito il progetto e di quale ruolo svolge ogni singolo file. Conoscere
bene questi aspetti non è fondamentale fino a quando ci si imbatte nella classica situazione del “non
ho cambiato niente eppure non va più un tubo!”. Tenete presente questo paragrafo, qualora vi
trovaste in una situazione simile.
Si prende come riferimento il progetto TestInstallazione appena creato nel capitolo
precedente, partendo dal modello Qt GUI Application.
2.1.1
File di progetto
Il file principale che descrive il progetto è TestInstallazione.pro e si tratta di un file di testo che
contiene essenzialmente quattro sezioni: l'elenco dei moduli da includere, il modello da usare, il
nome dell'eseguibile che verrà creato, l'elenco dei file che compongono il progetto.
Fig. 2.1: Qt Creator e il file principale del progetto
L'elenco dei moduli da includere serve per collegare al progetto solo una selezione dei 20.000 e
più file che compongono la libreria. In particolare, la divisione in moduli è una delle maggiori
migliorie introdotte nella versione 5.0. Inoltre, guardando i moduli che vengono inclusi è possibile
sapere quali saranno i file .SO o le .DLL da distribuire con la propria applicazione. Nel nostro
esempio abbiamo tre moduli: core, gui e widgets.
QT
+= core gui
greaterThan(QT_MAJOR_VERSION, 4): QT += widgets
Si noti come il modulo widgets venga incluso solo nel caso in cui la versione della libreria sia
superiore a Qt4, questo perché la separazione delle widgets dalla gui è avvenuta con Qt5. Questa
sintassi mostra che il file del progetto è a sua volta un linguaggio di scripting con macro e funzioni.
Le librerie corrispondenti, nel caso di un sistema operativo Linux sono:
libQt5Gui.so, libQt5Widgets.so e si trovano nella cartella
libQt5Core.so,
Qt5.0.2/5.0.2/gcc_64.
Nel caso di sistema operativo Windows le DLL si chiamano: Qt5Core.dll, Qt5Gui.dll,
Qt5Widgets.dll e si trovano nella cartella
c:\Qt\Qt5.0.2\5.0.2\msvc2012_64\bin\
I moduli di cui è composta la libreria sono elencati nell'help, alla voce “All Modules”. Quelli che
verranno utilizzati nel libro sono:
Qt Core
Raccolta delle classi non grafiche usate dagli altri moduli.
Qt GUI
E' la classe base per l'interfaccia grafica e comprende
anche OpenGL.
Qt Multimedia
E' la collezione delle classi per gestire i flussi audio, video e
le applicazioni radio o le telecamere.
Qt Network
Raccolta delle classi per rendere la programmazione della
comunicazione di rete più facile e portabile nelle varie
piattaforme.
Qt SQL
Classi per la comunicazione con i database usando il
linguaggio SQL.
Qt Widgets
Classi che estendono il modulo Qt GUI con le Widgets C++.
Qt WebKitWidgets Classi per la gestione e la visualizzazione di pagine Web
La sezione successiva, TARGET specifica il nome del file che verrà generato. Il valore di default
è il nome del progetto, ma potrebbe essere diverso.
TARGET = TestInstallazione
Nella sezione TEMPLATE si specifica il tipo di file che verrà generato. I tipici modelli per la
generazione del codice sono due: applicazione e libreria. Nel caso applicazione il risultato della
compilazione sarà un file eseguibile, nel caso della libreria sarà un file DLL o SO. Nel nostro caso
si tratta di una applicazione.
TEMPLATE = app
L'ultima parte del file di progetto elenca i nomi dei file che compongono il progetto, raggruppati
per tipologia: SOURCES per i file con il codice C++, HEADERS per file di intestazione, in genere con
estensione *.h e FORMS per file di definizione dell'interfaccia grafica, con estensione *.ui.
SOURCES += main.cpp\
mainwindow.cpp
HEADERS += mainwindow.h
FORMS
+= mainwindow.ui
2.1.2
File di configurazione
A fianco del file di progetto viene creato in automatico il file TestInstallazione.pro.user.
Questo file contiene l'elenco dei file aperti e viene usato per ripristinare la sessione quando si riapre
il progetto in Qt Creator, oltre alla definizione dei kit di compilazione. Se si cancella questo file, nel
momento in cui il progetto viene riaperto, si apre immediatamente la pagina per la configurazione
del progetto e la selezione del kit di compilazione.
E' bene tener presente che questo è l'unico file che è obbligatorio cambiare, quando per esempio
si passa da Linux a Windows. La cosa più semplice è copiare tutto il codice nel nuovo sistema
operativo, cancellare il file .user e lasciare che Qt Creator ne crei uno adatto.
Fig. 2.2: Impostazione del progetto e delle configurazioni di compilazione.
2.1.3
File che contengono il codice
Sono i classici file *.cpp e *.h che in questo caso si chiamano: main.cpp, mainwindow.cpp
e mainwindow.h.
Apriamo il file main.cpp facendo doppio click sull'albero con tutti i file del progetto. La prima
cosa che si nota è che è estremamente sintetico e contemporaneamente chiaro.
Fig. 2.3: Contenuto del file main.cpp
Nella lista delle inclusioni troviamo mainwindow.h che è l'intestazione relativa alla classe
della finestra di dialogo principale, seguita da <QApplication> che invece raccoglie le definizioni
collegate alla classe QApplication.
Fondamentalmente la funzione principale (main appunto) non fa altro che creare un oggetto
QApplication, un oggetto MainWindow e visualizzarlo. Per ultima cosa entra nel ciclo di
gestione degli eventi dell'oggetto QApplication, da cui uscirà solo quando l'applicativo verrà
chiuso.
2.1.4
File che definiscono l'interfaccia grafica
La finestra di dialogo (MainWindow) visibile nell'esempio è definita dal file mainwindow.ui.
Si tratta di un file XML che descrive il contenuto della finestra. E' possibile editarlo a mano con un
editor di testo, oppure lo si può molto più comodamente editare in modo grafico da Qt Creator,
facendo doppio click sul file, nell'albero del progetto. Il risultato è una schermata in cui compare
l'editor delle finestre, con a sinistra l'elenco degli oggetti grafici, che vengono chiamati Widget e al
centro la nostra finestra di dialogo, detta “form”.
Per trasformarla nel classico Hello World! basta inserire un Widget di tipo QLabel al centro
della finestra di dialogo e cambiare il testo in esso contenuto semplicemente facendo doppio click
sulla QLabel. Già che ci siamo, possiamo anche rimpicciolire la finestra di dialogo usando i punti
di controllo quadrati (blu) presenti sul bordo della scheda.
Per finire possiamo anche impostare un titolo per la finestra di dialogo, ad esempio Test
Installazione, selezionando la finestra di dialogo principale ed impostando la proprietà
windowTitle.
Fig. 2.4: Modificare graficamente la finestra di dialogo
Fig. 2.5: Impostare il titolo della finestra di dialogo
2.1.5
File di risorse
Un menzione speciale va poi fatta per i file che contengono le risorse, come per esempio le
icone, le traduzioni nelle varie lingue, le immagini da inserire nell'applicazione. Queste vengono
inserite nel progetto tramite un file che ha estensione .qrc. Aggiungiamo al nostro progetto un file
di risorse ed usiamolo per impostare l'icona dell'applicazione.
Per la creazione del file si usa il menù “File”, “New File or Project”, e quando si apre la finestra
di dialogo per creare un nuovo file, nella colonna di sinistra si deve selezionare la riga Qt, e nella
parte centrale “Qt Resource file”. Premere “Choose” e passare alla impostazione del percorso.
Naturalmente la posizione di default è il percorso base del progetto, supponiamo di chiamare il
nuovo file “RisorseProgetto.qrc”. Premere “Next” per passare all'impostazione del controllo
di versione, premere “Finish” per completare la creazione.
Fig. 2.6: Creazione di un nuovo file di risorse
Fig. 2.7: Impostazione del nome del file di
risorse
Il nuovo file sarà visibile nell'albero del progetto, nella sezione “Resources”, mentre nel file
TestInstallazione.pro comparirà una nuova sezione che si chiama RESOURCES.
RESOURCES += \
RisorseProgetto.qrc
A questo punto cerchiamo da qualche parte un'immagine abbastanza piccola da essere usata
come icona, ad esempio usando un motore di ricerca e selezionando la prima immagine 32x32 che è
adatta al nostro programma. Nel mio caso ho trovato configuration32.png. Salviamo
l'immagine nella cartella del progetto e apriamo il file delle risorse con un doppio click.
Le risorse vanno organizzate come se fossero archiviate su un disco, pertanto oltre al nome del
file si deve mettere un prefisso che funge da percorso per trovare la risorsa. Va fatto notare che il
file delle risorse si limita a collezionare dei riferimenti a dei file che si trovano poi nella cartella del
progetto. Non vi è alcuna incorporazione di file all'interno di RisorseProgetto.qrc.
Per inserire un'immagine nel file delle risorse, cliccare sul pulsante “Add” che si trova nella
parte bassa di Qt Creator e selezionare “Add Prefix”. Dato che si tratta di un'icona, è ragionevole
chiamare il prefisso con /icon. Per accedere alla risorsa dall'interno del progetto basta aprirla
come fosse un file, con un percorso “speciale” che inizia con “:”. Ma non serve ricordare questa
sintassi, basta fare click con il tasto destro sulla nostra icona e selezionare: “Copy Resource Path to
Clipboard” e poi inserire il testo nel codice. Il testo memorizzato nella “clipboard” è il seguente:
:/icon/configuration32.png
Fig. 2.8: Inserire l'icona della applicazione nel file delle risorse
Per usare l'immagine, configuration32.png come icona della nostra applicazione, basta
aprire il file mainwindow.ui, selezionare tutta la finestra e nella tabella delle proprietà della
finestra di dialogo cercare la sezione QWidgets e la proprietà windowIcon. Cliccare sulla freccia
verso il basso e selezionare “Choose Resource”. A questo punto si apre un pop-up con l'elenco delle
risorse. Selezionare l'icona appena inserita e premere OK.
Fig. 2.9: Impostazione dell'icona della form
principale
Fig. 2.10: Selezione delle icone presenti nel file delle
risorse
Il passo successivo è quello di impostare la dimensione dell'icona, cercando la voce iconSize
all'interno della sezione QMainWindow. Il valore di default è 24 x 24, nel nostro caso lo si deve
portare a 32 x 32 pixel, dato che questa è la dimensione di configuration32.png
Fig. 2.11: Impostare la
dimensione dell'icona della
finestra principale
2.2 Compilare il progetto
Dopo aver esplorato tutti i file che compongono un progetto, aver inserito l'icona per la finestra
di dialogo principale, e un'etichetta di testo al centro della finestra di dialogo principale, proviamo a
vedere il risultato del nostro lavoro eseguendo la compilazione.
Per far questo possiamo premere la combinazione Ctrl+R oppure selezionare la voce “Run” del
menù “Build”, o semplicemente cliccare sulla freccia verde in basso a sinistra.
Fig. 2.12: Pulsante per compilare ed
eseguire il programma
2.2.1
Risultato finale in Linux
E' interessante osservare, come lo stesso codice sorgente possa essere compilato in Linux e in
Windows, e dare origine a due applicativi identici nella funzionalità, ma diversi nello stile. Questo
perché Qt si integra nel sistema operativo e ripropone lo stesso “Look and Feel”.
Iniziamo con Linux, dove la nostra icona compare sia nella barra delle applicazioni a sinistra
che nel task manager quando premiamo CTRL+TAB.
Fig. 2.13: Finestra di dialogo, icona nella barra delle applicazioni e
nel task manager nel caso di Ubuntu
2.2.2
Risultato finale in Windows
Per compilare l'applicativo in Windows basta prendere lo stesso codice sorgente, e copiarlo in
Windows. L'unica modifica è che il file TestInstallazione.pro.user, va rigenerato dato che è stato
creato per una piattaforma diversa. Premere No nella finestra di dialogo che compare appena si
cerca di aprire il progetto e l'aggiornamento si completa velocemente.
La schermata successiva è quella della finestra di dialogo “configure project”, che suggerisce i
parametri di compilazione adatti al nuovo sistema operativo. Basta premere il tasto “Configure
Project” e la conversione è fatta.
Fig. 2.14: Avviso relativo al file .user che va rigenerato nel nuovo
sistema operativo
Fig. 2.15: Schermata di configurazione del progetto in Windows
Fig. 2.16: Finestra di dialogo, icona sulla barra dei programmi, e nel task
manager, nel caso di Windows 7
2.2.3
Compilare in Release
Automaticamente Qt Creator crea due configurazioni di compilazione, che si chiamano Debug e
Release. La compilazione Debug contiene simboli e informazioni necessarie per il debug appunto
della applicazione, mentre queste informazioni vengono omesse nella configurazione Release.
Inoltre nel caso debug si usano librerie a loro volta compilate in debug, riconoscibili dal suffisso
“d”, che sono diverse da quelle che vengono usate in Release. Per finire, va fatto notare che se ci
sono opzioni di ottimizzazione del codice, queste vengono applicate solo in Release. Questo perché
alcune ottimizzazioni cambiano l'ordine di esecuzione del codice.
L'impostazione selezionata di default è la compilazione in Debug, ma quando lo sviluppo
dell'applicativo è completo, e si è pronti per fare una versione definitiva, va compilato in Release.
Per attivare questa configurazione in Qt Creator, si deve cliccare sul pulsante che si trova in
basso a sinistra, sopra la freccia verde, e selezionare Release.
Fig. 2.17: Compilare il progetto in Release
A questo punto selezionare dal menù “Build” la voce “Build TestInstallazione” e l'eseguibile
viene compilato e messo nella cartella
build-TestInstallazione-Desktop_Qt_5_0_2_GCC_64bit-Release
che è diversa dalla cartella di destinazione dell'applicazione compilata selezionando Debug.
2.3 Compilazione ed esecuzione di un applicativo
Non sono un fanatico dei compilatori e non voglio addentrarmi nei dettagli della compilazione,
ma vorrei brevemente descrivere come si passa dal file Testinstallazione.pro
all'applicazione TestInstallazione. In genere non è indispensabile conoscere questi tecnicismi,
tranne nei casi in cui qualche meccanismo si inceppa e genera messaggi di errore che fanno
riferimento ai comandi citati nel presente paragrafo.
La sequenza di comandi (comunemente detti “tool”) che vengono attivati per passare dal file:
•
TestInstallazione.pro
al corrispondente file eseguibile:
•
TestInstallazione, (TestInstallazione.exe nel caso di Windows)
è detta “tool chain”.
Quando attiviamo il menu “Build”, “Run”, o la combinazione di tasti Ctrl+R, oppure premiamo
la freccia verde in basso a sinistra, i “tool” della libreria Qt che vengono eseguiti sono:
•
qmake: converte il file di progetto nel cosiddetto Makefile
•
make: interpreta il Makefile
•
moc: genera il codice di supporto per i Qt Meta Objects
•
rcc: converte i file delle risorse in file C++
•
uic: prende i file con estensione ui e li converte in file C++
Poi ci sono i “tool” esterni che dipendono dalla piattaforma per cui stiamo sviluppando, ovvero:
•
il compilatore C++
•
il linker C++
•
il Program Loader che mette in esecuzione il programma
Analizziamo in dettaglio i vari comandi, tenendo presente che il loro nome è sempre scritto in
caratteri minuscoli per evitare problemi con i sistemi operativi “case-sensitive”, come per esempio
Linux.
2.3.1
Il comando qmake
Il primo che viene invocato è qmake e lo si può anche invocare direttamente dal menu “Build”,
alla voce “Run qmake”. Il lavoro di qmake consiste nel creare la cartella in cui verrà messo il file
compilato, processare il file di progetto e creare il file Makefile. Questo file (il nome è proprio
Makefile, con la M maiuscola) non è altro che una sequenza di comandi, uno “script file”, che
viene interpretato da un altro programma che si chiama make.
Se ci si riferisce all'esempio TestInstallazione la cartella di destinazione si chiama:
build-TestInstallazione-Desktop_Qt_5_0_2_GCC_64bit-Debug
Notate che il nome è molto lungo e contiene l'informazione sul tipo di applicazione (Desktop),
sulla libreria usata (Qt 5.0.2), sul tipo di piattaforma (32-bit o 64-bit) e sul tipo di compilazione
(Release / Debug).
2.3.2
Il comando make / jom
A questo punto, il controllo passa allo script Makefile fino al lancio dell'applicazione
compilata. In questo script vengono invocati i vari moc, rcc, uic, il compilatore e il linker.
Va fatto notare che nel caso di compilazione usando Visual Studio in Windows, il tool che viene
invocato è jom, un clone di NMAKE.EXE, il comando originale Microsoft. Questo tool è pensato per
gestire la compilazione di un progetto, partendo da una sequenza di comandi contenuti in un file di
istruzioni.
Il miglioramento introdotto da jom, rispetto ad NMAKE.exe, sta nel fatto di poter sfruttare le
architetture multi-core, eseguendo più di un comando in parallelo.
2.3.3
Il comando moc
Il nome moc è l'acronimo di “Meta-Object Compiler” ed è il tool che converte alcune estensioni
al linguaggio C++ previste dalla libreria Qt (ad esempio l'istruzione foreach e la gestione signals
and slots) in codice C++. Ad esempio nel caso di TestInstallazione, il file mainwindow.cpp
viene processato e viene generato il file moc_mainwindow.cpp.
2.3.4
Il comando rcc
Il nome rcc deriva da “Resource Compiler” ed è il tool che converte i file con estensione qrc
in variabili C++ inizializzate, e le scrive in un file. Ad esempio nel caso di TestInstallazione,
il file RisorseProgetto.qrc diventa qrc_RisorseProgetto.cpp.
2.3.5
Il comando uic
Questo è l'acronimo di “User Interface Compiler” ed è un “tool” che interpreta il contenuto dei
file con estensione ui, ovvero i file che definiscono l'interfaccia utente e li trasforma in file per il
compilatore C++.
Ad esempio il file mainwindow.ui viene convertito in ui_mainwindow.h.
2.3.6
Compilatore C++
Il ruolo del compilatore è quello di convertire i file cpp, che sono dei file testuali, in file binari
con estensione .o detti file oggetto. Ad esempio nel caso TestInstallazione i file generati dal
compilatore sono:
main.o
mainwindow.o
moc_mainwindow.o
qrc_RisorseProgetto.o
Nel caso del compilatore Microsoft, i file oggetto hanno estensione .obj.
2.3.7
Linker
I file oggetto contengono dei pezzi di codice eseguibile dal processore, ma necessitano di una
ulteriore fase prima di diventare dei programmi eseguibili. Questo lavoro viene fatto dal linker, che
collega tra di loro tutti i file, calcola gli indirizzi di tutte le variabili e delle funzioni, poi genera il
cosiddetto file ELF, “Executable and Linked File”, che tipicamente in Windows ha estensione .exe.
2.4 QDebug: inserire un messaggio trace
Nello sviluppo di un'applicazione, capita spesso che le cose vadano in modo diverso da come ci
si aspettava. La tecnica più semplice per investigare queste anomalie, è quella di inserire dei
messaggi, detti “trace”, in alcuni punti specifici dell'applicazione. Questo lavoro viene fatto con la
classe QDebug, che appartiene al modulo QtCore.
Sempre partendo dall'esempio TestInstallazione, supponiamo di modificare la funzione
main in modo che appena l'oggetto applicazione viene creato, venga stampato un messaggio con il
nome dell'applicazione.
Il primo passo è quello di includere l'intestazione <QDebug>. Si noti che si usano QDebug, non
QDebug.h e lo si mette tra parentesi ad angolo.
Aprire il file main.cpp e inserire <QDebug> immediatamente sotto a <QApplication>.
#include <QApplication>
#include <QDebug>
Poi si deve inserire la stampa del messaggio, nella funzione main, subito dopo aver creato
l'oggetto QApplication:
QApplication a(argc, argv);
qDebug() << qApp->applicationDisplayName();
Fig. 2.18: Stampa del nome dell'applicazione usando qDebug()
Notare che l'oggetto che riceve la stampa si chiama qDebug() con la q minuscola e che il nome
dell'applicazione viene preso da un oggetto globale che si chiama qApp e che rappresenta il
riferimento alla applicazione corrente.
Quando l'applicazione viene eseguita, il messaggio viene stampato in basso a destra, nella
sezione “Application Output” di Qt Creator.
2.5 Altri file che possono far parte del progetto
E' possibile inserire nel progetto anche dei file di documentazione che hanno un formato libero e
vengono catalogati nella sezione OTHER_FILES. Ad esempio supponiamo di aggiungere un file per
tenere traccia delle modifiche che abbiamo fatto e di chiamarlo ChangeLog.txt. Basta andare sul
menu “File”, “New File or Project” e si aprirà la finestra di dialogo per creare un nuovo file o
progetto. Selezionare l'ultima voce in fondo alla lista (“General”) e poi selezionare “Text File”.
Premere “Choose” e impostare la posizione del file. Naturalmente viene suggerita come base la
cartella del progetto. Premere “Next” per passare all'impostazione del controllo di versione e infine
premere “Finish”.
Fig. 2.19: Creazione di un file di testo da aggiungere al progetto
Fig. 2.20: Impostazione del percorso del file
A questo punto il file è visibile nell'albero del progetto e viene aggiunto anche nel file
TestInstallazione.pro, nella sezione “OTHER_FILES”
OTHER_FILES += \
ChangeLog.txt
Fig. 2.21: Il file ChangeLog.txt fa parte
dell'albero del progetto.