{

std::vector<sqlb::SortedColumn> vector;

vector.emplace_back(index, mode == Qt::AscendingOrder ? sqlb::Ascending : sqlb::Descending);

return vector;

: QMainWindow(parent),

ui(new Ui::MainWindow),

db(),

m_remoteDb(new RemoteDatabase),

editDock(new EditDialog(this)),

plotDock(new PlotDock(this)),

remoteDock(new RemoteDock(this)),

findReplaceDialog(new FindReplaceDialog(this)),

execute_sql_worker(nullptr),

isProjectModified(false)

{

ui->setupUi(this);

init();

activateFields(false);

updateRecentFileActions();

{

// Load window settings

tabifyDockWidget(ui->dockLog, ui->dockPlot);

tabifyDockWidget(ui->dockLog, ui->dockSchema);

tabifyDockWidget(ui->dockLog, ui->dockRemote);

#ifdef Q_OS_MACX

// Add OpenGL Context for macOS

QOpenGLWidget *ogl = new QOpenGLWidget(this);

ui->verticalLayout->addWidget(ogl);

ogl->setHidden(true);

#endif

// Automatic update check

#ifdef CHECKNEWVERSION

connect(m_remoteDb, &RemoteDatabase::networkReady, [this]() {

// Check for a new version if automatic update check aren't disabled in the settings dialog

if(Settings::getValue("checkversion", "enabled").toBool())

m_remoteDb->fetch("https://download.sqlitebrowser.org/currentrelease", RemoteDatabase::RequestTypeNewVersionCheck);

});

#endif

// Connect SQL logging and database state setting to main window

connect(&db, &DBBrowserDB::dbChanged, this, &MainWindow::dbState, Qt::QueuedConnection);

connect(&db, &DBBrowserDB::sqlExecuted, this, &MainWindow::logSql, Qt::QueuedConnection);

connect(&db, &DBBrowserDB::requestCollation, this, &MainWindow::requestCollation);

// Initialise table browser first

ui->tableBrowser->init(&db);

// Set project modified flag when the settings in the table browser were changed

connect(ui->tableBrowser, &TableBrowser::projectModified, this, [this]() {

isProjectModified = true;

});

connect(ui->tableBrowser->model(), &SqliteTableModel::dataChanged, this, &MainWindow::dataTableSelectionChanged);

connect(ui->tableBrowser, &TableBrowser::selectionChanged, this, &MainWindow::dataTableSelectionChanged);

connect(ui->tableBrowser, &TableBrowser::selectionChangedByDoubleClick, this, &MainWindow::doubleClickTable);

connect(ui->tableBrowser, &TableBrowser::updatePlot, this, &MainWindow::attachPlot);

connect(ui->tableBrowser, &TableBrowser::createView, this, &MainWindow::saveAsView);

connect(ui->tableBrowser, &TableBrowser::requestFileOpen, this, [this](const QString& file) {

fileOpen(file);

});

connect(ui->tableBrowser, &TableBrowser::statusMessageRequested, ui->statusbar, [this](const QString& message) {

ui->statusbar->showMessage(message);

});

m_currentTabTableModel = ui->tableBrowser->model();

// Set up DB structure tab

dbStructureModel = new DbStructureModel(db, this);

connect(&db, &DBBrowserDB::structureUpdated, this, [this]() {

QString old_table = QString::fromStdString(ui->tableBrowser->currentlyBrowsedTableName().name());

dbStructureModel->reloadData();

populateStructure(old_table);

});

ui->dbTreeWidget->setModel(dbStructureModel);

ui->dbTreeWidget->setColumnWidth(DbStructureModel::ColumnName, 300);

ui->dbTreeWidget->setColumnHidden(DbStructureModel::ColumnObjectType, true);

ui->dbTreeWidget->setColumnHidden(DbStructureModel::ColumnSchema, true);

// Set up DB schema dock

ui->treeSchemaDock->setModel(dbStructureModel);

ui->treeSchemaDock->setColumnHidden(DbStructureModel::ColumnObjectType, true);

ui->treeSchemaDock->setColumnHidden(DbStructureModel::ColumnSchema, true);

// Set up the table combo box in the Browse Data tab

ui->tableBrowser->setStructure(dbStructureModel);

// Create docks

ui->dockEdit->setWidget(editDock);

ui->dockPlot->setWidget(plotDock);

ui->dockRemote->setWidget(remoteDock);

// Set up edit dock

editDock->setReadOnly(true);

// Restore window geometry

restoreGeometry(Settings::getValue("MainWindow", "geometry").toByteArray());

// Save default and restore window state

defaultWindowState = saveState();

restoreState(Settings::getValue("MainWindow", "windowState").toByteArray());

// Save default and restore open tab order if the openTabs setting is saved.

defaultOpenTabs = saveOpenTabs();

restoreOpenTabs(Settings::getValue("MainWindow", "openTabs").toString());

// Restore dock state settings

ui->comboLogSubmittedBy->setCurrentIndex(ui->comboLogSubmittedBy->findText(Settings::getValue("SQLLogDock", "Log").toString()));

// Add keyboard shortcuts

QShortcut* shortcutBrowseRefreshF5 = new QShortcut(QKeySequence("F5"), this);

connect(shortcutBrowseRefreshF5, &QShortcut::activated, this, &MainWindow::refresh);

QShortcut* shortcutBrowseRefreshCtrlR = new QShortcut(QKeySequence("Ctrl+R"), this);

connect(shortcutBrowseRefreshCtrlR, &QShortcut::activated, this, &MainWindow::refresh);

// Add print shortcut for the DB Structure tab (dbTreeWidget) with context to the widget, so other print shortcuts aren't eclipsed.

QShortcut* shortcutPrint = new QShortcut(QKeySequence(QKeySequence::Print), ui->dbTreeWidget, nullptr, nullptr, Qt::WidgetShortcut);

connect(shortcutPrint, &QShortcut::activated, this, &MainWindow::printDbStructure);

QShortcut* closeTabShortcut = new QShortcut(tr("Ctrl+W"), ui->tabSqlAreas, nullptr, nullptr, Qt::WidgetWithChildrenShortcut);

connect(closeTabShortcut, &QShortcut::activated, this, [this]() {

if(ui->tabSqlAreas->currentIndex() >= 0)

closeSqlTab(ui->tabSqlAreas->currentIndex());

});

// Create the actions for the recently opened dbs list

for(int i = 0; i < MaxRecentFiles; ++i) {

recentFileActs[i] = new QAction(this);

recentFileActs[i]->setVisible(false);

connect(recentFileActs[i], &QAction::triggered, this, &MainWindow::openRecentFile);

}

for(int i = 0; i < MaxRecentFiles; ++i)

ui->fileMenu->insertAction(ui->fileExitAction, recentFileActs[i]);

recentSeparatorAct = ui->fileMenu->insertSeparator(ui->fileExitAction);

// Create popup menus

popupTableMenu = new QMenu(this);

popupTableMenu->addAction(ui->actionEditBrowseTable);

popupTableMenu->addAction(ui->editModifyObjectAction);

popupTableMenu->addAction(ui->editDeleteObjectAction);

popupTableMenu->addSeparator();

popupTableMenu->addAction(ui->actionEditCopyCreateStatement);

popupTableMenu->addAction(ui->actionExportCsvPopup);

popupSchemaDockMenu = new QMenu(this);

popupSchemaDockMenu->addAction(ui->actionPopupSchemaDockBrowseTable);

popupSchemaDockMenu->addSeparator();

popupSchemaDockMenu->addAction(ui->actionDropQualifiedCheck);

popupSchemaDockMenu->addAction(ui->actionEnquoteNamesCheck);

popupOpenDbMenu = new QMenu(this);

popupOpenDbMenu->addAction(ui->fileOpenAction);

popupOpenDbMenu->addAction(ui->fileOpenReadOnlyAction);

ui->fileOpenActionPopup->setMenu(popupOpenDbMenu);

popupSaveSqlFileMenu = new QMenu(this);

popupSaveSqlFileMenu->addAction(ui->actionSqlSaveFile);

popupSaveSqlFileMenu->addAction(ui->actionSqlSaveFileAs);

ui->actionSqlSaveFilePopup->setMenu(popupSaveSqlFileMenu);

popupSaveSqlResultsMenu = new QMenu(this);

popupSaveSqlResultsMenu->addAction(ui->actionSqlResultsExportCsv);

popupSaveSqlResultsMenu->addAction(ui->actionSqlResultsSaveAsView);

ui->actionSqlResultsSave->setMenu(popupSaveSqlResultsMenu);

qobject_cast<QToolButton*>(ui->toolbarSql->widgetForAction(ui->actionSqlResultsSave))->setPopupMode(QToolButton::InstantPopup);

// Add menu item for log dock

ui->viewMenu->insertAction(ui->viewDBToolbarAction, ui->dockLog->toggleViewAction());

ui->viewMenu->actions().at(0)->setShortcut(QKeySequence(tr("Ctrl+L")));

ui->viewMenu->actions().at(0)->setIcon(QIcon(":/icons/log_dock"));

// Add menu item for plot dock

ui->viewMenu->insertAction(ui->viewDBToolbarAction, ui->dockPlot->toggleViewAction());

ui->viewMenu->actions().at(1)->setShortcut(QKeySequence(tr("Ctrl+D")));

ui->viewMenu->actions().at(1)->setIcon(QIcon(":/icons/log_dock"));

// Add menu item for schema dock

ui->viewMenu->insertAction(ui->viewDBToolbarAction, ui->dockSchema->toggleViewAction());

ui->viewMenu->actions().at(2)->setShortcut(QKeySequence(tr("Ctrl+I")));

ui->viewMenu->actions().at(2)->setIcon(QIcon(":/icons/log_dock"));

// Add menu item for edit dock

ui->viewMenu->insertAction(ui->viewDBToolbarAction, ui->dockEdit->toggleViewAction());

ui->viewMenu->actions().at(3)->setShortcut(QKeySequence(tr("Ctrl+E")));

ui->viewMenu->actions().at(3)->setIcon(QIcon(":/icons/log_dock"));

// Add menu item for plot dock

ui->viewMenu->insertAction(ui->viewDBToolbarAction, ui->dockRemote->toggleViewAction());

ui->viewMenu->actions().at(4)->setIcon(QIcon(":/icons/log_dock"));

// Set checked state if toolbar is visible

ui->viewDBToolbarAction->setChecked(!ui->toolbarDB->isHidden());

ui->viewExtraDBToolbarAction->setChecked(!ui->toolbarExtraDB->isHidden());

ui->viewProjectToolbarAction->setChecked(!ui->toolbarProject->isHidden());

// Add separator between docks and toolbars

ui->viewMenu->insertSeparator(ui->viewDBToolbarAction);

// Connect the tabCloseRequested to the actual closeTab function.

// This must be done before the connections for checking the actions in the View menu so

// they are updated accordingly.

connect(ui->mainTab, &QTabWidget::tabCloseRequested, this, &MainWindow::closeTab);

// Add entries for toggling the visibility of main tabs

for (QWidget* widget : {ui->structure, ui->browser, ui->pragmas, ui->query}) {

QAction* action = ui->viewMenu->addAction(QIcon(":/icons/tab"), widget->accessibleName());

action->setCheckable(true);

action->setChecked(ui->mainTab->indexOf(widget) != -1);

connect(action, &QAction::toggled, [=](bool show) { toggleTabVisible(widget, show); });

// Connect tabCloseRequested for setting checked the appropiate menu entry.

// Note these are called after the actual tab is closed only because they are connected

// after connecting closeTab.

connect(ui->mainTab, &QTabWidget::tabCloseRequested, [=](int /*index*/) {

action->setChecked(ui->mainTab->indexOf(widget) != -1);

});

}

ui->viewMenu->addSeparator();

QAction* resetLayoutAction = ui->viewMenu->addAction(tr("Reset Window Layout"));

resetLayoutAction->setShortcut(QKeySequence(tr("Alt+0")));

connect(resetLayoutAction, &QAction::triggered, [=]() {

restoreState(defaultWindowState);

restoreOpenTabs(defaultOpenTabs);

});

// Set Alt+[1-4] shortcuts for opening the corresponding tab in that position.

// Note that it is safe to call setCurrentIndex with a tab that is currently closed,

// since setCurrentIndex does nothing in that case.

QShortcut* setTab1Shortcut = new QShortcut(QKeySequence("Alt+1"), this);

connect(setTab1Shortcut, &QShortcut::activated, [this]() { ui->mainTab->setCurrentIndex(0); });

QShortcut* setTab2Shortcut = new QShortcut(QKeySequence("Alt+2"), this);

connect(setTab2Shortcut, &QShortcut::activated, [this]() { ui->mainTab->setCurrentIndex(1); });

QShortcut* setTab3Shortcut = new QShortcut(QKeySequence("Alt+3"), this);

connect(setTab3Shortcut, &QShortcut::activated, [this]() { ui->mainTab->setCurrentIndex(2); });

QShortcut* setTab4Shortcut = new QShortcut(QKeySequence("Alt+4"), this);

connect(setTab4Shortcut, &QShortcut::activated, [this]() { ui->mainTab->setCurrentIndex(3); });

// If we're not compiling in SQLCipher, hide its FAQ link in the help menu

#ifndef ENABLE_SQLCIPHER

ui->actionSqlCipherFaq->setVisible(false);

#endif

// Set statusbar fields

statusBusyLabel = new QLabel(ui->statusbar);

statusBusyLabel->setEnabled(false);

statusBusyLabel->setVisible(false);

statusBusyLabel->setToolTip(tr("The database is currenctly busy."));

ui->statusbar->addPermanentWidget(statusBusyLabel);

statusStopButton = new QToolButton(ui->statusbar);

statusStopButton->setVisible(false);

statusStopButton->setIcon(QIcon(":icons/cancel"));

statusStopButton->setToolTip(tr("Click here to interrupt the currently running query."));

statusStopButton->setMaximumSize(ui->statusbar->geometry().height() - 6, ui->statusbar->geometry().height() - 6);

statusStopButton->setAutoRaise(true);

ui->statusbar->addPermanentWidget(statusStopButton);

statusEncryptionLabel = new QLabel(ui->statusbar);

statusEncryptionLabel->setEnabled(false);

statusEncryptionLabel->setVisible(false);

statusEncryptionLabel->setText(tr("Encrypted"));

statusEncryptionLabel->setToolTip(tr("Database is encrypted using SQLCipher"));

ui->statusbar->addPermanentWidget(statusEncryptionLabel);

statusReadOnlyLabel = new QLabel(ui->statusbar);

statusReadOnlyLabel->setEnabled(false);

statusReadOnlyLabel->setVisible(false);

statusReadOnlyLabel->setText(tr("Read only"));

statusReadOnlyLabel->setToolTip(tr("Database file is read only. Editing the database is disabled."));

ui->statusbar->addPermanentWidget(statusReadOnlyLabel);

statusEncodingLabel = new QLabel(ui->statusbar);

statusEncodingLabel->setEnabled(false);

statusEncodingLabel->setText("UTF-8");

statusEncodingLabel->setToolTip(tr("Database encoding"));

ui->statusbar->addPermanentWidget(statusEncodingLabel);

// When changing the text of the toolbar actions, also automatically change their icon text and their tooltip text

connect(ui->editModifyObjectAction, &QAction::changed, [=]() {

ui->editModifyObjectAction->setIconText(ui->editModifyObjectAction->text());

ui->editModifyObjectAction->setToolTip(ui->editModifyObjectAction->text());

});

connect(ui->editDeleteObjectAction, &QAction::changed, [=]() {

ui->editDeleteObjectAction->setIconText(ui->editDeleteObjectAction->text());

ui->editDeleteObjectAction->setToolTip(ui->editDeleteObjectAction->text());

});

// When clicking the interrupt query button in the status bar, ask SQLite to interrupt the current query

connect(statusStopButton, &QToolButton::clicked, [this]() {

db.interruptQuery();

});

// Connect some more signals and slots

connect(editDock, &EditDialog::recordTextUpdated, this, &MainWindow::updateRecordText);

connect(ui->dbTreeWidget->selectionModel(), &QItemSelectionModel::currentChanged, this, &MainWindow::changeTreeSelection);

connect(ui->dockEdit, &QDockWidget::visibilityChanged, this, &MainWindow::toggleEditDock);

connect(m_remoteDb, SIGNAL(openFile(QString)), this, SLOT(fileOpen(QString)));

connect(m_remoteDb, &RemoteDatabase::gotCurrentVersion, this, &MainWindow::checkNewVersion);

connect(ui->actionDropQualifiedCheck, &QAction::toggled, dbStructureModel, &DbStructureModel::setDropQualifiedNames);

connect(ui->actionEnquoteNamesCheck, &QAction::toggled, dbStructureModel, &DbStructureModel::setDropEnquotedNames);

connect(&db, &DBBrowserDB::databaseInUseChanged, this, &MainWindow::updateDatabaseBusyStatus);

ui->actionDropQualifiedCheck->setChecked(Settings::getValue("SchemaDock", "dropQualifiedNames").toBool());

ui->actionEnquoteNamesCheck->setChecked(Settings::getValue("SchemaDock", "dropEnquotedNames").toBool());

connect(ui->tableBrowser->model(), &SqliteTableModel::finishedFetch, [this](){

auto& settings = ui->tableBrowser->settings(ui->tableBrowser->currentlyBrowsedTableName());

plotDock->updatePlot(ui->tableBrowser->model(), &settings, true, false);

});

connect(ui->actionSqlStop, &QAction::triggered, [this]() {

if(execute_sql_worker && execute_sql_worker->isRunning())

execute_sql_worker->stop();

});

// Connect tool pragmas

connect(ui->actionIntegrityCheck, &QAction::triggered, [this]() {

runSqlNewTab("PRAGMA integrity_check;", ui->actionIntegrityCheck->text());

});

connect(ui->actionQuickCheck, &QAction::triggered, [this]() {

runSqlNewTab("PRAGMA quick_check;", ui->actionQuickCheck->text());

});

connect(ui->actionForeignKeyCheck, &QAction::triggered, [this]() {

runSqlNewTab("PRAGMA foreign_key_check;", ui->actionForeignKeyCheck->text());

});

connect(ui->actionOptimize, &QAction::triggered, [this]() {

runSqlNewTab("PRAGMA optimize;", ui->actionOptimize->text());

});

// Action for switching the table via the Database Structure tab

connect(ui->actionPopupSchemaDockBrowseTable, &QAction::triggered, [this]() {

sqlb::ObjectIdentifier obj(ui->treeSchemaDock->model()->data(ui->treeSchemaDock->currentIndex().sibling(ui->treeSchemaDock->currentIndex().row(), DbStructureModel::ColumnSchema), Qt::EditRole).toString().toStdString(),

ui->treeSchemaDock->model()->data(ui->treeSchemaDock->currentIndex().sibling(ui->treeSchemaDock->currentIndex().row(), DbStructureModel::ColumnName), Qt::EditRole).toString().toStdString());

switchToBrowseDataTab(obj);

refresh(); // Required in case the Browse Data tab already was the active main tab

});

// Set other window settings

setAcceptDrops(true);

setWindowTitle(QApplication::applicationName());

// Add the documentation of shortcuts, which aren't otherwise visible in the user interface, to some buttons.

addShortcutsTooltip(ui->actionDbPrint);

addShortcutsTooltip(ui->actionSqlOpenTab);

addShortcutsTooltip(ui->actionSqlPrint);

addShortcutsTooltip(ui->actionExecuteSql, {shortcutBrowseRefreshF5->key(), shortcutBrowseRefreshCtrlR->key()});

addShortcutsTooltip(ui->actionSqlExecuteLine);

addShortcutsTooltip(ui->actionSqlFind);

addShortcutsTooltip(ui->actionSqlFindReplace);

addShortcutsTooltip(ui->actionSqlToggleComment);

// Load all settings

reloadSettings();

#ifndef ENABLE_SQLCIPHER

// Only show encryption menu action when SQLCipher support is enabled

ui->actionEncryption->setVisible(false);

#endif

/* Remove all the '&' signs from the dock titles. On at least Windows and

ui->dockEdit->setWindowTitle(ui->dockEdit->windowTitle().remove('&'));

ui->dockLog->setWindowTitle(ui->dockLog->windowTitle().remove('&'));

ui->dockPlot->setWindowTitle(ui->dockPlot->windowTitle().remove('&'));

ui->dockSchema->setWindowTitle(ui->dockSchema->windowTitle().remove('&'));

ui->dockRemote->setWindowTitle(ui->dockRemote->windowTitle().remove('&'));

{

bool retval = false;

QString wFile = fileName;

// QFile::exist will produce error message if passed empty string.

// Test string length before usage w/ QFile to silence warning

if (wFile.isEmpty() || !QFile::exists(wFile))

{

wFile = FileDialog::getOpenFileName(

OpenDatabaseFile,

this,

tr("Choose a database file")

#ifndef Q_OS_MAC // Filters on OS X are buggy

, FileDialog::getSqlDatabaseFileFilter()

#endif

);

}

// catch situation where user has canceled file selection from dialog

if(!wFile.isEmpty() && QFile::exists(wFile) )

{

// Close the database. If the user didn't want to close it, though, stop here

if (db.isOpen())

if(!fileClose())

return false;

// Try opening it as a project file first

if(loadProject(wFile, readOnly))

{

retval = true;

} else {

// No project file; so it should be a database file

if(db.open(wFile, readOnly))

{

// Close all open but empty SQL tabs

for(int i=ui->tabSqlAreas->count()-1;i>=0;i--)

{

if(qobject_cast<SqlExecutionArea*>(ui->tabSqlAreas->widget(i))->getSql().trimmed().isEmpty())

closeSqlTab(i, true);

}

statusEncodingLabel->setText(db.getPragma("encoding"));

statusEncryptionLabel->setVisible(db.encrypted());

statusReadOnlyLabel->setVisible(db.readOnly());

setCurrentFile(wFile);

if(!openFromProject) {

currentProjectFilename.clear();

addToRecentFilesMenu(wFile, readOnly);

}

openSqlTab(true);

if(ui->mainTab->currentWidget() == ui->browser)

populateTable();

else if(ui->mainTab->currentWidget() == ui->pragmas)

loadPragmas();

retval = true;

} else {

QMessageBox::warning(this, qApp->applicationName(), tr("Could not open database file.\nReason: %1").arg(db.lastError()));

return false;

}

}

}

return retval;

{

QString fileName = FileDialog::getSaveFileName(

CreateDatabaseFile,

this,

tr("Choose a filename to save under"),

FileDialog::getSqlDatabaseFileFilter());

if(!fileName.isEmpty())

{

if(QFile::exists(fileName))

QFile::remove(fileName);

db.create(fileName);

setCurrentFile(fileName);

addToRecentFilesMenu(fileName);

statusEncodingLabel->setText(db.getPragma("encoding"));

statusEncryptionLabel->setVisible(false);

statusReadOnlyLabel->setVisible(false);

populateTable();

openSqlTab(true);

createTable();

}

{

db.create(":memory:");

setCurrentFile(tr("In-Memory database"));

statusEncodingLabel->setText(db.getPragma("encoding"));

statusEncryptionLabel->setVisible(false);

statusReadOnlyLabel->setVisible(false);

populateTable();

openSqlTab(true);

createTable();

{

// Refresh the structure tab

ui->dbTreeWidget->setRootIndex(dbStructureModel->index(1, 0)); // Show the 'All' part of the db structure

ui->dbTreeWidget->expandToDepth(0);

ui->treeSchemaDock->setRootIndex(dbStructureModel->index(1, 0)); // Show the 'All' part of the db structure

ui->treeSchemaDock->expandToDepth(0);

// Refresh the browse data tab

ui->tableBrowser->setStructure(dbStructureModel, old_table);

// Cancel here if no database is opened

if(!db.isOpen())

return;

// Update table and column names for syntax highlighting

SqlUiLexer::QualifiedTablesMap qualifiedTablesMap;

for(const auto& it : db.schemata)

{

SqlUiLexer::TablesAndColumnsMap tablesToColumnsMap;

for(const auto& jt : it.second)

{

if(jt.second->type() == sqlb::Object::Types::Table || jt.second->type() == sqlb::Object::Types::View)

{

QString objectname = QString::fromStdString(jt.second->name());

sqlb::FieldInfoList fi = jt.second->fieldInformation();

for(const sqlb::FieldInfo& f : fi)

tablesToColumnsMap[objectname].push_back(QString::fromStdString(f.name));

}

}

qualifiedTablesMap[QString::fromStdString(it.first)] = tablesToColumnsMap;

}

SqlTextEdit::sqlLexer->setTableNames(qualifiedTablesMap);

ui->editLogApplication->reloadKeywords();

ui->editLogUser->reloadKeywords();

for(int i=0;i<ui->tabSqlAreas->count();i++)

qobject_cast<SqlExecutionArea*>(ui->tabSqlAreas->widget(i))->getEditor()->reloadKeywords();

// Resize SQL column to fit contents

ui->dbTreeWidget->resizeColumnToContents(DbStructureModel::ColumnSQL);

ui->treeSchemaDock->resizeColumnToContents(DbStructureModel::ColumnSQL);

// Resize also the Name column in the Dock since it has usually

// short content and there is little space there.

ui->treeSchemaDock->resizeColumnToContents(DbStructureModel::ColumnName);

{

// Early exit if the Browse Data tab isn't visible as there is no need to update it in this case

if(ui->mainTab->currentWidget() != ui->browser)

return;

QApplication::setOverrideCursor(Qt::WaitCursor);

ui->tableBrowser->updateTable();

QApplication::restoreOverrideCursor();

{

// Stop any running SQL statements before closing the database

if(execute_sql_worker && execute_sql_worker->isRunning())

{

if(QMessageBox::warning(this, qApp->applicationName(),

tr("You are still executing SQL statements. When closing the database now the execution will be stopped. maybe "

"leaving the database in an incosistent state. Are you sure you want to close the database?"),

QMessageBox::Yes, QMessageBox::Cancel | QMessageBox::Default | QMessageBox::Escape) == QMessageBox::Cancel)

return false;

execute_sql_worker->stop();

execute_sql_worker->wait();

}

// Close the database but stop the closing process here if the user pressed the cancel button in there

if(!closeProject())

return false;

setWindowTitle(QApplication::applicationName());

loadPragmas();

statusEncryptionLabel->setVisible(false);

statusReadOnlyLabel->setVisible(false);

// Reset the table browser of the Browse Data tab

ui->tableBrowser->reset();

// Clear edit dock

editDock->setCurrentIndex(QModelIndex());

activateFields(false);

// Clear the SQL Log

ui->editLogApplication->clear();

ui->editLogUser->clear();

ui->editLogErrorLog->clear();

// Remove completion and highlighting for identifiers

SqlTextEdit::sqlLexer->setTableNames(SqlUiLexer::QualifiedTablesMap());

for(int i=0; i < ui->tabSqlAreas->count(); i++)

qobject_cast<SqlExecutionArea*>(ui->tabSqlAreas->widget(i))->getEditor()->reloadKeywords();

return true;

{

if(closeFiles())

{

Settings::setValue("MainWindow", "geometry", saveGeometry());

Settings::setValue("MainWindow", "windowState", saveState());

Settings::setValue("MainWindow", "openTabs", saveOpenTabs());

Settings::setValue("SQLLogDock", "Log", ui->comboLogSubmittedBy->currentText());

Settings::setValue("SchemaDock", "dropQualifiedNames", ui->actionDropQualifiedCheck->isChecked());

Settings::setValue("SchemaDock", "dropEnquotedNames", ui->actionEnquoteNamesCheck->isChecked());

SqlExecutionArea::saveState();

QMainWindow::closeEvent(event);

} else {

event->ignore();

}

{

bool ignoreUnattachedBuffers = false;

// Ask for saving all modified open SQL files in their files and all the unattached tabs in a project file.

for(int i=0; i<ui->tabSqlAreas->count(); i++)

// Ask for saving and comply with cancel answer.

if(!askSaveSqlTab(i, ignoreUnattachedBuffers))

return false;

return closeProject();

{

if(!currentProjectFilename.isEmpty() && isProjectModified) {

QMessageBox::StandardButton reply = QMessageBox::question

(nullptr,

QApplication::applicationName(),

tr("Do you want to save the changes made to the project file %1?").

arg(QFileInfo(currentProjectFilename).fileName()),

QMessageBox::Save | QMessageBox::No | QMessageBox::Cancel);

switch(reply) {

case QMessageBox::Save:

saveProject();

break;

case QMessageBox::Cancel:

return false;

default:

break;

}

}

currentProjectFilename.clear();

return db.close();

{

plotDock->updatePlot(model, settings, true, keepOrResetSelection);

// Disconnect previous connection

disconnect(plotDock, SIGNAL(pointsSelected(int,int)), nullptr, nullptr);

if(tableWidget) {

// Connect plot selection to the current table results widget.

connect(plotDock, SIGNAL(pointsSelected(int,int)), tableWidget, SLOT(selectTableLines(int, int)));

connect(tableWidget, &ExtendedTableWidget::destroyed, plotDock, &PlotDock::resetPlot);

}

{

// What the Refresh function does depends on the currently active tab. This way the keyboard shortcuts (F5 and Ctrl+R)

// always perform some meaningful task; they just happen to be context dependent in the function they trigger.

QWidget* currentTab = ui->mainTab->currentWidget();

if (currentTab == ui->structure) {

// Refresh the schema

db.updateSchema();

} else if (currentTab == ui->browser) {

// Refresh the schema and reload the current table

db.updateSchema();

populateTable();

} else if (currentTab == ui->pragmas) {

// Reload pragma values

loadPragmas();

} else if (currentTab == ui->query) {

// (Re-)Run the current SQL query

executeQuery();

}

{

EditTableDialog dialog(db, sqlb::ObjectIdentifier(), true, this);

if(dialog.exec())

{

populateTable();

}

{

EditIndexDialog dialog(db, sqlb::ObjectIdentifier(), true, this);

if(dialog.exec())

populateTable();

{

VacuumDialog dialog(&db, this);

dialog.exec();

{

// Get name and type of object to delete

sqlb::ObjectIdentifier name(ui->dbTreeWidget->model()->data(ui->dbTreeWidget->currentIndex().sibling(ui->dbTreeWidget->currentIndex().row(), DbStructureModel::ColumnSchema), Qt::EditRole).toString().toStdString(),

ui->dbTreeWidget->model()->data(ui->dbTreeWidget->currentIndex().sibling(ui->dbTreeWidget->currentIndex().row(), DbStructureModel::ColumnName), Qt::EditRole).toString().toStdString());

QString type = ui->dbTreeWidget->model()->data(ui->dbTreeWidget->currentIndex().sibling(ui->dbTreeWidget->currentIndex().row(), DbStructureModel::ColumnObjectType), Qt::EditRole).toString();

// Due to different grammar in languages (e.g. gender or declension), each message must be given separately to translation.

QString message;

if (type == "table")

message = tr("Are you sure you want to delete the table '%1'?\nAll data associated with the table will be lost.");

else if (type == "view")

message = tr("Are you sure you want to delete the view '%1'?");

else if (type == "trigger")

message = tr("Are you sure you want to delete the trigger '%1'?");

else if (type == "index")

message = tr("Are you sure you want to delete the index '%1'?");

// Ask user if he really wants to delete that table

if(QMessageBox::warning(this, QApplication::applicationName(), message.arg(QString::fromStdString(name.name())),

QMessageBox::Yes | QMessageBox::No, QMessageBox::No) == QMessageBox::Yes)

{

// Delete the table

QString statement = QString("DROP %1 %2;").arg(type.toUpper(), QString::fromStdString(name.toString()));

if(!db.executeSQL(statement.toStdString()))

{

if (type == "table")

message = tr("Error: could not delete the table.");

else if (type == "view")

message = tr("Error: could not delete the view.");

else if (type == "trigger")

message = tr("Error: could not delete the trigger.");

else if (type == "index")

message = tr("Error: could not delete the index.");

QString error = tr("Message from database engine:\n%1").arg(db.lastError());

QMessageBox::warning(this, QApplication::applicationName(), message + " " + error);

} else {

populateTable();

changeTreeSelection();

}

}

{

if(!ui->dbTreeWidget->selectionModel()->hasSelection())

return;

// Get name and type of the object to edit

sqlb::ObjectIdentifier name(ui->dbTreeWidget->model()->data(ui->dbTreeWidget->currentIndex().sibling(ui->dbTreeWidget->currentIndex().row(), DbStructureModel::ColumnSchema), Qt::EditRole).toString().toStdString(),

ui->dbTreeWidget->model()->data(ui->dbTreeWidget->currentIndex().sibling(ui->dbTreeWidget->currentIndex().row(), DbStructureModel::ColumnName), Qt::EditRole).toString().toStdString());

QString type = ui->dbTreeWidget->model()->data(ui->dbTreeWidget->currentIndex().sibling(ui->dbTreeWidget->currentIndex().row(), DbStructureModel::ColumnObjectType), Qt::EditRole).toString();

if(type == "table")

{

// For a safe and possibly complex table modification we must follow the steps documented in

// https://www.sqlite.org/lang_altertable.html

// Paragraph (first procedure): Making Other Kinds Of Table Schema Changes

QString foreign_keys = db.getPragma("foreign_keys");

if (foreign_keys == "1") {

if(db.getDirty() && QMessageBox::question(this,

QApplication::applicationName(),

tr("Editing the table requires to save all pending changes now.\nAre you sure you want to save the database?"),

QMessageBox::Save | QMessageBox::Default,

QMessageBox::Cancel | QMessageBox::Escape) != QMessageBox::Save)

return;

// Commit all changes so the foreign_keys can be effective.

fileSave();

db.setPragma("foreign_keys", "0");

}

EditTableDialog dialog(db, name, false, this);

bool ok = dialog.exec();

// If foreign_keys were enabled, we must commit or rollback the transaction so the foreign_keys pragma can be restored.

if (foreign_keys == "1") {

if (!db.querySingleValueFromDb("PRAGMA " + sqlb::escapeIdentifier(name.schema()) + ".foreign_key_check").isNull()) {

// Raise warning for accepted modification. When rejected, warn user also since we know now that the table has problems,

// but it wasn't our fault.

if (ok)

QMessageBox::warning(this, QApplication::applicationName(),

tr("Error checking foreign keys after table modification. The changes will be reverted."));

else

QMessageBox::warning(this, QApplication::applicationName(),

tr("This table did not pass a foreign-key check.<br/>"

"You should run 'Tools | Foreign-Key Check' and fix the reported issues."));

db.revertAll();

} else {

// Commit all changes so the foreign_keys can be effective.

fileSave();

}

db.setPragma("foreign_keys", foreign_keys);

}

if(ok) {

ui->tableBrowser->clearFilters();

populateTable();

}

} else if(type == "index") {

EditIndexDialog dialog(db, name, false, this);

if(dialog.exec())

populateTable();

}

{

AboutDialog dialog(this);

dialog.exec();

{

if (!visible) {

// Update main window

ui->tableBrowser->setFocus();

} else {

// fill edit dock with actual data

editDock->setCurrentIndex(ui->tableBrowser->currentIndex());

}

{

// Cancel on invalid index

if (!index.isValid()) {

return;

}

// * Don't allow editing of other objects than tables and editable views

bool isEditingAllowed = !db.readOnly() && m_currentTabTableModel == ui->tableBrowser->model() &&

ui->tableBrowser->model()->isEditable();

// Enable or disable the Apply, Null, & Import buttons in the Edit Cell

// dock depending on the value of the "isEditingAllowed" bool above

editDock->setReadOnly(!isEditingAllowed);

editDock->setCurrentIndex(index);

// Show the edit dock

ui->dockEdit->setVisible(true);

// Set focus on the edit dock

editDock->setFocus();

{

// Cancel on invalid index

if(!index.isValid()) {

editDock->setCurrentIndex(QModelIndex());

return;

}

bool editingAllowed = !db.readOnly() && (m_currentTabTableModel == ui->tableBrowser->model()) &&

ui->tableBrowser->model()->isEditable();

// Don't allow editing of other objects than tables and editable views

editDock->setReadOnly(!editingAllowed);

// If the Edit Cell dock is visible, load the new value into it

if (editDock->isVisible()) {

editDock->setCurrentIndex(index);

}

{

// Make sure a database is opened. This is necessary because we allow opened SQL editor tabs even if no database is loaded. Hitting F5 or similar

// then might call this function.

if(!db.isOpen())

return;

// Check if other task is still running and stop it if necessary

if(execute_sql_worker && execute_sql_worker->isRunning())

{

// Ask the user and do nothing if he/she doesn't want to interrupt the running query

if(QMessageBox::warning(this, qApp->applicationName(),

tr("You are already executing SQL statements. Do you want to stop them in order to execute the current "

"statements instead? Note that this might leave the database in an inconsistent state."),

QMessageBox::Yes, QMessageBox::Cancel | QMessageBox::Default | QMessageBox::Escape) == QMessageBox::Cancel)

return;

// Stop the running query

execute_sql_worker->stop();

execute_sql_worker->wait();

}

// Get current SQL tab and editor

SqlExecutionArea* sqlWidget = qobject_cast<SqlExecutionArea*>(ui->tabSqlAreas->currentWidget());

SqlTextEdit* editor = sqlWidget->getEditor();

auto* current_tab = ui->tabSqlAreas->currentWidget();

const QString tabName = ui->tabSqlAreas->tabText(ui->tabSqlAreas->currentIndex()).remove('&');

// Remove any error indicators

editor->clearErrorIndicators();

// Determine execution mode: execute all, execute selection or execute current line

enum executionMode