#include "MainWindow.h"

#include "ui_MainWindow.h"

#include "CreateIndexDialog.h"

#include "AboutDialog.h"

#include "EditTableDialog.h"

#include "ImportCsvDialog.h"

#include "ExportCsvDialog.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 <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, PreferencesDialog::getSettingsValue("db", "prefetchsize").toInt())),

m_currentTabTableModel(m_browseTableModel),

editWin(new EditDialog(this)),

editDock(new EditDialog(this, true)),

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

{

ui->setupUi(this);

init();

activateFields(false);

updateRecentFileActions();

}

MainWindow::~MainWindow()

{

delete gotoValidator;

delete ui;

}

void MainWindow::init()

{

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

// Set the validator for the goto line edit

ui->editGoto->setValidator(gotoValidator);

// Set up DB models

ui->dataTable->setModel(m_browseTableModel);

// Set up DB structure tab

dbStructureModel = new DbStructureModel(ui->dbTreeWidget);

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

// Edit dock

ui->dockEditWindow->setWidget(editDock);

ui->dockEditWindow->hide(); // Hidden by default

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

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

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

// 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(editWin, SIGNAL(goingAway()), this, SLOT(editWinAway()));

connect(editWin, SIGNAL(updateRecordText(int, int, bool, QByteArray)), this, SLOT(updateRecordText(int, int, bool, QByteArray)));

connect(editDock, SIGNAL(goingAway()), this, SLOT(editWinAway()));

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

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

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

// Load window settings

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

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

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

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

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

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

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

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

// 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(PreferencesDialog::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(/sitelet?url=https%3A%2F%2Fgithub.com%2Ffeifeiq%2Fsqlitebrowser%2Fblob%2Fmaster%2Fsrc%2F%26quot%3Bhttps%3A%2F%2Fraw.githubusercontent.com%2Fsqlitebrowser%2Fsqlitebrowser%2Fmaster%2Fcurrentrelease%26quot%3B);

m_NetworkManager->get(QNetworkRequest(url));

}

#endif

#ifndef ENABLE_SQLCIPHER

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

ui->actionEncryption->setVisible(false);

#endif

#ifdef Q_OS_WIN

// On Windows remove all the & signs from the dock titles. Windows (or Qt on Windows) doesn't seem

// to support them properly, so they end up being visible instead of creating a keyboard shortcut.

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

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

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

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

#endif

}

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

populateStructure();

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

resetBrowser();

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

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

populateStructure();

resetBrowser();

openSqlTab(true);

createTable();

}

}

void MainWindow::populateStructure()

{

// Refresh the structure tab

db.updateSchema();

dbStructureModel->reloadData(&db);

ui->dbTreeWidget->expandToDepth(0);

ui->treeSchemaDock->expandToDepth(0);

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)

{

// If it is a table or a view add the fields

if((*it).gettype() == "table" || (*it).gettype() == "view")

{

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::populateTable(QString tablename)

{

// 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() == 0 && tablename.isEmpty())

{

ui->dataTable->setModel(0);

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

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

return;

}

QApplication::setOverrideCursor(Qt::WaitCursor);

// Update combo box

if(ui->comboBrowseTable->currentText() != tablename)

{

int pos = ui->comboBrowseTable->findText(tablename);

if(pos == -1)

{

ui->comboBrowseTable->setCurrentIndex(0);

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

} else {

ui->comboBrowseTable->setCurrentIndex(pos);

}

}

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

// Reset the edit dialog

editWin->reset();

editDock->reset();

// update plot

updatePlot(m_browseTableModel);

QApplication::restoreOverrideCursor();

}

void MainWindow::resetBrowser(bool reloadTable)

{

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

ui->comboBrowseTable->clear();

const objectMap& tab = db.getBrowsableObjects();

// fill a objmap which is sorted by table/view names

QMap<QString, DBBrowserObject> objmap;

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

{

objmap[i.value().getname()] = i.value();

}

// Finally fill the combobox in sorted order

for(QMap<QString, DBBrowserObject>::ConstIterator it=objmap.constBegin();

it!=objmap.constEnd();

++it)

{

ui->comboBrowseTable->addItem(

QIcon(QString(":icons/%1").arg((*it).gettype())),

(*it).getname());

}

setRecordsetLabel();

if(reloadTable)

populateTable(sCurrentTable);

}

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

resetBrowser();

populateStructure();

loadPragmas();

statusEncryptionLabel->setVisible(false);

statusReadOnlyLabel->setVisible(false);

// Delete the model for the Browse tab and create a new one

delete m_browseTableModel;

m_browseTableModel = new SqliteTableModel(this, &db, PreferencesDialog::getSettingsValue("db", "prefetchsize").toInt());

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

connect(m_browseTableModel, SIGNAL(dataChanged(QModelIndex,QModelIndex,QVector<int>)), this, SLOT(dataTableSelectionChanged(QModelIndex)));

// Reset the edit dialog/dock

editDock->reset();

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

ui->buttonLogClear->click();

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

closeSqlTab(i, true);

return true;

}

void MainWindow::closeEvent( QCloseEvent* event )

{

if(db.close())

{

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

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

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

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

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

PreferencesDialog::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;

}

}

populateTable(ui->comboBrowseTable->currentText());

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

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(ui->comboBrowseTable->currentText());

}

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

