Category Archives: QT

QT – WEBINAR: Getting Started with Qt/C++ Programming. Parte 2

La scorsa volta ci siamo lasciati alla gestione degli eventi. Ecco cosa ci propone QT.

QT gestione eventi

Le QT usano gli SLOT e i SIGNAL per la comunicazione ad alto livello con l’utente (ad esempio il movimento del mouse o la pressione di un bottone…proprio quello che vogliamo noi 🙂 ). I virtual method sono invece usati per interazioni a basso livello con il sistema operativo o ad esempio la pressione dei tasti… su una tastiera naturalmente.
Quindi il funzionamento di SLOT e SIGNAL è molto semplice. Un oggetto emette un segnale (il SIGNAL) e un altro risponde al segnale con una funzione particolare (lo SLOT).
La connessione tra i due viene fatta usando la funzione connect che appartiene alla classae QObject. I parametri della connect sono i seguenti (copiati dall’help QT):

bool QObject::connect ( const QObject * sender, const char * signal, const QObject * receiver, const char * method, Qt::ConnectionType type = Qt::AutoConnection ) [static]

Come farli funzionare nel nostro esempio della volta scorsa? Il sender e l’evento lo abbiamo, ci mancano il receiver e il metodo di risposta… almeno per il bottone “Ciao”. Perché per il bottone “Esci” useremo un artificio 🙂

Il codice è il seguente:

Eventibottoni.h

#ifndef EVENTIBOTTONI_H
#define EVENTIBOTTONI_H

#include <QObject>

class EventiBottoni : public QObject
{
    Q_OBJECT

public slots:
    void rispondiButton1();

};

#endif // EVENTIBOTTONI_H

Eventibottoni.cpp

#include <QMessageBox>

#include "eventibottoni.h"

void EventiBottoni::rispondiButton1()
{
    QMessageBox::information(0, QObject::tr("Messaggio"), QObject::tr("Ciao, mondo!!"));
}

main.cpp

#include <QApplication>
#include <QtGui>

#include "eventibottoni.h"

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    QWidget window;

    QPushButton *button1 = new QPushButton("Ciao", &window);
    QPushButton *button2 = new QPushButton("Esci", &window);
    QHBoxLayout *layout = new QHBoxLayout(&window);

    layout->addWidget(button1);
    layout->addWidget(button2);

    EventiBottoni eventi;

    QObject::connect(button1, SIGNAL(clicked()), &eventi, SLOT(rispondiButton1()));
    QObject::connect(button2, SIGNAL(clicked()), qApp, SLOT(quit()));

    //window.setLayout(layout);
    window.show();

    return a.exec();
}

E questo è il risultato:

Pulsante ciao

Allora come si vede abbiamo dovuto generare un oggetto derivante da QObject in cui definire il metodo di risposta alla pressione del tasto “Ciao”. L’oggetto deve forzatamente derivare da QObject pena il non poter definire la connect. Se vi chiedete il perché guardate la definizione della funzione 🙂 l’ho messa a posta all’inizio.

L’artificio per il bottone “Esci” invece è semplice 🙂 ho definito una connessione verso l’oggetto qApp (che non abbiamo definito noi) ma è definito dalle QT ed è un puntatore globale all’oggetto applicazione. Per cui diciamo all’applicazione di chiudersi chiamando lo slot quit().

Ok Siamo quasi arrivati alla fine, il webminar era di soli 45 minuti, manca solo un punto da chiarire. Quel “Q_OBJECT” che vedete in mezzo alla classe abilita il MOC, cioè il Meta object compiler. Diciamo che è il traduttore di alcune feature QT verso codice standard C++ ad esempio converte le funzioni signals e slots in codice C++ al momento della compilazione. Un sunto lo trovate nell’immagine di seguito:

MOC

Il mio prossimo webinar sarà il 13 di marzo 🙂 per cui potete stare tranquilli per un po’. 😛

Annunci

QT – WEBINAR: Getting Started with Qt/C++ Programming. Parte 1

Che dire… con le QT (si pronuncia cute) è stato amore a prima vista 🙂 spero mia moglie non scopra con chi passo le notti 😀 Per cui dato che hanno risvegliato i miei “peggiori istinti Nerd” 🙂 mi sono iscritto ad un paio di webminar. Se vi interessano i webinar li trovate qui mentre i link ai miei precedenti post sono questo e questo.
Vi riporto di seguito alcune info/tips che ho ascoltato nel webinar “Getting Started with Qt/C++ Programming”.

