|  | Home · All Classes · Main Classes · Grouped Classes · Modules · Functions |

# browser.cpp Example File
demos/sqlbrowser/browser.cpp

        /****************************************************************************
        **
        ** Copyright (C) 2004-2006 Trolltech AS. All rights reserved.
        **
        ** This file is part of the documentation of the Qt Toolkit.
        **
        ** This file may be used under the terms of the GNU General Public
        ** License version 2.0 as published by the Free Software Foundation
        ** and appearing in the file LICENSE.GPL included in the packaging of
        ** this file.  Please review the following information to ensure GNU
        ** General Public Licensing requirements will be met:
        ** http://www.trolltech.com/products/qt/opensource.html
        **
        ** If you are unsure which license is appropriate for your use, please
        ** review the following information:
        ** http://www.trolltech.com/products/qt/licensing.html or contact the
        ** sales department at sales@trolltech.com.
        **
        ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
        ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
        **
        ****************************************************************************/

        #include "browser.h"
        #include "qsqlconnectiondialog.h"

        #include <QtGui>
        #include <QtSql>

        Browser::Browser(QWidget *parent)
            : QWidget(parent)
        {
            setupUi(this);

            table->addAction(insertRowAction);
            table->addAction(deleteRowAction);

            if (QSqlDatabase::drivers().isEmpty())
                QMessageBox::information(this, tr("No database drivers found"),
                                         tr("This demo requires at least one Qt database driver. "
                                            "Please check the documentation how to build the "
                                            "Qt SQL plugins."));

            emit statusMessage(tr("Ready."));
        }

        Browser::~Browser()
        {
        }

        void Browser::exec()
        {
            QSqlQueryModel *model = new QSqlQueryModel(table);
            model->setQuery(QSqlQuery(sqlEdit->toPlainText(), connectionWidget->currentDatabase()));
            table->setModel(model);

            if (model->lastError().type() != QSqlError::NoError)
                emit statusMessage(model->lastError().text());
            else if (model->query().isSelect())
                emit statusMessage(tr("Query OK."));
            else
                emit statusMessage(tr("Query OK, number of affected rows: %1").arg(
                                   model->query().numRowsAffected()));

            updateActions();
        }

        QSqlError Browser::addConnection(const QString &driver, const QString &dbName, const QString &host,
                                    const QString &user, const QString &passwd, int port)
        {
            static int cCount = 0;

            QSqlError err;
            QSqlDatabase db = QSqlDatabase::addDatabase(driver, QString("Browser%1").arg(++cCount));
            db.setDatabaseName(dbName);
            db.setHostName(host);
            db.setPort(port);
            if (!db.open(user, passwd)) {
                err = db.lastError();
                db = QSqlDatabase();
                QSqlDatabase::removeDatabase(QString("Browser%1").arg(cCount));
            }
            connectionWidget->refresh();

            return err;
        }

        void Browser::addConnection()
        {
            QSqlConnectionDialog dialog(this);
            if (dialog.exec() != QDialog::Accepted)
                return;

            if (dialog.useInMemoryDatabase()) {
                QSqlDatabase::database("in_mem_db", false).close();
                QSqlDatabase::removeDatabase("in_mem_db");
                QSqlDatabase db = QSqlDatabase::addDatabase("QSQLITE", "in_mem_db");
                db.setDatabaseName(":memory:");
                if (!db.open())
                    QMessageBox::warning(this, tr("Unable to open database"), tr("An error occured while "
                                                                                 "opening the connection: ") + db.lastError().text());
                QSqlQuery q("", db);
                q.exec("drop table Movies");
                q.exec("drop table Names");
                q.exec("create table Movies (id integer primary key, Title varchar, Director varchar, Rating number)");
                q.exec("insert into Movies values (0, 'Metropolis', 'Fritz Lang', '8.4')");
                q.exec("insert into Movies values (1, 'Nosferatu, eine Symphonie des Grauens', 'F.W. Murnau', '8.1')");
                q.exec("insert into Movies values (2, 'Bis ans Ende der Welt', 'Wim Wenders', '6.5')");
                q.exec("insert into Movies values (3, 'Hardware', 'Richard Stanley', '5.2')");
                q.exec("insert into Movies values (4, 'Mitchell', 'Andrew V. McLaglen', '2.1')");
                q.exec("create table Names (id integer primary key, Firstname varchar, Lastname varchar, City varchar)");
                q.exec("insert into Names values (0, 'Sala', 'Palmer', 'Morristown')");
                q.exec("insert into Names values (1, 'Christopher', 'Walker', 'Morristown')");
                q.exec("insert into Names values (2, 'Donald', 'Duck', 'Andeby')");
                q.exec("insert into Names values (3, 'Buck', 'Rogers', 'Paris')");
                q.exec("insert into Names values (4, 'Sherlock', 'Holmes', 'London')");
                connectionWidget->refresh();
            } else {
                QSqlError err = addConnection(dialog.driverName(), dialog.databaseName(), dialog.hostName(),
                                   dialog.userName(), dialog.password(), dialog.port());
                if (err.type() != QSqlError::NoError)
                    QMessageBox::warning(this, tr("Unable to open database"), tr("An error occured while "
                                              "opening the connection: ") + err.text());
            }
        }

        void Browser::showTable(const QString &t)
        {
            QSqlTableModel *model = new QSqlTableModel(table, connectionWidget->currentDatabase());
            model->setEditStrategy(QSqlTableModel::OnRowChange);
            model->setTable(t);
            model->select();
            if (model->lastError().type() != QSqlError::NoError)
                emit statusMessage(model->lastError().text());
            table->setModel(model);
            table->setEditTriggers(QAbstractItemView::DoubleClicked|QAbstractItemView::EditKeyPressed);

            connect(table->selectionModel(), SIGNAL(currentRowChanged(QModelIndex,QModelIndex)),
                    this, SLOT(currentChanged()));
            updateActions();
        }

        void Browser::showMetaData(const QString &t)
        {
            QSqlRecord rec = connectionWidget->currentDatabase().record(t);
            QStandardItemModel *model = new QStandardItemModel(table);

            model->insertRows(0, rec.count());
            model->insertColumns(0, 7);

            model->setHeaderData(0, Qt::Horizontal, "Fieldname");
            model->setHeaderData(1, Qt::Horizontal, "Type");
            model->setHeaderData(2, Qt::Horizontal, "Length");
            model->setHeaderData(3, Qt::Horizontal, "Precision");
            model->setHeaderData(4, Qt::Horizontal, "Required");
            model->setHeaderData(5, Qt::Horizontal, "AutoValue");
            model->setHeaderData(6, Qt::Horizontal, "DefaultValue");

            for (int i = 0; i < rec.count(); ++i) {
                QSqlField fld = rec.field(i);
                model->setData(model->index(i, 0), fld.name());
                model->setData(model->index(i, 1), fld.typeID() == -1
                        ? QString(QVariant::typeToName(fld.type()))
                        : QString("%1 (%2)").arg(QVariant::typeToName(fld.type())).arg(fld.typeID()));
                model->setData(model->index(i, 2), fld.length());
                model->setData(model->index(i, 3), fld.precision());
                model->setData(model->index(i, 4), fld.requiredStatus() == -1 ? QVariant("?")
                        : QVariant(bool(fld.requiredStatus())));
                model->setData(model->index(i, 5), fld.isAutoValue());
                model->setData(model->index(i, 6), fld.defaultValue());
            }

            table->setModel(model);
            table->setEditTriggers(QAbstractItemView::NoEditTriggers);

            updateActions();
        }

        void Browser::insertRow()
        {
            QSqlTableModel *model = qobject_cast<QSqlTableModel *>(table->model());
            if (!model)
                return;

            QModelIndex insertIndex = table->currentIndex();
            int row = insertIndex.row() == -1 ? 0 : insertIndex.row();
            model->insertRow(row);
            insertIndex = model->index(row, 0);
            table->setCurrentIndex(insertIndex);
            table->edit(insertIndex);
        }

        void Browser::deleteRow()
        {
            QSqlTableModel *model = qobject_cast<QSqlTableModel *>(table->model());
            if (!model)
                return;

            model->setEditStrategy(QSqlTableModel::OnManualSubmit);

            QModelIndexList currentSelection = table->selectionModel()->selectedIndexes();
            for (int i = 0; i < currentSelection.count(); ++i) {
                if (currentSelection.at(i).column() != 0)
                    continue;
                model->removeRow(currentSelection.at(i).row());
            }

            model->submitAll();
            model->setEditStrategy(QSqlTableModel::OnRowChange);

            updateActions();
        }

        void Browser::updateActions()
        {
            bool enableIns = qobject_cast<QSqlTableModel *>(table->model());
            bool enableDel = enableIns && table->currentIndex().isValid();

            insertRowAction->setEnabled(enableIns);
            deleteRowAction->setEnabled(enableDel);
        }