#include "MainWindow.h"

#include "ui_MainWindow.h"

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

#include <QApplication>

#include <QTextStream>

#include <QWhatsThis>

#include <QMessageBox>

#include <QUrl>

#include <QStandardItemModel>

#include <QPersistentModelIndex>

#include <QDragEnterEvent>

#include <QScrollBar>

#include <QSortFilterProxyModel>

#include <QElapsedTimer>

#include <QNetworkRequest>

#include <QNetworkReply>

#include <QNetworkAccessManager>

#include <QSettings>

#include <QMimeData>

#include <QColorDialog>

#include <QDesktopServices>

#include <QXmlStreamReader>

#include <QXmlStreamWriter>

#include <QInputDialog>

#include <QProgressDialog>

#include <QTextEdit>

#include <QClipboard>

#include <QShortcut>

#include <QTextCodec>

MainWindow::MainWindow(QWidget* parent)

: QMainWindow(parent),

ui(new Ui::MainWindow),

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

m_currentTabTableModel(m_browseTableModel),

editDock(new EditDialog(this)),

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

{

ui->setupUi(this);

init();

activateFields(false);

updateRecentFileActions();

}

MainWindow::~MainWindow()

{

delete gotoValidator;

delete ui;

}

void MainWindow::init()

{

// Load window settings

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

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

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

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

// Set up DB structure tab

dbStructureModel = new DbStructureModel(db, this);

ui->dbTreeWidget->setModel(dbStructureModel);

ui->dbTreeWidget->setColumnHidden(1, true);

ui->dbTreeWidget->setColumnWidth(0, 300);

// Set up DB schema dock

ui->treeSchemaDock->setModel(dbStructureModel);

ui->treeSchemaDock->setColumnHidden(1, true);

ui->treeSchemaDock->setColumnWidth(0, 300);

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

ui->comboBrowseTable->setModel(dbStructureModel);

// Edit dock

ui->dockEdit->setWidget(editDock);

// Restore window geometry

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

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

// Restore various dock state settings

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

ui->splitterForPlot->restoreState(Settings::getSettingsValue("PlotDock", "splitterSize").toByteArray());

ui->comboLineType->setCurrentIndex(Settings::getSettingsValue("PlotDock", "lineType").toInt());

ui->comboPointShape->setCurrentIndex(Settings::getSettingsValue("PlotDock", "pointShape").toInt());

// Add keyboard shortcuts

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

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

ui->actionExecuteSql->setShortcuts(shortcuts);

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

connect(shortcutBrowseRefresh, SIGNAL(activated()), ui->buttonRefresh, SLOT(click()));

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

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

popupBrowseDataHeaderMenu = new QMenu(this);

popupBrowseDataHeaderMenu->addAction(ui->actionShowRowidColumn);

popupBrowseDataHeaderMenu->addAction(ui->actionBrowseTableEditDisplayFormat);

popupBrowseDataHeaderMenu->addAction(ui->actionSetTableEncoding);

popupBrowseDataHeaderMenu->addSeparator();

popupBrowseDataHeaderMenu->addAction(ui->actionSetAllTablesEncoding);

popupRecordMenu = new QMenu(this);

popupRecordMenu->addAction(ui->actionDittoRecord);

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

connect(dittoRecordShortcut, SIGNAL(activated()), this, SLOT(dittoRecord()));

// 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)->setIcon(QIcon(":/icons/log_dock"));

// Add keyboard shortcut for "Edit Cell" dock

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

// 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->dockEdit, SIGNAL(visibilityChanged(bool)), this, SLOT(toggleEditDock(bool)));

// plot widgets

ui->treePlotColumns->setSelectionMode(QAbstractItemView::NoSelection);

// 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::getSettingsValue("checkversion", "enabled").toBool())

{

// Check for a new release version, usually only enabled on windows

m_NetworkManager = new QNetworkAccessManager(this);

connect(m_NetworkManager, SIGNAL(finished(QNetworkReply*)), this, SLOT(httpresponse(QNetworkReply*)));

QUrl url("https://raw.githubusercontent.com/sqlitebrowser/sqlitebrowser/master/currentrelease");

m_NetworkManager->get(QNetworkRequest(url));

}

#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('&'));

}