Il segreto della portabilità è qmake che genera il makefile adatto al sistema opertativo usato. Ottenuto il make file si potrà passare alla compilazione. Questo è il mio output di qmake in ambiente windows, notate il parametro “-spec win32-g++”:

14:22:22: Running steps for project DBTest...
14:22:22: Starting: "C:\Qt\Qt5.0.1\5.0.1\mingw47_32\bin\qmake.exe" C:\Users\wildwolf\Desktop\DBTest\DBTest\DBTest.pro -r -spec win32-g++ "CONFIG+=debug" "CONFIG

+=declarative_debug" "CONFIG+=qml_debug"
14:22:25: The process "C:\Qt\Qt5.0.1\5.0.1\mingw47_32\bin\qmake.exe" exited normally.

La compilazione invece è stata questa. Notate l’utilizzo di “mingw32-make.exe” che è il “Minimalist GNU for Windows” cioè il compilatore GNU minimale per winzoz.

14:24:10: Running steps for project DBTest...
14:24:11: Starting: "C:\Qt\Qt5.0.1\Tools\MinGW\bin\mingw32-make.exe" clean
C:/Qt/Qt5.0.1/Tools/MinGW/bin/mingw32-make -f Makefile.Debug clean
mingw32-make[1]: Entering directory 'C:/Users/wildwolf/Desktop/DBTest/DBTest-build-Desktop_Qt_5_0_1_MinGW_32bit-Debug'
rm -f debug/moc_mainwindow.cpp
rm -f ui_mainwindow.h
rm -f debug/main.o debug/mainwindow.o debug/moc_mainwindow.o
mingw32-make[1]: Leaving directory 'C:/Users/wildwolf/Desktop/DBTest/DBTest-build-Desktop_Qt_5_0_1_MinGW_32bit-Debug'
C:/Qt/Qt5.0.1/Tools/MinGW/bin/mingw32-make -f Makefile.Release clean
mingw32-make[1]: Entering directory 'C:/Users/wildwolf/Desktop/DBTest/DBTest-build-Desktop_Qt_5_0_1_MinGW_32bit-Debug'
rm -f release/moc_mainwindow.cpp
rm -f ui_mainwindow.h
rm -f release/main.o release/mainwindow.o release/moc_mainwindow.o
mingw32-make[1]: Leaving directory 'C:/Users/wildwolf/Desktop/DBTest/DBTest-build-Desktop_Qt_5_0_1_MinGW_32bit-Debug'
14:24:37: The process "C:\Qt\Qt5.0.1\Tools\MinGW\bin\mingw32-make.exe" exited normally.
14:24:37: Configuration unchanged, skipping qmake step.
14:24:37: Starting: "C:\Qt\Qt5.0.1\Tools\MinGW\bin\mingw32-make.exe" 
C:/Qt/Qt5.0.1/Tools/MinGW/bin/mingw32-make -f Makefile.Debug
mingw32-make[1]: Entering directory 'C:/Users/wildwolf/Desktop/DBTest/DBTest-build-Desktop_Qt_5_0_1_MinGW_32bit-Debug'
C:/Qt/Qt5.0.1/5.0.1/mingw47_32/bin/uic.exe ../DBTest/mainwindow.ui -o ui_mainwindow.h
g++ -c -pipe -fno-keep-inline-dllexport -g -frtti -Wall -Wextra -fexceptions -mthreads -DUNICODE -DQT_QML_DEBUG -DQT_DECLARATIVE_DEBUG -DQT_WIDGETS_LIB -DQT_SQL_LIB -
DQT_GUI_LIB -DQT_CORE_LIB -DQT_OPENGL_ES_2 -DQT_OPENGL_ES_2_ANGLE -DQT_NEEDS_QMAIN -I../DBTest -I'../../../../../Qt/Qt5.0.1/5.0.1/mingw47_32/include' -
I'../../../../../Qt/Qt5.0.1/5.0.1/mingw47_32/include/QtWidgets' -I'../../../../../Qt/Qt5.0.1/5.0.1/mingw47_32/include/QtSql' -
I'../../../../../Qt/Qt5.0.1/5.0.1/mingw47_32/include/QtGui' -I'../../../../../Qt/Qt5.0.1/5.0.1/mingw47_32/include/QtCore' -I'debug' -I'.' -I'.' -
I'../../../../../Qt/Qt5.0.1/5.0.1/mingw47_32/mkspecs/win32-g++' -o debug/main.o ../DBTest/main.cpp
g++ -c -pipe -fno-keep-inline-dllexport -g -frtti -Wall -Wextra -fexceptions -mthreads -DUNICODE -DQT_QML_DEBUG -DQT_DECLARATIVE_DEBUG -DQT_WIDGETS_LIB -DQT_SQL_LIB -
DQT_GUI_LIB -DQT_CORE_LIB -DQT_OPENGL_ES_2 -DQT_OPENGL_ES_2_ANGLE -DQT_NEEDS_QMAIN -I../DBTest -I'../../../../../Qt/Qt5.0.1/5.0.1/mingw47_32/include' -
I'../../../../../Qt/Qt5.0.1/5.0.1/mingw47_32/include/QtWidgets' -I'../../../../../Qt/Qt5.0.1/5.0.1/mingw47_32/include/QtSql' -
I'../../../../../Qt/Qt5.0.1/5.0.1/mingw47_32/include/QtGui' -I'../../../../../Qt/Qt5.0.1/5.0.1/mingw47_32/include/QtCore' -I'debug' -I'.' -I'.' -
I'../../../../../Qt/Qt5.0.1/5.0.1/mingw47_32/mkspecs/win32-g++' -o debug/mainwindow.o ../DBTest/mainwindow.cpp
C:/Qt/Qt5.0.1/5.0.1/mingw47_32/bin/moc.exe -DUNICODE -DQT_QML_DEBUG -DQT_DECLARATIVE_DEBUG -DQT_WIDGETS_LIB -DQT_SQL_LIB -DQT_GUI_LIB -DQT_CORE_LIB -DQT_OPENGL_ES_2 -
DQT_OPENGL_ES_2_ANGLE -DQT_NEEDS_QMAIN -I../DBTest -I'../../../../../Qt/Qt5.0.1/5.0.1/mingw47_32/include' -I'../../../../../Qt/Qt5.0.1/5.0.1/mingw47_32/include/QtWidgets' 
-I'../../../../../Qt/Qt5.0.1/5.0.1/mingw47_32/include/QtSql' -I'../../../../../Qt/Qt5.0.1/5.0.1/mingw47_32/include/QtGui' -
I'../../../../../Qt/Qt5.0.1/5.0.1/mingw47_32/include/QtCore' -I'debug' -I'.' -I'.' -I'../../../../../Qt/Qt5.0.1/5.0.1/mingw47_32/mkspecs/win32-g++' -D__GNUC__ -DWIN32 
../DBTest/mainwindow.h -o debug/moc_mainwindow.cpp
g++ -c -pipe -fno-keep-inline-dllexport -g -frtti -Wall -Wextra -fexceptions -mthreads -DUNICODE -DQT_QML_DEBUG -DQT_DECLARATIVE_DEBUG -DQT_WIDGETS_LIB -DQT_SQL_LIB -
DQT_GUI_LIB -DQT_CORE_LIB -DQT_OPENGL_ES_2 -DQT_OPENGL_ES_2_ANGLE -DQT_NEEDS_QMAIN -I../DBTest -I'../../../../../Qt/Qt5.0.1/5.0.1/mingw47_32/include' -
I'../../../../../Qt/Qt5.0.1/5.0.1/mingw47_32/include/QtWidgets' -I'../../../../../Qt/Qt5.0.1/5.0.1/mingw47_32/include/QtSql' -
I'../../../../../Qt/Qt5.0.1/5.0.1/mingw47_32/include/QtGui' -I'../../../../../Qt/Qt5.0.1/5.0.1/mingw47_32/include/QtCore' -I'debug' -I'.' -I'.' -
I'../../../../../Qt/Qt5.0.1/5.0.1/mingw47_32/mkspecs/win32-g++' -o debug/moc_mainwindow.o debug/moc_mainwindow.cpp
g++ -Wl,-subsystem,windows -mthreads -o debug/DBTest.exe debug/main.o debug/mainwindow.o debug/moc_mainwindow.o  -lmingw32 -lqtmaind -LC:\Qt\Qt5.0.1\5.0.1\mingw47_32\lib 
-lQt5Widgetsd -lQt5Sqld -lQt5Guid -lQt5Cored -llibEGLd -llibGLESv2d -lgdi32 -luser32 
mingw32-make[1]: Leaving directory 'C:/Users/wildwolf/Desktop/DBTest/DBTest-build-Desktop_Qt_5_0_1_MinGW_32bit-Debug'
14:25:07: The process "C:\Qt\Qt5.0.1\Tools\MinGW\bin\mingw32-make.exe" exited normally.

