Qt 5 Quanto BastaLa 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 GualeniSeconda 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: info@gianbattistagualeni.it

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 generalePrefazione...........................................................................................................................................7Glossario.............................................................................................................................................8Introduzione........................................................................................................................................9

Come nasce questo libro..................................................................................................................9Perché la scelta di Qt come libreria di sviluppo............................................................................10Ubuntu ovvero la scelta della distribuzione Linux........................................................................11Come finì la storia..........................................................................................................................11

1 Prerequisiti: libreria, editor e compilatore.....................................................................................131.1 Prima di iniziare.......................................................................................................................131.2 La licenza duale.......................................................................................................................131.3 Componenti del sistema...........................................................................................................141.4 Scaricare la libreria Qt 5.0.2....................................................................................................141.5 Configurazione del sistema Linux...........................................................................................161.6 Configurazione del sistema Windows......................................................................................22

2 Hello World! Creare il primo applicativo......................................................................................342.1 Analisi dei file che compongono il progetto............................................................................342.2 Compilare il progetto...............................................................................................................402.3 Compilazione ed esecuzione di un applicativo........................................................................432.4 QDebug: inserire un messaggio trace......................................................................................452.5 Altri file che possono far parte del progetto............................................................................462.6 Rimuovere un file dal progetto................................................................................................48

3 Distribuire l'applicativo.................................................................................................................493.1 Distribuire un applicativo per Linux........................................................................................493.2 Distribuire un applicativo per Windows..................................................................................58

4 Un visualizzatore immagini con QGraphicsView.........................................................................684.1 Creare l'applicazione di base....................................................................................................684.2 QAction e l'interazione con l'utente.........................................................................................694.3 QGraphicsView per visualizzare le immagini.........................................................................774.4 Selezionare la cartella e caricare le immagini.........................................................................824.5 Completare le azioni per sfogliare le immagini.......................................................................884.6 Gestire lo zoom........................................................................................................................894.7 Risultato finale.........................................................................................................................93

5 Completare il visualizzatore di immagini......................................................................................945.1 La versione dell'applicazione...................................................................................................945.2 QSettings per salvare la configurazione................................................................................1035.3 QMessageBox::question() per chiedere conferma prima di chiudere...................................1085.4 Impostare il colore dello sfondo.............................................................................................1115.5 QStatusBar: informazioni sulla barra di stato........................................................................1175.6 Gestire l'attesa durante il caricamento delle immagini..........................................................1275.7 Finestra con le informazioni dell'immagine...........................................................................1305.8 Distribuire Visualizzatore Immagini 1.0................................................................................151

6 Creare una libreria con Qt...........................................................................................................1556.1 Classificazione delle librerie..................................................................................................1556.2 Cap6ElaIm: creare una libreria statica...................................................................................1566.3 D-pointer per fare una vera libreria.......................................................................................1616.4 Come si usa una libreria statica.............................................................................................1726.5 Creare una libreria dinamica..................................................................................................1836.6 Usare una libreria dinamica...................................................................................................1876.7 Controllare il contenuto di una libreria..................................................................................1916.8 La compatibilità binaria.........................................................................................................194

7 Argomenti avanzati......................................................................................................................196

7.1 Mostrare una gif animata durante l'attesa..............................................................................1967.2 Formati immagine supportati.................................................................................................2157.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

PrefazionePenso 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, inquanto in diversi anni di attività (e di letture) mi è capitato raramente di incontrare un autore checon passione, talento e spirito di condivisione mette a disposizione di tutti quanto ha imparatoautonomamente.

Essere un buon software designer, oggi come sempre, richiede contemporaneamente unacapacità 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 ispirazionecreativa e tecnica di programmazione.

Fatta questa premessa è quindi intuibile comprendere l’abilità dell’autore che ha saputotrasmettere, con passione, la semplicità, la potenza e non ultimo l’eleganza, del codice sorgentescritto impiegando questo toolkit.

Le pagine di questo libro scorrono piacevolmente presentando una sequenza fitta diinformazioni 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 loconosce già; posso confermare infatti che, pur seguendo l’evoluzione di questo toolkit sin dallontano 2003, ho trovato nel libro informazioni utili, stimoli per migliorare e punti di vistainteressanti.

Lo stile impiegato dall’autore mette il lettore a proprio agio fornendo con precisione, sin dallebattute iniziali, tutte le informazioni necessarie per poter mettere in pratica i concetti esposti; illettore viene così accompagnato “per mano” nella realizzazione di applicazioni dalle “GUI” evoluteed allo stato dell’arte.

