#include "MainWindow.h"

#include "ui_MainWindow.h"

#include "EditIndexDialog.h"

#include "AboutDialog.h"

#include "EditTableDialog.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 <QFile>

#include <QApplication>

#include <QTextStream>

#include <QWhatsThis>

#include <QMessageBox>

#include <QStandardItemModel>

#include <QPersistentModelIndex>

#include <QDragEnterEvent>

#include <QScrollBar>

#include <QSortFilterProxyModel>

#include <QElapsedTimer>

#include <QMimeData>

#include <QColorDialog>

#include <QDesktopServices>

#include <QXmlStreamReader>

#include <QXmlStreamWriter>

#include <QInputDialog>

#include <QProgressDialog>

#include <QTextEdit>

#include <QClipboard>

#include <QShortcut>

#include <QTextCodec>

#include <QOpenGLWidget>

MainWindow::MainWindow(QWidget* parent)

: QMainWindow(parent),

ui(new Ui::MainWindow),

m_browseTableModel(new SqliteTableModel(db, this, Settings::getValue("db", "prefetchsize").toInt())),

m_currentTabTableModel(m_browseTableModel),

m_remoteDb(new RemoteDatabase),

editDock(new EditDialog(this)),

plotDock(new PlotDock(this)),

remoteDock(new RemoteDock(this)),

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

{

ui->setupUi(this);

init();

activateFields(false);

updateRecentFileActions();

}

MainWindow::~MainWindow()

{

delete m_remoteDb;

delete gotoValidator;

delete ui;

}

void MainWindow::init()

{

// Load window settings

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

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

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

// Add OpenGL Context for macOS

#ifdef Q_OS_MACX

QOpenGLWidget *ogl = new QOpenGLWidget(this);

ui->horizontalLayout->addWidget(ogl);

ogl->setHidden(true);

#endif

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

connect(&db, SIGNAL(dbChanged(bool)), this, SLOT(dbState(bool)));

connect(&db, SIGNAL(sqlExecuted(QString, int)), this, SLOT(logSql(QString,int)));

connect(&db, SIGNAL(structureUpdated()), this, SLOT(populateStructure()));

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(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)), this, SLOT(selectTableLines(int,int)));

// Set up DB structure tab

dbStructureModel = new DbStructureModel(db, this);

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->setColumnWidth(DbStructureModel::ColumnName, 300);

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

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

// Restore dock state settings

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

// Add keyboard shortcuts

QList<QKeySequence> shortcuts = ui->actionExecuteSql->shortcuts();

shortcuts.push_back(QKeySequence(tr("Ctrl+Return")));

ui->actionExecuteSql->setShortcuts(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()));

// 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], SIGNAL(triggered()), this, SLOT(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);

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

popupBrowseDataHeaderMenu = new QMenu(this);

popupBrowseDataHeaderMenu->addAction(ui->actionShowRowidColumn);

popupBrowseDataHeaderMenu->addAction(ui->actionUnlockViewEditing);

popupBrowseDataHeaderMenu->addAction(ui->actionBrowseTableEditDisplayFormat);

popupBrowseDataHeaderMenu->addAction(ui->actionSetTableEncoding);

popupBrowseDataHeaderMenu->addSeparator();

popupBrowseDataHeaderMenu->addAction(ui->actionSetAllTablesEncoding);

popupBrowseDataHeaderMenu->addAction(ui->actionHideColumns);

popupBrowseDataHeaderMenu->addAction(ui->actionShowAllColumns);

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

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

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

auto row = m_browseTableModel->dittoRecord(currentRow);

ui->dataTable->setCurrentIndex(row);

});

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

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

// Add menu item for plot dock

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

QList<QKeySequence> plotkeyseqlist;

plotkeyseqlist << QKeySequence(tr("Ctrl+P")) << QKeySequence(tr("Ctrl+D"));

ui->viewMenu->actions().at(1)->setShortcuts(plotkeyseqlist);

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

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

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

// Connect some more signals and slots

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

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

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

});

// Set other window settings

setAcceptDrops(true);

setWindowTitle(QApplication::applicationName());

// Load all settings

reloadSettings();

#ifdef CHECKNEWVERSION

// 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://raw.githubusercontent.com/sqlitebrowser/sqlitebrowser/master/currentrelease",

RemoteDatabase::RequestTypeNewVersionCheck);

}

#endif

#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 dontAddToRecentFiles, bool readOnly)