Ed in ambiente GNU Linux? 🙂 Tutto uguale a parte che qmake imposta il make file per linux e quindi trovate il parametro “-spec linux-g++”

14:43:38: Running steps for project DBTest...
14:43:38: Starting: "/usr/bin/qmake" /home/wildwolf/Documenti/Projects/CPP/DBTest/DBTest/DBTest.pro -r -spec linux-g++ CONFIG+=debug CONFIG+=declarative_debug
14:43:40: The process "/usr/bin/qmake" exited normally.

Non vi riporto la sbrodolata della compilazione 🙂 … e non cercate di farmi credere che qualcuno ha letto quella di prima 😛
Ok andiamo oltre la compilazione… Per chi soffre di insonnia da memory leak e sindrome da delete, c’è una bella notizia. Quando si alloca un puntatore di un oggetto QT e questo ha un padre, cioè, vi riporto le parole del docente del webinar, “nel costruttore dell’oggetto viene passato come ultimo parametro un oggetto padre” allora questo si occuperà di deallocare la memoria, se poi noi siamo presi da forme di “delete” compulsivo, un oggetto figlio comunicherà comunque al padre la sua deallocazione e quindi non verrà eliminato 2 volte 🙂 come dire… “quasi salvi” 😛

Quindi il codice del nostro applicativo base con 2 bottoni sarà:

