#include "MainWindow.h"

#include "ui_MainWindow.h"

#include "Application.h"

#include "EditIndexDialog.h"

#include "AboutDialog.h"

#include "EditTableDialog.h"

#include "AddRecordDialog.h"

#include "ImportCsvDialog.h"

#include "ExportDataDialog.h"

#include "Settings.h"

#include "PreferencesDialog.h"

#include "EditDialog.h"

#include "sqlitetablemodel.h"

#include "SqlExecutionArea.h"

#include "VacuumDialog.h"

#include "DbStructureModel.h"

#include "version.h"

#include "sqlite.h"

#include "CipherDialog.h"

#include "ExportSqlDialog.h"

#include "SqlUiLexer.h"

#include "FileDialog.h"

#include "ColumnDisplayFormatDialog.h"

#include "FilterTableHeader.h"

#include "RemoteDock.h"

#include "RemoteDatabase.h"

#include "FindReplaceDialog.h"

#include "Data.h"

#include "CondFormat.h"

#include "CondFormatManager.h"

#include "RunSql.h"

#include <chrono>

#include <QFile>

#include <QApplication>

#include <QTextStream>

#include <QWhatsThis>

#include <QMessageBox>

#include <QStandardItemModel>

#include <QPersistentModelIndex>

#include <QDragEnterEvent>

#include <QScrollBar>

#include <QSortFilterProxyModel>

#include <QMimeData>

#include <QColorDialog>

#include <QDesktopServices>

#include <QXmlStreamReader>

#include <QXmlStreamWriter>

#include <QInputDialog>

#include <QProgressDialog>

#include <QTextEdit>

#include <QClipboard>

#include <QShortcut>

#include <QTextCodec>

#include <QUrlQuery>

#include <QDataStream> // This include seems to only be necessary for the Windows build

#include <QPrinter>

#include <QPrintPreviewDialog>

#ifdef Q_OS_MACX //Needed only on macOS

#include <QOpenGLWidget>

#endif

#include <limits>

const int MainWindow::MaxRecentFiles;

// These are needed for reading and writing object files

QDataStream& operator>>(QDataStream& ds, sqlb::ObjectIdentifier& objid)

{

// Read in the item

QVariant v;

ds >> v;

// If it is a string list, we can treat it as an object identifier. If it isn't, we assume it's just a

// single string and use interpret it as the table name in the main schema. This is done for backwards

// compatability with old project file formats.

QStringList str = v.toStringList();

if(str.isEmpty())

{

objid = sqlb::ObjectIdentifier("main", v.toString().toStdString());

} else {

objid.setSchema(str.first().toStdString());

if(str.size() >= 2)

objid.setName(str.last().toStdString());

}

return ds;

}

// This is a temporary helper function. Delete it once we clean up the project file loading.

static std::vector<sqlb::SortedColumn> toSortOrderVector(int index, Qt::SortOrder mode)

{

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

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

return vector;

}

MainWindow::MainWindow(QWidget* parent)

: QMainWindow(parent),

ui(new Ui::MainWindow),

db(),

m_browseTableModel(new SqliteTableModel(db, this, static_cast<std::size_t>(Settings::getValue("db", "prefetchsize").toUInt()))),

m_currentTabTableModel(m_browseTableModel),

m_remoteDb(new RemoteDatabase),

editDock(new EditDialog(this)),

plotDock(new PlotDock(this)),

remoteDock(new RemoteDock(this)),

findReplaceDialog(new FindReplaceDialog(this)),

gotoValidator(new QIntValidator(0, 0, this)),

execute_sql_worker(nullptr),

isProjectModified(false)

{

ui->setupUi(this);

init();

activateFields(false);

updateRecentFileActions();

}

MainWindow::~MainWindow()

{

delete m_remoteDb;

delete gotoValidator;

delete ui;

}

// Functions for documenting the shortcuts in the user interface using native names

static QString shortcutsTip(const QList<QKeySequence>& keys)

{

QString tip("");

if (!keys.isEmpty()) {

tip = " [";

for (auto shortcut : keys)

tip.append(shortcut.toString(QKeySequence::NativeText) + ", ");

tip.chop(2);

tip.append("]");

}

return tip;

}