Termino quest’introduzione del libro con, permettetemi, una nota di orgoglio in quantofinalmente, grazie a Gianbattista Gualeni, è disponibile un libro in lingua italiana sulle famose“librerie Qt”.

Paolo Sereno, Torino, 20 Maggio 2014

GlossarioIn 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 operativousando la “command line interface”. In realtà in Ubuntu non si usa la bash ma un applicativo che sichiama 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 linguaggioad alto livello, contenuto in un file di testo, in un file binario contente del codice Assembly, in modoche possa essere interpretato dal processore.

DLL: ovvero “Dynamic Link Library” è un file che contiene parte del codice, organizzato comeuna 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 diUbuntu che uso si appoggia ad un desktop GNOME.

GNU: è un progetto per lo sviluppo cooperativo di software libero, lanciato da Richard Stallmannel 1983. Oltre ad essere probabilmente la prima volta che si è formulato, con tanto di licenza e basilegali, 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 delconcetto di Open Source. Si tratta di una licenza che pur proteggendo il diritto d'autore di chi hacreato 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 dellaGPL, che impediva di usare codice Open Source all'interno di progetti che a loro volta non fosseroOpen Source.

Linker: è un applicativo che prende il risultato del compilatore e lo impacchetta in uneseguibile.

Linux: è un sistema operativo, simile a Unix, ma libero, sviluppato nei primi anni '90 da LinusTorvalds. Attualmente è molto molto popolare dato che viene usato in tutti i telefoni Android. Lasua 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 innestatein un applicativo al fine di espandere le sue funzionalità. Tecnicamente sono delle librerie acollegamento dinamico, con alcune funzionalità aggiuntive.

SDK: “software development kit”, è una collezione di esempi, librerie software edocumentazione, che assieme formano un Kit per lo sviluppo di applicazioni software.

SO: ovvero “Shared Object” è l'estensione usata per identificare le librerie a caricamentodinamico nel mondo Linux.

Ubuntu: si tratta di una distribuzione di Linux, basata su Debian e Gnome. Viene manutenuta esviluppata principalmente da Canonical, che è una azienda fondata da Mark Shuttleworth, ungiovane imprenditore sudafricano.

Widget: si usa per indicare un elemento riusabile in una interfaccia grafica. Pulsanti, caselle ditesto, barre di scorrimento, finestre per visualizzare immagini, sono tutti Widget. In alcune libreriesono chiamati anche Controlli.

IntroduzioneIn 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 perWindows.

Come nasce questo libroNel 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 permedicinali.

In queste applicazioni c'era sempre un pannello operatore che veniva usato per controllare lamacchina o la linea di produzione. Dietro di esso c'era quasi sempre un computer industriale con unsistema operativo Windows 2000 o Windows XP.

Sicuramente saprete che le applicazioni industriali hanno in genere un approccio moltoconservativo, e che sono sistemi pensati per garantire la produttività della macchina o della linea perun minimo di 10 anni. Nel 2008 Windows 2000 era vicino ai 10 anni di vita, e non veniva più usatoper i nuovi progetti, mentre Windows XP era considerato il sistema operativo ideale per i nuovisviluppi, 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 lafinanza anglosassone è scesa dalla cattedra e ci ha trascinato nella più grande crisi economica disempre. 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 unaserie di motivi, tra cui la necessità di processori più potenti, di schede grafiche aggiornate, dimemoria 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 eraquasi sempre da 256 MB (a volte da 512 MB), e il disco fisso veniva sostituito da una memoriaflash da 4 GB con scrittura bloccata per aumentarne al massimo l'affidabilità. Installare WindowsVista significava passare a sistemi con ventola di raffreddamento. Ve lo immaginate cosa si sarebbepotuto formare dentro un PC, a causa della ventola, dopo dieci anni di funzionamento? Saresteriusciti 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 Microsoftavesse deciso di chiudere la vendita di Windows XP e Windows 2000, le opzioni erano due: oinstallare copie pirata o passare ad un altro sistema operativo, meno esoso nei requisiti, e più stabilenel 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 andatooltre la simpatia per il sistema operativo creato da Linus Torvalds nel 1991. Al tempo avevo giustoprovato 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'è ildesktop, c'è la shell di comando, c'è il gestore dei pacchetti di installazione... A differenza diWindows, dove nel bene e nel male tutte queste opzioni sono già state valutate e tutte le scelte sonostate 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 problemicon le ventole iniziarono a progettare la migrazione della loro applicazione verso Linux. Gli altri simisero in una sorta di limbo in attesa che Microsoft mandasse loro un segnale di speranza. A talproposito si narra che Michael Dell in persona, il titolare di Dell Computers, partì da Austin, inTexas, in sella al suo cavallo nero, con cappello bianco a falda larga, il fucile Winchester e nellafondina una pistola Colt (forse sto un poco esagerando…) e arrivò fino a Redmond, nello stato diWashington, dopo 2150 miglia di viaggio. Suonò al campanello di Steve Ballmer, che al tempo eral'amministratore delegato di Microsoft, e lo implorò di permettergli di continuare a vendere PC coninstallato Windows XP. Alla fine trovarono un accordo e fu concesso a Dell, e poi a tutti gli altricostruttori di computer, di installare Windows Vista e Windows XP contemporaneamente, lasciandopoi che il cliente decidesse, al primo avvio, quale dei due sistemi operativi usare. Il povero SteveBallmer si arrese all'evidenza quando realizzò che il 99,9% dei clienti preferiva Windows XP. I mieiclienti 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. Perintenderci, l'SDK è una collezione di documenti, esempi, manuali, e librerie software che servono alcliente per collegare la telecamera alla sua applicazione. Per fare un SDK serve una buonaconoscenza delle applicazioni, dei tool di sviluppo e del sistema operativo. Il nostro SDK non eraeccezionale, ma si difendeva, solo che era pensato per funzionare solo con Windows XP. Sviluppareun nuovo SDK per Linux voleva dire studiare il sistema operativo, studiare i tool di sviluppo estudiare le applicazioni, il tutto per piattaforme a 32-bit o a 64-bit e probabilmente per più di unadistribuzione. Capite che il problema non ammetteva una soluzione semplice. Più entravo nelmondo 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 primascelta 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 nonmi avrebbero autorizzato a rilasciare l'SDK in formato Open Source o GPL. La fortuna volle che nel2008 Nokia acquistò l'azienda proprietaria di Qt e nel 2009 rilasciò la libreria in formato LGPL. Aquesto punto passai definitivamente a Qt.