#include <QApplication>
#include <QtGui>

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    QWidget window;

    QPushButton *button1 = new QPushButton("Ciao", &window);
    QPushButton *button2 = new QPushButton("Esci",&window);
    QHBoxLayout *layout = new QHBoxLayout();

    layout->addWidget(button1);
    layout->addWidget(button2);

    window.setLayout(layout);
    window.show();

    return a.exec();
}

Il nostro mini applicativo… va beh finestra con 2 bottoni 🙂 farà quindi vedere 2 bottoni 🙂 come in figura:

Applicazione

e dato che abbiamo applicato un layout orizzontale, allargando la finestra otterremo un risultato simile:

Applicazione strechata

button1 e button2 avendo definito un parent saranno deallocati in automatico e il layout verrà sempre eliminato da window perché impostato con la setLayout. E window? Beh è allocato sullo stack 🙂 per cui alla chiusura del programma ci saluterà senza recriminare alcunchè 🙂

Avremmo potuto scrivere il codice anche così, assegnando un parent al nostro layout.

#include <QApplication>
#include <QtGui>

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    QWidget window;

    QPushButton *button1 = new QPushButton("Ciao", &window);
    QPushButton *button2 = new QPushButton("Esci", &window);
    QHBoxLayout *layout = new QHBoxLayout(&window);

    layout->addWidget(button1);
    layout->addWidget(button2);

    //window.setLayout(layout);
    window.show();

    return a.exec();
}

Per adesso è tutto. La prossima volta faremo fare qualche cosa con i 2 bottoni. Per concludere una notiziona… le QT 5.2 dovrebbero permettere di creare applicativi Android, si troverà una beta delle API con la versione 5.1

Ancora QT e ancora database.

Comincio subito con il ringraziare b3h3m0th che mi ha segnalato che le QT non sono più di Nokia dalla scorsa estate e adesso appartengono a digia.

Dopo essere rimasto favorevolmente impressionato dalle QT ho deciso di approfondirle ulteriormente andando a complicare l’esempio di collegamento al database. L’idea era di avere una griglia con l’elenco dei record e un dettaglio separato (in modo da sincronizzare il record attivo sulla griglia con una parte separata ma dipendente)
La finestra ha l’aspetto in figura.

Il nostro primo risultato

Lo schema del database era il seguente:

CREATE TABLE tblProvincia
(cod character varying(2) NOT NULL,
 des character varying(40)
);

CREATE TABLE tbllocalita
(
  cod character varying(4) NOT NULL,
  des character varying(40),
  fk_provincia_cod character varying(2)
);

Il codice C++ invece è il seguente:

#include <QMessageBox>
#include <QSqlQuery>
#include <QSqlError>
#include <QSqlRecord>
#include <QTableWidgetItem>
#include <QDir>
#include <QSqlQuery>
#include <QtSql>
#include <QDataWidgetMapper>

#include "mainwindow.h"
#include "ui_mainwindow.h"

MainWindow::MainWindow(QWidget *parent) :
    QMainWindow(parent),
    ui(new Ui::MainWindow)
{
  ui->setupUi(this);
}

MainWindow::~MainWindow()
{
    db.close();
    delete ui;
}