{

bool retval = false;

QString wFile = fileName;

if (!QFile::exists(wFile))

{

wFile = FileDialog::getOpenFileName(

this,

tr("Choose a database file")

#ifndef Q_OS_MAC // Filters on OS X are buggy

, FileDialog::getSqlDatabaseFileFilter()

#endif

);

}

if(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(!dontAddToRecentFiles)

addToRecentFilesMenu(wFile);

openSqlTab(true);

loadExtensionsFromSettings();

if(ui->mainTab->currentIndex() == BrowseTab)

populateTable();

else if(ui->mainTab->currentIndex() == PragmaTab)

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

loadExtensionsFromSettings();

populateTable();

openSqlTab(true);

createTable();

}

}

void MainWindow::populateStructure()

{

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

// Refresh the structure tab

dbStructureModel->reloadData();

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::TablesAndColumnsMap tablesToColumnsMap;

for(auto it=db.schemata.constBegin();it!=db.schemata.constEnd();++it)

{

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

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

{

QString objectname = (*it)->name();

sqlb::FieldInfoList fi = (*it)->fieldInformation();

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

tablesToColumnsMap[objectname].append(f.name);

}

}

SqlTextEdit::sqlLexer->setTableNames(tablesToColumnsMap);

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

}

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->currentIndex() != BrowseTab)

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

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

// Lambda function for updating the delete record button to reflect number of selected records

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

// NOTE: We're assuming here that the selection is always contiguous, i.e. that there are never two selected rows with a non-selected

// row in between.

int rows = 0;

if(ui->dataTable->selectionModel()->selectedIndexes().count())

rows = ui->dataTable->selectionModel()->selectedIndexes().last().row() - ui->dataTable->selectionModel()->selectedIndexes().first().row() + 1;

if(rows > 1)

ui->buttonDeleteRecord->setText(tr("Delete records"));

else

ui->buttonDeleteRecord->setText(tr("Delete record"));

});

}

// 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->setTable(tablename, 0, Qt::AscendingOrder);

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

// Sorting

ui->dataTable->filterHeader()->setSortIndicator(0, Qt::AscendingOrder);

// Encoding

m_browseTableModel->setEncoding(defaultBrowseTableEncoding);

// Plot

plotDock->updatePlot(m_browseTableModel, &browseTableSettings[tablename]);

// The filters can be left empty as they are

} else {

// Stored settings found. Retrieve them.

BrowseDataTableSettings storedData = browseTableSettings[tablename];

// Load display formats and set them along with the table name

QVector<QString> v;

bool only_defaults = true;

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

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

{

QString format = storedData.displayFormats[i+1];

if(format.size())

{

v.push_back(format);

only_defaults = false;

} else {

v.push_back(sqlb::escapeIdentifier(tablefields.at(i).name));

}

}

if(only_defaults)

m_browseTableModel->setTable(tablename, storedData.sortOrderIndex, storedData.sortOrderMode);

else

m_browseTableModel->setTable(tablename, storedData.sortOrderIndex, storedData.sortOrderMode, v);

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

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

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

// Sorting

ui->dataTable->filterHeader()->setSortIndicator(storedData.sortOrderIndex, storedData.sortOrderMode);

// Filters

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

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

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

// Encoding

m_browseTableModel->setEncoding(storedData.encoding);

// Plot

plotDock->updatePlot(m_browseTableModel, &browseTableSettings[tablename], true, false);

}

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

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

{

// Table

ui->actionUnlockViewEditing->setVisible(false);

ui->actionShowRowidColumn->setVisible(true);

} else {

// View

ui->actionUnlockViewEditing->setVisible(true);

ui->actionShowRowidColumn->setVisible(false);

}

QApplication::restoreOverrideCursor();

}

bool MainWindow::fileClose()

{

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

if(!db.close())

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

plotDock->updatePlot(nullptr);

activateFields(false);

// Clear the SQL Log

ui->editLogApplication->clear();

ui->editLogUser->clear();

return true;

}

void MainWindow::closeEvent( QCloseEvent* event )

{

if(db.close())

{

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

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

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

QMainWindow::closeEvent(event);

} else {

event->ignore();

}

}

void MainWindow::addRecord()

{

int row = m_browseTableModel->rowCount();

if(m_browseTableModel->insertRow(row))

{

selectTableLine(row);

} else {

QMessageBox::warning(this, QApplication::applicationName(), tr("Error adding record:\n") + db.lastError());

}

}

void MainWindow::deleteRecord()