Perché la scelta di Qt come libreria di sviluppoL'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 unapplicativo e compilarlo per Windows, per Linux, per Mac (da poco anche per iPhone, iPad edispositivi 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 statoconvertito in Qt, avremmo potuto manutenere un solo progetto e compilarlo sia per Windows cheper Linux. Inoltre Qt era disponibile come LGPL, quindi anche i nostri clienti avrebbero potutosviluppare i loro applicativi in Linux, senza investire 3/4000 € in un ambiente di sviluppo. E ancheper noi era fantastico, perché avremmo potuto fare delle demo o delle presentazioni ai clienti senzaproblemi di licenza.

Inoltre, a seguito dell'acquisizione da parte di Nokia, venne posto grande impegno per rendere itool di sviluppo più facili da usare. Furono create delle distribuzioni che a fianco della libreriacontenevano anche Qt Creator e tutti gli applicativi di supporto (ad esempio per il multilingua). Perfarla 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 facendodoppio click.

Ubuntu ovvero la scelta della distribuzione LinuxBene, 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 fuunanime: la distribuzione più adatta, secondo loro, era Debian. Tutti mi indicarono quella come ladistribuzione migliore per un uso professionale. Pertanto iniziai a studiare tutti gli aspetti, ascaricarmi e a masterizzare i cinque DVD necessari e a capire come avrei potuto installarla sul PCportatile 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'ombrainiziai ad installare Debian. Non si trattava di un sacrificio straordinario, dato che non ho mai amatole vacanze di Agosto. Con tutta l'Italia ferma, qualsiasi vacanza è molto più costosa e qualsiasilocalità troppo affollata per essere un'esperienza rilassante. Ma non pensavo nemmeno chediventasse una operazione tanto complicata da portarmi via tutta la vacanza. Tra l'altro, per la primavolta, 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 sichiamasse 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 inUbuntu.

Fu una sorta di folgorazione, fu come vedere l'arcobaleno dopo essere stato nel bosco sotto untemporale che sembrava non finire mai. Nello slogan di Ubuntu: “Linux per esseri umani” colsil'attenzione per il grido di dolore che si sollevava da tutti coloro che come me, avevano provato adinstallare Linux e avevano rinunciato. Subito, mi comperai una chiavetta USB da 8 GB, su cuiinstallai la distribuzione in formato Live, ovvero in modo che potesse funzionare senza installarealcunché 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 storiaMicrosoft 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 tesorodelle critiche degli utenti.

La crisi colpì duramente l'azienda per cui lavoravo e, dopo un primo tentativo di recupero nel2010, nel 2011 arrivò il cosiddetto “double deep”, vale a dire la seconda recessione, e alla fine del2011, 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 unsistema operativo in grado di impensierire Windows, mentre nel mondo Linux la distribuzioneLinux Mint, a partire dal 2011, la soppiantò in termini di popolarità (stando alle statistichepubblicate dal sito www. distrowatch.com, anche se l'argomento è fonte di accesissime discussioniin cui non voglio entrare).