void MainWindow::on_btnDBConnection_clicked()
{
    //Connessione al DB
    db = QSqlDatabase::addDatabase("QSQLITE");

    QString path(QDir::home().path());
    path.append(QDir::separator()).append("qtTest.sqlite");
    path = QDir::toNativeSeparators(path);
    db.setDatabaseName(path);
    bool ok = db.QSqlDatabase::open();
    if (!ok)
        QMessageBox::critical(0, QObject::tr("Errore database"), db.lastError().text());

}

void MainWindow::on_btnQuery_clicked()
{

    if (db.isOpen())
    {
        QSqlRelationalTableModel *model = new QSqlRelationalTableModel;

        model->setTable("tbllocalita");
        provIndex = model->fieldIndex("fk_provincia_cod");
        model->setRelation(provIndex, QSqlRelation("tblprovincia", "cod", "des"));
        model->setHeaderData(0, Qt::Horizontal, tr("Codice"));
        model->setHeaderData(1, Qt::Horizontal, tr("Descrizione"));
        model->setHeaderData(2, Qt::Horizontal, tr("Provincia"));
        model->select();

        ui->tblData->setModel(model);

        QSqlTableModel *relModel = model->relationModel(provIndex);
        ui->qcbProvincia->setModel(relModel);
        ui->qcbProvincia->setModelColumn(relModel->fieldIndex("des"));

        QDataWidgetMapper *mapper = new QDataWidgetMapper;
        mapper->setModel(model);
        mapper->setItemDelegate(new QSqlRelationalDelegate(this));
        mapper->addMapping(ui->pteCod, 0);
        mapper->addMapping(ui->pteDes, 1);
        mapper->addMapping(ui->qcbProvincia, provIndex);

        mapper->toFirst();
        connect(ui->tblData->selectionModel(), SIGNAL(currentRowChanged(QModelIndex,QModelIndex)), mapper, SLOT(setCurrentModelIndex(QModelIndex)));

    }
}

void MainWindow::on_btnExit_clicked()
{
    QApplication::quit();
}

Rispetto al mio precedente esempio ci sono poche modifiche. La prima è che ho dovuto usare un modello dati di tipo QSqlRelationalTableModel. In questo modo ho potuto impostare una relazione tra il campo fk_provincia_cod della tabella tbllocalita e il codice della tblprovincia in modo da salvare il codice come dato ma vedere la sua descrizione come visualizzazione. In parole povere la classica normalizzazione della base dati.
Usando un modello di tipo QSqlRelationalTableModel ho dovuto eliminare la query ed impostare una tabella di partenza:

model->setTable("tbllocalita");

ed impostarne la relazione con la tblprovincia:

provIndex = model->fieldIndex("fk_provincia_cod");
model->setRelation(provIndex, QSqlRelation("tblprovincia", "cod", "des"));

Attenzione… se siete tentati come me nella prima versione a non dichiarare una variabile provIndex di tipo int e ad usare ovunque direttamente

model->fieldIndex("fk_provincia_cod")

non fatelo… otterreste un bruttissimo errore di “QComboBox::setModel: cannot set a 0 model” a runtime alla riga:

ui->qcbProvincia->setModelColumn(relModel->fieldIndex("des"));

Sinceramente non capisco il perché dell’errore… se qualcuno ha dei suggerimenti e ben accetto 🙂

Dopo di che ho usato un QDataWidgetMapper per legare i widget alla sorgente dati:

QDataWidgetMapper *mapper = new QDataWidgetMapper;
mapper->setModel(model);
mapper->setItemDelegate(new QSqlRelationalDelegate(this));
mapper->addMapping(ui->pteCod, 0);
mapper->addMapping(ui->pteDes, 1);
mapper->addMapping(ui->qcbProvincia, provIndex);

E per ultimo per far si che allo spostarsi della cella attiva sulla griglia venissero aggiornati i dati dei widget sotto la stessa ho creato una connessione tra il segnale dell’oggetto mittente (sender) e il metodo dell’oggetto ricevente (receiver).

connect(ui->tblData->selectionModel(), SIGNAL(currentRowChanged(QModelIndex,QModelIndex)), mapper, SLOT(setCurrentModelIndex(QModelIndex)));

Come si vede nella finestra anche la combo è popolata con le descrizioni giuste.

Una bella combo box con i miei dati

Le istruzioni per caricare i dati nella combo sono state le seguenti:

ui->qcbProvincia->setModel(relModel);
ui->qcbProvincia->setModelColumn(relModel->fieldIndex("des"));
...
...
mapper->addMapping(ui->qcbProvincia, provIndex);

E se si volesse fare un collegamento master detail? Altra prassi comune in applicativi database oriented… le cose 🙂 rimangono ancora semplici.

Master - Detail

