1berry/qtbase
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Examples/sqlbrowser: improve coding style

Browse Source 
Fix the coding style to match the current Qt style.

Fixes: QTBUG-68661
Fixes: QTBUG-120909
Change-Id: I314ca9da8a03727e3e0336a23fce1ce9d065d3a4
Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
Reviewed-by: Kai Köhne <kai.koehne@qt.io>
(cherry picked from commit 2690822428deec4f0c08f4d118d69a7c6036369e)
Reviewed-by: Qt Cherry-pick Bot <cherrypick_bot@qt-project.org>
This commit is contained in:
Christian Ehrlicher 2024-01-12 22:25:23 +01:00 committed by Qt Cherry-pick Bot
parent 02ba4b14dc
commit fb453fe28c
7 changed files with 246 additions and 192 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

202
examples/sql/sqlbrowser/browser.cpp
View File

@ -3,23 +3,49 @@
#include "browser.h"
#include "qsqlconnectiondialog.h"
#include <ui_browserwidget.h>
#include <QtWidgets>
#include <QtSql>
#include <QAction>
#include <QMessageBox>
#include <QStandardItemModel>
#include <QSqlDriver>
#include <QSqlError>
#include <QSqlField>
#include <QSqlQuery>
#include <QSqlRecord>
#include <QTextEdit>
#include <QTimer>
Browser::Browser(QWidget *parent)
: QWidget(parent)
, m_ui(new Ui::Browser)
{
setupUi(this);
m_ui->setupUi(this);
table->addAction(insertRowAction);
table->addAction(deleteRowAction);
table->addAction(fieldStrategyAction);
table->addAction(rowStrategyAction);
table->addAction(manualStrategyAction);
table->addAction(submitAction);
table->addAction(revertAction);
table->addAction(selectAction);
m_ui->table->addAction(m_ui->insertRowAction);
m_ui->table->addAction(m_ui->deleteRowAction);
m_ui->table->addAction(m_ui->fieldStrategyAction);
m_ui->table->addAction(m_ui->rowStrategyAction);
m_ui->table->addAction(m_ui->manualStrategyAction);
m_ui->table->addAction(m_ui->submitAction);
m_ui->table->addAction(m_ui->revertAction);
m_ui->table->addAction(m_ui->selectAction);
connect(m_ui->insertRowAction, &QAction::triggered, this, &Browser::insertRow);
connect(m_ui->deleteRowAction, &QAction::triggered, this, &Browser::deleteRow);
connect(m_ui->fieldStrategyAction, &QAction::triggered, this, &Browser::onFieldStrategyAction);
connect(m_ui->rowStrategyAction, &QAction::triggered, this, &Browser::onRowStrategyAction);
connect(m_ui->sqlEdit, &QTextEdit::textChanged, this, &Browser::updateActions);
connect(m_ui->connectionWidget, &ConnectionWidget::tableActivated,
this, &Browser::showTable);
connect(m_ui->connectionWidget, &ConnectionWidget::metaDataRequested,
this, &Browser::showMetaData);
connect(m_ui->submitButton, &QPushButton::clicked,
this, &Browser::onSubmitButton);
connect(m_ui->clearButton, &QPushButton::clicked,
this, &Browser::onClearButton);
if (QSqlDatabase::drivers().isEmpty())
QMessageBox::information(this, tr("No database drivers found"),
@ -27,18 +53,22 @@ Browser::Browser(QWidget *parent)
"Please check the documentation how to build the "
"Qt SQL plugins."));
emit statusMessage(tr("Ready."));
QTimer::singleShot(0, this, [this]() {
updateActions();
emit statusMessage(tr("Ready."));
});
}
Browser::~Browser()
{
delete m_ui;
}
void Browser::exec()
{
QSqlQueryModel *model = new QSqlQueryModel(table);
model->setQuery(QSqlQuery(sqlEdit->toPlainText(), connectionWidget->currentDatabase()));
table->setModel(model);
QSqlQueryModel *model = new QSqlQueryModel(m_ui->table);
model->setQuery(QSqlQuery(m_ui->sqlEdit->toPlainText(), m_ui->connectionWidget->currentDatabase()));
m_ui->table->setModel(model);
if (model->lastError().type() != QSqlError::NoError)
emit statusMessage(model->lastError().text());
@ -52,7 +82,7 @@ void Browser::exec()
}
QSqlError Browser::addConnection(const QString &driver, const QString &dbName, const QString &host,
const QString &user, const QString &passwd, int port)
const QString &user, const QString &passwd, int port)
{
static int cCount = 0;
@ -66,7 +96,7 @@ QSqlError Browser::addConnection(const QString &driver, const QString &dbName, c
db = QSqlDatabase();
QSqlDatabase::removeDatabase(QString("Browser%1").arg(cCount));
}
connectionWidget->refresh();
m_ui->connectionWidget->refresh();
return err;
}
@ -82,10 +112,14 @@ void Browser::openNewConnectionDialog()
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 occurred while "
"opening the connection: ") + db.lastError().text());
QSqlQuery q("", db);
if (!db.open()) {
QMessageBox::warning(this, tr("Unable to open database"),
tr("An error occurred while "
"opening the connection: %1") .arg(db.lastError().text()));
return;
}
db.transaction();
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)");
@ -100,37 +134,43 @@ void Browser::openNewConnectionDialog()
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();
db.commit();
m_ui->connectionWidget->refresh();
} else {
QSqlError err = addConnection(dialog.driverName(), dialog.databaseName(), dialog.hostName(),
dialog.userName(), dialog.password(), dialog.port());
dialog.userName(), dialog.password(), dialog.port());
if (err.type() != QSqlError::NoError)
QMessageBox::warning(this, tr("Unable to open database"), tr("An error occurred while "
"opening the connection: ") + err.text());
QMessageBox::warning(this, tr("Unable to open database"),
tr("An error occurred while "
"opening the connection: %1").arg(err.text()));
}
}
void Browser::showTable(const QString &t)
{
QSqlTableModel *model = new CustomModel(table, connectionWidget->currentDatabase());
QSqlTableModel *model = new CustomModel(m_ui->table, m_ui->connectionWidget->currentDatabase());
model->setEditStrategy(QSqlTableModel::OnRowChange);
model->setTable(connectionWidget->currentDatabase().driver()->escapeIdentifier(t, QSqlDriver::TableName));
model->setTable(m_ui->connectionWidget->currentDatabase().driver()->escapeIdentifier(t, QSqlDriver::TableName));
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(), &QItemSelectionModel::currentRowChanged,
this, &Browser::currentChanged);
m_ui->table->setModel(model);
m_ui->table->setEditTriggers(QAbstractItemView::DoubleClicked|QAbstractItemView::EditKeyPressed);
connect(m_ui->table->selectionModel(), &QItemSelectionModel::currentRowChanged,
this, &Browser::updateActions);
connect(m_ui->submitAction, &QAction::triggered, model, &QSqlTableModel::submitAll);
connect(m_ui->revertAction, &QAction::triggered, model, &QSqlTableModel::revertAll);
connect(m_ui->selectAction, &QAction::triggered, model, &QSqlTableModel::select);
updateActions();
}
void Browser::showMetaData(const QString &t)
{
QSqlRecord rec = connectionWidget->currentDatabase().record(t);
QStandardItemModel *model = new QStandardItemModel(table);
QSqlRecord rec = m_ui->connectionWidget->currentDatabase().record(t);
QStandardItemModel *model = new QStandardItemModel(m_ui->table);
model->insertRows(0, rec.count());
model->insertColumns(0, 7);
@ -157,37 +197,37 @@ void Browser::showMetaData(const QString &t)
model->setData(model->index(i, 6), fld.defaultValue());
}
table->setModel(model);
table->setEditTriggers(QAbstractItemView::NoEditTriggers);
m_ui->table->setModel(model);
m_ui->table->setEditTriggers(QAbstractItemView::NoEditTriggers);
updateActions();
}
void Browser::insertRow()
{
QSqlTableModel *model = qobject_cast<QSqlTableModel *>(table->model());
QSqlTableModel *model = qobject_cast<QSqlTableModel *>(m_ui->table->model());
if (!model)
return;
QModelIndex insertIndex = table->currentIndex();
QModelIndex insertIndex = m_ui->table->currentIndex();
int row = insertIndex.row() == -1 ? 0 : insertIndex.row();
model->insertRow(row);
insertIndex = model->index(row, 0);
table->setCurrentIndex(insertIndex);
table->edit(insertIndex);
m_ui->table->setCurrentIndex(insertIndex);
m_ui->table->edit(insertIndex);
}
void Browser::deleteRow()
{
QSqlTableModel *model = qobject_cast<QSqlTableModel *>(table->model());
QSqlTableModel *model = qobject_cast<QSqlTableModel *>(m_ui->table->model());
if (!model)
return;
QModelIndexList currentSelection = table->selectionModel()->selectedIndexes();
for (int i = 0; i < currentSelection.count(); ++i) {
if (currentSelection.at(i).column() != 0)
const QModelIndexList currentSelection = m_ui->table->selectionModel()->selectedIndexes();
for (const auto &idx : currentSelection) {
if (idx.column() != 0)
continue;
model->removeRow(currentSelection.at(i).row());
model->removeRow(idx.row());
}
updateActions();
@ -195,74 +235,70 @@ void Browser::deleteRow()
void Browser::updateActions()
{
QSqlTableModel * tm = qobject_cast<QSqlTableModel *>(table->model());
bool enableIns = tm;
bool enableDel = enableIns && table->currentIndex().isValid();
QSqlTableModel *tm = qobject_cast<QSqlTableModel *>(m_ui->table->model());
bool enableIns = tm != nullptr;
bool enableDel = enableIns && m_ui->table->currentIndex().isValid();
insertRowAction->setEnabled(enableIns);
deleteRowAction->setEnabled(enableDel);
m_ui->insertRowAction->setEnabled(enableIns);
m_ui->deleteRowAction->setEnabled(enableDel);
fieldStrategyAction->setEnabled(tm);
rowStrategyAction->setEnabled(tm);
manualStrategyAction->setEnabled(tm);
submitAction->setEnabled(tm);
revertAction->setEnabled(tm);
selectAction->setEnabled(tm);
m_ui->submitAction->setEnabled(tm);
m_ui->revertAction->setEnabled(tm);
m_ui->selectAction->setEnabled(tm);
const bool isEmpty = m_ui->sqlEdit->toPlainText().isEmpty();
m_ui->submitButton->setEnabled(m_ui->connectionWidget->currentDatabase().isOpen() && !isEmpty);
m_ui->clearButton->setEnabled(!isEmpty);
if (tm) {
QSqlTableModel::EditStrategy es = tm->editStrategy();
fieldStrategyAction->setChecked(es == QSqlTableModel::OnFieldChange);
rowStrategyAction->setChecked(es == QSqlTableModel::OnRowChange);
manualStrategyAction->setChecked(es == QSqlTableModel::OnManualSubmit);
m_ui->fieldStrategyAction->setChecked(es == QSqlTableModel::OnFieldChange);
m_ui->rowStrategyAction->setChecked(es == QSqlTableModel::OnRowChange);
m_ui->manualStrategyAction->setChecked(es == QSqlTableModel::OnManualSubmit);
} else {
m_ui->fieldStrategyAction->setEnabled(false);
m_ui->rowStrategyAction->setEnabled(false);
m_ui->manualStrategyAction->setEnabled(false);
}
}
void Browser::about()
{
QMessageBox::about(this, tr("About"), tr("The SQL Browser demonstration "
"shows how a data browser can be used to visualize the results of SQL"
"statements on a live database"));
QMessageBox::about(this, tr("About"),
tr("The SQL Browser demonstration shows how a data browser "
"can be used to visualize the results of SQL "
"statements on a live database"));
}
void Browser::on_fieldStrategyAction_triggered()
void Browser::onFieldStrategyAction()
{
QSqlTableModel * tm = qobject_cast<QSqlTableModel *>(table->model());
QSqlTableModel *tm = qobject_cast<QSqlTableModel *>(m_ui->table->model());
if (tm)
tm->setEditStrategy(QSqlTableModel::OnFieldChange);
}
void Browser::on_rowStrategyAction_triggered()
void Browser::onRowStrategyAction()
{
QSqlTableModel * tm = qobject_cast<QSqlTableModel *>(table->model());
QSqlTableModel *tm = qobject_cast<QSqlTableModel *>(m_ui->table->model());
if (tm)
tm->setEditStrategy(QSqlTableModel::OnRowChange);
}
void Browser::on_manualStrategyAction_triggered()
void Browser::onManualStrategyAction()
{
QSqlTableModel * tm = qobject_cast<QSqlTableModel *>(table->model());
QSqlTableModel *tm = qobject_cast<QSqlTableModel *>(m_ui->table->model());
if (tm)
tm->setEditStrategy(QSqlTableModel::OnManualSubmit);
}
void Browser::on_submitAction_triggered()
void Browser::onSubmitButton()
{
QSqlTableModel * tm = qobject_cast<QSqlTableModel *>(table->model());
if (tm)
tm->submitAll();
exec();
m_ui->sqlEdit->setFocus();
}
void Browser::on_revertAction_triggered()
void Browser::onClearButton()
{
QSqlTableModel * tm = qobject_cast<QSqlTableModel *>(table->model());
if (tm)
tm->revertAll();
m_ui->sqlEdit->clear();
m_ui->sqlEdit->setFocus();
}
void Browser::on_selectAction_triggered()
{
QSqlTableModel * tm = qobject_cast<QSqlTableModel *>(table->model());
if (tm)
tm->select();
}

66
examples/sql/sqlbrowser/browser.h
View File

@ -6,72 +6,58 @@
#include <QWidget>
#include <QSqlTableModel>
#include "ui_browserwidget.h"
class ConnectionWidget;
QT_FORWARD_DECLARE_CLASS(QTableView)
QT_FORWARD_DECLARE_CLASS(QPushButton)
QT_FORWARD_DECLARE_CLASS(QTextEdit)
QT_FORWARD_DECLARE_CLASS(QSqlError)
class Browser: public QWidget, private Ui::Browser
QT_BEGIN_NAMESPACE
namespace Ui
{
class Browser;
}
QT_END_NAMESPACE
class Browser : public QWidget
{
Q_OBJECT
public:
Browser(QWidget *parent = nullptr);
virtual ~Browser();
~Browser();
QSqlError addConnection(const QString &driver, const QString &dbName, const QString &host,
const QString &user, const QString &passwd, int port = -1);
const QString &user, const QString &passwd, int port);
public slots:
void openNewConnectionDialog();
void about();
protected:
void insertRow();
void deleteRow();
void updateActions();
public slots:
protected slots:
void exec();
void showTable(const QString &table);
void showMetaData(const QString &table);
void openNewConnectionDialog();
void currentChanged() { updateActions(); }
void about();
void on_insertRowAction_triggered()
{ insertRow(); }
void on_deleteRowAction_triggered()
{ deleteRow(); }
void on_fieldStrategyAction_triggered();
void on_rowStrategyAction_triggered();
void on_manualStrategyAction_triggered();
void on_submitAction_triggered();
void on_revertAction_triggered();
void on_selectAction_triggered();
void on_connectionWidget_tableActivated(const QString &table)
{ showTable(table); }
void on_connectionWidget_metaDataRequested(const QString &table)
{ showMetaData(table); }
void on_submitButton_clicked()
{
exec();
sqlEdit->setFocus();
}
void on_clearButton_clicked()
{
sqlEdit->clear();
sqlEdit->setFocus();
}
void onFieldStrategyAction();
void onRowStrategyAction();
void onManualStrategyAction();
void onSubmitButton();
void onClearButton();
signals:
void statusMessage(const QString &message);
private:
Ui::Browser *m_ui;
};
class CustomModel: public QSqlTableModel
class CustomModel : public QSqlTableModel
{
Q_OBJECT
public:
explicit CustomModel(QObject *parent = nullptr, QSqlDatabase db = QSqlDatabase())
: QSqlTableModel(parent, db) {}
using QSqlTableModel::QSqlTableModel;
QVariant data(const QModelIndex &idx, int role) const override
{
if (role == Qt::BackgroundRole && isDirty(idx))

63
examples/sql/sqlbrowser/connectionwidget.cpp
View File

@ -3,17 +3,19 @@
#include "connectionwidget.h"
#include <QtWidgets>
#include <QtSql>
#include <QAction>
#include <QHeaderView>
#include <QSqlDatabase>
#include <QTreeWidget>
#include <QVBoxLayout>
ConnectionWidget::ConnectionWidget(QWidget *parent)
: QWidget(parent)
, tree(new QTreeWidget(this))
{
QVBoxLayout *layout = new QVBoxLayout(this);
tree = new QTreeWidget(this);
tree->setObjectName(QLatin1String("tree"));
tree->setHeaderLabels(QStringList(tr("database")));
tree->header()->setSectionResizeMode(QHeaderView::Stretch);
tree->setHeaderLabels(QStringList(tr("Database")));
tree->header()->setStretchLastSection(true);
QAction *refreshAction = new QAction(tr("Refresh"), tree);
metaDataAction = new QAction(tr("Show Schema"), tree);
connect(refreshAction, &QAction::triggered, this, &ConnectionWidget::refresh);
@ -24,34 +26,37 @@ ConnectionWidget::ConnectionWidget(QWidget *parent)
layout->addWidget(tree);
QMetaObject::connectSlotsByName(this);
connect(tree, &QTreeWidget::itemActivated,
this, &ConnectionWidget::onItemActivated);
connect(tree, &QTreeWidget::currentItemChanged,
this, &ConnectionWidget::onCurrentItemChanged);
}
ConnectionWidget::~ConnectionWidget()
{
}
static QString qDBCaption(const QSqlDatabase &db)
{
QString nm = db.driverName();
nm.append(QLatin1Char(':'));
if (!db.userName().isEmpty())
nm.append(db.userName()).append(QLatin1Char('@'));
nm.append(db.databaseName());
return nm;
}
void ConnectionWidget::refresh()
{
const auto qDBCaption = [](const QSqlDatabase &db)
{
QString nm = db.driverName() + QLatin1Char(':');
if (!db.userName().isEmpty())
nm += db.userName() + QLatin1Char('@');
nm += db.databaseName();
return nm;
};
tree->clear();
QStringList connectionNames = QSqlDatabase::connectionNames();
const QStringList connectionNames = QSqlDatabase::connectionNames();
bool gotActiveDb = false;
for (int i = 0; i < connectionNames.count(); ++i) {
for (const auto &connectionName : connectionNames) {
QTreeWidgetItem *root = new QTreeWidgetItem(tree);
QSqlDatabase db = QSqlDatabase::database(connectionNames.at(i), false);
QSqlDatabase db = QSqlDatabase::database(connectionName, false);
root->setText(0, qDBCaption(db));
if (connectionNames.at(i) == activeDb) {
if (connectionName == activeDb) {
gotActiveDb = true;
setActive(root);
}
@ -76,15 +81,15 @@ QSqlDatabase ConnectionWidget::currentDatabase() const
return QSqlDatabase::database(activeDb);
}
static void qSetBold(QTreeWidgetItem *item, bool bold)
{
QFont font = item->font(0);
font.setBold(bold);
item->setFont(0, font);
}
void ConnectionWidget::setActive(QTreeWidgetItem *item)
{
const auto qSetBold = [](QTreeWidgetItem *item, bool bold)
{
QFont font = item->font(0);
font.setBold(bold);
item->setFont(0, font);
};
for (int i = 0; i < tree->topLevelItemCount(); ++i) {
if (tree->topLevelItem(i)->font(0).bold())
qSetBold(tree->topLevelItem(i), false);
@ -97,7 +102,7 @@ void ConnectionWidget::setActive(QTreeWidgetItem *item)
activeDb = QSqlDatabase::connectionNames().value(tree->indexOfTopLevelItem(item));
}
void ConnectionWidget::on_tree_itemActivated(QTreeWidgetItem *item, int /* column */)
void ConnectionWidget::onItemActivated(QTreeWidgetItem *item)
{
if (!item)
return;
@ -119,7 +124,7 @@ void ConnectionWidget::showMetaData()
emit metaDataRequested(cItem->text(0));
}
void ConnectionWidget::on_tree_currentItemChanged(QTreeWidgetItem *current, QTreeWidgetItem *)
void ConnectionWidget::onCurrentItemChanged(QTreeWidgetItem *current)
{
metaDataAction->setEnabled(current && current->parent());
}

9
examples/sql/sqlbrowser/connectionwidget.h
View File

@ -9,14 +9,13 @@
QT_FORWARD_DECLARE_CLASS(QTreeWidget)
QT_FORWARD_DECLARE_CLASS(QTreeWidgetItem)
QT_FORWARD_DECLARE_CLASS(QSqlDatabase)
QT_FORWARD_DECLARE_CLASS(QMenu)
class ConnectionWidget: public QWidget
class ConnectionWidget : public QWidget
{
Q_OBJECT
public:
ConnectionWidget(QWidget *parent = nullptr);
virtual ~ConnectionWidget();
~ConnectionWidget();
QSqlDatabase currentDatabase() const;
@ -27,8 +26,8 @@ signals:
public slots:
void refresh();
void showMetaData();
void on_tree_itemActivated(QTreeWidgetItem *item, int column);
void on_tree_currentItemChanged(QTreeWidgetItem *current, QTreeWidgetItem *previous);
void onItemActivated(QTreeWidgetItem *item);
void onCurrentItemChanged(QTreeWidgetItem *current);
private:
void setActive(QTreeWidgetItem *);

36
examples/sql/sqlbrowser/main.cpp
View File

@ -3,16 +3,21 @@
#include "browser.h"
#include <QtCore>
#include <QtWidgets>
#include <QtSql>
#include <QApplication>
#include <QMainWindow>
#include <QMenu>
#include <QMenuBar>
#include <QSqlError>
#include <QStatusBar>
#include <QUrl>
void addConnectionsFromCommandline(const QStringList &args, Browser *browser)
{
for (int i = 1; i < args.count(); ++i) {
QUrl url(args.at(i), QUrl::TolerantMode);
for (qsizetype i = 1; i < args.count(); ++i) {
const auto &arg = args.at(i);
const QUrl url(arg, QUrl::TolerantMode);
if (!url.isValid()) {
qWarning("Invalid URL: %s", qPrintable(args.at(i)));
qWarning("Invalid URL: %s", qPrintable(arg));
continue;
}
QSqlError err = browser->addConnection(url.scheme(), url.path().mid(1), url.host(),
@ -27,23 +32,26 @@ int main(int argc, char *argv[])
QApplication app(argc, argv);
QMainWindow mainWin;
mainWin.setWindowTitle(QObject::tr("Qt SQL Browser"));
mainWin.setWindowTitle(QApplication::translate("MainWindow", "Qt SQL Browser"));
Browser browser(&mainWin);
mainWin.setCentralWidget(&browser);
QMenu *fileMenu = mainWin.menuBar()->addMenu(QObject::tr("&File"));
fileMenu->addAction(QObject::tr("Add &Connection..."), &browser,
&Browser::openNewConnectionDialog);
fileMenu->addAction(QApplication::translate("MainWindow", "Add &Connection..."),
&browser, &Browser::openNewConnectionDialog);
fileMenu->addSeparator();
fileMenu->addAction(QObject::tr("&Quit"), qApp, &QApplication::quit);
fileMenu->addAction(QApplication::translate("MainWindow", "&Quit"),
qApp, &QApplication::quit);
QMenu *helpMenu = mainWin.menuBar()->addMenu(QObject::tr("&Help"));
helpMenu->addAction(QObject::tr("About"), &browser, &Browser::about);
helpMenu->addAction(QObject::tr("About Qt"), qApp, &QApplication::aboutQt);
helpMenu->addAction(QApplication::translate("MainWindow", "About"),
&browser, &Browser::about);
helpMenu->addAction(QApplication::translate("MainWindow", "About Qt"),
qApp, &QApplication::aboutQt);
QObject::connect(&browser, &Browser::statusMessage, &mainWin,
[&mainWin](const QString &text) { mainWin.statusBar()->showMessage(text); });
QObject::connect(&browser, &Browser::statusMessage,
&mainWin, [&mainWin](const QString &text) { mainWin.statusBar()->showMessage(text); });
addConnectionsFromCommandline(app.arguments(), &browser);
mainWin.show();

45
examples/sql/sqlbrowser/qsqlconnectiondialog.cpp
View File

@ -2,69 +2,86 @@
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
#include "qsqlconnectiondialog.h"
#include "ui_qsqlconnectiondialog.h"
#include <ui_qsqlconnectiondialog.h>
#include <QCheckBox>
#include <QMessageBox>
#include <QPushButton>
#include <QSqlDatabase>
QSqlConnectionDialog::QSqlConnectionDialog(QWidget *parent)
: QDialog(parent)
, m_ui(new Ui::QSqlConnectionDialogUi)
{
ui.setupUi(this);
m_ui->setupUi(this);
QStringList drivers = QSqlDatabase::drivers();
if (!drivers.contains("QSQLITE"))
ui.dbCheckBox->setEnabled(false);
m_ui->dbCheckBox->setEnabled(false);
ui.comboDriver->addItems(drivers);
m_ui->comboDriver->addItems(drivers);
connect(m_ui->okButton, &QPushButton::clicked,
this, &QSqlConnectionDialog::onOkButton);
connect(m_ui->cancelButton, &QPushButton::clicked,
this, &QSqlConnectionDialog::reject);
connect(m_ui->dbCheckBox, &QCheckBox::stateChanged,
this, &QSqlConnectionDialog::onDbCheckBox);
}
QSqlConnectionDialog::~QSqlConnectionDialog()
{
delete m_ui;
}
QString QSqlConnectionDialog::driverName() const
{
return ui.comboDriver->currentText();
return m_ui->comboDriver->currentText();
}
QString QSqlConnectionDialog::databaseName() const
{
return ui.editDatabase->text();
return m_ui->editDatabase->text();
}
QString QSqlConnectionDialog::userName() const
{
return ui.editUsername->text();
return m_ui->editUsername->text();
}
QString QSqlConnectionDialog::password() const
{
return ui.editPassword->text();
return m_ui->editPassword->text();
}
QString QSqlConnectionDialog::hostName() const
{
return ui.editHostname->text();
return m_ui->editHostname->text();
}
int QSqlConnectionDialog::port() const
{
return ui.portSpinBox->value();
return m_ui->portSpinBox->value();
}
bool QSqlConnectionDialog::useInMemoryDatabase() const
{
return ui.dbCheckBox->isChecked();
return m_ui->dbCheckBox->isChecked();
}
void QSqlConnectionDialog::on_okButton_clicked()
void QSqlConnectionDialog::onOkButton()
{
if (ui.comboDriver->currentText().isEmpty()) {
if (m_ui->comboDriver->currentText().isEmpty()) {
QMessageBox::information(this, tr("No database driver selected"),
tr("Please select a database driver"));
ui.comboDriver->setFocus();
m_ui->comboDriver->setFocus();
} else {
accept();
}
}
void QSqlConnectionDialog::onDbCheckBox()
{
m_ui->connGroupBox->setEnabled(!m_ui->dbCheckBox->isChecked());
}

17
examples/sql/sqlbrowser/qsqlconnectiondialog.h
View File

@ -5,11 +5,15 @@
#define QSQLCONNECTIONDIALOG_H
#include <QDialog>
#include <QMessageBox>
#include "ui_qsqlconnectiondialog.h"
QT_BEGIN_NAMESPACE
namespace Ui
{
class QSqlConnectionDialogUi;
}
QT_END_NAMESPACE
class QSqlConnectionDialog: public QDialog
class QSqlConnectionDialog : public QDialog
{
Q_OBJECT
public:
@ -25,12 +29,11 @@ public:
bool useInMemoryDatabase() const;
private slots:
void on_okButton_clicked();
void on_cancelButton_clicked() { reject(); }
void on_dbCheckBox_clicked() { ui.connGroupBox->setEnabled(!ui.dbCheckBox->isChecked()); }
void onOkButton();
void onDbCheckBox();
private:
Ui::QSqlConnectionDialogUi ui;
Ui::QSqlConnectionDialogUi *m_ui;
};
#endif