bool MainWindow::fileOpen(const QString& fileName, bool dontAddToRecentFiles)

{

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

{

retval = true;

} else {

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

if(db.open(wFile))

{

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("Invalid file format."));

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

objectMap tab = db.getBrowsableObjects();

SqlUiLexer::TablesAndColumnsMap tablesToColumnsMap;

for(objectMap::ConstIterator it=tab.begin(); it!=tab.end(); ++it)

{

QString objectname = it.value().getname();

for(int i=0; i < (*it).table.fields().size(); ++i)

{

QString fieldname = (*it).table.fields().at(i)->name();

tablesToColumnsMap[objectname].append(fieldname);

}

}

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

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

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

// Set model

bool reconnectSelectionSignals = false;

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

reconnectSelectionSignals = true;

ui->dataTable->setModel(m_browseTableModel);

if(reconnectSelectionSignals)

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

// Search stored table settings for this table

QMap<QString, BrowseDataTableSettings>::ConstIterator tableIt;

tableIt = browseTableSettings.constFind(tablename);

bool storedDataFound = tableIt != browseTableSettings.constEnd();

// Set new table

if(!storedDataFound)

{

m_browseTableModel->setTable(tablename);

} else {

QVector<QString> v;

bool only_defaults = true;

for(int i=0;i<db.getObjectByName(tablename).table.fields().size();i++)

{

QString format = tableIt.value().displayFormats[i+1];

if(format.size())

{

v.push_back(format);

only_defaults = false;

} else {

v.push_back(sqlb::escapeIdentifier(db.getObjectByName(tablename).table.fields().at(i)->name()));

}

}

if(only_defaults)

m_browseTableModel->setTable(tablename);

else

m_browseTableModel->setTable(tablename, v);

}

// Restore table settings

if(storedDataFound)

{

// 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(tableIt.value().showRowid);

// Column widths

for(QMap<int, int>::ConstIterator widthIt=tableIt.value().columnWidths.constBegin();widthIt!=tableIt.value().columnWidths.constEnd();++widthIt)

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

// Sorting

m_browseTableModel->sort(tableIt.value().sortOrderIndex, tableIt.value().sortOrderMode);

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

// Filters

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

for(QMap<int, QString>::ConstIterator filterIt=tableIt.value().filterValues.constBegin();filterIt!=tableIt.value().filterValues.constEnd();++filterIt)

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

// Encoding

m_browseTableModel->setEncoding(tableIt.value().encoding);

} else {

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

// Column widths

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

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

// Sorting

m_browseTableModel->sort(0, Qt::AscendingOrder);

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

// Encoding

m_browseTableModel->setEncoding(defaultBrowseTableEncoding);

// The filters can be left empty as they are

}

// Activate the add and delete record buttons and editing only if a table has been selected

bool editable = db.getObjectByName(tablename).gettype() == "table" && !db.readOnly();

ui->buttonNewRecord->setEnabled(editable);

ui->buttonDeleteRecord->setEnabled(editable);

ui->dataTable->setEditTriggers(editable ? QAbstractItemView::SelectedClicked | QAbstractItemView::AnyKeyPressed | QAbstractItemView::EditKeyPressed : QAbstractItemView::NoEditTriggers);

// Set the recordset label

setRecordsetLabel();

// update plot

updatePlot(m_browseTableModel);

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

// Manually update the recordset label inside the Browse tab now

setRecordsetLabel();

// Reset the plot dock model

updatePlot(0);

activateFields(false);

// Clear the SQL Log

ui->editLogApplication->clear();

ui->editLogUser->clear();

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

closeSqlTab(i, true);

return true;

}

void MainWindow::closeEvent( QCloseEvent* event )

{

if(db.close())

{

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

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

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

Settings::setSettingsValue("PlotDock", "splitterSize", ui->splitterForPlot->saveState());

Settings::setSettingsValue("PlotDock", "lineType", ui->comboLineType->currentIndex());

Settings::setSettingsValue("PlotDock", "pointShape", ui->comboPointShape->currentIndex());

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

}

}

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

{

if(!m_browseTableModel->removeRow(ui->dataTable->selectionModel()->selectedIndexes().first().row()))

{

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

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::dittoRecord()

{

const QString sCurrentTable = ui->comboBrowseTable->currentText();

if (!(db.getObjectByName(sCurrentTable).gettype() == "table" && !db.readOnly()))

return;

int row;

if (qobject_cast<QShortcut*>(sender()))

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

else

row = ui->actionDittoRecord->property("current_row").toInt();

if (row == -1)

return;

QModelIndex idx = m_browseTableModel->dittoRecord(row);

ui->dataTable->setCurrentIndex(idx);

}

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

QApplication::restoreOverrideCursor();

}

void MainWindow::navigatePrevious()

{

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

curRow -= 100;

if(curRow < 0)

curRow = 0;

selectTableLine(curRow);

}

void MainWindow::navigateNext()

{

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

curRow += 100;

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 to = ui->dataTable->verticalHeader()->visualIndexAt(ui->dataTable->height()) - 1;

int total = m_browseTableModel->totalRowCount();

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::browseRefresh()

{

db.updateSchema();

populateTable();

}

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

}

CreateIndexDialog dialog(&db, this);

dialog.exec();

}

void MainWindow::compact()

{

VacuumDialog dialog(&db, this);

dialog.exec();

}

void MainWindow::deleteObject()

{

// Get name and type of object to delete

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

QString type = ui->dbTreeWidget->model()->data(ui->dbTreeWidget->currentIndex().sibling(ui->dbTreeWidget->currentIndex().row(), 1), 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(table),

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

{

// Delete the table

QString statement = QString("DROP %1 %2;").arg(type.toUpper()).arg(sqlb::escapeIdentifier(table));

if(!db.executeSQL( statement))

{

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

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

} else {

populateTable();

changeTreeSelection();

}

}

}

void MainWindow::editTable()

{

if (!db.isOpen()){

QMessageBox::information( this, QApplication::applicationName(), tr("There is no database opened."));

return;

}

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

return;

}

QString tableToEdit = ui->dbTreeWidget->model()->data(ui->dbTreeWidget->currentIndex().sibling(ui->dbTreeWidget->currentIndex().row(), 0)).toString();

EditTableDialog dialog(&db, tableToEdit, 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

activateWindow();

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 = (m_currentTabTableModel == m_browseTableModel) &&

(db.getObjectByName(ui->comboBrowseTable->currentText()).gettype() == "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 = (m_currentTabTableModel == m_browseTableModel) &&

(db.getObjectByName(ui->comboBrowseTable->currentText()).gettype() == "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);

}

}

/*

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

{

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

editor->getCursorPosition(&cursor_line, &cursor_index);

execution_start_line = cursor_line;

int lineStartCursorPosition = editor->positionFromLineIndex(cursor_line, 0);

QString entireSQL = editor->text();

QString firstPartEntireSQL = entireSQL.left(lineStartCursorPosition);

QString secondPartEntireSQL = entireSQL.right(entireSQL.length() - lineStartCursorPosition);

QString firstPartSQL = firstPartEntireSQL.split(";").last();

QString lastPartSQL = secondPartEntireSQL.split(";").first();

query = firstPartSQL + lastPartSQL;

} else {

// if a part of the query is selected, we will only execute this part

query = sqlWidget->getSelectedSql();

int dummy;

if(query.isEmpty())

query = sqlWidget->getSql();

else

sqlWidget->getEditor()->getSelection(&execution_start_line, &execution_start_index, &dummy, &dummy);

}

if (query.trimmed().isEmpty())

return;

query = query.remove(QRegExp("^\\s*BEGIN TRANSACTION;|COMMIT;\\s*$")).trimmed();

//log the query

db.logSQL(query, kLogMsg_User);

sqlite3_stmt *vm;

QByteArray utf8Query = query.toUtf8();

const char *tail = utf8Query.data();

int sql3status = 0;

int tail_length = utf8Query.length();

QString statusMessage;

bool modified = false;

bool wasdirty = db.getDirty();

bool structure_updated = false;

// there is no choice, we have to start a transaction before

// we create the prepared statement, otherwise every executed

// statement will get committed after the prepared statement

// gets finalized, see http://www.sqlite.org/lang_transaction.html

db.setSavepoint();

// Remove any error indicators

sqlWidget->getEditor()->clearErrorIndicators();

//Accept multi-line queries, by looping until the tail is empty

QElapsedTimer timer;

timer.start();

do

{

// Check whether the DB structure is changed by this statement

QString qtail = QString(tail);

if(!structure_updated && (qtail.startsWith("ALTER", Qt::CaseInsensitive) ||

qtail.startsWith("CREATE", Qt::CaseInsensitive) ||

qtail.startsWith("DROP", Qt::CaseInsensitive) ||

qtail.startsWith("ROLLBACK", Qt::CaseInsensitive)))

structure_updated = true;

// Execute next statement

int tail_length_before = tail_length;

const char* qbegin = tail;

sql3status = sqlite3_prepare_v2(db._db,tail, tail_length, &vm, &tail);

QString queryPart = QString::fromUtf8(qbegin, tail - qbegin);

tail_length -= (tail - qbegin);

int execution_end_index = execution_start_index + tail_length_before - tail_length;

if (sql3status == SQLITE_OK)

{

sql3status = sqlite3_step(vm);

sqlite3_finalize(vm);

// SQLite returns SQLITE_DONE when a valid SELECT statement was executed but returned no results. To run into the branch that updates

// the status message and the table view anyway manipulate the status value here. This is also done for PRAGMA statements as they (sometimes)

// return rows just like SELECT statements, too.

if((queryPart.trimmed().startsWith("SELECT", Qt::CaseInsensitive) ||

queryPart.trimmed().startsWith("PRAGMA", Qt::CaseInsensitive)) && sql3status == SQLITE_DONE)

sql3status = SQLITE_ROW;

switch(sql3status)

{

case SQLITE_ROW:

{

sqlWidget->getModel()->setQuery(queryPart);

if(sqlWidget->getModel()->valid())

{

// The query takes the last placeholder as it may itself contain the sequence '%' + number

statusMessage = tr("%1 rows returned in %2ms from: %3").arg(

#if QT_VERSION < 0x050000

sqlWidget->getModel()->totalRowCount()).arg(timer.elapsed()).arg(Qt::escape(queryPart.trimmed()));

#else

sqlWidget->getModel()->totalRowCount()).arg(timer.elapsed()).arg(queryPart.trimmed().toHtmlEscaped());

#endif

sqlWidget->enableSaveButton(true);

sql3status = SQLITE_OK;

}

else

{

statusMessage = tr("Error executing query: %1").arg(queryPart);

sql3status = SQLITE_ERROR;

}

}

case SQLITE_DONE:

case SQLITE_OK:

{

if( !queryPart.trimmed().startsWith("SELECT", Qt::CaseInsensitive) )

{

modified = true;

QString stmtHasChangedDatabase;

if(queryPart.trimmed().startsWith("INSERT", Qt::CaseInsensitive) ||

queryPart.trimmed().startsWith("UPDATE", Qt::CaseInsensitive) ||

queryPart.trimmed().startsWith("DELETE", Qt::CaseInsensitive))

{

stmtHasChangedDatabase = tr(", %1 rows affected").arg(sqlite3_changes(db._db));

}

statusMessage = tr("Query executed successfully: %1 (took %2ms%3)").arg(queryPart.trimmed()).arg(timer.elapsed()).arg(stmtHasChangedDatabase);

}

break;

}

default:

statusMessage = QString::fromUtf8((const char*)sqlite3_errmsg(db._db)) +

": " + queryPart;

break;

}

timer.restart();

} else {

statusMessage = QString::fromUtf8((const char*)sqlite3_errmsg(db._db)) +

": " + queryPart;

sqlWidget->getEditor()->setErrorIndicator(execution_start_line, execution_start_index, execution_start_line, execution_end_index);

}

execution_start_index = execution_end_index;

} while( tail && *tail != 0 && (sql3status == SQLITE_OK || sql3status == SQLITE_DONE));

sqlWidget->finishExecution(statusMessage);