Le tabelle usate hanno la seguente struttura:

CREATE TABLE tblPersona (
  ID INTEGER,
  NOME character varying(40),
  PRIMARY KEY (ID)
);

CREATE TABLE tblFilm (
  ID INTEGER,
  FK_PERSONA_ID INTEGER,
  TITOLO character varying(40),
  PRIMARY KEY (ID),
  FOREIGN KEY (FK_PERSONA_ID) REFERENCES tblPersona
);

Il codice C++ è invece il seguente:

#ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include <QMainWindow>
#include <QtSql/QSqlDatabase>
#include <QSqlRelationalTableModel>

namespace Ui {
class MainWindow;
}

class MainWindow : public QMainWindow
{
    Q_OBJECT

public:
    explicit MainWindow(QWidget *parent = 0);
    ~MainWindow();

private slots:
    void on_btnDBConnection_clicked();
    void on_btnExit_clicked();
    void updateDetailGrid();
    void on_btnOpenTable_clicked();

private:
    Ui::MainWindow *ui;

    QSqlDatabase db;
    QSqlRelationalTableModel *masterModel;
    QSqlRelationalTableModel *detailModel;

};

e poi,

#include <QDir>
#include <QMessageBox>
#include <QSqlError>
#include <QSqlRelationalTableModel>
#include <QSqlRecord>

#include "mainwindow.h"
#include "ui_mainwindow.h"

MainWindow::MainWindow(QWidget *parent) :
    QMainWindow(parent),
    ui(new Ui::MainWindow)
{
    masterModel = NULL;
    detailModel = NULL;

    ui->setupUi(this);
}

MainWindow::~MainWindow()
{
    db.close();
    if (masterModel == NULL)
        delete masterModel;
    if (detailModel == NULL)
        delete detailModel;

    delete ui;
}

void MainWindow::on_btnDBConnection_clicked()
{
    //Connessione al DB
    db = QSqlDatabase::addDatabase("QSQLITE");

    QString path(QDir::home().path());
    path.append(QDir::separator()).append("qtTest.sqlite");
    path = QDir::toNativeSeparators(path);
    db.setDatabaseName(path);
    bool ok = db.QSqlDatabase::open();
    if (!ok)
        QMessageBox::critical(0, QObject::tr("Errore database"), db.lastError().text());

}

void MainWindow::updateDetailGrid()
{
    QModelIndex index = ui->vieGridMaster->currentIndex();
    if (index.isValid())
    {
        QSqlRecord record = masterModel->record(index.row());
        int id = record.value("id").toInt();
        detailModel->setFilter(QString("fk_persona_id = %1").arg(id));
    }
    else
        detailModel->setFilter("fk_persona_id = -1");

    detailModel->select();
    ui->vieGridDetail->horizontalHeader()->setVisible(detailModel->rowCount() > 0);
}

void MainWindow::on_btnExit_clicked()
{
    QApplication::quit();
}

void MainWindow::on_btnOpenTable_clicked()
{
    if (db.isOpen())
    {
        masterModel = new QSqlRelationalTableModel;
        masterModel->setTable("tblpersona");
        masterModel->setHeaderData(0, Qt::Horizontal, tr("ID"));
        masterModel->setHeaderData(1, Qt::Horizontal, tr("Nome"));
        masterModel->select();

        detailModel = new QSqlRelationalTableModel;
        detailModel->setTable("tblfilm");
        detailModel->setHeaderData(0, Qt::Horizontal, tr("ID"));
        detailModel->setHeaderData(1, Qt::Horizontal, tr("fk_Perosna_id"));
        detailModel->setHeaderData(2, Qt::Horizontal, tr("Titolo"));
        detailModel->select();

        ui->vieGridMaster->setModel(masterModel);
        ui->vieGridDetail->setModel(detailModel);

        connect(ui->vieGridMaster->selectionModel(), SIGNAL(currentRowChanged(QModelIndex,QModelIndex)), this, SLOT(updateDetailGrid()));
        ui->vieGridMaster->selectRow(0);
    }
}

Si creano 2 datamodel di tipo QSqlRelationalTableModel. Dopo di che si crea un evento che collega il cambio di riga selezionata sulla griglia master e lo comunica alla funzione che si occuperà di aggiornare il dettaglio, la funzione updateDetailGrid. Quest’ultima per aggiornare i propri dati crea un filtro sul suo modello dati e aggiorna l’estrazione. Veramente facile 🙂 dopo che si ha acquisito un po’ di esperienza.