{

populateStructure();

resetBrowser();

}

}

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

if(dialog.exec())

{

populateStructure();

resetBrowser();

}

}

void MainWindow::compact()

{

VacuumDialog dialog(&db, this);

if(dialog.exec())

{

populateStructure();

resetBrowser();

}

}

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

QString type = ui->dbTreeWidget->model()->data(ui->dbTreeWidget->currentIndex().sibling(ui->dbTreeWidget->currentIndex().row(), 1)).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::Default | QMessageBox::Escape) == 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 {

populateStructure();

resetBrowser();

}

}

}

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

{

populateStructure();

resetBrowser();

}

}

void MainWindow::helpWhatsThis()

{

QWhatsThis::enterWhatsThisMode ();

}

void MainWindow::helpAbout()

{

AboutDialog dialog(this);

dialog.exec();

}

void MainWindow::updateRecordText(int row, int col, bool isBlob, const QByteArray& newtext)

{

m_currentTabTableModel->setTypedData(m_currentTabTableModel->index(row, col), isBlob, newtext);

}

void MainWindow::editWinAway()

{

// Get the sender

EditDialog* sendingEditDialog = qobject_cast<EditDialog*>(sender());

// Only hide the edit window, not the edit dock

editWin->hide();

// Update main window

activateWindow();

ui->dataTable->setFocus();

ui->dataTable->setCurrentIndex(ui->dataTable->currentIndex().sibling(sendingEditDialog->getCurrentRow(), sendingEditDialog->getCurrentCol()));

}

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

editDock->allowEditing(allowEditing);

editWin->allowEditing(allowEditing);

// Load the current value into both, edit window and edit dock

editWin->loadText(index.data(Qt::EditRole).toByteArray(), index.row(), index.column());

editDock->loadText(index.data(Qt::EditRole).toByteArray(), index.row(), index.column());

// If the edit dock is visible don't open the edit window. If it's invisible open the edit window.

// The edit dock obviously doesn't need to be opened when it's already visible but setting focus to it makes sense.

if(!ui->dockEditWindow->isVisible())

editWin->show();

else

editDock->setFocus();

}

void MainWindow::dataTableSelectionChanged(const QModelIndex& index)

{

// Cancel on invalid index

if(!index.isValid())

return;

bool edit = (m_currentTabTableModel == m_browseTableModel) &&

(db.getObjectByName(ui->comboBrowseTable->currentText()).gettype() == "table");

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

editDock->allowEditing(edit);

// Load the current value into the edit dock only

editDock->loadText(index.data(Qt::EditRole).toByteArray(), index.row(), index.column());

}

/*

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

bool singleStep = false;

int execution_start_line = 0;

int execution_start_index = 0;

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

{

int cursor_line, cursor_index;

sqlWidget->getEditor()->getCursorPosition(&cursor_line, &cursor_index);

execution_start_line = cursor_line;

while(cursor_line < sqlWidget->getEditor()->lines())

query += sqlWidget->getEditor()->text(cursor_line++);

singleStep = true;

} 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.isEmpty())

return;

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

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

{

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(

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

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

// Stop after the first full statement if we're in single step mode

if(singleStep)

break;

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

updatePlot(sqlWidget->getModel());

connect(sqlWidget->getTableResult(), SIGNAL(clicked(QModelIndex)), this, SLOT(dataTableSelectionChanged(QModelIndex)));

connect(sqlWidget->getTableResult(), SIGNAL(doubleClicked(QModelIndex)), this, SLOT(doubleClickTable(QModelIndex)));

if(!modified && !wasdirty)

db.revertToSavepoint(); // better rollback, if the logic is not enough we can tune it.

}

void MainWindow::mainTabSelected(int tabindex)

{

editDock->allowEditing(false);

if(tabindex == 0)

{

populateStructure();

} else if(tabindex == 1) {

m_currentTabTableModel = m_browseTableModel;

populateStructure();

resetBrowser();

} else if(tabindex == 2) {

loadPragmas();

} else if(tabindex == 3) {

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

if (sqlWidget) {