{

if(ui->dataTable->selectionModel()->hasSelection())

{

// If only filter header is selected

if(ui->dataTable->selectionModel()->selectedIndexes().isEmpty())

return;

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

while(ui->dataTable->selectionModel()->hasSelection())

{

int first_selected_row = ui->dataTable->selectionModel()->selectedIndexes().first().row();

int last_selected_row = ui->dataTable->selectionModel()->selectedIndexes().last().row();

int selected_rows_count = last_selected_row - first_selected_row + 1;

if(!m_browseTableModel->removeRows(first_selected_row, selected_rows_count))

{

QMessageBox::warning(this, QApplication::applicationName(), tr("Error deleting record:\n%1").arg(db.lastError()));

break;

}

}

if(old_row > m_browseTableModel->totalRowCount())

old_row = m_browseTableModel->totalRowCount();

selectTableLine(old_row);

} else {

QMessageBox::information( this, QApplication::applicationName(), tr("Please select a record first"));

}

}

void MainWindow::selectTableLine(int lineToSelect)

{

// Are there even that many lines?

if(lineToSelect >= m_browseTableModel->totalRowCount())

return;

QApplication::setOverrideCursor( Qt::WaitCursor );

// Make sure this line has already been fetched

while(lineToSelect >= m_browseTableModel->rowCount() && m_browseTableModel->canFetchMore())

m_browseTableModel->fetchMore();

// Select it

ui->dataTable->clearSelection();

ui->dataTable->selectRow(lineToSelect);

ui->dataTable->scrollTo(ui->dataTable->currentIndex(), QAbstractItemView::PositionAtTop);

QApplication::restoreOverrideCursor();

}

void MainWindow::selectTableLines(int firstLine, int count)

{

int lastLine = firstLine+count-1;

// Are there even that many lines?

if(lastLine >= m_browseTableModel->totalRowCount())

return;

selectTableLine(firstLine);

QModelIndex topLeft = ui->dataTable->model()->index(firstLine, 0);

QModelIndex bottomRight = ui->dataTable->model()->index(lastLine, ui->dataTable->model()->columnCount()-1);

ui->dataTable->selectionModel()->select(QItemSelection(topLeft, bottomRight), QItemSelectionModel::Select | QItemSelectionModel::Rows);

}

void MainWindow::navigatePrevious()

{

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

curRow -= ui->dataTable->numVisibleRows() - 1;

if(curRow < 0)

curRow = 0;

selectTableLine(curRow);

}

void MainWindow::navigateNext()

{

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

curRow += ui->dataTable->numVisibleRows() - 1;

if(curRow >= m_browseTableModel->totalRowCount())

curRow = m_browseTableModel->totalRowCount() - 1;

selectTableLine(curRow);

}

void MainWindow::navigateBegin()

{

selectTableLine(0);

}

void MainWindow::navigateEnd()

{

selectTableLine(m_browseTableModel->totalRowCount()-1);

}

void MainWindow::navigateGoto()

{

int row = ui->editGoto->text().toInt();

if(row <= 0)

row = 1;

if(row > m_browseTableModel->totalRowCount())

row = m_browseTableModel->totalRowCount();

selectTableLine(row - 1);

ui->editGoto->setText(QString::number(row));

}

void MainWindow::setRecordsetLabel()

{

// Get all the numbers, i.e. the number of the first row and the last row as well as the total number of rows

int from = ui->dataTable->verticalHeader()->visualIndexAt(0) + 1;

int total = m_browseTableModel->totalRowCount();

int to = ui->dataTable->verticalHeader()->visualIndexAt(ui->dataTable->height()) - 1;

if (to == -2)

to = total;

// Update the validator of the goto row field

gotoValidator->setRange(0, total);

// Update the label showing the current position

ui->labelRecordset->setText(tr("%1 - %2 of %3").arg(from).arg(to).arg(total));

}

void MainWindow::refresh()

{

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

switch(ui->mainTab->currentIndex())

{

case StructureTab:

// Refresh the schema

db.updateSchema();

break;

case BrowseTab:

// Refresh the schema and reload the current table

db.updateSchema();

populateTable();

break;

case PragmaTab:

// Reload pragma values

loadPragmas();

break;

case ExecuteTab:

// (Re-)Run the current SQL query

executeQuery();

break;

}

}

void MainWindow::createTable()

{

if (!db.isOpen()){

QMessageBox::information( this, QApplication::applicationName(), tr("There is no database opened. Please open or create a new database file."));

return;

}

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

if(dialog.exec())

{

populateTable();

}

}