Per concludere il mio parere personale è che QT sia un’ottima libreria per lo sviluppo di applicativi client multipiattaforma (insomma mi ha dato una bella soddisfazione usarla per questi test 🙂 ).E’ sicuramente ben studiata e soprattutto va studiata… e con l’avvento di internet (e Google) almeno io tendo a cercare la soluzione piuttosto che leggermi i manuali, per cui l’occhio sui QDataWidgetMapper mi è caduto dopo vari tentativi e ore perse a leggermi vari post. La parte di accesso all’SQL sembra meno curata del resto (ma è la mia prima impressione da utilizzatore di altri framework). L’utilizzo di un filtro per il master/detail funziona bene con pochi record… ma se questi aumentassero? Sicuramente ci sono altri framwork di sviluppo (ad esempio Delphi e la sua VCL) che sono più flessibili e sofisticati (anche nell’integrazione con l’IDE), ma evidentemente gli sviluppatori QT hanno deciso di porre l’enfasi su altri aspetti del framework e in tutta franchezza CHE ASPETTI 🙂

Sviluppo multipiattaforma con QT

A settembre 2011 Embarcadero annunciava il suo Delphi XE2 con la libreria firemonkey che permettevano una compilazione di un eseguibile tra piattaforme diverse. Un solo sorgente per Windows e OSX.
In realtà esiste già da tempo una libreria che permette di fare compilazioni cross-platform e si chiama QT un solo sorgente per i sitemi Linux/OSX/Windows e inoltre embedded Linux e Symbian. Così giusto per fare una qualche prova e scrivere un po’ di codice in C++ ho provato a fare un programma che si collegasse ad un database sqlite 🙂
Con le librerie Qt viene anche fornito un IDE, QT Creator, che permette di sviluppare i propri applicativi. Esiste una versione opensource per i progetti non commerciali altrimenti bisogna investire qualche euro (per sapere i prezzi bisogna contattare il loro team vendite).
Per la creazione della for ho usato il designer visuale integrato con il QT Creator. 3 bottoni, connessione al DB, esecuzione query e uscita dall’applicativo e una griglia per visualizzare i dati. La griglia è una QTableWidget (non ‘è l’oggetto consigliato per i dati che arrivano da un database, ma per la prova va benissimo).

Per usare le librerie per i database ho dovuto aggiungere sql nel file di progetto “.pro” Che di default aveva questo contenuto:

#-------------------------------------------------
#
# Project created by QtCreator 2013-02-07T11:50:15
#
#-------------------------------------------------

QT += core gui

greaterThan(QT_MAJOR_VERSION, 4): QT += widgets

TARGET = DBTest
TEMPLATE = app

SOURCES += main.cpp\
 mainwindow.cpp

HEADERS += mainwindow.h

FORMS += mainwindow.ui

Che io ho cambiato in:

QT += core gui sql

Il file header (mainwindow.h) è il seguente:

#ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include <QMainWindow>
#include <QtSql/QSqlDatabase>

namespace Ui {
  class MainWindow;
}

class MainWindow : public QMainWindow
{
 Q_OBJECT

  public:
    explicit MainWindow(QWidget *parent = 0);
    ~MainWindow();

  private slots:
    void on_btnDBConnection_clicked();
    void on_btnQuery_clicked();

  private:
    Ui::MainWindow *ui;
    QSqlDatabase db;
};

#endif // MAINWINDOW_H

Il file sorgente è invece questo.

#include <QMessageBox>
#include <QSqlQuery>
#include <QSqlError>
#include <QSqlRecord>
#include <QTableWidgetItem>
#include <QDir>
#include <QSqlQuery>
#include <QtSql>

#include "mainwindow.h"
#include "ui_mainwindow.h"

MainWindow::MainWindow(QWidget *parent) :
 QMainWindow(parent),
 ui(new Ui::MainWindow)
{
 ui->setupUi(this);
}

MainWindow::~MainWindow()
{
 db.close();
 delete ui;
}

void MainWindow::on_btnDBConnection_clicked()
{
  //Connessione al DB
  db = QSqlDatabase::addDatabase("QSQLITE");
  QString path(QDir::home().path());
  path.append(QDir::separator()).append("qtTest.sqlite");
  path = QDir::toNativeSeparators(path);
  db.setDatabaseName(path);
  bool ok = db.QSqlDatabase::open();
  if (!ok)
    QMessageBox::critical(0, QObject::tr("Errore database"), db.lastError().text());
}