Anche Nokia, che era proprietaria della libreria Qt, non se la passò bene. L'arrivo di Apple nelmercato della telefonia, con il suo iPhone e le sue app, la colse impreparata, o forse addormentatasugli 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 troppovecchio, con MeeGo, ma era troppo tardi. Gli sviluppatori deridevano Nokia giocando sul nomeMeeGo e chiamandolo Mee Gone, per indicare qualcosa del tipo: “io, me ne sono andato”. Allafine, nel 2010, Nokia annunciò un accordo con Microsoft, in base al quale la nuova linea di telefoniLumia presto avrebbe avuto come sistema operativo Windows Phone 8. A quel punto era chiaro atutti gli sviluppatori e gli appassionati che come me usavano Qt, che la libreria non era più unprodotto 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 abbastanzaimprobabile 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 lasciaronoNokia. Iniziò un pesantissimo lavoro di migrazione di tutta la documentazione e di tutti i serververso il nuovo dominio (qt.digia.com).

Il 19 Dicembre 2012 la versione 5.0 venne finalmente rilasciata.

1 Prerequisiti: libreria, editor e compilatoreIn 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. Inoltreverranno descritte le differenze tra licenza commerciale e licenza LGPL.

1.1 Prima di iniziareQuesto 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. Gliesempi non verranno testati con un Mac, ma data l'attenzione posta da Digia per la qualità dellalibreria, dato che Mac Os ha un kernel molto simile a Linux e dato che verificheremo direttamentecome la stessa applicazione possa essere compilata sia per Linux che per Windows, non ho alcundubbio 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 fatteprincipalmente usando Qt in Ubuntu. Non voglio fare evangelizzazione a favore di Ubuntu, matrovo molto più comodo lavorare in Linux che in Windows 7. Il vantaggio principale è la velocità diavvio del sistema. Ho degli amici che accendono il computer la mattina, vanno a fare colazione, epoi lo lasciano acceso tutto il giorno. Non è il mio caso. Il mio nuovo portatile, pur essendo scarsinocome processore, grazie a Ubuntu e ad un disco allo stato solido fa il boot in soli 16 secondi. Se miservono dei test con Windows 7, posso usare una macchina virtuale, riavviarla in pochi secondi ericongelarla. Addirittura a volte ho l'impressione che Windows 7 giri meglio in una macchinavirtuale lanciata da Linux, che non nel caso nativo.

1.2 La licenza dualeUno 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 dellalibreria, esattamente come si fa con Microsoft Visual Studio, e nessun'altra spesa per rilasciare leapplicazioni. Questa è obbligatoria nel caso di applicazioni “embedded” o nel caso in cui si vogliarilasciare 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 farequalsiasi cosa, compreso la creazione di applicativi con codice sorgente chiuso e commercializzarlia patto che:

• Sia ben chiaro all'utente finale, tramite l'uso del logo di Qt, che si sta utilizzando lalibreria.

• Le DLL (Dynamic Link Libraries) o gli SO (Shared Objects) siano visibili esostituibili dall'utente, che in questo modo mantiene il diritto di poter modificare ilcodice, relativamente alla parte di libreria Qt.

In entrambi i casi le librerie sono identiche, identica la qualità dei test che vengono fatti eidentici 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 farepiccole applicazioni. Per le aziende che sviluppano prodotti basati su Qt è più adatta la versionecommerciale 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 disoftware open source non è ammesso per motivi di sicurezza. Ve lo immaginate un infermiere checambia una DLL in un apparato per la dialisi? In questi casi la licenza commerciale è l'unicaopzione.

Prima che nel 2009 venisse introdotta la licenza LGPL, era possibile solo lo sviluppo diapplicazioni Open Source, cioè il codice dell'applicazione doveva essere distribuito, aperto emodificabile, dall'utente.

1.3 Componenti del sistemaPer 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 LinkLibraries”) nel caso di Windows, gli “header file” (ovvero i file .h, per intenderci) che descrivono ilcontenuto delle librerie, gli esempi e tutta la documentazione necessaria. Per dare un'idea dellacomplessità, basti pensare che la cartella della documentazione contiene più di 7.000 file e occupacirca 250 MB.

Qt Creator è l'applicativo che si usa per creare un progetto, scrivere il codice, interrogare ladocumentazione, costruire l'interfaccia utente, invocare il compilatore per generare l'eseguibile, edeseguire il proprio applicativo in modalità debug.

