Qt Lezione0: uso del C++ per scrivere applicazioni QtPaolo Sereno
Per essere sicuri che la nostra competenza di C++ sia sufficiente per la programmazione delle librerie Qt, facciamo un piccolo ripasso dei concetti principali
Le applicazioni GUI vengono definite applicazioni di tipo “event-driven”, ovvero pilotate dagli eventi; questa definizione è davvero rappresentativa, in quanto in un'applicazione GUI, tutto ciò che succede è il risultato di un evento.
Quando programmiamo con il toolkit Qt, raramente abbiamo bisogno di preoccuparci del meccanismo degli eventi, poiché i widgets Qt che usiamo emettono autonomamente dei segnali nel momento in cui occorre qualcosa di significativo. La gestione degli eventi diventa quindi importante nel momento in cui vogliamo scrivere dei nuovi custom widgets o vogliamo modificare il comportamento di widgets esistenti.
Qt Lezione3: un visualizzatore di immaginiPaolo Sereno
Questa lezione sul toolkit Qt permette di scrivere una semplice applicazione di visualizzazione immagini, i formati sono quelli più comunemente usati: JPG, BMP, PNG etc.
Qt Lezione5: Layout management e Qt DesignerPaolo Sereno
qtQuesta lezione vuole essere un semplice avvicinamento al meccanismo di layout management di Qt. Trattandosi di un primo esempio di layout management ho preferito affrontarlo tramite il Qt Designer, in modo da vederne in pratica il suo funzionamento ancora prima di apprendere la sua programmazione.
Qt Lezione2: Creare un’applicazione con Qt Creator in pochi semplici passiPaolo Sereno
qtScopo di questa seconda lezione è quello di introdurre l’uso di Qt Creator per scrivere una prima applicazione composta da una main window (QMainWindow).
L’applicazione non fa nulla e serve solamente per impratichirsi con le nozioni di base dell’ambiente di sviluppo Qt.
La lezione è organizzata in pochi semplici passi; ogni passo è corredato da una o più immagini (screenshot) per facilitare la comprensione.
Qt Lezione1: Creare una dialog Window con Qt Creator in 10 semplici passiPaolo Sereno
Scopo di questa prima lezione è quello di introdurre l’uso di Qt Creator per scrivere una prima applicazione composta da una dialog window. L’applicazione non fa nulla e serve solamente per impratichirsi con le nozioni di base dell’ambiente di sviluppo Qt. La lezione è organizzata in 10 semplici passi. Ogni passo è corredato da una o più immagini (screenshot) per facilitare la comprensione.
Qt Lezione0: uso del C++ per scrivere applicazioni QtPaolo Sereno
Per essere sicuri che la nostra competenza di C++ sia sufficiente per la programmazione delle librerie Qt, facciamo un piccolo ripasso dei concetti principali
Le applicazioni GUI vengono definite applicazioni di tipo “event-driven”, ovvero pilotate dagli eventi; questa definizione è davvero rappresentativa, in quanto in un'applicazione GUI, tutto ciò che succede è il risultato di un evento.
Quando programmiamo con il toolkit Qt, raramente abbiamo bisogno di preoccuparci del meccanismo degli eventi, poiché i widgets Qt che usiamo emettono autonomamente dei segnali nel momento in cui occorre qualcosa di significativo. La gestione degli eventi diventa quindi importante nel momento in cui vogliamo scrivere dei nuovi custom widgets o vogliamo modificare il comportamento di widgets esistenti.
Qt Lezione3: un visualizzatore di immaginiPaolo Sereno
Questa lezione sul toolkit Qt permette di scrivere una semplice applicazione di visualizzazione immagini, i formati sono quelli più comunemente usati: JPG, BMP, PNG etc.
Qt Lezione5: Layout management e Qt DesignerPaolo Sereno
qtQuesta lezione vuole essere un semplice avvicinamento al meccanismo di layout management di Qt. Trattandosi di un primo esempio di layout management ho preferito affrontarlo tramite il Qt Designer, in modo da vederne in pratica il suo funzionamento ancora prima di apprendere la sua programmazione.
Qt Lezione2: Creare un’applicazione con Qt Creator in pochi semplici passiPaolo Sereno
qtScopo di questa seconda lezione è quello di introdurre l’uso di Qt Creator per scrivere una prima applicazione composta da una main window (QMainWindow).
L’applicazione non fa nulla e serve solamente per impratichirsi con le nozioni di base dell’ambiente di sviluppo Qt.
La lezione è organizzata in pochi semplici passi; ogni passo è corredato da una o più immagini (screenshot) per facilitare la comprensione.
Qt Lezione1: Creare una dialog Window con Qt Creator in 10 semplici passiPaolo Sereno
Scopo di questa prima lezione è quello di introdurre l’uso di Qt Creator per scrivere una prima applicazione composta da una dialog window. L’applicazione non fa nulla e serve solamente per impratichirsi con le nozioni di base dell’ambiente di sviluppo Qt. La lezione è organizzata in 10 semplici passi. Ogni passo è corredato da una o più immagini (screenshot) per facilitare la comprensione.
Attraverso un semplice esempio viene mostrato come utilizzare Glade e Anjuta per la realizzazione di GUI sfruttando la libreria grafica GTK e il linguaggio C.
Installazione Qt/Qt Quick per target AndroidPaolo Sereno
Questo breve tutorial rappresenta una mini guida per iniziare a programmare con Qt e Qt Quick su target Android. In particolare esso vuole essere un “memo” da usare durante i meetup e workshop sull’argomento organizzati dalla web community Qt-Italia.org.
Introduzione alla programmazione android - Android@tulug lezione 3Ivan Gualandri
Terza lezione del corso android tenuto presso il TuLug (Tuscia Lug) A Viterbo. Le slides sono completamente in italiano (Slides are in italian! Sorry!)
Introduzione alla programmazione Android - Android@tulugIvan Gualandri
Prima lezione del corso android tenuto presso il TuLug (Tuscia Lug) A Viterbo. Le slides sono completamente in italiano (Slides are in italian! Sorry!)
Introduzione alla programmazione Android - Android@tulug lezione 4Ivan Gualandri
Quarta e ultima lezione del corso android tenuto presso il TuLug (Tuscia Lug) A Viterbo. Le slides sono completamente in italiano (Slides are in italian! Sorry!)
Presentazione introduttiva su Groovy e Grails tratta dal materiale della serie di eventi Into The Groovy del JUG Milano tenuta allo Spring Meeting del 26/06/2010 a Cagliari organizzato da JUG Sardegna http://www.jugsardegna.org/vqwiki/jsp/Wiki?26giugno2010
Introduzioni all'uso dei preprocessori Sass e Less per la stesura di un foglio di stile CSS intelligente
Autore: Valerio Radice - valix85
Data: Giugno 2017
Introduzione alla programmazione android - Android@tulug lezione 2Ivan Gualandri
Seconda lezione del corso android tenuto presso il TuLug (Tuscia Lug) A Viterbo. Le slides sono completamente in italiano (Slides are in italian! Sorry!)
by Davide Cerbo e Stefano Linguerri
La programmazione web sta facendo passi da gigante e oggi l’utente si aspetta che l’esperienza di utilizzo si avvicini sempre di più a quella a cui è abituato nei classici applicativi desktop. Il mondo degli sviluppatori ha risposto inventanto una nuova sigla: RIA, cioè Rich Internet Application. Google non è stata a guardare e ha fornito la sua risposta a questa esigenza donando alla community Google Web Toolkit. Questo nuovo framework permette di sviluppare in Java tutta l’interfaccia utente per poi ottenere un codice javascript che funzionerà su qualsiasi browser web senza l’installazione di plugin aggiuntivi. In questa presentazione vedremo:
* perchè sviluppare applicazioni RIA
* perchè usare GWT
* come GWT utilizza AJAX per comunicare con il server
* le ottimizzazione che avremo utilizzando GWT
* come uscire dal browser con Google Gear e Mozilla Prism
* e non solo…
Attraverso un semplice esempio viene mostrato come utilizzare Glade e Anjuta per la realizzazione di GUI sfruttando la libreria grafica GTK e il linguaggio C.
Installazione Qt/Qt Quick per target AndroidPaolo Sereno
Questo breve tutorial rappresenta una mini guida per iniziare a programmare con Qt e Qt Quick su target Android. In particolare esso vuole essere un “memo” da usare durante i meetup e workshop sull’argomento organizzati dalla web community Qt-Italia.org.
Introduzione alla programmazione android - Android@tulug lezione 3Ivan Gualandri
Terza lezione del corso android tenuto presso il TuLug (Tuscia Lug) A Viterbo. Le slides sono completamente in italiano (Slides are in italian! Sorry!)
Introduzione alla programmazione Android - Android@tulugIvan Gualandri
Prima lezione del corso android tenuto presso il TuLug (Tuscia Lug) A Viterbo. Le slides sono completamente in italiano (Slides are in italian! Sorry!)
Introduzione alla programmazione Android - Android@tulug lezione 4Ivan Gualandri
Quarta e ultima lezione del corso android tenuto presso il TuLug (Tuscia Lug) A Viterbo. Le slides sono completamente in italiano (Slides are in italian! Sorry!)
Presentazione introduttiva su Groovy e Grails tratta dal materiale della serie di eventi Into The Groovy del JUG Milano tenuta allo Spring Meeting del 26/06/2010 a Cagliari organizzato da JUG Sardegna http://www.jugsardegna.org/vqwiki/jsp/Wiki?26giugno2010
Introduzioni all'uso dei preprocessori Sass e Less per la stesura di un foglio di stile CSS intelligente
Autore: Valerio Radice - valix85
Data: Giugno 2017
Introduzione alla programmazione android - Android@tulug lezione 2Ivan Gualandri
Seconda lezione del corso android tenuto presso il TuLug (Tuscia Lug) A Viterbo. Le slides sono completamente in italiano (Slides are in italian! Sorry!)
by Davide Cerbo e Stefano Linguerri
La programmazione web sta facendo passi da gigante e oggi l’utente si aspetta che l’esperienza di utilizzo si avvicini sempre di più a quella a cui è abituato nei classici applicativi desktop. Il mondo degli sviluppatori ha risposto inventanto una nuova sigla: RIA, cioè Rich Internet Application. Google non è stata a guardare e ha fornito la sua risposta a questa esigenza donando alla community Google Web Toolkit. Questo nuovo framework permette di sviluppare in Java tutta l’interfaccia utente per poi ottenere un codice javascript che funzionerà su qualsiasi browser web senza l’installazione di plugin aggiuntivi. In questa presentazione vedremo:
* perchè sviluppare applicazioni RIA
* perchè usare GWT
* come GWT utilizza AJAX per comunicare con il server
* le ottimizzazione che avremo utilizzando GWT
* come uscire dal browser con Google Gear e Mozilla Prism
* e non solo…
Programmazione a oggetti tramite la macchina del caffé (pt. 2)Marcello Missiroli
Una introduzione semplice e (spero) intuitiva al mondo della programmazione a oggetti usando come riferimento una macchina del caffé (tipo Nespresso)
Slides 2 di 3
Asp.Net MVC 3 - Il Model View Controller secondo MicrosoftStefano Benedetti
Il pattern architetturale MVC (Model View Controller) favorisce la manutenzione delle applicazioni web tramite una architettura elegante ed una chiara ed esplicita separazione delle competenze, l'impiego dei più diffusi pattern di software engineering, il controllo completo dell'HTML generato e degli URL, la testabilità ed estendibilità.
In questa sessione vedremo le novità principali di Asp.Net MVC in versione 3.
La sessione è stata tenuta a SMAU Business Bologna il 9 giugno 2011
Come portare il profiler di symfony2 in drupal8Luca Lusso
Molti progetti PHP open source hanno adottato Symfony2 come base per la loro prossima versione, tra questi c'è anche il CMS Drupal (http://drupal.org). In questo talk vedremo come scrivere un modulo per Drupal8 in modo da sfruttare il più possibile il suo nuovo motore Symfony2, dall'integrazione con il service container alla gestione degli eventi, dal routing a Twig. Verrà usato come esempio il modulo webprofiler (http://drupal.org/project/webprofiler) per dimostrare come un bundle per Symfony2 possa essere trasformato in un modulo per Drupal8 e integrato facilmente nel sistema.
Fare con Zend Framework 2 ciò che facevo con ZF1Steve Maraspin
Introduzione a Zend Framework 2 per chi proviene da Zend Framework 1, tenuta allo Zend Framework Day di Milano del 01/02/2013. Introduzione alle nuove caratteristiche e pattern architetturali di ZF2
Zend Framework 2 non è l'evoluzione di ZF, ma un progetto nuovo: il codice è stato riscritto e poche sono le parti in comune con la versione precedente. Lo sviluppatore abituato a ZF1 non ha vita facile, ed è fondato il timore di dover imparare tutto da capo. In questo talk vediamo come cambiare le vecchie abitudini di sviluppatori ZF1, per sfruttare al meglio le potenzialità del nuovo strumento. Attraverso esempi concreti, in cui vedremo all'opera i nuovi pattern e le best practice, mostriamo come - partendo con il piede giusto - il passaggio a ZF2 possa essere meno traumatico del previsto. Il talk è orientato soprattutto a chi già conosce ZF1, ma gli argomenti affrontati possono essere utili anche a chi si avvicina a ZF per la prima volta.
Qt Lezione4 Parte2: creare un custom widget plugin per Qt Designer
1. Creare un custom widget plugin
per Qt Designer
parte 2
Premessa
Questa presentazione è rilasciata sotto Licenza
Creative Commons: Attribution-NonCommercial-NoDerivativeWorks
(http://creativecommons.org/licenses/by-nc-nd/3.0/deed.it).
Questo documento può quindi essere riprodotto senza violare nessuna legge, sia in versione elettronica, sia in versione
cartacea, purché sia riprodotto integralmente in tutte le sue parti, compresa la pagina che contiene queste informazioni:
Versione originale scaricabile dal sito
http://www.sereno-online.com/site/
Tutti i marchi riportati in questa pubblicazione appartengono ai rispettivi proprietari.
Link Utili
Qui di seguito riporto alcuni link utili per chi usa quotidianamente l’ambiente di sviluppo Qt e vuole confrontarsi con
altri sviluppatore, utenti e semplici appassionati di questo toolkit gratuito ed open source.
Gruppo Programmatori Italiani Qt Software (GPIQt)
http://www.facebook.com/inbox/?ref=mb#/group.php?gid=81561439535
qt in Italy
http://qt-apps.org/groups/?id=17
qtitaliantranslators
http://gitorious.org/+qtitaliantranslators
Autore P. Sereno http://www.sereno-online.com/site
2. Scopo
Nella prima parte di questa lezione abbiamo trattato la derivazione della classe QWidget e la creazione di un custom
widget. Per poter usare il nostro custom widget come tutti gli altri controlli grafici di Qt, dobbiamo trasformarlo in un
plugin per Qt Designer.
Cos’è un plugin di Qt designer?
Qt Designer, l’ambiente di prototipazione rapida di Qt, è uno strumento molto potente e flessibile che può essere esteso
in molti modi. Un modo molto pratico per estendere le funzionalità di Qt Designer è quello di realizzare librerie
dinamiche (i plugin appunto) che Qt Designer va a caricare allo startup e che metterà a disposizione come controlli
custom allo stesso modo di tutti gli altri widget del Qt toolkit.
Passo 1: come si crea un plugin per Qt Designer
Non c’è modo migliore per spiegare come si realizza un plugin che illustrarne il codice sorgente.
Nella prima parte di questa lezione abbiamo realizzato una nuova classe di nome QLed, ora ci occuperemo di scrivere un
plugin che contiene QLed al suo interno e si interfaccia con il designer di Qt. Per fare ciò scriviamo due files sorgente
qledplugin.h e qledplugin.cpp.
Iniziamo da qledplugin.h:
#ifndef CUSTOMWIDGETPLUGIN_H
#define CUSTOMWIDGETPLUGIN_H
#include <QDesignerCustomWidgetInterface>
class QLedPlugin : public QObject, public QDesignerCustomWidgetInterface
{
Q_OBJECT
Q_INTERFACES(QDesignerCustomWidgetInterface)
public:
QLedPlugin(QObject *parent = 0);
bool isContainer() const;
bool isInitialized() const;
QIcon icon() const;
QString domXml() const;
QString group() const;
QString includeFile() const;
QString name() const;
QString toolTip() const;
QString whatsThis() const;
QWidget *createWidget(QWidget *parent);
void initialize(QDesignerFormEditorInterface *core);
private:
bool initialized;
};
#endif
Per prima cosa dobbiamo includere <QDesignerCustomWidgetInterface> per poter usare l’omonima classe e quindi
possiamo ora definire la nostra classe derivando come segue:
class QLedPlugin : public QObject, public QDesignerCustomWidgetInterface
questo perchè la nostra classe che è un Qobject è anche una classe di interfaccia con il Qt Designer.
Autore P. Sereno http://www.sereno-online.com/site
3. Le istruzioni che seguono
Q_OBJECT
Q_INTERFACES(QDesignerCustomWidgetInterface)
Permettono al meta object compiler di preparare tutto il codice “multipiattaforma” e di riconoscere la nostra classe come
interfaccia. In altre parole, nella costruzione di un widget plugin ricordiamoci sempre di queste due macro quando
scriviamo la classe.
Passiamo ora ai metodi pubblici
public:
QLedPlugin(QObject *parent = 0); // è il costruttore
bool isContainer() const; // il widget è un oggetto
container?
bool isInitialized() const; // il widget è inizializzato?
QIcon icon() const; // restituisce
l’icona del widget
QString domXml() const; // la stringa domXML
QString group() const; // il gruppo del widget
QString includeFile() const; // l’header file del widget
QString name() const; // il nome del widget
QString toolTip() const; // il tooltip del widget
QString whatsThis() const; // la stringa
whatsthis
QWidget *createWidget(QWidget *parent); // il metodo di creazione
void initialize(QDesignerFormEditorInterface *core); // il metodo di inzializzazione
ed infine le proprietà
private:
bool initialized;
Vediamo nel dettaglio ora l’implementazione dei metodi visti sopra.
Autore P. Sereno http://www.sereno-online.com/site
5. " <bool>false</bool>n"
" </property>n"
" <property name="whatsThis" >n"
" <string>Led widget</string>n"
" </property>n"
" <property name="color" >n"
" <enum>QLed::Red</enum>n"
" </property>n"
"</widget>n";
}
QString QLedPlugin::includeFile() const
{
return "qled.h";
}
Q_EXPORT_PLUGIN2(customwidgetplugin, QLedPlugin)
Per prima cosa dobbiamo ricordarci degli header file
#include "qled.h"
#include "qledplugin.h"
#include <QtPlugin>
Fatto ciò possiamo concentrarci sul costruttore
QLedPlugin::QLedPlugin(QObject *parent)
: QObject(parent)
{
initialized = false;
}
Questo metodo è banale e deve essere fatto esattamente così, per qualsiasi widget plugin; solo così infatti il designer
funziona correttamente.
void QLedPlugin::initialize(QDesignerFormEditorInterface * /* core */)
{
if (initialized)
return;
initialized = true;
}
Anche il metodo initialize deve essere considerato come un assioma; il funzionamento interno del Qt designer ci impone
di scrivere il metodo initialize in questo modo.
QWidget *QLedPlugin::createWidget(QWidget *parent)
{
return new QLed(parent);
}
createWidget è il vero metodo responsabile della creazione del nostro custom widget; esso infatti alloca mediante la new
una nuova istanza di QLed (poiché il nostro widget deve istanziare una sola volta QLed, ecco che il meccanismo di
initialize visto prima torna utile per questo scopo).
QString QLedPlugin::name() const
{
return "QLed";
}
Questo metodo deve restituire il nome della nostra classe.
Autore P. Sereno http://www.sereno-online.com/site
6. Vediamo ora in un’unica spiegazione i seguenti metodi:
QString QLedPlugin::group() const
{
return "Lab Widgets";
}
QIcon QLedPlugin::icon() const
{
return QIcon();
}
QString QLedPlugin::toolTip() const
{
return "";
}
QString QLedPlugin::whatsThis() const
{
return "";
}
Tutti i widget disponibili vengono raggruppati in diversi contenitori nella toolbar laterale a sinistra della finestra di Qt
designer. In questo caso si è scelto di creare un nuovo contenitore per QLed etichettato “Lab Widgets”
Icon() restituisce l’icona associata al nostro widget; nel caso del nostro esempio l’icona è vuota, ma qui potremo inserire
una qualsiasi immagine che rappresenta il nostro widget.
toolTip() restituisce il Tool Tip del nostro widget (vuoto nel nostro caso)
whatsthis() restituisce la stringa di aiuto (what’s this) che è vuota nel nostro caso.
Arriviamo ora alla novità delle Qt 4.X rispetto la precedente versione (Qt 3.X) e cioè il metodo seguente:
QString QLedPlugin::domXml() const
{
return "<widget class="QLed" name="qLed">n"
" <property name="geometry">n"
" <rect>n"
" <x>0</x>n"
" <y>0</y>n"
" <width>100</width>n"
" <height>100</height>n"
" </rect>n"
" </property>n"
" <property name="toolTip" >n"
" <string>Binary Led</string>n"
" </property>n"
" <property name="value" >n"
" <bool>false</bool>n"
" </property>n"
" <property name="whatsThis" >n"
" <string>Led widget</string>n"
" </property>n"
" <property name="color" >n"
" <enum>QLed::Red</enum>n"
" </property>n"
"</widget>n";
}
domXML ci consente di specificare in modo testuale, tramite XML appunto una serie di proprietà di default del nostro
widget. Il fatto di poter usare questa definizione testuale permette di modificare un custom widget in modo rapido ed
Autore P. Sereno http://www.sereno-online.com/site
7. efficiente. Nell’esempio sopra riportato possiamo vedere che si è impostata la geometria di default del widget, così come
il valore, il colore etc.
terminiamo infine con il metodo
QString QLedPlugin::includeFile() const
{
return "qled.h";
}
che ci consente, nel momento in cui usiamo il compilatore di interfaccia utente (UIC), di specificare dove si trova il file
header del nostro custom widget plugin. E’ importante sottolineare che se l’header file non si trova nella directory
“canonica” di include, è necessario riportare in questa stringa un path che consenta poi al compilatore di ritrovare il file .h
concludiamo infine con la macro
Q_EXPORT_PLUGIN2(customwidgetplugin, QLedPlugin)
Che ci consente di esportare il nostro plugin durante il processo di compilazione e linking e generare correttamente la
libreria dinamica per Qt Designer.
Installazione del plugin
A questo punto il nostro plugin è pronto. Dopo aver compilato il tutto ricordiamoci di posizionare il file di libreria
dinamica (il plugin appunto) nella directory plugin del Qt Designer ed inoltre ricordiamo anche che il file qled.h deve
essere posizionato in una directory di include nota al processo di compilazione.
Ovviamente queste operazioni di “copia” della libreria dinamica e del file .h possono essere automatizzate con qmake per
generare così il classico “make install” (che si occuperà perciò di fare l’installazione del plugin). Si lascia al lettore, come
esercizio finale, la realizzazione di questo “script” per qmake.
Considerazioni finali
Questa lezione è parte di un ciclo reso disponibile gratuitamente in Internet sul sito
http://www.sereno-online.com/site
Come preannunciato, le cose si sono complicate a partire da questa lezione. Per capire bene come si disegna un custom
widget è consigliabile partire dal codice sorgente di esempio e provare a modificarne alcune parti per vedere l’effetto. Un
utile ausilio per la comprensione dell’esempio è il Qt Assistano che fornisce molte informazioni dettagliate circa le classi
i metodi e riporta utili esempi ove possibile.
A questo punto ricordo che ogni commento o richiesta di informazioni rappresenta un utile punto di partenza per nuove
lezioni o miglioramenti e auguro
Buon divertimento!
Paolo
Autore P. Sereno http://www.sereno-online.com/site