void MainWindow::on_btnQuery_clicked()
{
  if (db.isOpen())
  {
    QSqlQuery query("Select * from tbllocalita");

    int codNo = query.record().indexOf("cod");
    int desNo = query.record().indexOf("des");
    ui->tblData->insertColumn(0);
    ui->tblData->insertColumn(1);
    while (query.next())
    {
      QString sCod = query.value(codNo).toString();
      QString sDes = query.value(desNo).toString();
      int row = ui->tblData->rowCount();
      ui->tblData->insertRow(row);
      ui->tblData->setItem(row, 0, new QTableWidgetItem(sCod));
      ui->tblData->setItem(row, 1, new QTableWidgetItem(sDes));
    }
  }
}

E’ da notare la definizione del tipo di database a cui connettersi:

db = QSqlDatabase::addDatabase("QSQLITE");

I database supportati sono i seguenti (copio e incollo dal sito):

“IBM DB2 (version 7.1 and above)Borland InterBase
MySQL
Oracle Call Interface Driver
Open Database Connectivity (ODBC) – Microsoft SQL Server and other ODBC-compliant databases
PostgreSQL (versions 7.3 and above)
SQLite version 2
SQLite version 3
SQLite version 3 for Symbian SQL Database
Sybase Adaptive Server Note: obsolete from Qt 4.7”

Trovate più informazioni sui database qui.

Dopo la scelta del tipo di database, bisognerà definire i parametri di connessione. Nel caso in questione avendo scelto sqlite si dovrà definire la path del file (l’ultima riga), ed ecco comparire alcune utili funzioni integrate in QT che permettono di otterene la path della propria home e di riscrivere i separatori delle cartelle rispettando lo standard del sistema operativo su cui gira il programma (le prime 3 righe).

QString path(QDir::home().path());
path.append(QDir::separator()).append("qtTest.sqlite");
path = QDir::toNativeSeparators(path);
db.setDatabaseName(path);

Di seguito potete vedere come nella finestra di debug le path siano corrette:

Path in ambiente windows

Path in ambiente windows

Path in ambiente Linux

Path in ambiente Linux

Una volta aperto il DB, potremo fare la nostra estrazione dei dati:

if (db.isOpen())
{
  QSqlQuery query("Select * from tbllocalita");

  int codNo = query.record().indexOf("cod");
  int desNo = query.record().indexOf("des");
  ui->tblData->insertColumn(0);
  ui->tblData->insertColumn(1);
  while (query.next())
  {
    QString sCod = query.value(codNo).toString();
    QString sDes = query.value(desNo).toString();
    int row = ui->tblData->rowCount();
    ui->tblData->insertRow(row);
    ui->tblData->setItem(row, 0, new QTableWidgetItem(sCod));
    ui->tblData->setItem(row, 1, new QTableWidgetItem(sDes));
  }
}

Sempre in questo esempio la tabella era banale e aveva solo 2 colonne, ma nel caso ve ne siano molte di più si può vedere che è possibile abbinare un identificativo menmonico (una variabile di tipo intero) alla colonna fisica della query risultante in maniera da poterla usare per ottenere il valore del campo. Si è vero si poteva scrivere anche così:

QString sCod = query.value(query.record().indexOf("cod")).toString();
QString sDes = query.value(query.record().indexOf("des")).toString();

Infine i dati vengono salvati nella griglia, oggetto tbldata.

int row = ui->tblData->rowCount();
ui->tblData->insertRow(row);
ui->tblData->setItem(row, 0, new QTableWidgetItem(sCod));
ui->tblData->setItem(row, 1, new QTableWidgetItem(sDes));

La funzione insertRow inserisce una riga vuota alla posizione specificata da row, per cui nel nostro caso ci viene comodo impostarla sempre al numero di righe inserite che partono da 0.

Si compila quindi il tutto e lo stesso sorgente genera due eseguibili diversi funzionanti nello stesso modo su Windows e Linux.

Binario Linux

Binario Linux

Binario Windows

Binario Windows

Si lo so… i più bravi saranno già li a dire che con QT esisteno le QTableView a cui è possibile abbinare direttamente un modello dati di tipo QSqlQueryModel (che è in sola lettura) o QSqlTableModel (anche in scrittura). Per cui il codice in on_btnQuery_clicked diventerà molto semplicemente:

QSqlQueryModel *model = new QSqlQueryModel;
QSqlQuery query("Select cod, des from tbllocalita");

model->setQuery(query);
model->setHeaderData(0, Qt::Horizontal, tr("Codice"));
model->setHeaderData(1, Qt::Horizontal, tr("Descrizione"));

ui->tblData->setModel(model);

Speriamo che Nokia non decida in futuro di farci pagare questo gioiellino 🙂