static void addShortcutsTooltip(QAction* action, const QList<QKeySequence>& extraKeys = QList<QKeySequence>())

{

if (!action->shortcuts().isEmpty() || !extraKeys.isEmpty())

action->setToolTip(action->toolTip() + shortcutsTip(action->shortcuts() + extraKeys));

}

void MainWindow::init()

{

// 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->horizontalLayout->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);

// Set the validator for the goto line edit

ui->editGoto->setValidator(gotoValidator);

// Set up filters

connect(ui->dataTable->filterHeader(), SIGNAL(filterChanged(int,QString)), this, SLOT(updateFilter(int,QString)));

connect(ui->dataTable->filterHeader(), SIGNAL(addCondFormat(int,QString)), this, SLOT(addCondFormat(int,QString)));

connect(ui->dataTable->filterHeader(), SIGNAL(clearAllCondFormats(int)), this, SLOT(clearAllCondFormats(int)));

connect(ui->dataTable->filterHeader(), SIGNAL(editCondFormats(int)), this, SLOT(editCondFormats(int)));

connect(ui->dataTable, SIGNAL(editCondFormats(int)), this, SLOT(editCondFormats(int)));

connect(m_browseTableModel, SIGNAL(dataChanged(QModelIndex,QModelIndex)), this, SLOT(dataTableSelectionChanged(QModelIndex)));

// Select in table the rows correspoding to the selected points in plot

connect(plotDock, SIGNAL(pointsSelected(int,int)), ui->dataTable, SLOT(selectTableLines(int,int)));

// Set up DB structure tab

dbStructureModel = new DbStructureModel(db, this);

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

// TODO This needs to be a queued connection because the schema can be updated from different threads than the main thread.

// However, this makes calling this lambda asynchronous which can lead to unexpected results. One example is that opening a database,

// changing to the Browse Data tab, and then opening another database makes the table browser try to load the old table because the table

// list wasn't updated yet.

QString old_table = ui->comboBrowseTable->currentText();

dbStructureModel->reloadData();

populateStructure(old_table);

}, Qt::QueuedConnection);

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->comboBrowseTable->setModel(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, SIGNAL(activated()), this, SLOT(refresh()));

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

connect(shortcutBrowseRefreshCtrlR, SIGNAL(activated()), this, SLOT(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);

// 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);

popupNewRecordMenu = new QMenu(this);

popupNewRecordMenu->addAction(ui->newRecordAction);

popupNewRecordMenu->addAction(ui->insertValuesAction);

ui->actionNewRecord->setMenu(popupNewRecordMenu);

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);

popupSaveFilterAsMenu = new QMenu(this);

popupSaveFilterAsMenu->addAction(ui->actionFilteredTableExportCsv);

popupSaveFilterAsMenu->addAction(ui->actionFilterSaveAsView);

ui->actionSaveFilterAsPopup->setMenu(popupSaveFilterAsMenu);

qobject_cast<QToolButton*>(ui->browseToolbar->widgetForAction(ui->actionSaveFilterAsPopup))->setPopupMode(QToolButton::InstantPopup);

popupBrowseDataHeaderMenu = new QMenu(this);

popupBrowseDataHeaderMenu->addAction(ui->actionShowRowidColumn);

popupBrowseDataHeaderMenu->addAction(ui->actionHideColumns);

popupBrowseDataHeaderMenu->addAction(ui->actionShowAllColumns);

popupBrowseDataHeaderMenu->addSeparator();

popupBrowseDataHeaderMenu->addAction(ui->actionUnlockViewEditing);

popupBrowseDataHeaderMenu->addAction(ui->actionBrowseTableEditDisplayFormat);

popupBrowseDataHeaderMenu->addSeparator();

popupBrowseDataHeaderMenu->addAction(ui->actionSetTableEncoding);

popupBrowseDataHeaderMenu->addAction(ui->actionSetAllTablesEncoding);

QShortcut* dittoRecordShortcut = new QShortcut(QKeySequence("Ctrl+\""), this);

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

int currentRow = ui->dataTable->currentIndex().row();

duplicateRecord(currentRow);

});

// 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(ui->dataTable->filterHeader(), SIGNAL(sectionClicked(int)), this, SLOT(browseTableHeaderClicked(int)));