void MainWindow::createIndex()

{

if (!db.isOpen()){

QMessageBox::information( this, QApplication::applicationName(), tr("There is no database opened. Please open or create a new database file."));

return;

}

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

if(dialog.exec())

populateTable();

}

void MainWindow::compact()

{

VacuumDialog dialog(&db, this);

dialog.exec();

}

void MainWindow::deleteObject()

{

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

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

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

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

if(QMessageBox::warning(this, QApplication::applicationName(), tr("Are you sure you want to delete the %1 '%2'?\nAll data associated with the %1 will be lost.").arg(type).arg(name.name()),

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

{

// Delete the table

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

if(!db.executeSQL(statement))

{

QString error = tr("Error: could not delete the %1. Message from database engine:\n%2").arg(type).arg(db.lastError());

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

} else {

populateTable();

changeTreeSelection();

}

}

}

void MainWindow::editObject()

{

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

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

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

if(type == "table")

{

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

if(dialog.exec()) {

ui->dataTable->filterHeader()->clearFilters();

populateTable();

}

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

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

if(dialog.exec())

populateTable();

}

}

void MainWindow::helpWhatsThis()

{

QWhatsThis::enterWhatsThisMode ();

}

void MainWindow::helpAbout()

{

AboutDialog dialog(this);

dialog.exec();

}

void MainWindow::updateRecordText(const QPersistentModelIndex& idx, const QByteArray& text, bool isBlob)

{

m_currentTabTableModel->setTypedData(idx, isBlob, text);

}

void MainWindow::toggleEditDock(bool visible)

{

if (!visible) {

// Update main window

ui->dataTable->setFocus();

} else {

// fill edit dock with actual data

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

}

}

void MainWindow::doubleClickTable(const QModelIndex& index)

{

// Cancel on invalid index

if (!index.isValid()) {

return;

}

// * Don't allow editing of other objects than tables (on the browse table) *

bool isEditingAllowed = !db.readOnly() && m_currentTabTableModel == m_browseTableModel &&

(db.getObjectByName(currentlyBrowsedTableName())->type() == sqlb::Object::Types::Table);

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

}

void MainWindow::dataTableSelectionChanged(const QModelIndex& index)

{

// Cancel on invalid index

if(!index.isValid()) {

editDock->setCurrentIndex(QModelIndex());

return;

}

bool editingAllowed = !db.readOnly() && (m_currentTabTableModel == m_browseTableModel) &&

(db.getObjectByName(currentlyBrowsedTableName())->type() == sqlb::Object::Types::Table);

// Don't allow editing of other objects than tables

editDock->setReadOnly(!editingAllowed);

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

if (editDock->isVisible()) {

editDock->setCurrentIndex(index);

}

}

MainWindow::StatementType MainWindow::getQueryType(const QString& query) const

{

// Helper function for getting the type of a given query

if(query.startsWith("SELECT", Qt::CaseInsensitive)) return SelectStatement;

if(query.startsWith("ALTER", Qt::CaseInsensitive)) return AlterStatement;

if(query.startsWith("DROP", Qt::CaseInsensitive)) return DropStatement;

if(query.startsWith("ROLLBACK", Qt::CaseInsensitive)) return RollbackStatement;

if(query.startsWith("PRAGMA", Qt::CaseInsensitive)) return PragmaStatement;

if(query.startsWith("VACUUM", Qt::CaseInsensitive)) return VacuumStatement;

if(query.startsWith("INSERT", Qt::CaseInsensitive)) return InsertStatement;

if(query.startsWith("UPDATE", Qt::CaseInsensitive)) return UpdateStatement;

if(query.startsWith("DELETE", Qt::CaseInsensitive)) return DeleteStatement;

if(query.startsWith("CREATE", Qt::CaseInsensitive)) return CreateStatement;

return OtherStatement;

}

/*

* I'm still not happy how the results are represented to the user

* right now you only see the result of the last executed statement.

* A better experience would be tabs on the bottom with query results

* for all the executed statements.

* Or at least a some way the use could see results/status message

* per executed statement.

*/

void MainWindow::executeQuery()

{

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

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

// Get SQL code to execute. This depends on the button that's been pressed

QString query;

int execution_start_line = 0;

int execution_start_index = 0;

if(sender()->objectName() == "actionSqlExecuteLine")

{

int cursor_line, cursor_index;

SqlTextEdit *editor = sqlWidget->getEditor();