Il compilatore è l'unica parte esterna a Qt. Nel caso Linux si usa il GNU C++ Compiler, dettoanche 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 treelementi vi suonerà strana, ma è solo perché l'ambiente di programmazione nasconde la struttura. Inrealtà il framework .NET è la libreria, Visual Studio equivale a Qt Creator e il compilatore sichiama “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.2La 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 al100% e non ci siano intoppi. Naturalmente non mi aspetto dei cambiamenti straordinari passando aversioni 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, maprobabilmente 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 allaconfigurazione in uso

1.5 Configurazione del sistema LinuxIn 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 siacorretta.

La distribuzione Linux usata durante la revisione finale del libro è Ubuntu 12.10 QuantalQuetzal 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 laversione 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 sullapartizione di sistema (root).

1.5.1 Installazione del compilatore

Il compilatore da usare è GNU C++ Compiler, conosciuto anche come g++. Lo si può installareusando il comando:

sudo apt-get install g++

Oppure, se come me siete un poco pigri, non vi ricordate la sintassi esatta o semplicementepreferite l'interfaccia grafica, potete usare Ubuntu Software Center, cercare g++ nella lista deiprogrammi 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'unicaopzione è il terminale di comando, dove per installare libgl-dev e libglu-dev dobbiamodigitare:

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 delparagrafo 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 incui è 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 Qt5.0.2 su Linux

Fig. 1.11: Schermata finale dell'installazione di Qt5.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, nellaprima colonna selezionate “Applications”, nella seconda colonna “Qt Gui Application”, e premete ilpulsante “Choose”.

Procedete inserendo il nome dell'applicazione che volete creare, ad esempioTestInstallazione, ed impostate la cartella di lavoro. Premete “Next” quando appare laschermata relativa alla sezione del kit di compilazione, selezionate “Next” alla schermata “ClassInformation”, e poi “Finish” nella schermata “Project Management”.

In pochi secondi ci si ritrova in Qt Creator con il progetto creato, pronto per essere compilato edeseguito.

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'applicazionedi test in Linux

1.6 Configurazione del sistema WindowsIn 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 chel'installazione sia corretta.

Visual Studio Express è la versione prova per 30 gg del blasonato Visual Studio ed è disponibilesul sito di Microsoft. Passati i 30 gg è possibile registrarsi sul sito di Microsoft ed estenderegratuitamente 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 unospreco installare una libreria compilata a 32-bit, pertanto ho scelto di lavorare con Visual StudioExpress 2012.

E poi personalmente credo che la piattaforma a 32-bit vada archiviata come un retaggio delsecolo scorso, dato che sono passati ormai più di 10 anni dal rilascio del primo processore AMD a64-bit. Ormai tutti i processori in commercio sono in grado di funzionare a 64-bit e, poveretti, moltidi loro si ritrovano a vivere una vita non loro, limitata, a 32-bit, mentre potrebbero girare a 64-bit. Iloro sistemi operativi non li valorizzano.

Spesso sui computer portatili viene installato Windows 7 a 32-bit, perché in questo modo ilprocessore consuma meno e la batteria dura di più. Non ho esperienze dirette di Windows 8, mavoglio 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 memorieRAM superiori a 4 GB.

Per inciso, l'architettura a 64-bit attuale si chiama AMD64 a seguito del prevalere dellasoluzione AMD sulla soluzione Intel, che era stata denominata IA64 e venne implementata per laprima volta con il processore Itanium nel 2002. Il passaggio alla nuova architettura fu ritenutotroppo oneroso dal mercato e fu preferita l'architettura AMD, i cui primi processori vennerorilasciati nel 2003 (Athlon 64 e Opteron 64). Abbastanza rapidamente, nel 2004, Intel inserì nei suoiprocessori 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. Lalibreria installata è la versione 5.0.2 a 64-bit, rilasciata il 10 Aprile 2013, mentre il compilatoreusato è Visual Studio 2012, che è in grado di compilare sia a 32-bit che a 64-bit. Per quantoriguarda Qt Creator, si è optato per la versione 2.7.0 resa pubblica il 21 Marzo 2013 e distribuitacon 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 Microsoftwww.microsoft.com/visualstudio/ita/downloads e selezionando Visual Studio Express 2012. Aquesto 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 è possibilescaricare un file in formato ISO che contiene l'installazione.

Fig. 1.18: Selezionare l'immagine del CD per scaricare il file ISO conl'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 unapposito programma. Nella mia installazione ho utilizzato il programma “free-ware” “Virtual CloneDrive”, prodotto da slysoft (www.slysoft.com). Dopo aver installato Virtual Clone Drive, basta faredoppio click sul file VS2012_WDX_ITA.iso e nella schermata che appare selezionare “Open folderto 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 2012Express