connect(ui->dataTable->filterHeader(), &QHeaderView::sectionDoubleClicked, ui->dataTable, &QTableView::selectColumn);

connect(ui->dataTable->verticalScrollBar(), SIGNAL(valueChanged(int)), this, SLOT(setRecordsetLabel()));

connect(ui->dataTable->horizontalHeader(), SIGNAL(sectionResized(int,int,int)), this, SLOT(updateBrowseDataColumnWidth(int,int,int)));

connect(editDock, SIGNAL(recordTextUpdated(QPersistentModelIndex, QByteArray, bool)), this, SLOT(updateRecordText(QPersistentModelIndex, QByteArray, bool)));

connect(ui->dbTreeWidget->selectionModel(), SIGNAL(currentChanged(QModelIndex,QModelIndex)), this, SLOT(changeTreeSelection()));

connect(ui->dataTable->horizontalHeader(), SIGNAL(customContextMenuRequested(QPoint)), this, SLOT(showDataColumnPopupMenu(QPoint)));

connect(ui->dataTable->verticalHeader(), SIGNAL(customContextMenuRequested(QPoint)), this, SLOT(showRecordPopupMenu(QPoint)));

connect(ui->dataTable, SIGNAL(openFileFromDropEvent(QString)), this, SLOT(fileOpen(QString)));

connect(ui->dockEdit, SIGNAL(visibilityChanged(bool)), this, SLOT(toggleEditDock(bool)));

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

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

connect(m_browseTableModel, &SqliteTableModel::finishedFetch, this, &MainWindow::setRecordsetLabel);

connect(ui->dataTable, &ExtendedTableWidget::selectedRowsToBeDeleted, this, &MainWindow::deleteRecord);

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(m_browseTableModel, &SqliteTableModel::finishedFetch, [this](){

auto & settings = browseTableSettings[currentlyBrowsedTableName()];

plotDock->updatePlot(m_browseTableModel, &settings, true, false);

});

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

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

execute_sql_worker->stop();

});

// Lambda function for keyboard shortcuts for selecting next/previous table in Browse Data tab

connect(ui->dataTable, &ExtendedTableWidget::switchTable, [this](bool next) {

int index = ui->comboBrowseTable->currentIndex();

int num_items = ui->comboBrowseTable->count();

if(next)

{

if(++index >= num_items)

index = 0;

} else {

if(--index < 0)

index = num_items - 1;

}

ui->comboBrowseTable->setCurrentIndex(index);

populateTable();

});

// 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());

QString tableToBrowse = QString::fromStdString(obj.toDisplayString());

switchToBrowseDataTab(tableToBrowse);

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->actionRefresh, {shortcutBrowseRefreshCtrlR->key()});

addShortcutsTooltip(ui->actionPrintTable);

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

* OSX, Qt doesn't seem to support them properly, so they end up being

* visible instead of creating a keyboard shortcut

*/

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 MainWindow::fileOpen(const QString& fileName, bool openFromProject, bool readOnly)

{

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;

}

void MainWindow::fileNew()

{

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();

}

}

void MainWindow::fileNewInMemoryDatabase()

{

db.create(":memory:");

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

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

statusEncryptionLabel->setVisible(false);

statusReadOnlyLabel->setVisible(false);

populateTable();

openSqlTab(true);

createTable();

}

void MainWindow::populateStructure(const QString& old_table)

{

// 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->comboBrowseTable->setRootModelIndex(dbStructureModel->index(0, 0)); // Show the 'browsable' section of the db structure tree

int old_table_index = ui->comboBrowseTable->findText(old_table);

if(old_table_index == -1 && ui->comboBrowseTable->count()) // If the old table couldn't be found anymore but there is another table, select that

ui->comboBrowseTable->setCurrentIndex(0);

else if(old_table_index == -1) // If there aren't any tables to be selected anymore, clear the table view

clearTableBrowser();

else // Under normal circumstances just select the old table again

ui->comboBrowseTable->setCurrentIndex(old_table_index);

// 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;

objectMap tab = db.getBrowsableObjects(it.first);

for(const auto& jt : tab)

{

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);

}

void MainWindow::clearTableBrowser()