Dopo qualche secondo, credo dovuto alla macchina virtuale del framework .NET, comparirà unaschermata in cui si devono accettare tutte le condizioni di licenza chieste da Microsoft e poi farpartire l'installazione vera e propria premendo “INSTALLA”.

Preparatevi al fatto che l'operazione non sarà veloce. Solo per far uscire la finestra iniziale civogliono 25 secondi, figuratevi quanti minuti servono per installare il tutto. Ascoltate il mioconsiglio, portate fuori il cane a fare i suoi bisogni, bevetevi un caffè al bar, leggetevi la Gazzetta equando tornate l'installazione potrebbe essere finita. Non pensate di poter usare il computer nelfrattempo. Nonostante i 4 processori siano assolutamente disoccupati, il computer è comunqueinutilizzabile.

Fig. 1.21: Schermata iniziale dell'installazione di VisualStudio 2012 Express

Fig. 1.22: Installazione di Visual Studio 2012Express 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 chescaricare 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 è necessarioscaricare 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 appenascaricato 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 epremere “Next” nella schermata che permette di selezionare quali componenti installare. A questopunto basta attendere pochi minuti e l'installazione è completa.

Fig. 1.24: Schermata iniziale dell'installazione inWindows 7

Fig. 1.25: Selezione della cartella di destinazione inWindows 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 diconfigurazione 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 cartellaQt 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 secondacolonna selezionare “Qt Gui Application”, e premere il pulsante “Choose”.

Procedere inserendo il nome dell'applicazione, ad esempio TestInstallazioneW7, edimpostando la cartella di lavoro. Premere “Next” quando appare la schermata relativa alla sezionedel kit di compilazione, premere “Next” alla schermata “Class Information”, premere “Finish”quando chiede di selezionare un controllo di versione nella schermata “Project Management”. Inpochi secondi ci si ritrova in Qt Creator con il progetto completato, pronto per essere compilato edeseguito.

Fig. 1.29: Posizione di QtCreator

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 delprogetto

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 ilmenù “Build”, “Run” (o premere Ctrl+R) e se tutto funziona vedrete comparire una finestra vuotache si chiama MainWindow

Fig. 1.36: Ecco come appare la formprincipale in Windows 7

2 Hello World! Creare il primo applicativoIn 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 HelloWorld! valido.

Questa, sarà anche l'occasione per vedere bene, quali sono i componenti di un progetto, e qualifasi si devono attraversare per passare dal codice, all'eseguibile.

2.1 Analisi dei file che compongono il progettoPer 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. Conoscerebene questi aspetti non è fondamentale fino a quando ci si imbatte nella classica situazione del “nonho cambiato niente eppure non va più un tubo!”. Tenete presente questo paragrafo, qualora vitrovaste in una situazione simile.

Si prende come riferimento il progetto TestInstallazione appena creato nel capitoloprecedente, 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 checontiene essenzialmente quattro sezioni: l'elenco dei moduli da includere, il modello da usare, ilnome 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 epiù 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 è possibilesapere quali saranno i file .SO o le .DLL da distribuire con la propria applicazione. Nel nostroesempio abbiamo tre moduli: core, gui e widgets.

QT += core guigreaterThan(QT_MAJOR_VERSION, 4): QT += widgets

Si noti come il modulo widgets venga incluso solo nel caso in cui la versione della libreria siasuperiore a Qt4, questo perché la separazione delle widgets dalla gui è avvenuta con Qt5. Questasintassi 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: libQt5Core.so,libQt5Gui.so, libQt5Widgets.so e si trovano nella cartella

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 cheverranno 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 comprendeanche OpenGL.

Qt Multimedia E' la collezione delle classi per gestire i flussi audio, video ele applicazioni radio o le telecamere.

Qt Network Raccolta delle classi per rendere la programmazione dellacomunicazione di rete più facile e portabile nelle variepiattaforme.

Qt SQL Classi per la comunicazione con i database usando illinguaggio 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 lagenerazione del codice sono due: applicazione e libreria. Nel caso applicazione il risultato dellacompilazione sarà un file eseguibile, nel caso della libreria sarà un file DLL o SO. Nel nostro casosi tratta di una applicazione.

TEMPLATE = app

L'ultima parte del file di progetto elenca i nomi dei file che compongono il progetto, raggruppatiper tipologia: SOURCES per i file con il codice C++, HEADERS per file di intestazione, in genere conestensione *.h e FORMS per file di definizione dell'interfaccia grafica, con estensione *.ui.

SOURCES += main.cpp\ mainwindow.cppHEADERS += mainwindow.hFORMS += 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 riapreil progetto in Qt Creator, oltre alla definizione dei kit di compilazione. Se si cancella questo file, nelmomento in cui il progetto viene riaperto, si apre immediatamente la pagina per la configurazionedel progetto e la selezione del kit di compilazione.

E' bene tener presente che questo è l'unico file che è obbligatorio cambiare, quando per esempiosi passa da Linux a Windows. La cosa più semplice è copiare tutto il codice nel nuovo sistemaoperativo, 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.cppe mainwindow.h.

Apriamo il file main.cpp facendo doppio click sull'albero con tutti i file del progetto. La primacosa 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 classedella finestra di dialogo principale, seguita da <QApplication> che invece raccoglie le definizionicollegate alla classe QApplication.

Fondamentalmente la funzione principale (main appunto) non fa altro che creare un oggettoQApplication, un oggetto MainWindow e visualizzarlo. Per ultima cosa entra nel ciclo digestione 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 uneditor 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 comparel'editor delle finestre, con a sinistra l'elenco degli oggetti grafici, che vengono chiamati Widget e alcentro la nostra finestra di dialogo, detta “form”.

Per trasformarla nel classico Hello World! basta inserire un Widget di tipo QLabel al centrodella finestra di dialogo e cambiare il testo in esso contenuto semplicemente facendo doppio clicksulla QLabel. Già che ci siamo, possiamo anche rimpicciolire la finestra di dialogo usando i puntidi controllo quadrati (blu) presenti sul bordo della scheda.

Per finire possiamo anche impostare un titolo per la finestra di dialogo, ad esempio TestInstallazione, 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 leicone, le traduzioni nelle varie lingue, le immagini da inserire nell'applicazione. Queste vengonoinserite nel progetto tramite un file che ha estensione .qrc. Aggiungiamo al nostro progetto un filedi 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 finestradi dialogo per creare un nuovo file, nella colonna di sinistra si deve selezionare la riga Qt, e nellaparte 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 ilnuovo file “RisorseProgetto.qrc”. Premere “Next” per passare all'impostazione del controllodi 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 dirisorse

Il nuovo file sarà visibile nell'albero del progetto, nella sezione “Resources”, mentre nel fileTestInstallazione.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 usatacome 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. Salviamol'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 delfile si deve mettere un prefisso che funge da percorso per trovare la risorsa. Va fatto notare che ilfile delle risorse si limita a collezionare dei riferimenti a dei file che si trovano poi nella cartella delprogetto. 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 nellaparte bassa di Qt Creator e selezionare “Add Prefix”. Dato che si tratta di un'icona, è ragionevolechiamare il prefisso con /icon. Per accedere alla risorsa dall'interno del progetto basta aprirlacome fosse un file, con un percorso “speciale” che inizia con “:”. Ma non serve ricordare questasintassi, basta fare click con il tasto destro sulla nostra icona e selezionare: “Copy Resource Path toClipboard” 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, bastaaprire il file mainwindow.ui, selezionare tutta la finestra e nella tabella delle proprietà dellafinestra di dialogo cercare la sezione QWidgets e la proprietà windowIcon. Cliccare sulla frecciaverso il basso e selezionare “Choose Resource”. A questo punto si apre un pop-up con l'elenco dellerisorse. Selezionare l'icona appena inserita e premere OK.

Fig. 2.9: Impostazione dell'icona della formprincipale

Fig. 2.10: Selezione delle icone presenti nel file dellerisorse

Il passo successivo è quello di impostare la dimensione dell'icona, cercando la voce iconSizeall'interno della sezione QMainWindow. Il valore di default è 24 x 24, nel nostro caso lo si deveportare a 32 x 32 pixel, dato che questa è la dimensione di configuration32.png

Fig. 2.11: Impostare ladimensione dell'icona della

finestra principale

2.2 Compilare il progettoDopo 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 avedere il risultato del nostro lavoro eseguendo la compilazione.

Per far questo possiamo premere la combinazione Ctrl+R oppure selezionare la voce “Run” delmenù “Build”, o semplicemente cliccare sulla freccia verde in basso a sinistra.

Fig. 2.12: Pulsante per compilare edeseguire il programma

2.2.1 Risultato finale in Linux

E' interessante osservare, come lo stesso codice sorgente possa essere compilato in Linux e inWindows, e dare origine a due applicativi identici nella funzionalità, ma diversi nello stile. Questoperché 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 sinistrache nel task manager quando premiamo CTRL+TAB.