{

if (!ui->dataTable->model())

return;

ui->dataTable->setModel(nullptr);

if(qobject_cast<FilterTableHeader*>(ui->dataTable->horizontalHeader()))

qobject_cast<FilterTableHeader*>(ui->dataTable->horizontalHeader())->generateFilters(0);

}

void MainWindow::populateTable()

{

// 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;

// Remove the model-view link if the table name is empty in order to remove any data from the view

if(ui->comboBrowseTable->model()->rowCount(ui->comboBrowseTable->rootModelIndex()) == 0)

{

clearTableBrowser();

return;

}

QApplication::setOverrideCursor(Qt::WaitCursor);

// Restore default value that could have been modified in updateFilter or browseTableHeaderClicked

ui->dataTable->verticalHeader()->setMinimumWidth(0);

// Get current table name

sqlb::ObjectIdentifier tablename = currentlyBrowsedTableName();

// Set model

bool reconnectSelectionSignals = false;

if(ui->dataTable->model() == nullptr)

reconnectSelectionSignals = true;

ui->dataTable->setModel(m_browseTableModel);

if(reconnectSelectionSignals)

{

connect(ui->dataTable->selectionModel(), SIGNAL(currentChanged(QModelIndex,QModelIndex)), this, SLOT(dataTableSelectionChanged(QModelIndex)));

connect(ui->dataTable->selectionModel(), &QItemSelectionModel::selectionChanged, [this](const QItemSelection&, const QItemSelection&) {

updateInsertDeleteRecordButton();

const QModelIndexList& sel = ui->dataTable->selectionModel()->selectedIndexes();

QString statusMessage;

if (sel.count() > 1) {

int rows = sel.last().row() - sel.first().row() + 1;

statusMessage = tr("%n row(s)", "", rows);

int columns = sel.last().column() - sel.first().column() + 1;

statusMessage += tr(", %n column(s)", "", columns);

if (sel.count() < Settings::getValue("databrowser", "complete_threshold").toInt()) {

double sum = 0;

double first = m_browseTableModel->data(sel.first(), Qt::EditRole).toDouble();

double min = first;

double max = first;

for (const QModelIndex& index : sel) {

double dblData = m_browseTableModel->data(index, Qt::EditRole).toDouble();

sum += dblData;

min = std::min(min, dblData);

max = std::max(max, dblData);

}

statusMessage += tr(". Sum: %1; Average: %2; Min: %3; Max: %4").arg(sum).arg(sum/sel.count()).arg(min).arg(max);

}

};

ui->statusbar->showMessage(statusMessage);

});

}

// Search stored table settings for this table

bool storedDataFound = browseTableSettings.contains(tablename);

// Set new table

if(!storedDataFound)

{

// No stored settings found.

// Set table name and apply default display format settings

m_browseTableModel->setQuery(sqlb::Query(tablename));

// There aren't any information stored for this table yet, so use some default values

// Hide rowid column. Needs to be done before the column widths setting because of the workaround in there

showRowidColumn(false);

// Unhide all columns by default

on_actionShowAllColumns_triggered();

// Enable editing in general, but lock view editing

unlockViewEditing(false);

// Column widths

for(int i=1;i<m_browseTableModel->columnCount();i++)

ui->dataTable->setColumnWidth(i, ui->dataTable->horizontalHeader()->defaultSectionSize());

// Encoding

m_browseTableModel->setEncoding(defaultBrowseTableEncoding);

setRecordsetLabel();

// Plot

attachPlot(ui->dataTable, m_browseTableModel, &browseTableSettings[tablename]);

// The filters can be left empty as they are

} else {

// Stored settings found. Retrieve them and assemble a query from them.

BrowseDataTableSettings storedData = browseTableSettings[tablename];

sqlb::Query query(tablename);

// Sorting

query.setOrderBy(storedData.query.orderBy());

// Filters

for(auto it=storedData.filterValues.constBegin();it!=storedData.filterValues.constEnd();++it)

query.where().insert({it.key(), CondFormat::filterToSqlCondition(it.value(), m_browseTableModel->encoding()).toStdString()});

// Display formats

bool only_defaults = true;

if(db.getObjectByName(tablename))

{

const sqlb::FieldInfoList& tablefields = db.getObjectByName(tablename)->fieldInformation();

for(size_t i=0; i<tablefields.size(); ++i)

{

QString format = storedData.displayFormats[static_cast<int>(i)+1];

if(format.size())

{

query.selectedColumns().emplace_back(tablefields.at(i).name, format.toStdString());

only_defaults = false;

} else {

query.selectedColumns().emplace_back(tablefields.at(i).name, tablefields.at(i).name);

}

}

}

if(only_defaults)

query.selectedColumns().clear();

// Unlock view editing

query.setRowIdColumn(storedData.unlockViewPk.toStdString());

// Apply query

m_browseTableModel->setQuery(query);

// There is information stored for this table, so extract it and apply it

applyBrowseTableSettings(storedData);

setRecordsetLabel();

// Plot

attachPlot(ui->dataTable, m_browseTableModel, &browseTableSettings[tablename], false);

}

// Show/hide menu options depending on whether this is a table or a view

if(db.getObjectByName(currentlyBrowsedTableName()) && db.getObjectByName(currentlyBrowsedTableName())->type() == sqlb::Object::Table)

{

// Table

sqlb::TablePtr table = db.getObjectByName<sqlb::Table>(currentlyBrowsedTableName());

ui->actionUnlockViewEditing->setVisible(false);

ui->actionShowRowidColumn->setVisible(!table->withoutRowidTable());

} else {

// View

ui->actionUnlockViewEditing->setVisible(true);

ui->actionShowRowidColumn->setVisible(false);

}

updateInsertDeleteRecordButton();

QApplication::restoreOverrideCursor();

}