Fig. 2.13: Finestra di dialogo, icona nella barra delle applicazioni enel 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 inWindows. L'unica modifica è che il file TestInstallazione.pro.user, va rigenerato dato che è statocreato per una piattaforma diversa. Premere No nella finestra di dialogo che compare appena sicerca di aprire il progetto e l'aggiornamento si completa velocemente.

La schermata successiva è quella della finestra di dialogo “configure project”, che suggerisce iparametri 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 nuovosistema operativo

Fig. 2.15: Schermata di configurazione del progetto in Windows

2.2.3 Compilare in Release

Automaticamente Qt Creator crea due configurazioni di compilazione, che si chiamano Debug eRelease. La compilazione Debug contiene simboli e informazioni necessarie per il debug appuntodella 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 cisono opzioni di ottimizzazione del codice, queste vengono applicate solo in Release. Questo perchéalcune ottimizzazioni cambiano l'ordine di esecuzione del codice.

Fig. 2.16: Finestra di dialogo, icona sulla barra dei programmi, e nel taskmanager, nel caso di Windows 7

L'impostazione selezionata di default è la compilazione in Debug, ma quando lo sviluppodell'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 inbasso 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'eseguibileviene 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 applicativoNon sono un fanatico dei compilatori e non voglio addentrarmi nei dettagli della compilazione,

ma vorrei brevemente descrivere come si passa dal file Testinstallazione.proall'applicazione TestInstallazione. In genere non è indispensabile conoscere questi tecnicismi,tranne nei casi in cui qualche meccanismo si inceppa e genera messaggi di errore che fannoriferimento 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 premiamola 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 incaratteri minuscoli per evitare problemi con i sistemi operativi “case-sensitive”, come per esempioLinux.

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 filecompilato, processare il file di progetto e creare il file Makefile. Questo file (il nome è proprioMakefile, con la M maiuscola) non è altro che una sequenza di comandi, uno “script file”, cheviene 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'applicazionecompilata. 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 vieneinvocato è jom, un clone di NMAKE.EXE, il comando originale Microsoft. Questo tool è pensato pergestire la compilazione di un progetto, partendo da una sequenza di comandi contenuti in un file diistruzioni.

Il miglioramento introdotto da jom, rispetto ad NMAKE.exe, sta nel fatto di poter sfruttare learchitetture 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 estensionial linguaggio C++ previste dalla libreria Qt (ad esempio l'istruzione foreach e la gestione signalsand slots) in codice C++. Ad esempio nel caso di TestInstallazione, il file mainwindow.cppviene 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 qrcin 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 deifile con estensione ui, ovvero i file che definiscono l'interfaccia utente e li trasforma in file per ilcompilatore 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 binaricon estensione .o detti file oggetto. Ad esempio nel caso TestInstallazione i file generati dalcompilatore sono:

main.omainwindow.omoc_mainwindow.oqrc_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 unaulteriore fase prima di diventare dei programmi eseguibili. Questo lavoro viene fatto dal linker, checollega tra di loro tutti i file, calcola gli indirizzi di tutte le variabili e delle funzioni, poi genera ilcosiddetto file ELF, “Executable and Linked File”, che tipicamente in Windows ha estensione .exe.

2.4 QDebug: inserire un messaggio traceNello 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 deimessaggi, detti “trace”, in alcuni punti specifici dell'applicazione. Questo lavoro viene fatto con laclasse QDebug, che appartiene al modulo QtCore.

Sempre partendo dall'esempio TestInstallazione, supponiamo di modificare la funzionemain in modo che appena l'oggetto applicazione viene creato, venga stampato un messaggio con ilnome dell'applicazione.

Il primo passo è quello di includere l'intestazione <QDebug>. Si noti che si usano QDebug, nonQDebug.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 creatol'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 nomedell'applicazione viene preso da un oggetto globale che si chiama qApp e che rappresenta ilriferimento alla applicazione corrente.

Quando l'applicazione viene eseguita, il messaggio viene stampato in basso a destra, nellasezione “Application Output” di Qt Creator.

2.5 Altri file che possono far parte del progettoE' 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 pertenere traccia delle modifiche che abbiamo fatto e di chiamarlo ChangeLog.txt. Basta andare sulmenu “File”, “New File or Project” e si aprirà la finestra di dialogo per creare un nuovo file oprogetto. 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 lacartella del progetto. Premere “Next” per passare all'impostazione del controllo di versione e infinepremere “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 fileTestInstallazione.pro, nella sezione “OTHER_FILES”

OTHER_FILES += \ ChangeLog.txt

Fig. 2.21: Il file ChangeLog.txt fa partedell'albero del progetto.