void MainWindow::applyBrowseTableSettings(const BrowseDataTableSettings& storedData, bool skipFilters)

{

// We don't want to pass storedData by reference because the functions below would change the referenced data in their original

// place, thus modifiying the data this function can use. To have a static description of what the view should look like we want

// a copy here.

// Show rowid column. Needs to be done before the column widths setting because of the workaround in there and before the filter setting

// because of the filter row generation.

showRowidColumn(storedData.showRowid, skipFilters);

// Enable editing in general and (un)lock view editing depending on the settings

unlockViewEditing(!storedData.unlockViewPk.isEmpty(), storedData.unlockViewPk);

// Column hidden status

on_actionShowAllColumns_triggered();

for(auto hiddenIt=storedData.hiddenColumns.constBegin();hiddenIt!=storedData.hiddenColumns.constEnd();++hiddenIt)

hideColumns(hiddenIt.key(), hiddenIt.value());

// Column widths

for(auto widthIt=storedData.columnWidths.constBegin();widthIt!=storedData.columnWidths.constEnd();++widthIt)

ui->dataTable->setColumnWidth(widthIt.key(), widthIt.value());

// Filters

if(!skipFilters)

{

// Set filters blocking signals, since the filter is already applied to the browse table model

FilterTableHeader* filterHeader = qobject_cast<FilterTableHeader*>(ui->dataTable->horizontalHeader());

bool oldState = filterHeader->blockSignals(true);

for(auto filterIt=storedData.filterValues.constBegin();filterIt!=storedData.filterValues.constEnd();++filterIt)

filterHeader->setFilter(static_cast<size_t>(filterIt.key()), filterIt.value());

// Conditional formats

for(auto formatIt=storedData.condFormats.constBegin(); formatIt!=storedData.condFormats.constEnd(); ++formatIt)

m_browseTableModel->setCondFormats(formatIt.key(), formatIt.value());

filterHeader->blockSignals(oldState);

}

// Encoding

m_browseTableModel->setEncoding(storedData.encoding);

}

bool MainWindow::fileClose()

{

// 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 model for the Browse tab

m_browseTableModel->reset();

// Remove all stored table information browse data tab

browseTableSettings.clear();

defaultBrowseTableEncoding = QString();

// Clear edit dock

editDock->setCurrentIndex(QModelIndex());

// Reset the recordset label inside the Browse tab now

setRecordsetLabel();

// Reset the plot dock model and connection

attachPlot(nullptr, nullptr);

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;

}

void MainWindow::closeEvent( QCloseEvent* event )

{

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 MainWindow::closeFiles()

{

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();