/********************************************************************************
** Form generated from reading UI file 'MainWindow.ui'
**
** Created by: Qt User Interface Compiler version 5.15.18
**
** WARNING! All changes made in this file will be lost when recompiling UI file!
********************************************************************************/

#ifndef UI_MAINWINDOW_H
#define UI_MAINWINDOW_H

#include <QtCore/QVariant>
#include <QtGui/QIcon>
#include <QtWidgets/QAction>
#include <QtWidgets/QApplication>
#include <QtWidgets/QCheckBox>
#include <QtWidgets/QComboBox>
#include <QtWidgets/QDialogButtonBox>
#include <QtWidgets/QDockWidget>
#include <QtWidgets/QGridLayout>
#include <QtWidgets/QHBoxLayout>
#include <QtWidgets/QHeaderView>
#include <QtWidgets/QLabel>
#include <QtWidgets/QMainWindow>
#include <QtWidgets/QMenu>
#include <QtWidgets/QMenuBar>
#include <QtWidgets/QScrollArea>
#include <QtWidgets/QSpacerItem>
#include <QtWidgets/QSpinBox>
#include <QtWidgets/QStackedWidget>
#include <QtWidgets/QStatusBar>
#include <QtWidgets/QTabWidget>
#include <QtWidgets/QToolBar>
#include <QtWidgets/QToolButton>
#include <QtWidgets/QTreeView>
#include <QtWidgets/QVBoxLayout>
#include <QtWidgets/QWidget>
#include "ExtendedScintilla.h"
#include "sqltextedit.h"

QT_BEGIN_NAMESPACE

class Ui_MainWindow
{
public:
    QAction *fileNewAction;
    QAction *fileOpenAction;
    QAction *fileCloseAction;
    QAction *fileRevertAction;
    QAction *undoAction;
    QAction *fileSaveAction;
    QAction *fileCompactAction;
    QAction *fileExitAction;
    QAction *fileImportSQLAction;
    QAction *fileImportCSVAction;
    QAction *fileExportSQLAction;
    QAction *fileExportCSVAction;
    QAction *editCreateTableAction;
    QAction *editDeleteObjectAction;
    QAction *editModifyObjectAction;
    QAction *editCreateIndexAction;
    QAction *viewPreferencesAction;
    QAction *viewDBToolbarAction;
    QAction *helpWhatsThisAction;
    QAction *helpAboutAction;
    QAction *actionRecent_y_opened;
    QAction *actionSqlOpenTab;
    QAction *actionExecuteSql;
    QAction *actionSqlOpenFile;
    QAction *actionSqlSaveFile;
    QAction *actionLoadExtension;
    QAction *actionSqlExecuteLine;
    QAction *actionExportCsvPopup;
    QAction *actionWiki;
    QAction *actionBug_report;
    QAction *actionFeature_Request;
    QAction *actionWebsite;
    QAction *actionDonatePatreon;
    QAction *actionSaveProject;
    QAction *actionOpenProject;
    QAction *fileAttachAction;
    QAction *actionEncryption;
    QAction *actionSqlSaveFileAs;
    QAction *actionSqlSaveFilePopup;
    QAction *actionEditBrowseTable;
    QAction *actionEditCopyCreateStatement;
    QAction *actionSqlCipherFaq;
    QAction *fileExportJsonAction;
    QAction *fileOpenReadOnlyAction;
    QAction *actionSqlResultsSave;
    QAction *actionSqlFind;
    QAction *actionSqlFindReplace;
    QAction *actionSqlResultsExportCsv;
    QAction *actionSqlResultsExportJson;
    QAction *actionSqlResultsSaveAsView;
    QAction *viewProjectToolbarAction;
    QAction *viewExtraDBToolbarAction;
    QAction *fileOpenActionPopup;
    QAction *fileNewInMemoryDatabaseAction;
    QAction *actionDropSelectQueryCheck;
    QAction *actionDropQualifiedCheck;
    QAction *actionEnquoteNamesCheck;
    QAction *actionIntegrityCheck;
    QAction *actionForeignKeyCheck;
    QAction *actionQuickCheck;
    QAction *actionOptimize;
    QAction *actionSqlPrint;
    QAction *actionDbPrint;
    QAction *actionSqlToggleComment;
    QAction *actionSqlStop;
    QAction *actionSaveProjectAs;
    QAction *actionSaveAll;
    QAction *actionPopupSchemaDockBrowseTable;
    QAction *actionCloseProject;
    QAction *fileDetachAction;
    QAction *actionPopupSchemaDockDetachDatabase;
    QAction *actionFileImportCsvClipboard;
    QAction *actionRowCounts;
    QAction *fileSaveAsAction;
    QAction *actionRefreshStructure;
    QWidget *centralwidget;
    QVBoxLayout *verticalLayout_7;
    QTabWidget *mainTab;
    QWidget *structure;
    QVBoxLayout *verticalLayout;
    QToolBar *dbToolbar;
    QTreeView *dbTreeWidget;
    QWidget *browser;
    QVBoxLayout *verticalLayout_2;
    QMainWindow *tabBrowsers;
    QWidget *pragmas;
    QVBoxLayout *verticalLayout_4;
    QScrollArea *scrollareaPragmas;
    QWidget *scrollAreaWidgetContents;
    QGridLayout *gridLayout;
    QLabel *labelPragmaTempStore;
    QLabel *labelPragmaSecureDelete;
    QLabel *labelPragmaWalAutoCheckpoint_2;
    QLabel *labelPragmaCaseSensitiveLike;
    QLabel *labelPragmaJournalMode_2;
    QLabel *labelPragmaSecureDelete_2;
    QLabel *labelPragmaSynchronous_2;
    QLabel *labelPragmaJournalMode;
    QLabel *labelJournalSizeLimit;
    QLabel *labelPragmaRecursiveTriggers;
    QComboBox *comboboxPragmaJournalMode;
    QLabel *labelPragmaFullFsync_2;
    QLabel *labelJournalSizeLimit_2;
    QLabel *labelPragmaPageSize;
    QLabel *labelPragmaCaseSensitiveLike_2;
    QCheckBox *checkboxPragmaSecureDelete;
    QLabel *labelPragmaForeignKeys;
    QCheckBox *checkboxPragmaIgnoreCheckConstraints;
    QCheckBox *checkboxPragmaCheckpointFullFsync;
    QCheckBox *checkboxPragmaFullFsync;
    QCheckBox *checkboxPragmaRecursiveTriggers;
    QSpinBox *spinPragmaUserVersion;
    QCheckBox *checkboxPragmaForeignKeys;
    QLabel *labelPragmaIgnoreCheckConstraints_2;
    QLabel *labelPragmaAutomaticIndex_2;
    QCheckBox *checkboxPragmaAutomaticIndex;
    QLabel *labelPragmaPageSize_2;
    QLabel *labelPragmaAutoVacuum_2;
    QLabel *labelPragmaRecursiveTriggers_2;
    QLabel *labelPragmaTempStore_2;
    QLabel *labelPragmaCheckpointFullFsync_2;
    QLabel *labelPragmaAutoVacuum;
    QSpinBox *spinPragmaWalAutoCheckpoint;
    QLabel *labelPragmaMaxPageCount;
    QLabel *labelPragmaLockingMode_2;
    QComboBox *comboboxPragmaLockingMode;
    QLabel *labelPragmaCheckpointFullFsync;
    QLabel *labelPragmaForeignKeys_2;
    QComboBox *comboboxPragmaSynchronous;
    QComboBox *comboboxPragmaTempStore;
    QLabel *labelPragmaAutomaticIndex;
    QSpinBox *spinPragmaMaxPageCount;
    QLabel *labelPragmaUserVersion_2;
    QLabel *labelPragmaMaxPageCount_2;
    QLabel *labelPragmaIgnoreCheckConstraints;
    QLabel *labelPragmaFullFsync;
    QLabel *labelPragmaWalAutoCheckpoint;
    QSpinBox *spinPragmaJournalSizeLimit;
    QLabel *labelPragmaUserVersion;
    QComboBox *comboPragmaPageSize;
    QLabel *labelPragmaSynchronous;
    QCheckBox *checkboxPragmaCaseSensitiveLike;
    QComboBox *comboboxPragmaAutoVacuum;
    QLabel *labelPragmaLockingMode;
    QDialogButtonBox *buttonBoxPragmas;
    QWidget *query;
    QVBoxLayout *verticalLayout_3;
    QToolBar *toolbarSql;
    QTabWidget *tabSqlAreas;
    QMenuBar *menubar;
    QMenu *fileMenu;
    QMenu *menuImport;
    QMenu *menuExport;
    QMenu *fileRecentFiles;
    QMenu *editMenu;
    QMenu *viewMenu;
    QMenu *helpMenu;
    QMenu *menuTools;
    QStatusBar *statusbar;
    QToolBar *toolbarDB;
    QDockWidget *dockEdit;
    QWidget *dockWidgetContents_4;
    QDockWidget *dockLog;
    QWidget *dockWidgetContents;
    QVBoxLayout *verticalLayout_5;
    QHBoxLayout *horizontalLayout_3;
    QLabel *labelLogSubmittedBy;
    QComboBox *comboLogSubmittedBy;
    QSpacerItem *horizontalSpacer_3;
    QToolButton *buttonLogClear;
    QStackedWidget *stackLog;
    SqlTextEdit *editLogUser;
    SqlTextEdit *editLogApplication;
    ExtendedScintilla *editLogErrorLog;
    QDockWidget *dockPlot;
    QWidget *dockWidgetContents_2;
    QVBoxLayout *verticalLayout_6;
    QDockWidget *dockSchema;
    QWidget *dockWidgetContents_3;
    QVBoxLayout *verticalLayout_9;
    QTreeView *treeSchemaDock;
    QDockWidget *dockRemote;
    QWidget *dockWidgetContents_5;
    QToolBar *toolbarProject;
    QToolBar *toolbarExtraDB;

    void setupUi(QMainWindow *MainWindow)
    {
        if (MainWindow->objectName().isEmpty())
            MainWindow->setObjectName(QString::fromUtf8("MainWindow"));
        MainWindow->resize(1037, 630);
        QIcon icon;
        icon.addFile(QString::fromUtf8(":/icons/appicon"), QSize(), QIcon::Normal, QIcon::Off);
        MainWindow->setWindowIcon(icon);
        fileNewAction = new QAction(MainWindow);
        fileNewAction->setObjectName(QString::fromUtf8("fileNewAction"));
        QIcon icon1;
        icon1.addFile(QString::fromUtf8(":/icons/db_new"), QSize(), QIcon::Normal, QIcon::Off);
        fileNewAction->setIcon(icon1);
        fileNewAction->setMenuRole(QAction::NoRole);
        fileOpenAction = new QAction(MainWindow);
        fileOpenAction->setObjectName(QString::fromUtf8("fileOpenAction"));
        QIcon icon2;
        icon2.addFile(QString::fromUtf8(":/icons/db_open"), QSize(), QIcon::Normal, QIcon::Off);
        fileOpenAction->setIcon(icon2);
        fileOpenAction->setMenuRole(QAction::NoRole);
        fileCloseAction = new QAction(MainWindow);
        fileCloseAction->setObjectName(QString::fromUtf8("fileCloseAction"));
        fileCloseAction->setEnabled(false);
        QIcon icon3;
        icon3.addFile(QString::fromUtf8(":/icons/close"), QSize(), QIcon::Normal, QIcon::Off);
        fileCloseAction->setIcon(icon3);
        fileCloseAction->setMenuRole(QAction::NoRole);
        fileRevertAction = new QAction(MainWindow);
        fileRevertAction->setObjectName(QString::fromUtf8("fileRevertAction"));
        fileRevertAction->setEnabled(false);
        QIcon icon4;
        icon4.addFile(QString::fromUtf8(":/icons/db_revert"), QSize(), QIcon::Normal, QIcon::Off);
        fileRevertAction->setIcon(icon4);
        fileRevertAction->setMenuRole(QAction::NoRole);
        undoAction = new QAction(MainWindow);
        undoAction->setObjectName(QString::fromUtf8("undoAction"));
        undoAction->setEnabled(false);
        QIcon icon5;
        icon5.addFile(QString::fromUtf8(":/icons/undo.svg"), QSize(), QIcon::Normal, QIcon::Off);
        undoAction->setIcon(icon5);
        undoAction->setMenuRole(QAction::NoRole);
        fileSaveAction = new QAction(MainWindow);
        fileSaveAction->setObjectName(QString::fromUtf8("fileSaveAction"));
        fileSaveAction->setEnabled(false);
        QIcon icon6;
        icon6.addFile(QString::fromUtf8(":/icons/db_save"), QSize(), QIcon::Normal, QIcon::Off);
        fileSaveAction->setIcon(icon6);
        fileSaveAction->setMenuRole(QAction::NoRole);
        fileCompactAction = new QAction(MainWindow);
        fileCompactAction->setObjectName(QString::fromUtf8("fileCompactAction"));
        fileCompactAction->setEnabled(false);
        fileCompactAction->setMenuRole(QAction::NoRole);
        fileExitAction = new QAction(MainWindow);
        fileExitAction->setObjectName(QString::fromUtf8("fileExitAction"));
        fileExitAction->setMenuRole(QAction::QuitRole);
        fileImportSQLAction = new QAction(MainWindow);
        fileImportSQLAction->setObjectName(QString::fromUtf8("fileImportSQLAction"));
        fileImportSQLAction->setMenuRole(QAction::NoRole);
        fileImportCSVAction = new QAction(MainWindow);
        fileImportCSVAction->setObjectName(QString::fromUtf8("fileImportCSVAction"));
        fileImportCSVAction->setMenuRole(QAction::NoRole);
        fileExportSQLAction = new QAction(MainWindow);
        fileExportSQLAction->setObjectName(QString::fromUtf8("fileExportSQLAction"));
        fileExportSQLAction->setMenuRole(QAction::NoRole);
        fileExportCSVAction = new QAction(MainWindow);
        fileExportCSVAction->setObjectName(QString::fromUtf8("fileExportCSVAction"));
        fileExportCSVAction->setMenuRole(QAction::NoRole);
        editCreateTableAction = new QAction(MainWindow);
        editCreateTableAction->setObjectName(QString::fromUtf8("editCreateTableAction"));
        editCreateTableAction->setEnabled(false);
        QIcon icon7;
        icon7.addFile(QString::fromUtf8(":/icons/table_create"), QSize(), QIcon::Normal, QIcon::Off);
        editCreateTableAction->setIcon(icon7);
        editCreateTableAction->setMenuRole(QAction::NoRole);
        editDeleteObjectAction = new QAction(MainWindow);
        editDeleteObjectAction->setObjectName(QString::fromUtf8("editDeleteObjectAction"));
        editDeleteObjectAction->setEnabled(false);
        QIcon icon8;
        icon8.addFile(QString::fromUtf8(":/icons/table_delete"), QSize(), QIcon::Normal, QIcon::Off);
        editDeleteObjectAction->setIcon(icon8);
        editDeleteObjectAction->setMenuRole(QAction::NoRole);
        editModifyObjectAction = new QAction(MainWindow);
        editModifyObjectAction->setObjectName(QString::fromUtf8("editModifyObjectAction"));
        editModifyObjectAction->setEnabled(false);
        QIcon icon9;
        icon9.addFile(QString::fromUtf8(":/icons/table_modify"), QSize(), QIcon::Normal, QIcon::Off);
        editModifyObjectAction->setIcon(icon9);
        editModifyObjectAction->setMenuRole(QAction::NoRole);
        editCreateIndexAction = new QAction(MainWindow);
        editCreateIndexAction->setObjectName(QString::fromUtf8("editCreateIndexAction"));
        editCreateIndexAction->setEnabled(false);
        QIcon icon10;
        icon10.addFile(QString::fromUtf8(":/icons/index_create"), QSize(), QIcon::Normal, QIcon::Off);
        editCreateIndexAction->setIcon(icon10);
        editCreateIndexAction->setMenuRole(QAction::NoRole);
        viewPreferencesAction = new QAction(MainWindow);
        viewPreferencesAction->setObjectName(QString::fromUtf8("viewPreferencesAction"));
        QIcon icon11;
        icon11.addFile(QString::fromUtf8(":/icons/settings"), QSize(), QIcon::Normal, QIcon::Off);
        viewPreferencesAction->setIcon(icon11);
        viewPreferencesAction->setMenuRole(QAction::PreferencesRole);
        viewDBToolbarAction = new QAction(MainWindow);
        viewDBToolbarAction->setObjectName(QString::fromUtf8("viewDBToolbarAction"));
        viewDBToolbarAction->setCheckable(true);
        QIcon icon12;
        icon12.addFile(QString::fromUtf8(":/icons/toolbar"), QSize(), QIcon::Normal, QIcon::Off);
        viewDBToolbarAction->setIcon(icon12);
        viewDBToolbarAction->setMenuRole(QAction::NoRole);
        helpWhatsThisAction = new QAction(MainWindow);
        helpWhatsThisAction->setObjectName(QString::fromUtf8("helpWhatsThisAction"));
        QIcon icon13;
        icon13.addFile(QString::fromUtf8(":/icons/whatis"), QSize(), QIcon::Normal, QIcon::Off);
        helpWhatsThisAction->setIcon(icon13);
        helpWhatsThisAction->setMenuRole(QAction::NoRole);
        helpAboutAction = new QAction(MainWindow);
        helpAboutAction->setObjectName(QString::fromUtf8("helpAboutAction"));
        helpAboutAction->setMenuRole(QAction::AboutRole);
        actionRecent_y_opened = new QAction(MainWindow);
        actionRecent_y_opened->setObjectName(QString::fromUtf8("actionRecent_y_opened"));
        actionSqlOpenTab = new QAction(MainWindow);
        actionSqlOpenTab->setObjectName(QString::fromUtf8("actionSqlOpenTab"));
        QIcon icon14;
        icon14.addFile(QString::fromUtf8(":/icons/new_tab"), QSize(), QIcon::Normal, QIcon::Off);
        actionSqlOpenTab->setIcon(icon14);
        actionExecuteSql = new QAction(MainWindow);
        actionExecuteSql->setObjectName(QString::fromUtf8("actionExecuteSql"));
        QIcon icon15;
        icon15.addFile(QString::fromUtf8(":/icons/run"), QSize(), QIcon::Normal, QIcon::Off);
        actionExecuteSql->setIcon(icon15);
        actionSqlOpenFile = new QAction(MainWindow);
        actionSqlOpenFile->setObjectName(QString::fromUtf8("actionSqlOpenFile"));
        QIcon icon16;
        icon16.addFile(QString::fromUtf8(":/icons/document_open"), QSize(), QIcon::Normal, QIcon::Off);
        actionSqlOpenFile->setIcon(icon16);
        actionSqlSaveFile = new QAction(MainWindow);
        actionSqlSaveFile->setObjectName(QString::fromUtf8("actionSqlSaveFile"));
        QIcon icon17;
        icon17.addFile(QString::fromUtf8(":/icons/save_sql"), QSize(), QIcon::Normal, QIcon::Off);
        actionSqlSaveFile->setIcon(icon17);
        actionLoadExtension = new QAction(MainWindow);
        actionLoadExtension->setObjectName(QString::fromUtf8("actionLoadExtension"));
        actionLoadExtension->setEnabled(false);
        QIcon icon18;
        icon18.addFile(QString::fromUtf8(":/icons/load_extension"), QSize(), QIcon::Normal, QIcon::Off);
        actionLoadExtension->setIcon(icon18);
        actionLoadExtension->setMenuRole(QAction::NoRole);
        actionSqlExecuteLine = new QAction(MainWindow);
        actionSqlExecuteLine->setObjectName(QString::fromUtf8("actionSqlExecuteLine"));
        QIcon icon19;
        icon19.addFile(QString::fromUtf8(":/icons/run_line"), QSize(), QIcon::Normal, QIcon::Off);
        actionSqlExecuteLine->setIcon(icon19);
        actionExportCsvPopup = new QAction(MainWindow);
        actionExportCsvPopup->setObjectName(QString::fromUtf8("actionExportCsvPopup"));
        actionExportCsvPopup->setEnabled(false);
        actionWiki = new QAction(MainWindow);
        actionWiki->setObjectName(QString::fromUtf8("actionWiki"));
        QIcon icon20;
        icon20.addFile(QString::fromUtf8(":/icons/browser_open"), QSize(), QIcon::Normal, QIcon::Off);
        actionWiki->setIcon(icon20);
        actionWiki->setMenuRole(QAction::NoRole);
        actionBug_report = new QAction(MainWindow);
        actionBug_report->setObjectName(QString::fromUtf8("actionBug_report"));
        actionBug_report->setIcon(icon20);
        actionBug_report->setMenuRole(QAction::NoRole);
        actionFeature_Request = new QAction(MainWindow);
        actionFeature_Request->setObjectName(QString::fromUtf8("actionFeature_Request"));
        actionFeature_Request->setIcon(icon20);
        actionFeature_Request->setMenuRole(QAction::NoRole);
        actionWebsite = new QAction(MainWindow);
        actionWebsite->setObjectName(QString::fromUtf8("actionWebsite"));
        actionWebsite->setIcon(icon20);
        actionWebsite->setMenuRole(QAction::NoRole);
        actionDonatePatreon = new QAction(MainWindow);
        actionDonatePatreon->setObjectName(QString::fromUtf8("actionDonatePatreon"));
        actionDonatePatreon->setIcon(icon20);
        actionDonatePatreon->setMenuRole(QAction::NoRole);
        actionSaveProject = new QAction(MainWindow);
        actionSaveProject->setObjectName(QString::fromUtf8("actionSaveProject"));
        QIcon icon21;
        icon21.addFile(QString::fromUtf8(":/icons/project_save"), QSize(), QIcon::Normal, QIcon::Off);
        actionSaveProject->setIcon(icon21);
        actionSaveProject->setMenuRole(QAction::NoRole);
        actionOpenProject = new QAction(MainWindow);
        actionOpenProject->setObjectName(QString::fromUtf8("actionOpenProject"));
        QIcon icon22;
        icon22.addFile(QString::fromUtf8(":/icons/project_open"), QSize(), QIcon::Normal, QIcon::Off);
        actionOpenProject->setIcon(icon22);
        actionOpenProject->setMenuRole(QAction::NoRole);
        fileAttachAction = new QAction(MainWindow);
        fileAttachAction->setObjectName(QString::fromUtf8("fileAttachAction"));
        fileAttachAction->setEnabled(false);
        QIcon icon23;
        icon23.addFile(QString::fromUtf8(":/icons/db_attach"), QSize(), QIcon::Normal, QIcon::Off);
        fileAttachAction->setIcon(icon23);
        fileAttachAction->setMenuRole(QAction::NoRole);
        actionEncryption = new QAction(MainWindow);
        actionEncryption->setObjectName(QString::fromUtf8("actionEncryption"));
        QIcon icon24;
        icon24.addFile(QString::fromUtf8(":/icons/encryption"), QSize(), QIcon::Normal, QIcon::Off);
        actionEncryption->setIcon(icon24);
        actionEncryption->setMenuRole(QAction::NoRole);
        actionSqlSaveFileAs = new QAction(MainWindow);
        actionSqlSaveFileAs->setObjectName(QString::fromUtf8("actionSqlSaveFileAs"));
        actionSqlSaveFileAs->setIcon(icon17);
        actionSqlSaveFilePopup = new QAction(MainWindow);
        actionSqlSaveFilePopup->setObjectName(QString::fromUtf8("actionSqlSaveFilePopup"));
        actionSqlSaveFilePopup->setIcon(icon17);
        actionEditBrowseTable = new QAction(MainWindow);
        actionEditBrowseTable->setObjectName(QString::fromUtf8("actionEditBrowseTable"));
        QIcon icon25;
        icon25.addFile(QString::fromUtf8(":/icons/table"), QSize(), QIcon::Normal, QIcon::Off);
        actionEditBrowseTable->setIcon(icon25);
        actionEditCopyCreateStatement = new QAction(MainWindow);
        actionEditCopyCreateStatement->setObjectName(QString::fromUtf8("actionEditCopyCreateStatement"));
        QIcon icon26;
        icon26.addFile(QString::fromUtf8(":/icons/copy"), QSize(), QIcon::Normal, QIcon::Off);
        actionEditCopyCreateStatement->setIcon(icon26);
        actionSqlCipherFaq = new QAction(MainWindow);
        actionSqlCipherFaq->setObjectName(QString::fromUtf8("actionSqlCipherFaq"));
        actionSqlCipherFaq->setIcon(icon20);
        fileExportJsonAction = new QAction(MainWindow);
        fileExportJsonAction->setObjectName(QString::fromUtf8("fileExportJsonAction"));
        fileExportJsonAction->setMenuRole(QAction::NoRole);
        fileOpenReadOnlyAction = new QAction(MainWindow);
        fileOpenReadOnlyAction->setObjectName(QString::fromUtf8("fileOpenReadOnlyAction"));
        fileOpenReadOnlyAction->setIcon(icon2);
        fileOpenReadOnlyAction->setMenuRole(QAction::NoRole);
        actionSqlResultsSave = new QAction(MainWindow);
        actionSqlResultsSave->setObjectName(QString::fromUtf8("actionSqlResultsSave"));
        QIcon icon27;
        icon27.addFile(QString::fromUtf8(":/icons/save_table"), QSize(), QIcon::Normal, QIcon::Off);
        actionSqlResultsSave->setIcon(icon27);
        actionSqlFind = new QAction(MainWindow);
        actionSqlFind->setObjectName(QString::fromUtf8("actionSqlFind"));
        actionSqlFind->setCheckable(true);
        QIcon icon28;
        icon28.addFile(QString::fromUtf8(":/icons/find"), QSize(), QIcon::Normal, QIcon::Off);
        actionSqlFind->setIcon(icon28);
        actionSqlFind->setShortcutContext(Qt::WidgetShortcut);
        actionSqlFindReplace = new QAction(MainWindow);
        actionSqlFindReplace->setObjectName(QString::fromUtf8("actionSqlFindReplace"));
        actionSqlFindReplace->setCheckable(false);
        QIcon icon29;
        icon29.addFile(QString::fromUtf8(":/icons/text_replace"), QSize(), QIcon::Normal, QIcon::Off);
        actionSqlFindReplace->setIcon(icon29);
        actionSqlFindReplace->setShortcutContext(Qt::WidgetShortcut);
        actionSqlResultsExportCsv = new QAction(MainWindow);
        actionSqlResultsExportCsv->setObjectName(QString::fromUtf8("actionSqlResultsExportCsv"));
        actionSqlResultsExportJson = new QAction(MainWindow);
        actionSqlResultsExportJson->setObjectName(QString::fromUtf8("actionSqlResultsExportJson"));
        actionSqlResultsSaveAsView = new QAction(MainWindow);
        actionSqlResultsSaveAsView->setObjectName(QString::fromUtf8("actionSqlResultsSaveAsView"));
        viewProjectToolbarAction = new QAction(MainWindow);
        viewProjectToolbarAction->setObjectName(QString::fromUtf8("viewProjectToolbarAction"));
        viewProjectToolbarAction->setCheckable(true);
        viewProjectToolbarAction->setChecked(false);
        viewProjectToolbarAction->setIcon(icon12);
        viewProjectToolbarAction->setMenuRole(QAction::NoRole);
        viewExtraDBToolbarAction = new QAction(MainWindow);
        viewExtraDBToolbarAction->setObjectName(QString::fromUtf8("viewExtraDBToolbarAction"));
        viewExtraDBToolbarAction->setCheckable(true);
        viewExtraDBToolbarAction->setIcon(icon12);
        fileOpenActionPopup = new QAction(MainWindow);
        fileOpenActionPopup->setObjectName(QString::fromUtf8("fileOpenActionPopup"));
        fileOpenActionPopup->setIcon(icon2);
        fileOpenActionPopup->setMenuRole(QAction::TextHeuristicRole);
        fileNewInMemoryDatabaseAction = new QAction(MainWindow);
        fileNewInMemoryDatabaseAction->setObjectName(QString::fromUtf8("fileNewInMemoryDatabaseAction"));
        actionDropSelectQueryCheck = new QAction(MainWindow);
        actionDropSelectQueryCheck->setObjectName(QString::fromUtf8("actionDropSelectQueryCheck"));
        actionDropSelectQueryCheck->setCheckable(true);
        actionDropQualifiedCheck = new QAction(MainWindow);
        actionDropQualifiedCheck->setObjectName(QString::fromUtf8("actionDropQualifiedCheck"));
        actionDropQualifiedCheck->setCheckable(true);
        actionEnquoteNamesCheck = new QAction(MainWindow);
        actionEnquoteNamesCheck->setObjectName(QString::fromUtf8("actionEnquoteNamesCheck"));
        actionEnquoteNamesCheck->setCheckable(true);
        actionIntegrityCheck = new QAction(MainWindow);
        actionIntegrityCheck->setObjectName(QString::fromUtf8("actionIntegrityCheck"));
        actionForeignKeyCheck = new QAction(MainWindow);
        actionForeignKeyCheck->setObjectName(QString::fromUtf8("actionForeignKeyCheck"));
        actionQuickCheck = new QAction(MainWindow);
        actionQuickCheck->setObjectName(QString::fromUtf8("actionQuickCheck"));
        actionOptimize = new QAction(MainWindow);
        actionOptimize->setObjectName(QString::fromUtf8("actionOptimize"));
        actionSqlPrint = new QAction(MainWindow);
        actionSqlPrint->setObjectName(QString::fromUtf8("actionSqlPrint"));
        QIcon icon30;
        icon30.addFile(QString::fromUtf8(":/icons/print"), QSize(), QIcon::Normal, QIcon::Off);
        actionSqlPrint->setIcon(icon30);
        actionSqlPrint->setShortcutContext(Qt::WidgetShortcut);
        actionDbPrint = new QAction(MainWindow);
        actionDbPrint->setObjectName(QString::fromUtf8("actionDbPrint"));
        actionDbPrint->setEnabled(false);
        actionDbPrint->setIcon(icon30);
        actionDbPrint->setShortcutContext(Qt::WidgetShortcut);
        actionSqlToggleComment = new QAction(MainWindow);
        actionSqlToggleComment->setObjectName(QString::fromUtf8("actionSqlToggleComment"));
        QIcon icon31;
        icon31.addFile(QString::fromUtf8(":/icons/comment_block"), QSize(), QIcon::Normal, QIcon::Off);
        actionSqlToggleComment->setIcon(icon31);
        actionSqlToggleComment->setShortcutContext(Qt::WidgetShortcut);
        actionSqlStop = new QAction(MainWindow);
        actionSqlStop->setObjectName(QString::fromUtf8("actionSqlStop"));
        QIcon icon32;
        icon32.addFile(QString::fromUtf8(":/icons/cancel"), QSize(), QIcon::Normal, QIcon::Off);
        actionSqlStop->setIcon(icon32);
        actionSaveProjectAs = new QAction(MainWindow);
        actionSaveProjectAs->setObjectName(QString::fromUtf8("actionSaveProjectAs"));
        QIcon icon33;
        icon33.addFile(QString::fromUtf8(":/icons/project_save_as"), QSize(), QIcon::Normal, QIcon::Off);
        actionSaveProjectAs->setIcon(icon33);
        actionSaveAll = new QAction(MainWindow);
        actionSaveAll->setObjectName(QString::fromUtf8("actionSaveAll"));
        QIcon icon34;
        icon34.addFile(QString::fromUtf8(":/icons/save_all"), QSize(), QIcon::Normal, QIcon::Off);
        actionSaveAll->setIcon(icon34);
        actionPopupSchemaDockBrowseTable = new QAction(MainWindow);
        actionPopupSchemaDockBrowseTable->setObjectName(QString::fromUtf8("actionPopupSchemaDockBrowseTable"));
        actionPopupSchemaDockBrowseTable->setIcon(icon25);
        actionCloseProject = new QAction(MainWindow);
        actionCloseProject->setObjectName(QString::fromUtf8("actionCloseProject"));
        fileDetachAction = new QAction(MainWindow);
        fileDetachAction->setObjectName(QString::fromUtf8("fileDetachAction"));
        QIcon icon35;
        icon35.addFile(QString::fromUtf8(":/icons/db_detach"), QSize(), QIcon::Normal, QIcon::Off);
        fileDetachAction->setIcon(icon35);
        actionPopupSchemaDockDetachDatabase = new QAction(MainWindow);
        actionPopupSchemaDockDetachDatabase->setObjectName(QString::fromUtf8("actionPopupSchemaDockDetachDatabase"));
        actionPopupSchemaDockDetachDatabase->setIcon(icon35);
        actionFileImportCsvClipboard = new QAction(MainWindow);
        actionFileImportCsvClipboard->setObjectName(QString::fromUtf8("actionFileImportCsvClipboard"));
        actionRowCounts = new QAction(MainWindow);
        actionRowCounts->setObjectName(QString::fromUtf8("actionRowCounts"));
        fileSaveAsAction = new QAction(MainWindow);
        fileSaveAsAction->setObjectName(QString::fromUtf8("fileSaveAsAction"));
        fileSaveAsAction->setEnabled(false);
        fileSaveAsAction->setIcon(icon6);
        actionRefreshStructure = new QAction(MainWindow);
        actionRefreshStructure->setObjectName(QString::fromUtf8("actionRefreshStructure"));
        QIcon icon36;
        icon36.addFile(QString::fromUtf8(":/icons/refresh"), QSize(), QIcon::Normal, QIcon::Off);
        actionRefreshStructure->setIcon(icon36);
        centralwidget = new QWidget(MainWindow);
        centralwidget->setObjectName(QString::fromUtf8("centralwidget"));
        verticalLayout_7 = new QVBoxLayout(centralwidget);
        verticalLayout_7->setSpacing(3);
        verticalLayout_7->setObjectName(QString::fromUtf8("verticalLayout_7"));
        verticalLayout_7->setContentsMargins(3, 3, 3, 3);
        mainTab = new QTabWidget(centralwidget);
        mainTab->setObjectName(QString::fromUtf8("mainTab"));
        mainTab->setMovable(true);
        mainTab->setTabBarAutoHide(true);
        structure = new QWidget();
        structure->setObjectName(QString::fromUtf8("structure"));
        verticalLayout = new QVBoxLayout(structure);
        verticalLayout->setSpacing(3);
        verticalLayout->setObjectName(QString::fromUtf8("verticalLayout"));
        verticalLayout->setContentsMargins(3, 3, 3, 3);
        dbToolbar = new QToolBar(structure);
        dbToolbar->setObjectName(QString::fromUtf8("dbToolbar"));
        dbToolbar->setWindowTitle(QString::fromUtf8("toolBar1"));
        dbToolbar->setToolButtonStyle(Qt::ToolButtonTextBesideIcon);

        verticalLayout->addWidget(dbToolbar);

        dbTreeWidget = new QTreeView(structure);
        dbTreeWidget->setObjectName(QString::fromUtf8("dbTreeWidget"));
        dbTreeWidget->setContextMenuPolicy(Qt::CustomContextMenu);
        dbTreeWidget->setDragEnabled(true);
        dbTreeWidget->setDragDropMode(QAbstractItemView::DragDrop);
        dbTreeWidget->setAlternatingRowColors(true);
        dbTreeWidget->setVerticalScrollMode(QAbstractItemView::ScrollPerPixel);
        dbTreeWidget->setAnimated(true);

        verticalLayout->addWidget(dbTreeWidget);

        mainTab->addTab(structure, QString());
        browser = new QWidget();
        browser->setObjectName(QString::fromUtf8("browser"));
        verticalLayout_2 = new QVBoxLayout(browser);
        verticalLayout_2->setSpacing(0);
        verticalLayout_2->setObjectName(QString::fromUtf8("verticalLayout_2"));
        verticalLayout_2->setContentsMargins(0, 0, 0, 0);
        tabBrowsers = new QMainWindow(browser);
        tabBrowsers->setObjectName(QString::fromUtf8("tabBrowsers"));
        tabBrowsers->setContextMenuPolicy(Qt::CustomContextMenu);
        tabBrowsers->setDockOptions(QMainWindow::AllowNestedDocks|QMainWindow::AllowTabbedDocks|QMainWindow::AnimatedDocks);

        verticalLayout_2->addWidget(tabBrowsers);

        mainTab->addTab(browser, QString());
        pragmas = new QWidget();
        pragmas->setObjectName(QString::fromUtf8("pragmas"));
        verticalLayout_4 = new QVBoxLayout(pragmas);
        verticalLayout_4->setSpacing(3);
        verticalLayout_4->setObjectName(QString::fromUtf8("verticalLayout_4"));
        verticalLayout_4->setContentsMargins(3, 3, 3, 3);
        scrollareaPragmas = new QScrollArea(pragmas);
        scrollareaPragmas->setObjectName(QString::fromUtf8("scrollareaPragmas"));
        scrollareaPragmas->setWidgetResizable(true);
        scrollareaPragmas->setAlignment(Qt::AlignCenter);
        scrollAreaWidgetContents = new QWidget();
        scrollAreaWidgetContents->setObjectName(QString::fromUtf8("scrollAreaWidgetContents"));
        scrollAreaWidgetContents->setGeometry(QRect(153, 0, 329, 510));
        QSizePolicy sizePolicy(QSizePolicy::Fixed, QSizePolicy::Preferred);
        sizePolicy.setHorizontalStretch(0);
        sizePolicy.setVerticalStretch(0);
        sizePolicy.setHeightForWidth(scrollAreaWidgetContents->sizePolicy().hasHeightForWidth());
        scrollAreaWidgetContents->setSizePolicy(sizePolicy);
        gridLayout = new QGridLayout(scrollAreaWidgetContents);
        gridLayout->setObjectName(QString::fromUtf8("gridLayout"));
        labelPragmaTempStore = new QLabel(scrollAreaWidgetContents);
        labelPragmaTempStore->setObjectName(QString::fromUtf8("labelPragmaTempStore"));
#if QT_CONFIG(tooltip)
        labelPragmaTempStore->setToolTip(QString::fromUtf8("PRAGMA temp_store"));
#endif // QT_CONFIG(tooltip)
        labelPragmaTempStore->setAlignment(Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter);

        gridLayout->addWidget(labelPragmaTempStore, 30, 0, 1, 1);

        labelPragmaSecureDelete = new QLabel(scrollAreaWidgetContents);
        labelPragmaSecureDelete->setObjectName(QString::fromUtf8("labelPragmaSecureDelete"));
#if QT_CONFIG(tooltip)
        labelPragmaSecureDelete->setToolTip(QString::fromUtf8("PRAGMA secure_delete"));
#endif // QT_CONFIG(tooltip)
        labelPragmaSecureDelete->setAlignment(Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter);

        gridLayout->addWidget(labelPragmaSecureDelete, 26, 0, 1, 1);

        labelPragmaWalAutoCheckpoint_2 = new QLabel(scrollAreaWidgetContents);
        labelPragmaWalAutoCheckpoint_2->setObjectName(QString::fromUtf8("labelPragmaWalAutoCheckpoint_2"));
        QSizePolicy sizePolicy1(QSizePolicy::Preferred, QSizePolicy::Fixed);
        sizePolicy1.setHorizontalStretch(0);
        sizePolicy1.setVerticalStretch(0);
        sizePolicy1.setHeightForWidth(labelPragmaWalAutoCheckpoint_2->sizePolicy().hasHeightForWidth());
        labelPragmaWalAutoCheckpoint_2->setSizePolicy(sizePolicy1);
        labelPragmaWalAutoCheckpoint_2->setText(QString::fromUtf8("<html><head/><body><p><a href=\"https://www.sqlite.org/pragma.html#pragma_wal_autocheckpoint\"><img src=\":/icons/whatis\"/></a></p></body></html>"));
#if QT_CONFIG(statustip)
        labelPragmaWalAutoCheckpoint_2->setStatusTip(QString::fromUtf8("https://www.sqlite.org/pragma.html#pragma_wal_autocheckpoint"));
#endif // QT_CONFIG(statustip)
        labelPragmaWalAutoCheckpoint_2->setAlignment(Qt::AlignCenter);
        labelPragmaWalAutoCheckpoint_2->setOpenExternalLinks(true);

        gridLayout->addWidget(labelPragmaWalAutoCheckpoint_2, 34, 1, 1, 1);

        labelPragmaCaseSensitiveLike = new QLabel(scrollAreaWidgetContents);
        labelPragmaCaseSensitiveLike->setObjectName(QString::fromUtf8("labelPragmaCaseSensitiveLike"));
#if QT_CONFIG(tooltip)
        labelPragmaCaseSensitiveLike->setToolTip(QString::fromUtf8("PRAGMA case_sensitive_like"));
#endif // QT_CONFIG(tooltip)
        labelPragmaCaseSensitiveLike->setAlignment(Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter);

        gridLayout->addWidget(labelPragmaCaseSensitiveLike, 4, 0, 1, 1);

        labelPragmaJournalMode_2 = new QLabel(scrollAreaWidgetContents);
        labelPragmaJournalMode_2->setObjectName(QString::fromUtf8("labelPragmaJournalMode_2"));
        sizePolicy1.setHeightForWidth(labelPragmaJournalMode_2->sizePolicy().hasHeightForWidth());
        labelPragmaJournalMode_2->setSizePolicy(sizePolicy1);
        labelPragmaJournalMode_2->setText(QString::fromUtf8("<html><head/><body><p><a href=\"https://www.sqlite.org/pragma.html#pragma_journal_mode\"><img src=\":/icons/whatis\"/></a></p></body></html>"));
#if QT_CONFIG(statustip)
        labelPragmaJournalMode_2->setStatusTip(QString::fromUtf8("https://www.sqlite.org/pragma.html#pragma_journal_mode"));
#endif // QT_CONFIG(statustip)
        labelPragmaJournalMode_2->setAlignment(Qt::AlignCenter);
        labelPragmaJournalMode_2->setOpenExternalLinks(true);

        gridLayout->addWidget(labelPragmaJournalMode_2, 14, 1, 1, 1);

        labelPragmaSecureDelete_2 = new QLabel(scrollAreaWidgetContents);
        labelPragmaSecureDelete_2->setObjectName(QString::fromUtf8("labelPragmaSecureDelete_2"));
        sizePolicy1.setHeightForWidth(labelPragmaSecureDelete_2->sizePolicy().hasHeightForWidth());
        labelPragmaSecureDelete_2->setSizePolicy(sizePolicy1);
        labelPragmaSecureDelete_2->setText(QString::fromUtf8("<html><head/><body><p><a href=\"https://www.sqlite.org/pragma.html#pragma_secure_delete\"><img src=\":/icons/whatis\"/></a></p></body></html>"));
#if QT_CONFIG(statustip)
        labelPragmaSecureDelete_2->setStatusTip(QString::fromUtf8("https://www.sqlite.org/pragma.html#pragma_secure_delete"));
#endif // QT_CONFIG(statustip)
        labelPragmaSecureDelete_2->setAlignment(Qt::AlignCenter);
        labelPragmaSecureDelete_2->setOpenExternalLinks(true);

        gridLayout->addWidget(labelPragmaSecureDelete_2, 26, 1, 1, 1);

        labelPragmaSynchronous_2 = new QLabel(scrollAreaWidgetContents);
        labelPragmaSynchronous_2->setObjectName(QString::fromUtf8("labelPragmaSynchronous_2"));
        sizePolicy1.setHeightForWidth(labelPragmaSynchronous_2->sizePolicy().hasHeightForWidth());
        labelPragmaSynchronous_2->setSizePolicy(sizePolicy1);
        labelPragmaSynchronous_2->setText(QString::fromUtf8("<html><head/><body><p><a href=\"https://www.sqlite.org/pragma.html#pragma_synchronous\"><img src=\":/icons/whatis\"/></a></p></body></html>"));
#if QT_CONFIG(statustip)
        labelPragmaSynchronous_2->setStatusTip(QString::fromUtf8("https://www.sqlite.org/pragma.html#pragma_synchronous"));
#endif // QT_CONFIG(statustip)
        labelPragmaSynchronous_2->setAlignment(Qt::AlignCenter);
        labelPragmaSynchronous_2->setOpenExternalLinks(true);

        gridLayout->addWidget(labelPragmaSynchronous_2, 28, 1, 1, 1);

        labelPragmaJournalMode = new QLabel(scrollAreaWidgetContents);
        labelPragmaJournalMode->setObjectName(QString::fromUtf8("labelPragmaJournalMode"));
#if QT_CONFIG(tooltip)
        labelPragmaJournalMode->setToolTip(QString::fromUtf8("PRAGMA journal_mode"));
#endif // QT_CONFIG(tooltip)
        labelPragmaJournalMode->setAlignment(Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter);

        gridLayout->addWidget(labelPragmaJournalMode, 14, 0, 1, 1);

        labelJournalSizeLimit = new QLabel(scrollAreaWidgetContents);
        labelJournalSizeLimit->setObjectName(QString::fromUtf8("labelJournalSizeLimit"));
#if QT_CONFIG(tooltip)
        labelJournalSizeLimit->setToolTip(QString::fromUtf8("PRAGMA journal_size_limit"));
#endif // QT_CONFIG(tooltip)
        labelJournalSizeLimit->setAlignment(Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter);

        gridLayout->addWidget(labelJournalSizeLimit, 16, 0, 1, 1);

        labelPragmaRecursiveTriggers = new QLabel(scrollAreaWidgetContents);
        labelPragmaRecursiveTriggers->setObjectName(QString::fromUtf8("labelPragmaRecursiveTriggers"));
#if QT_CONFIG(tooltip)
        labelPragmaRecursiveTriggers->setToolTip(QString::fromUtf8("PRAGMA recursive_triggers"));
#endif // QT_CONFIG(tooltip)
        labelPragmaRecursiveTriggers->setAlignment(Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter);

        gridLayout->addWidget(labelPragmaRecursiveTriggers, 24, 0, 1, 1);

        comboboxPragmaJournalMode = new QComboBox(scrollAreaWidgetContents);
        comboboxPragmaJournalMode->addItem(QString());
        comboboxPragmaJournalMode->addItem(QString());
        comboboxPragmaJournalMode->addItem(QString());
        comboboxPragmaJournalMode->addItem(QString());
        comboboxPragmaJournalMode->addItem(QString());
        comboboxPragmaJournalMode->addItem(QString());
        comboboxPragmaJournalMode->setObjectName(QString::fromUtf8("comboboxPragmaJournalMode"));

        gridLayout->addWidget(comboboxPragmaJournalMode, 14, 2, 1, 1);

        labelPragmaFullFsync_2 = new QLabel(scrollAreaWidgetContents);
        labelPragmaFullFsync_2->setObjectName(QString::fromUtf8("labelPragmaFullFsync_2"));
        sizePolicy1.setHeightForWidth(labelPragmaFullFsync_2->sizePolicy().hasHeightForWidth());
        labelPragmaFullFsync_2->setSizePolicy(sizePolicy1);
        labelPragmaFullFsync_2->setText(QString::fromUtf8("<html><head/><body><p><a href=\"https://www.sqlite.org/pragma.html#pragma_fullfsync\"><img src=\":/icons/whatis\"/></a></p></body></html>"));
#if QT_CONFIG(statustip)
        labelPragmaFullFsync_2->setStatusTip(QString::fromUtf8("https://www.sqlite.org/pragma.html#pragma_fullfsync"));
#endif // QT_CONFIG(statustip)
        labelPragmaFullFsync_2->setAlignment(Qt::AlignCenter);
        labelPragmaFullFsync_2->setOpenExternalLinks(true);

        gridLayout->addWidget(labelPragmaFullFsync_2, 10, 1, 1, 1);

        labelJournalSizeLimit_2 = new QLabel(scrollAreaWidgetContents);
        labelJournalSizeLimit_2->setObjectName(QString::fromUtf8("labelJournalSizeLimit_2"));
        sizePolicy1.setHeightForWidth(labelJournalSizeLimit_2->sizePolicy().hasHeightForWidth());
        labelJournalSizeLimit_2->setSizePolicy(sizePolicy1);
        labelJournalSizeLimit_2->setText(QString::fromUtf8("<html><head/><body><p><a href=\"https://www.sqlite.org/pragma.html#pragma_journal_size_limit\"><img src=\":/icons/whatis\"/></a></p></body></html>"));
#if QT_CONFIG(statustip)
        labelJournalSizeLimit_2->setStatusTip(QString::fromUtf8("https://www.sqlite.org/pragma.html#pragma_journal_size_limit"));
#endif // QT_CONFIG(statustip)
        labelJournalSizeLimit_2->setAlignment(Qt::AlignCenter);
        labelJournalSizeLimit_2->setOpenExternalLinks(true);

        gridLayout->addWidget(labelJournalSizeLimit_2, 16, 1, 1, 1);

        labelPragmaPageSize = new QLabel(scrollAreaWidgetContents);
        labelPragmaPageSize->setObjectName(QString::fromUtf8("labelPragmaPageSize"));
#if QT_CONFIG(tooltip)
        labelPragmaPageSize->setToolTip(QString::fromUtf8("PRAGMA page_size"));
#endif // QT_CONFIG(tooltip)
        labelPragmaPageSize->setAlignment(Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter);

        gridLayout->addWidget(labelPragmaPageSize, 22, 0, 1, 1);

        labelPragmaCaseSensitiveLike_2 = new QLabel(scrollAreaWidgetContents);
        labelPragmaCaseSensitiveLike_2->setObjectName(QString::fromUtf8("labelPragmaCaseSensitiveLike_2"));
        sizePolicy1.setHeightForWidth(labelPragmaCaseSensitiveLike_2->sizePolicy().hasHeightForWidth());
        labelPragmaCaseSensitiveLike_2->setSizePolicy(sizePolicy1);
        labelPragmaCaseSensitiveLike_2->setText(QString::fromUtf8("<html><head/><body><p><a href=\"https://www.sqlite.org/pragma.html#pragma_case_sensitive_like\"><img src=\":/icons/whatis\"/></a></p></body></html>"));
#if QT_CONFIG(statustip)
        labelPragmaCaseSensitiveLike_2->setStatusTip(QString::fromUtf8("https://www.sqlite.org/pragma.html#pragma_case_sensitive_like"));
#endif // QT_CONFIG(statustip)
        labelPragmaCaseSensitiveLike_2->setAlignment(Qt::AlignCenter);
        labelPragmaCaseSensitiveLike_2->setOpenExternalLinks(true);

        gridLayout->addWidget(labelPragmaCaseSensitiveLike_2, 4, 1, 1, 1);

        checkboxPragmaSecureDelete = new QCheckBox(scrollAreaWidgetContents);
        checkboxPragmaSecureDelete->setObjectName(QString::fromUtf8("checkboxPragmaSecureDelete"));

        gridLayout->addWidget(checkboxPragmaSecureDelete, 26, 2, 1, 1);

        labelPragmaForeignKeys = new QLabel(scrollAreaWidgetContents);
        labelPragmaForeignKeys->setObjectName(QString::fromUtf8("labelPragmaForeignKeys"));
#if QT_CONFIG(tooltip)
        labelPragmaForeignKeys->setToolTip(QString::fromUtf8("PRAGMA foreign_keys"));
#endif // QT_CONFIG(tooltip)
        labelPragmaForeignKeys->setAlignment(Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter);

        gridLayout->addWidget(labelPragmaForeignKeys, 8, 0, 1, 1);

        checkboxPragmaIgnoreCheckConstraints = new QCheckBox(scrollAreaWidgetContents);
        checkboxPragmaIgnoreCheckConstraints->setObjectName(QString::fromUtf8("checkboxPragmaIgnoreCheckConstraints"));

        gridLayout->addWidget(checkboxPragmaIgnoreCheckConstraints, 12, 2, 1, 1);

        checkboxPragmaCheckpointFullFsync = new QCheckBox(scrollAreaWidgetContents);
        checkboxPragmaCheckpointFullFsync->setObjectName(QString::fromUtf8("checkboxPragmaCheckpointFullFsync"));

        gridLayout->addWidget(checkboxPragmaCheckpointFullFsync, 6, 2, 1, 1);

        checkboxPragmaFullFsync = new QCheckBox(scrollAreaWidgetContents);
        checkboxPragmaFullFsync->setObjectName(QString::fromUtf8("checkboxPragmaFullFsync"));

        gridLayout->addWidget(checkboxPragmaFullFsync, 10, 2, 1, 1);

        checkboxPragmaRecursiveTriggers = new QCheckBox(scrollAreaWidgetContents);
        checkboxPragmaRecursiveTriggers->setObjectName(QString::fromUtf8("checkboxPragmaRecursiveTriggers"));

        gridLayout->addWidget(checkboxPragmaRecursiveTriggers, 24, 2, 1, 1);

        spinPragmaUserVersion = new QSpinBox(scrollAreaWidgetContents);
        spinPragmaUserVersion->setObjectName(QString::fromUtf8("spinPragmaUserVersion"));
        spinPragmaUserVersion->setMaximum(2147483647);

        gridLayout->addWidget(spinPragmaUserVersion, 32, 2, 1, 1);

        checkboxPragmaForeignKeys = new QCheckBox(scrollAreaWidgetContents);
        checkboxPragmaForeignKeys->setObjectName(QString::fromUtf8("checkboxPragmaForeignKeys"));

        gridLayout->addWidget(checkboxPragmaForeignKeys, 8, 2, 1, 1);

        labelPragmaIgnoreCheckConstraints_2 = new QLabel(scrollAreaWidgetContents);
        labelPragmaIgnoreCheckConstraints_2->setObjectName(QString::fromUtf8("labelPragmaIgnoreCheckConstraints_2"));
        sizePolicy1.setHeightForWidth(labelPragmaIgnoreCheckConstraints_2->sizePolicy().hasHeightForWidth());
        labelPragmaIgnoreCheckConstraints_2->setSizePolicy(sizePolicy1);
        labelPragmaIgnoreCheckConstraints_2->setText(QString::fromUtf8("<html><head/><body><p><a href=\"https://www.sqlite.org/pragma.html#pragma_ignore_check_constraints\"><img src=\":/icons/whatis\"/></a></p></body></html>"));
#if QT_CONFIG(statustip)
        labelPragmaIgnoreCheckConstraints_2->setStatusTip(QString::fromUtf8("https://www.sqlite.org/pragma.html#pragma_ignore_check_constraints"));
#endif // QT_CONFIG(statustip)
        labelPragmaIgnoreCheckConstraints_2->setAlignment(Qt::AlignCenter);
        labelPragmaIgnoreCheckConstraints_2->setOpenExternalLinks(true);

        gridLayout->addWidget(labelPragmaIgnoreCheckConstraints_2, 12, 1, 1, 1);

        labelPragmaAutomaticIndex_2 = new QLabel(scrollAreaWidgetContents);
        labelPragmaAutomaticIndex_2->setObjectName(QString::fromUtf8("labelPragmaAutomaticIndex_2"));
        sizePolicy1.setHeightForWidth(labelPragmaAutomaticIndex_2->sizePolicy().hasHeightForWidth());
        labelPragmaAutomaticIndex_2->setSizePolicy(sizePolicy1);
        labelPragmaAutomaticIndex_2->setText(QString::fromUtf8("<html><head/><body><p><a href=\"https://www.sqlite.org/pragma.html#pragma_automatic_index\"><img src=\":/icons/whatis\"/></a></p></body></html>"));
#if QT_CONFIG(statustip)
        labelPragmaAutomaticIndex_2->setStatusTip(QString::fromUtf8("https://www.sqlite.org/pragma.html#pragma_automatic_index"));
#endif // QT_CONFIG(statustip)
        labelPragmaAutomaticIndex_2->setAlignment(Qt::AlignCenter);
        labelPragmaAutomaticIndex_2->setOpenExternalLinks(true);

        gridLayout->addWidget(labelPragmaAutomaticIndex_2, 2, 1, 1, 1);

        checkboxPragmaAutomaticIndex = new QCheckBox(scrollAreaWidgetContents);
        checkboxPragmaAutomaticIndex->setObjectName(QString::fromUtf8("checkboxPragmaAutomaticIndex"));

        gridLayout->addWidget(checkboxPragmaAutomaticIndex, 2, 2, 1, 1);

        labelPragmaPageSize_2 = new QLabel(scrollAreaWidgetContents);
        labelPragmaPageSize_2->setObjectName(QString::fromUtf8("labelPragmaPageSize_2"));
        sizePolicy1.setHeightForWidth(labelPragmaPageSize_2->sizePolicy().hasHeightForWidth());
        labelPragmaPageSize_2->setSizePolicy(sizePolicy1);
        labelPragmaPageSize_2->setText(QString::fromUtf8("<html><head/><body><p><a href=\"https://www.sqlite.org/pragma.html#pragma_page_size\"><img src=\":/icons/whatis\"/></a></p></body></html>"));
#if QT_CONFIG(statustip)
        labelPragmaPageSize_2->setStatusTip(QString::fromUtf8("https://www.sqlite.org/pragma.html#pragma_page_size"));
#endif // QT_CONFIG(statustip)
        labelPragmaPageSize_2->setAlignment(Qt::AlignCenter);
        labelPragmaPageSize_2->setOpenExternalLinks(true);

        gridLayout->addWidget(labelPragmaPageSize_2, 22, 1, 1, 1);

        labelPragmaAutoVacuum_2 = new QLabel(scrollAreaWidgetContents);
        labelPragmaAutoVacuum_2->setObjectName(QString::fromUtf8("labelPragmaAutoVacuum_2"));
        QSizePolicy sizePolicy2(QSizePolicy::Fixed, QSizePolicy::Fixed);
        sizePolicy2.setHorizontalStretch(0);
        sizePolicy2.setVerticalStretch(0);
        sizePolicy2.setHeightForWidth(labelPragmaAutoVacuum_2->sizePolicy().hasHeightForWidth());
        labelPragmaAutoVacuum_2->setSizePolicy(sizePolicy2);
        labelPragmaAutoVacuum_2->setText(QString::fromUtf8("<html><head/><body><p><a href=\"https://www.sqlite.org/pragma.html#pragma_auto_vacuum\"><img src=\":/icons/whatis\"/></a></p></body></html>"));
#if QT_CONFIG(statustip)
        labelPragmaAutoVacuum_2->setStatusTip(QString::fromUtf8("https://www.sqlite.org/pragma.html#pragma_auto_vacuum"));
#endif // QT_CONFIG(statustip)
        labelPragmaAutoVacuum_2->setAlignment(Qt::AlignCenter);
        labelPragmaAutoVacuum_2->setOpenExternalLinks(true);
        labelPragmaAutoVacuum_2->setTextInteractionFlags(Qt::LinksAccessibleByMouse);

        gridLayout->addWidget(labelPragmaAutoVacuum_2, 0, 1, 1, 1);

        labelPragmaRecursiveTriggers_2 = new QLabel(scrollAreaWidgetContents);
        labelPragmaRecursiveTriggers_2->setObjectName(QString::fromUtf8("labelPragmaRecursiveTriggers_2"));
        sizePolicy1.setHeightForWidth(labelPragmaRecursiveTriggers_2->sizePolicy().hasHeightForWidth());
        labelPragmaRecursiveTriggers_2->setSizePolicy(sizePolicy1);
        labelPragmaRecursiveTriggers_2->setText(QString::fromUtf8("<html><head/><body><p><a href=\"https://www.sqlite.org/pragma.html#pragma_recursive_triggers\"><img src=\":/icons/whatis\"/></a></p></body></html>"));
#if QT_CONFIG(statustip)
        labelPragmaRecursiveTriggers_2->setStatusTip(QString::fromUtf8("https://www.sqlite.org/pragma.html#pragma_recursive_triggers"));
#endif // QT_CONFIG(statustip)
        labelPragmaRecursiveTriggers_2->setAlignment(Qt::AlignCenter);
        labelPragmaRecursiveTriggers_2->setOpenExternalLinks(true);

        gridLayout->addWidget(labelPragmaRecursiveTriggers_2, 24, 1, 1, 1);

        labelPragmaTempStore_2 = new QLabel(scrollAreaWidgetContents);
        labelPragmaTempStore_2->setObjectName(QString::fromUtf8("labelPragmaTempStore_2"));
        sizePolicy1.setHeightForWidth(labelPragmaTempStore_2->sizePolicy().hasHeightForWidth());
        labelPragmaTempStore_2->setSizePolicy(sizePolicy1);
        labelPragmaTempStore_2->setText(QString::fromUtf8("<html><head/><body><p><a href=\"https://www.sqlite.org/pragma.html#pragma_temp_store\"><img src=\":/icons/whatis\"/></a></p></body></html>"));
#if QT_CONFIG(statustip)
        labelPragmaTempStore_2->setStatusTip(QString::fromUtf8("https://www.sqlite.org/pragma.html#pragma_temp_store"));
#endif // QT_CONFIG(statustip)
        labelPragmaTempStore_2->setAlignment(Qt::AlignCenter);
        labelPragmaTempStore_2->setOpenExternalLinks(true);

        gridLayout->addWidget(labelPragmaTempStore_2, 30, 1, 1, 1);

        labelPragmaCheckpointFullFsync_2 = new QLabel(scrollAreaWidgetContents);
        labelPragmaCheckpointFullFsync_2->setObjectName(QString::fromUtf8("labelPragmaCheckpointFullFsync_2"));
        sizePolicy1.setHeightForWidth(labelPragmaCheckpointFullFsync_2->sizePolicy().hasHeightForWidth());
        labelPragmaCheckpointFullFsync_2->setSizePolicy(sizePolicy1);
        labelPragmaCheckpointFullFsync_2->setText(QString::fromUtf8("<html><head/><body><p><a href=\"https://www.sqlite.org/pragma.html#pragma_checkpoint_fullfsync\"><img src=\":/icons/whatis\"/></a></p></body></html>"));
#if QT_CONFIG(statustip)
        labelPragmaCheckpointFullFsync_2->setStatusTip(QString::fromUtf8("https://www.sqlite.org/pragma.html#pragma_checkpoint_fullfsync"));
#endif // QT_CONFIG(statustip)
        labelPragmaCheckpointFullFsync_2->setAlignment(Qt::AlignCenter);
        labelPragmaCheckpointFullFsync_2->setOpenExternalLinks(true);

        gridLayout->addWidget(labelPragmaCheckpointFullFsync_2, 6, 1, 1, 1);

        labelPragmaAutoVacuum = new QLabel(scrollAreaWidgetContents);
        labelPragmaAutoVacuum->setObjectName(QString::fromUtf8("labelPragmaAutoVacuum"));
#if QT_CONFIG(tooltip)
        labelPragmaAutoVacuum->setToolTip(QString::fromUtf8("PRAGMA auto_vacuum"));
#endif // QT_CONFIG(tooltip)
        labelPragmaAutoVacuum->setAlignment(Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter);

        gridLayout->addWidget(labelPragmaAutoVacuum, 0, 0, 1, 1);

        spinPragmaWalAutoCheckpoint = new QSpinBox(scrollAreaWidgetContents);
        spinPragmaWalAutoCheckpoint->setObjectName(QString::fromUtf8("spinPragmaWalAutoCheckpoint"));
        spinPragmaWalAutoCheckpoint->setMaximum(10000);

        gridLayout->addWidget(spinPragmaWalAutoCheckpoint, 34, 2, 1, 1);

        labelPragmaMaxPageCount = new QLabel(scrollAreaWidgetContents);
        labelPragmaMaxPageCount->setObjectName(QString::fromUtf8("labelPragmaMaxPageCount"));
#if QT_CONFIG(tooltip)
        labelPragmaMaxPageCount->setToolTip(QString::fromUtf8("PRAGMA max_page_count"));
#endif // QT_CONFIG(tooltip)
        labelPragmaMaxPageCount->setAlignment(Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter);

        gridLayout->addWidget(labelPragmaMaxPageCount, 20, 0, 1, 1);

        labelPragmaLockingMode_2 = new QLabel(scrollAreaWidgetContents);
        labelPragmaLockingMode_2->setObjectName(QString::fromUtf8("labelPragmaLockingMode_2"));
        sizePolicy1.setHeightForWidth(labelPragmaLockingMode_2->sizePolicy().hasHeightForWidth());
        labelPragmaLockingMode_2->setSizePolicy(sizePolicy1);
        labelPragmaLockingMode_2->setText(QString::fromUtf8("<html><head/><body><p><a href=\"https://www.sqlite.org/pragma.html#pragma_locking_mode\"><img src=\":/icons/whatis\"/></a></p></body></html>"));
#if QT_CONFIG(statustip)
        labelPragmaLockingMode_2->setStatusTip(QString::fromUtf8("https://www.sqlite.org/pragma.html#pragma_locking_mode"));
#endif // QT_CONFIG(statustip)
        labelPragmaLockingMode_2->setAlignment(Qt::AlignCenter);
        labelPragmaLockingMode_2->setOpenExternalLinks(true);

        gridLayout->addWidget(labelPragmaLockingMode_2, 18, 1, 1, 1);

        comboboxPragmaLockingMode = new QComboBox(scrollAreaWidgetContents);
        comboboxPragmaLockingMode->addItem(QString());
        comboboxPragmaLockingMode->addItem(QString());
        comboboxPragmaLockingMode->setObjectName(QString::fromUtf8("comboboxPragmaLockingMode"));

        gridLayout->addWidget(comboboxPragmaLockingMode, 18, 2, 1, 1);

        labelPragmaCheckpointFullFsync = new QLabel(scrollAreaWidgetContents);
        labelPragmaCheckpointFullFsync->setObjectName(QString::fromUtf8("labelPragmaCheckpointFullFsync"));
#if QT_CONFIG(tooltip)
        labelPragmaCheckpointFullFsync->setToolTip(QString::fromUtf8("PRAGMA checkpoint_fullfsync"));
#endif // QT_CONFIG(tooltip)
        labelPragmaCheckpointFullFsync->setAlignment(Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter);

        gridLayout->addWidget(labelPragmaCheckpointFullFsync, 6, 0, 1, 1);

        labelPragmaForeignKeys_2 = new QLabel(scrollAreaWidgetContents);
        labelPragmaForeignKeys_2->setObjectName(QString::fromUtf8("labelPragmaForeignKeys_2"));
        sizePolicy1.setHeightForWidth(labelPragmaForeignKeys_2->sizePolicy().hasHeightForWidth());
        labelPragmaForeignKeys_2->setSizePolicy(sizePolicy1);
        labelPragmaForeignKeys_2->setText(QString::fromUtf8("<html><head/><body><p><a href=\"https://www.sqlite.org/pragma.html#pragma_foreign_keys\"><img src=\":/icons/whatis\"/></a></p></body></html>"));
#if QT_CONFIG(statustip)
        labelPragmaForeignKeys_2->setStatusTip(QString::fromUtf8("https://www.sqlite.org/pragma.html#pragma_foreign_keys"));
#endif // QT_CONFIG(statustip)
        labelPragmaForeignKeys_2->setAlignment(Qt::AlignCenter);
        labelPragmaForeignKeys_2->setOpenExternalLinks(true);

        gridLayout->addWidget(labelPragmaForeignKeys_2, 8, 1, 1, 1);

        comboboxPragmaSynchronous = new QComboBox(scrollAreaWidgetContents);
        comboboxPragmaSynchronous->addItem(QString());
        comboboxPragmaSynchronous->addItem(QString());
        comboboxPragmaSynchronous->addItem(QString());
        comboboxPragmaSynchronous->setObjectName(QString::fromUtf8("comboboxPragmaSynchronous"));

        gridLayout->addWidget(comboboxPragmaSynchronous, 28, 2, 1, 1);

        comboboxPragmaTempStore = new QComboBox(scrollAreaWidgetContents);
        comboboxPragmaTempStore->addItem(QString());
        comboboxPragmaTempStore->addItem(QString());
        comboboxPragmaTempStore->addItem(QString());
        comboboxPragmaTempStore->setObjectName(QString::fromUtf8("comboboxPragmaTempStore"));

        gridLayout->addWidget(comboboxPragmaTempStore, 30, 2, 1, 1);

        labelPragmaAutomaticIndex = new QLabel(scrollAreaWidgetContents);
        labelPragmaAutomaticIndex->setObjectName(QString::fromUtf8("labelPragmaAutomaticIndex"));
#if QT_CONFIG(tooltip)
        labelPragmaAutomaticIndex->setToolTip(QString::fromUtf8("PRAGMA automatic_index"));
#endif // QT_CONFIG(tooltip)
        labelPragmaAutomaticIndex->setAlignment(Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter);

        gridLayout->addWidget(labelPragmaAutomaticIndex, 2, 0, 1, 1);

        spinPragmaMaxPageCount = new QSpinBox(scrollAreaWidgetContents);
        spinPragmaMaxPageCount->setObjectName(QString::fromUtf8("spinPragmaMaxPageCount"));
        spinPragmaMaxPageCount->setMaximum(2000000000);

        gridLayout->addWidget(spinPragmaMaxPageCount, 20, 2, 1, 1);

        labelPragmaUserVersion_2 = new QLabel(scrollAreaWidgetContents);
        labelPragmaUserVersion_2->setObjectName(QString::fromUtf8("labelPragmaUserVersion_2"));
        sizePolicy1.setHeightForWidth(labelPragmaUserVersion_2->sizePolicy().hasHeightForWidth());
        labelPragmaUserVersion_2->setSizePolicy(sizePolicy1);
        labelPragmaUserVersion_2->setText(QString::fromUtf8("<html><head/><body><p><a href=\"https://www.sqlite.org/pragma.html#pragma_user_version\"><img src=\":/icons/whatis\"/></a></p></body></html>"));
#if QT_CONFIG(statustip)
        labelPragmaUserVersion_2->setStatusTip(QString::fromUtf8("https://www.sqlite.org/pragma.html#pragma_user_version"));
#endif // QT_CONFIG(statustip)
        labelPragmaUserVersion_2->setAlignment(Qt::AlignCenter);
        labelPragmaUserVersion_2->setOpenExternalLinks(true);

        gridLayout->addWidget(labelPragmaUserVersion_2, 32, 1, 1, 1);

        labelPragmaMaxPageCount_2 = new QLabel(scrollAreaWidgetContents);
        labelPragmaMaxPageCount_2->setObjectName(QString::fromUtf8("labelPragmaMaxPageCount_2"));
        sizePolicy1.setHeightForWidth(labelPragmaMaxPageCount_2->sizePolicy().hasHeightForWidth());
        labelPragmaMaxPageCount_2->setSizePolicy(sizePolicy1);
        labelPragmaMaxPageCount_2->setText(QString::fromUtf8("<html><head/><body><p><a href=\"https://www.sqlite.org/pragma.html#pragma_max_page_count\"><img src=\":/icons/whatis\"/></a></p></body></html>"));
#if QT_CONFIG(statustip)
        labelPragmaMaxPageCount_2->setStatusTip(QString::fromUtf8("https://www.sqlite.org/pragma.html#pragma_max_page_count"));
#endif // QT_CONFIG(statustip)
        labelPragmaMaxPageCount_2->setAlignment(Qt::AlignCenter);
        labelPragmaMaxPageCount_2->setOpenExternalLinks(true);

        gridLayout->addWidget(labelPragmaMaxPageCount_2, 20, 1, 1, 1);

        labelPragmaIgnoreCheckConstraints = new QLabel(scrollAreaWidgetContents);
        labelPragmaIgnoreCheckConstraints->setObjectName(QString::fromUtf8("labelPragmaIgnoreCheckConstraints"));
#if QT_CONFIG(tooltip)
        labelPragmaIgnoreCheckConstraints->setToolTip(QString::fromUtf8("PRAGMA ignore_check_constraints"));
#endif // QT_CONFIG(tooltip)
        labelPragmaIgnoreCheckConstraints->setAlignment(Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter);

        gridLayout->addWidget(labelPragmaIgnoreCheckConstraints, 12, 0, 1, 1);

        labelPragmaFullFsync = new QLabel(scrollAreaWidgetContents);
        labelPragmaFullFsync->setObjectName(QString::fromUtf8("labelPragmaFullFsync"));
#if QT_CONFIG(tooltip)
        labelPragmaFullFsync->setToolTip(QString::fromUtf8("PRAGMA fullfsync"));
#endif // QT_CONFIG(tooltip)
        labelPragmaFullFsync->setAlignment(Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter);

        gridLayout->addWidget(labelPragmaFullFsync, 10, 0, 1, 1);

        labelPragmaWalAutoCheckpoint = new QLabel(scrollAreaWidgetContents);
        labelPragmaWalAutoCheckpoint->setObjectName(QString::fromUtf8("labelPragmaWalAutoCheckpoint"));
#if QT_CONFIG(tooltip)
        labelPragmaWalAutoCheckpoint->setToolTip(QString::fromUtf8("PRAGMA wal_autocheckpoint"));
#endif // QT_CONFIG(tooltip)
        labelPragmaWalAutoCheckpoint->setAlignment(Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter);

        gridLayout->addWidget(labelPragmaWalAutoCheckpoint, 34, 0, 1, 1);

        spinPragmaJournalSizeLimit = new QSpinBox(scrollAreaWidgetContents);
        spinPragmaJournalSizeLimit->setObjectName(QString::fromUtf8("spinPragmaJournalSizeLimit"));
        spinPragmaJournalSizeLimit->setMinimum(-1);
        spinPragmaJournalSizeLimit->setMaximum(100000);

        gridLayout->addWidget(spinPragmaJournalSizeLimit, 16, 2, 1, 1);

        labelPragmaUserVersion = new QLabel(scrollAreaWidgetContents);
        labelPragmaUserVersion->setObjectName(QString::fromUtf8("labelPragmaUserVersion"));
#if QT_CONFIG(tooltip)
        labelPragmaUserVersion->setToolTip(QString::fromUtf8("PRAGMA user_version"));
#endif // QT_CONFIG(tooltip)
        labelPragmaUserVersion->setAlignment(Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter);

        gridLayout->addWidget(labelPragmaUserVersion, 32, 0, 1, 1);

        comboPragmaPageSize = new QComboBox(scrollAreaWidgetContents);
        comboPragmaPageSize->addItem(QString::fromUtf8("512"));
        comboPragmaPageSize->addItem(QString::fromUtf8("1024"));
        comboPragmaPageSize->addItem(QString::fromUtf8("2048"));
        comboPragmaPageSize->addItem(QString::fromUtf8("4096"));
        comboPragmaPageSize->addItem(QString::fromUtf8("8192"));
        comboPragmaPageSize->addItem(QString::fromUtf8("16384"));
        comboPragmaPageSize->addItem(QString::fromUtf8("32768"));
        comboPragmaPageSize->addItem(QString::fromUtf8("65536"));
        comboPragmaPageSize->setObjectName(QString::fromUtf8("comboPragmaPageSize"));

        gridLayout->addWidget(comboPragmaPageSize, 22, 2, 1, 1);

        labelPragmaSynchronous = new QLabel(scrollAreaWidgetContents);
        labelPragmaSynchronous->setObjectName(QString::fromUtf8("labelPragmaSynchronous"));
#if QT_CONFIG(tooltip)
        labelPragmaSynchronous->setToolTip(QString::fromUtf8("PRAGMA synchronous"));
#endif // QT_CONFIG(tooltip)
        labelPragmaSynchronous->setAlignment(Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter);

        gridLayout->addWidget(labelPragmaSynchronous, 28, 0, 1, 1);

        checkboxPragmaCaseSensitiveLike = new QCheckBox(scrollAreaWidgetContents);
        checkboxPragmaCaseSensitiveLike->setObjectName(QString::fromUtf8("checkboxPragmaCaseSensitiveLike"));

        gridLayout->addWidget(checkboxPragmaCaseSensitiveLike, 4, 2, 1, 1);

        comboboxPragmaAutoVacuum = new QComboBox(scrollAreaWidgetContents);
        comboboxPragmaAutoVacuum->addItem(QString());
        comboboxPragmaAutoVacuum->addItem(QString());
        comboboxPragmaAutoVacuum->addItem(QString());
        comboboxPragmaAutoVacuum->setObjectName(QString::fromUtf8("comboboxPragmaAutoVacuum"));
        sizePolicy2.setHeightForWidth(comboboxPragmaAutoVacuum->sizePolicy().hasHeightForWidth());
        comboboxPragmaAutoVacuum->setSizePolicy(sizePolicy2);

        gridLayout->addWidget(comboboxPragmaAutoVacuum, 0, 2, 1, 1);

        labelPragmaLockingMode = new QLabel(scrollAreaWidgetContents);
        labelPragmaLockingMode->setObjectName(QString::fromUtf8("labelPragmaLockingMode"));
#if QT_CONFIG(tooltip)
        labelPragmaLockingMode->setToolTip(QString::fromUtf8("PRAGMA locking_mode"));
#endif // QT_CONFIG(tooltip)
        labelPragmaLockingMode->setAlignment(Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter);

        gridLayout->addWidget(labelPragmaLockingMode, 18, 0, 1, 1);

        scrollareaPragmas->setWidget(scrollAreaWidgetContents);

        verticalLayout_4->addWidget(scrollareaPragmas);

        buttonBoxPragmas = new QDialogButtonBox(pragmas);
        buttonBoxPragmas->setObjectName(QString::fromUtf8("buttonBoxPragmas"));
        buttonBoxPragmas->setStandardButtons(QDialogButtonBox::Cancel|QDialogButtonBox::Save);
        buttonBoxPragmas->setCenterButtons(false);

        verticalLayout_4->addWidget(buttonBoxPragmas);

        mainTab->addTab(pragmas, QString());
        query = new QWidget();
        query->setObjectName(QString::fromUtf8("query"));
        verticalLayout_3 = new QVBoxLayout(query);
        verticalLayout_3->setSpacing(3);
        verticalLayout_3->setObjectName(QString::fromUtf8("verticalLayout_3"));
        verticalLayout_3->setContentsMargins(3, 3, 3, 3);
        toolbarSql = new QToolBar(query);
        toolbarSql->setObjectName(QString::fromUtf8("toolbarSql"));

        verticalLayout_3->addWidget(toolbarSql);

        tabSqlAreas = new QTabWidget(query);
        tabSqlAreas->setObjectName(QString::fromUtf8("tabSqlAreas"));
        tabSqlAreas->setContextMenuPolicy(Qt::CustomContextMenu);
        tabSqlAreas->setMovable(true);

        verticalLayout_3->addWidget(tabSqlAreas);

        mainTab->addTab(query, QString());

        verticalLayout_7->addWidget(mainTab);

        MainWindow->setCentralWidget(centralwidget);
        menubar = new QMenuBar(MainWindow);
        menubar->setObjectName(QString::fromUtf8("menubar"));
        menubar->setGeometry(QRect(0, 0, 1037, 22));
        fileMenu = new QMenu(menubar);
        fileMenu->setObjectName(QString::fromUtf8("fileMenu"));
        menuImport = new QMenu(fileMenu);
        menuImport->setObjectName(QString::fromUtf8("menuImport"));
        menuExport = new QMenu(fileMenu);
        menuExport->setObjectName(QString::fromUtf8("menuExport"));
        fileRecentFiles = new QMenu(fileMenu);
        fileRecentFiles->setObjectName(QString::fromUtf8("fileRecentFiles"));
        editMenu = new QMenu(menubar);
        editMenu->setObjectName(QString::fromUtf8("editMenu"));
        viewMenu = new QMenu(menubar);
        viewMenu->setObjectName(QString::fromUtf8("viewMenu"));
        helpMenu = new QMenu(menubar);
        helpMenu->setObjectName(QString::fromUtf8("helpMenu"));
        menuTools = new QMenu(menubar);
        menuTools->setObjectName(QString::fromUtf8("menuTools"));
        MainWindow->setMenuBar(menubar);
        statusbar = new QStatusBar(MainWindow);
        statusbar->setObjectName(QString::fromUtf8("statusbar"));
        MainWindow->setStatusBar(statusbar);
        toolbarDB = new QToolBar(MainWindow);
        toolbarDB->setObjectName(QString::fromUtf8("toolbarDB"));
        toolbarDB->setToolButtonStyle(Qt::ToolButtonTextBesideIcon);
        MainWindow->addToolBar(Qt::TopToolBarArea, toolbarDB);
        dockEdit = new QDockWidget(MainWindow);
        dockEdit->setObjectName(QString::fromUtf8("dockEdit"));
        dockWidgetContents_4 = new QWidget();
        dockWidgetContents_4->setObjectName(QString::fromUtf8("dockWidgetContents_4"));
        dockEdit->setWidget(dockWidgetContents_4);
        MainWindow->addDockWidget(Qt::RightDockWidgetArea, dockEdit);
        dockLog = new QDockWidget(MainWindow);
        dockLog->setObjectName(QString::fromUtf8("dockLog"));
        dockWidgetContents = new QWidget();
        dockWidgetContents->setObjectName(QString::fromUtf8("dockWidgetContents"));
        verticalLayout_5 = new QVBoxLayout(dockWidgetContents);
        verticalLayout_5->setObjectName(QString::fromUtf8("verticalLayout_5"));
        verticalLayout_5->setContentsMargins(2, 0, 2, 0);
        horizontalLayout_3 = new QHBoxLayout();
        horizontalLayout_3->setObjectName(QString::fromUtf8("horizontalLayout_3"));
        labelLogSubmittedBy = new QLabel(dockWidgetContents);
        labelLogSubmittedBy->setObjectName(QString::fromUtf8("labelLogSubmittedBy"));
        labelLogSubmittedBy->setMinimumSize(QSize(0, 30));

        horizontalLayout_3->addWidget(labelLogSubmittedBy);

        comboLogSubmittedBy = new QComboBox(dockWidgetContents);
        comboLogSubmittedBy->addItem(QString());
        comboLogSubmittedBy->addItem(QString());
        comboLogSubmittedBy->addItem(QString());
        comboLogSubmittedBy->setObjectName(QString::fromUtf8("comboLogSubmittedBy"));
        comboLogSubmittedBy->setMinimumSize(QSize(0, 30));

        horizontalLayout_3->addWidget(comboLogSubmittedBy);

        horizontalSpacer_3 = new QSpacerItem(20, 20, QSizePolicy::Expanding, QSizePolicy::Minimum);

        horizontalLayout_3->addItem(horizontalSpacer_3);

        buttonLogClear = new QToolButton(dockWidgetContents);
        buttonLogClear->setObjectName(QString::fromUtf8("buttonLogClear"));
        buttonLogClear->setMinimumSize(QSize(0, 30));

        horizontalLayout_3->addWidget(buttonLogClear);


        verticalLayout_5->addLayout(horizontalLayout_3);

        stackLog = new QStackedWidget(dockWidgetContents);
        stackLog->setObjectName(QString::fromUtf8("stackLog"));
        editLogUser = new SqlTextEdit();
        editLogUser->setObjectName(QString::fromUtf8("editLogUser"));
        QFont font;
        font.setFamily(QString::fromUtf8("Monospace"));
        font.setPointSize(8);
        editLogUser->setFont(font);
        editLogUser->setProperty("readOnly", QVariant(true));
        stackLog->addWidget(editLogUser);
        editLogApplication = new SqlTextEdit();
        editLogApplication->setObjectName(QString::fromUtf8("editLogApplication"));
        editLogApplication->setFont(font);
        editLogApplication->setProperty("readOnly", QVariant(true));
        stackLog->addWidget(editLogApplication);
        editLogErrorLog = new ExtendedScintilla();
        editLogErrorLog->setObjectName(QString::fromUtf8("editLogErrorLog"));
        editLogErrorLog->setFont(font);
        editLogErrorLog->setReadOnly(true);
        stackLog->addWidget(editLogErrorLog);

        verticalLayout_5->addWidget(stackLog);

        dockLog->setWidget(dockWidgetContents);
        MainWindow->addDockWidget(Qt::RightDockWidgetArea, dockLog);
        dockPlot = new QDockWidget(MainWindow);
        dockPlot->setObjectName(QString::fromUtf8("dockPlot"));
        dockWidgetContents_2 = new QWidget();
        dockWidgetContents_2->setObjectName(QString::fromUtf8("dockWidgetContents_2"));
        verticalLayout_6 = new QVBoxLayout(dockWidgetContents_2);
        verticalLayout_6->setObjectName(QString::fromUtf8("verticalLayout_6"));
        dockPlot->setWidget(dockWidgetContents_2);
        MainWindow->addDockWidget(Qt::RightDockWidgetArea, dockPlot);
        dockSchema = new QDockWidget(MainWindow);
        dockSchema->setObjectName(QString::fromUtf8("dockSchema"));
        dockWidgetContents_3 = new QWidget();
        dockWidgetContents_3->setObjectName(QString::fromUtf8("dockWidgetContents_3"));
        verticalLayout_9 = new QVBoxLayout(dockWidgetContents_3);
        verticalLayout_9->setObjectName(QString::fromUtf8("verticalLayout_9"));
        verticalLayout_9->setContentsMargins(2, 0, 2, 0);
        treeSchemaDock = new QTreeView(dockWidgetContents_3);
        treeSchemaDock->setObjectName(QString::fromUtf8("treeSchemaDock"));
        treeSchemaDock->setContextMenuPolicy(Qt::CustomContextMenu);
        treeSchemaDock->setFrameShape(QFrame::NoFrame);
        treeSchemaDock->setFrameShadow(QFrame::Plain);
        treeSchemaDock->setDragEnabled(true);
        treeSchemaDock->setDragDropMode(QAbstractItemView::DragDrop);
        treeSchemaDock->setAlternatingRowColors(true);
        treeSchemaDock->setSelectionMode(QAbstractItemView::ExtendedSelection);
        treeSchemaDock->setSelectionBehavior(QAbstractItemView::SelectItems);
        treeSchemaDock->setVerticalScrollMode(QAbstractItemView::ScrollPerPixel);
        treeSchemaDock->setAnimated(true);

        verticalLayout_9->addWidget(treeSchemaDock);

        dockSchema->setWidget(dockWidgetContents_3);
        MainWindow->addDockWidget(Qt::RightDockWidgetArea, dockSchema);
        dockRemote = new QDockWidget(MainWindow);
        dockRemote->setObjectName(QString::fromUtf8("dockRemote"));
        dockWidgetContents_5 = new QWidget();
        dockWidgetContents_5->setObjectName(QString::fromUtf8("dockWidgetContents_5"));
        dockRemote->setWidget(dockWidgetContents_5);
        MainWindow->addDockWidget(Qt::RightDockWidgetArea, dockRemote);
        toolbarProject = new QToolBar(MainWindow);
        toolbarProject->setObjectName(QString::fromUtf8("toolbarProject"));
        toolbarProject->setToolButtonStyle(Qt::ToolButtonTextBesideIcon);
        MainWindow->addToolBar(Qt::TopToolBarArea, toolbarProject);
        toolbarExtraDB = new QToolBar(MainWindow);
        toolbarExtraDB->setObjectName(QString::fromUtf8("toolbarExtraDB"));
        toolbarExtraDB->setEnabled(true);
        toolbarExtraDB->setToolButtonStyle(Qt::ToolButtonTextBesideIcon);
        MainWindow->addToolBar(Qt::TopToolBarArea, toolbarExtraDB);
#if QT_CONFIG(shortcut)
        labelPragmaTempStore->setBuddy(comboboxPragmaTempStore);
        labelPragmaSecureDelete->setBuddy(checkboxPragmaSecureDelete);
        labelPragmaWalAutoCheckpoint_2->setBuddy(spinPragmaWalAutoCheckpoint);
        labelPragmaCaseSensitiveLike->setBuddy(checkboxPragmaCaseSensitiveLike);
        labelPragmaJournalMode_2->setBuddy(comboboxPragmaJournalMode);
        labelPragmaSecureDelete_2->setBuddy(checkboxPragmaSecureDelete);
        labelPragmaSynchronous_2->setBuddy(comboboxPragmaSynchronous);
        labelPragmaJournalMode->setBuddy(comboboxPragmaJournalMode);
        labelJournalSizeLimit->setBuddy(spinPragmaJournalSizeLimit);
        labelPragmaRecursiveTriggers->setBuddy(checkboxPragmaRecursiveTriggers);
        labelPragmaFullFsync_2->setBuddy(checkboxPragmaFullFsync);
        labelJournalSizeLimit_2->setBuddy(spinPragmaJournalSizeLimit);
        labelPragmaPageSize->setBuddy(comboPragmaPageSize);
        labelPragmaCaseSensitiveLike_2->setBuddy(checkboxPragmaCaseSensitiveLike);
        labelPragmaForeignKeys->setBuddy(checkboxPragmaForeignKeys);
        labelPragmaIgnoreCheckConstraints_2->setBuddy(checkboxPragmaIgnoreCheckConstraints);
        labelPragmaAutomaticIndex_2->setBuddy(checkboxPragmaAutomaticIndex);
        labelPragmaPageSize_2->setBuddy(comboPragmaPageSize);
        labelPragmaAutoVacuum_2->setBuddy(comboboxPragmaAutoVacuum);
        labelPragmaRecursiveTriggers_2->setBuddy(checkboxPragmaRecursiveTriggers);
        labelPragmaTempStore_2->setBuddy(comboboxPragmaTempStore);
        labelPragmaCheckpointFullFsync_2->setBuddy(checkboxPragmaCheckpointFullFsync);
        labelPragmaAutoVacuum->setBuddy(comboboxPragmaAutoVacuum);
        labelPragmaMaxPageCount->setBuddy(spinPragmaMaxPageCount);
        labelPragmaLockingMode_2->setBuddy(comboboxPragmaLockingMode);
        labelPragmaCheckpointFullFsync->setBuddy(checkboxPragmaCheckpointFullFsync);
        labelPragmaForeignKeys_2->setBuddy(checkboxPragmaForeignKeys);
        labelPragmaAutomaticIndex->setBuddy(checkboxPragmaAutomaticIndex);
        labelPragmaUserVersion_2->setBuddy(spinPragmaUserVersion);
        labelPragmaMaxPageCount_2->setBuddy(spinPragmaMaxPageCount);
        labelPragmaIgnoreCheckConstraints->setBuddy(checkboxPragmaIgnoreCheckConstraints);
        labelPragmaFullFsync->setBuddy(checkboxPragmaFullFsync);
        labelPragmaWalAutoCheckpoint->setBuddy(spinPragmaWalAutoCheckpoint);
        labelPragmaUserVersion->setBuddy(spinPragmaUserVersion);
        labelPragmaSynchronous->setBuddy(comboboxPragmaSynchronous);
        labelPragmaLockingMode->setBuddy(comboboxPragmaLockingMode);
        labelLogSubmittedBy->setBuddy(comboLogSubmittedBy);
#endif // QT_CONFIG(shortcut)
        QWidget::setTabOrder(mainTab, dbTreeWidget);
        QWidget::setTabOrder(dbTreeWidget, comboLogSubmittedBy);
        QWidget::setTabOrder(comboLogSubmittedBy, buttonLogClear);
        QWidget::setTabOrder(buttonLogClear, treeSchemaDock);
        QWidget::setTabOrder(treeSchemaDock, scrollareaPragmas);
        QWidget::setTabOrder(scrollareaPragmas, comboboxPragmaAutoVacuum);
        QWidget::setTabOrder(comboboxPragmaAutoVacuum, checkboxPragmaAutomaticIndex);
        QWidget::setTabOrder(checkboxPragmaAutomaticIndex, checkboxPragmaCaseSensitiveLike);
        QWidget::setTabOrder(checkboxPragmaCaseSensitiveLike, checkboxPragmaCheckpointFullFsync);
        QWidget::setTabOrder(checkboxPragmaCheckpointFullFsync, checkboxPragmaForeignKeys);
        QWidget::setTabOrder(checkboxPragmaForeignKeys, checkboxPragmaFullFsync);
        QWidget::setTabOrder(checkboxPragmaFullFsync, checkboxPragmaIgnoreCheckConstraints);
        QWidget::setTabOrder(checkboxPragmaIgnoreCheckConstraints, comboboxPragmaJournalMode);
        QWidget::setTabOrder(comboboxPragmaJournalMode, spinPragmaJournalSizeLimit);
        QWidget::setTabOrder(spinPragmaJournalSizeLimit, comboboxPragmaLockingMode);
        QWidget::setTabOrder(comboboxPragmaLockingMode, spinPragmaMaxPageCount);
        QWidget::setTabOrder(spinPragmaMaxPageCount, comboPragmaPageSize);
        QWidget::setTabOrder(comboPragmaPageSize, checkboxPragmaSecureDelete);
        QWidget::setTabOrder(checkboxPragmaSecureDelete, checkboxPragmaRecursiveTriggers);
        QWidget::setTabOrder(checkboxPragmaRecursiveTriggers, comboboxPragmaSynchronous);
        QWidget::setTabOrder(comboboxPragmaSynchronous, comboboxPragmaTempStore);
        QWidget::setTabOrder(comboboxPragmaTempStore, spinPragmaUserVersion);
        QWidget::setTabOrder(spinPragmaUserVersion, spinPragmaWalAutoCheckpoint);
        QWidget::setTabOrder(spinPragmaWalAutoCheckpoint, tabSqlAreas);

        dbToolbar->addAction(editCreateTableAction);
        dbToolbar->addAction(editCreateIndexAction);
        dbToolbar->addAction(editModifyObjectAction);
        dbToolbar->addAction(editDeleteObjectAction);
        dbToolbar->addSeparator();
        dbToolbar->addAction(actionDbPrint);
        dbToolbar->addSeparator();
        dbToolbar->addAction(actionRefreshStructure);
        toolbarSql->addAction(actionSqlOpenTab);
        toolbarSql->addAction(actionSqlOpenFile);
        toolbarSql->addAction(actionSqlSaveFilePopup);
        toolbarSql->addAction(actionSqlPrint);
        toolbarSql->addSeparator();
        toolbarSql->addAction(actionExecuteSql);
        toolbarSql->addAction(actionSqlExecuteLine);
        toolbarSql->addAction(actionSqlStop);
        toolbarSql->addSeparator();
        toolbarSql->addAction(actionSqlResultsSave);
        toolbarSql->addSeparator();
        toolbarSql->addAction(actionSqlFind);
        toolbarSql->addAction(actionSqlFindReplace);
        toolbarSql->addSeparator();
        toolbarSql->addAction(actionSqlToggleComment);
        menubar->addAction(fileMenu->menuAction());
        menubar->addAction(editMenu->menuAction());
        menubar->addAction(viewMenu->menuAction());
        menubar->addAction(menuTools->menuAction());
        menubar->addAction(helpMenu->menuAction());
        fileMenu->addAction(fileNewAction);
        fileMenu->addAction(fileNewInMemoryDatabaseAction);
        fileMenu->addAction(fileOpenAction);
        fileMenu->addAction(fileOpenReadOnlyAction);
        fileMenu->addAction(fileAttachAction);
        fileMenu->addAction(fileRecentFiles->menuAction());
        fileMenu->addAction(fileSaveAsAction);
        fileMenu->addAction(fileCloseAction);
        fileMenu->addSeparator();
        fileMenu->addAction(fileSaveAction);
        fileMenu->addAction(fileRevertAction);
        fileMenu->addAction(undoAction);
        fileMenu->addSeparator();
        fileMenu->addAction(menuImport->menuAction());
        fileMenu->addAction(menuExport->menuAction());
        fileMenu->addSeparator();
        fileMenu->addAction(actionOpenProject);
        fileMenu->addAction(actionSaveProject);
        fileMenu->addAction(actionSaveProjectAs);
        fileMenu->addAction(actionCloseProject);
        fileMenu->addSeparator();
        fileMenu->addAction(actionSaveAll);
        fileMenu->addSeparator();
        fileMenu->addAction(fileExitAction);
        menuImport->addAction(fileImportSQLAction);
        menuImport->addAction(fileImportCSVAction);
        menuImport->addAction(actionFileImportCsvClipboard);
        menuExport->addAction(fileExportSQLAction);
        menuExport->addAction(fileExportCSVAction);
        menuExport->addAction(fileExportJsonAction);
        editMenu->addAction(editCreateTableAction);
        editMenu->addAction(editModifyObjectAction);
        editMenu->addAction(editDeleteObjectAction);
        editMenu->addSeparator();
        editMenu->addAction(editCreateIndexAction);
        editMenu->addSeparator();
        editMenu->addAction(viewPreferencesAction);
        viewMenu->addAction(viewDBToolbarAction);
        viewMenu->addAction(viewExtraDBToolbarAction);
        viewMenu->addAction(viewProjectToolbarAction);
        viewMenu->addSeparator();
        helpMenu->addAction(helpWhatsThisAction);
        helpMenu->addSeparator();
        helpMenu->addAction(actionWebsite);
        helpMenu->addAction(actionWiki);
        helpMenu->addAction(actionSqlCipherFaq);
        helpMenu->addSeparator();
        helpMenu->addAction(actionBug_report);
        helpMenu->addAction(actionFeature_Request);
        helpMenu->addAction(actionDonatePatreon);
        helpMenu->addSeparator();
        helpMenu->addAction(helpAboutAction);
        menuTools->addAction(fileCompactAction);
        menuTools->addAction(actionEncryption);
        menuTools->addSeparator();
        menuTools->addAction(actionLoadExtension);
        menuTools->addSeparator();
        menuTools->addAction(actionIntegrityCheck);
        menuTools->addAction(actionQuickCheck);
        menuTools->addAction(actionForeignKeyCheck);
        menuTools->addAction(actionOptimize);
        menuTools->addAction(actionRowCounts);
        toolbarDB->addAction(fileNewAction);
        toolbarDB->addAction(fileOpenActionPopup);
        toolbarDB->addSeparator();
        toolbarDB->addAction(fileSaveAction);
        toolbarDB->addAction(fileRevertAction);
        toolbarDB->addAction(undoAction);
        toolbarProject->addAction(actionOpenProject);
        toolbarProject->addAction(actionSaveProject);
        toolbarExtraDB->addAction(fileAttachAction);
        toolbarExtraDB->addAction(fileCloseAction);

        retranslateUi(MainWindow);
        QObject::connect(fileExitAction, SIGNAL(triggered()), MainWindow, SLOT(close()));
        QObject::connect(fileOpenAction, SIGNAL(triggered()), MainWindow, SLOT(fileOpen()));
        QObject::connect(fileNewAction, SIGNAL(triggered()), MainWindow, SLOT(fileNew()));
        QObject::connect(fileCloseAction, SIGNAL(triggered()), MainWindow, SLOT(fileClose()));
        QObject::connect(fileSaveAsAction, SIGNAL(triggered()), MainWindow, SLOT(fileSaveAs()));
        QObject::connect(fileCompactAction, SIGNAL(triggered()), MainWindow, SLOT(compact()));
        QObject::connect(helpWhatsThisAction, SIGNAL(triggered()), MainWindow, SLOT(helpWhatsThis()));
        QObject::connect(helpAboutAction, SIGNAL(triggered()), MainWindow, SLOT(helpAbout()));
        QObject::connect(mainTab, SIGNAL(currentChanged(int)), MainWindow, SLOT(mainTabSelected(int)));
        QObject::connect(fileImportCSVAction, SIGNAL(triggered()), MainWindow, SLOT(importTableFromCSV()));
        QObject::connect(fileExportCSVAction, SIGNAL(triggered()), MainWindow, SLOT(exportTableToCSV()));
        QObject::connect(fileRevertAction, SIGNAL(triggered()), MainWindow, SLOT(fileRevert()));
        QObject::connect(undoAction, SIGNAL(triggered()), MainWindow, SLOT(undo()));
        QObject::connect(fileSaveAction, SIGNAL(triggered()), MainWindow, SLOT(fileSave()));
        QObject::connect(editCreateIndexAction, SIGNAL(triggered()), MainWindow, SLOT(createIndex()));
        QObject::connect(editDeleteObjectAction, SIGNAL(triggered()), MainWindow, SLOT(deleteObject()));
        QObject::connect(editModifyObjectAction, SIGNAL(triggered()), MainWindow, SLOT(editObject()));
        QObject::connect(fileExportSQLAction, SIGNAL(triggered()), MainWindow, SLOT(exportDatabaseToSQL()));
        QObject::connect(fileImportSQLAction, SIGNAL(triggered()), MainWindow, SLOT(importDatabaseFromSQL()));
        QObject::connect(viewPreferencesAction, SIGNAL(triggered()), MainWindow, SLOT(openPreferences()));
        QObject::connect(dbTreeWidget, SIGNAL(customContextMenuRequested(QPoint)), MainWindow, SLOT(createTreeContextMenu(QPoint)));
        QObject::connect(treeSchemaDock, SIGNAL(customContextMenuRequested(QPoint)), MainWindow, SLOT(createSchemaDockContextMenu(QPoint)));
        QObject::connect(viewDBToolbarAction, SIGNAL(toggled(bool)), toolbarDB, SLOT(setVisible(bool)));
        QObject::connect(actionSqlFind, SIGNAL(toggled(bool)), MainWindow, SLOT(setFindFrameVisibility(bool)));
        QObject::connect(actionSqlFindReplace, SIGNAL(triggered()), MainWindow, SLOT(openFindReplaceDialog()));
        QObject::connect(editCreateTableAction, SIGNAL(triggered()), MainWindow, SLOT(createTable()));
        QObject::connect(buttonBoxPragmas, SIGNAL(rejected()), MainWindow, SLOT(loadPragmas()));
        QObject::connect(buttonBoxPragmas, SIGNAL(accepted()), MainWindow, SLOT(savePragmas()));
        QObject::connect(buttonLogClear, SIGNAL(clicked()), editLogApplication, SLOT(clear()));
        QObject::connect(buttonLogClear, SIGNAL(clicked()), editLogUser, SLOT(clear()));
        QObject::connect(buttonLogClear, SIGNAL(clicked()), editLogErrorLog, SLOT(clear()));
        QObject::connect(comboLogSubmittedBy, SIGNAL(currentIndexChanged(int)), stackLog, SLOT(setCurrentIndex(int)));
        QObject::connect(tabSqlAreas, SIGNAL(tabCloseRequested(int)), MainWindow, SLOT(closeSqlTab(int)));
        QObject::connect(tabSqlAreas, SIGNAL(currentChanged(int)), MainWindow, SLOT(changeSqlTab(int)));
        QObject::connect(actionExecuteSql, SIGNAL(triggered()), MainWindow, SLOT(executeQuery()));
        QObject::connect(actionSqlOpenTab, SIGNAL(triggered()), MainWindow, SLOT(openSqlTab()));
        QObject::connect(actionSqlOpenFile, SIGNAL(triggered()), MainWindow, SLOT(openSqlFile()));
        QObject::connect(actionSqlSaveFile, SIGNAL(triggered()), MainWindow, SLOT(saveSqlFile()));
        QObject::connect(actionLoadExtension, SIGNAL(triggered()), MainWindow, SLOT(loadExtension()));
        QObject::connect(actionSqlExecuteLine, SIGNAL(triggered()), MainWindow, SLOT(executeQuery()));
        QObject::connect(actionExportCsvPopup, SIGNAL(triggered()), MainWindow, SLOT(exportTableToCSV()));
        QObject::connect(actionOpenProject, SIGNAL(triggered()), MainWindow, SLOT(loadProject()));
        QObject::connect(actionSaveProject, SIGNAL(triggered()), MainWindow, SLOT(saveProject()));
        QObject::connect(fileAttachAction, SIGNAL(triggered()), MainWindow, SLOT(fileAttach()));
        QObject::connect(fileDetachAction, SIGNAL(triggered()), MainWindow, SLOT(fileDetachDbTree()));
        QObject::connect(actionEncryption, SIGNAL(triggered()), MainWindow, SLOT(editEncryption()));
        QObject::connect(actionSqlSaveFilePopup, SIGNAL(triggered()), MainWindow, SLOT(saveSqlFile()));
        QObject::connect(actionSqlSaveFileAs, SIGNAL(triggered()), MainWindow, SLOT(saveSqlFileAs()));
        QObject::connect(actionEditBrowseTable, SIGNAL(triggered()), MainWindow, SLOT(switchToBrowseDataTab()));
        QObject::connect(actionEditCopyCreateStatement, SIGNAL(triggered()), MainWindow, SLOT(copyCurrentCreateStatement()));
        QObject::connect(fileExportJsonAction, SIGNAL(triggered()), MainWindow, SLOT(exportTableToJson()));
        QObject::connect(fileOpenReadOnlyAction, SIGNAL(triggered()), MainWindow, SLOT(fileOpenReadOnly()));
        QObject::connect(actionSqlResultsExportCsv, SIGNAL(triggered()), MainWindow, SLOT(saveSqlResultsAsCsv()));
        QObject::connect(actionSqlResultsExportJson, SIGNAL(triggered()), MainWindow, SLOT(saveSqlResultsAsJson()));
        QObject::connect(actionSqlResultsSaveAsView, SIGNAL(triggered()), MainWindow, SLOT(saveSqlResultsAsView()));
        QObject::connect(tabSqlAreas, SIGNAL(tabBarDoubleClicked(int)), MainWindow, SLOT(renameSqlTab(int)));
        QObject::connect(viewProjectToolbarAction, SIGNAL(toggled(bool)), toolbarProject, SLOT(setVisible(bool)));
        QObject::connect(viewExtraDBToolbarAction, SIGNAL(toggled(bool)), toolbarExtraDB, SLOT(setVisible(bool)));
        QObject::connect(MainWindow, SIGNAL(toolButtonStyleChanged(Qt::ToolButtonStyle)), toolbarDB, SLOT(setToolButtonStyle(Qt::ToolButtonStyle)));
        QObject::connect(MainWindow, SIGNAL(toolButtonStyleChanged(Qt::ToolButtonStyle)), toolbarExtraDB, SLOT(setToolButtonStyle(Qt::ToolButtonStyle)));
        QObject::connect(MainWindow, SIGNAL(toolButtonStyleChanged(Qt::ToolButtonStyle)), toolbarProject, SLOT(setToolButtonStyle(Qt::ToolButtonStyle)));
        QObject::connect(fileOpenActionPopup, SIGNAL(triggered()), MainWindow, SLOT(fileOpen()));
        QObject::connect(fileNewInMemoryDatabaseAction, SIGNAL(triggered()), MainWindow, SLOT(fileNewInMemoryDatabase()));
        QObject::connect(actionSqlPrint, SIGNAL(triggered()), MainWindow, SLOT(openSqlPrintDialog()));
        QObject::connect(actionDbPrint, SIGNAL(triggered()), MainWindow, SLOT(printDbStructure()));
        QObject::connect(actionSqlToggleComment, SIGNAL(triggered()), MainWindow, SLOT(toggleSqlBlockComment()));
        QObject::connect(labelPragmaAutomaticIndex, SIGNAL(linkHovered(QString)), MainWindow, SLOT(showStatusMessage5s(QString)));
        QObject::connect(labelPragmaCaseSensitiveLike, SIGNAL(linkHovered(QString)), MainWindow, SLOT(showStatusMessage5s(QString)));
        QObject::connect(labelPragmaCheckpointFullFsync, SIGNAL(linkHovered(QString)), MainWindow, SLOT(showStatusMessage5s(QString)));
        QObject::connect(labelPragmaForeignKeys, SIGNAL(linkHovered(QString)), MainWindow, SLOT(showStatusMessage5s(QString)));
        QObject::connect(labelPragmaFullFsync, SIGNAL(linkHovered(QString)), MainWindow, SLOT(showStatusMessage5s(QString)));
        QObject::connect(labelPragmaIgnoreCheckConstraints, SIGNAL(linkHovered(QString)), MainWindow, SLOT(showStatusMessage5s(QString)));
        QObject::connect(labelPragmaJournalMode, SIGNAL(linkHovered(QString)), MainWindow, SLOT(showStatusMessage5s(QString)));
        QObject::connect(labelPragmaLockingMode, SIGNAL(linkHovered(QString)), MainWindow, SLOT(showStatusMessage5s(QString)));
        QObject::connect(labelPragmaMaxPageCount, SIGNAL(linkHovered(QString)), MainWindow, SLOT(showStatusMessage5s(QString)));
        QObject::connect(labelPragmaPageSize, SIGNAL(linkHovered(QString)), MainWindow, SLOT(showStatusMessage5s(QString)));
        QObject::connect(labelPragmaRecursiveTriggers, SIGNAL(linkHovered(QString)), MainWindow, SLOT(showStatusMessage5s(QString)));
        QObject::connect(labelPragmaSecureDelete, SIGNAL(linkHovered(QString)), MainWindow, SLOT(showStatusMessage5s(QString)));
        QObject::connect(labelPragmaSynchronous, SIGNAL(linkHovered(QString)), MainWindow, SLOT(showStatusMessage5s(QString)));
        QObject::connect(labelPragmaTempStore, SIGNAL(linkHovered(QString)), MainWindow, SLOT(showStatusMessage5s(QString)));
        QObject::connect(labelPragmaUserVersion, SIGNAL(linkHovered(QString)), MainWindow, SLOT(showStatusMessage5s(QString)));
        QObject::connect(labelPragmaWalAutoCheckpoint, SIGNAL(linkHovered(QString)), MainWindow, SLOT(showStatusMessage5s(QString)));
        QObject::connect(labelPragmaAutoVacuum, SIGNAL(linkHovered(QString)), MainWindow, SLOT(showStatusMessage5s(QString)));
        QObject::connect(labelPragmaAutoVacuum, SIGNAL(linkHovered(QString)), MainWindow, SLOT(showStatusMessage5s(QString)));
        QObject::connect(labelJournalSizeLimit, SIGNAL(linkHovered(QString)), MainWindow, SLOT(showStatusMessage5s(QString)));
        QObject::connect(actionSaveProjectAs, SIGNAL(triggered()), MainWindow, SLOT(saveProjectAs()));
        QObject::connect(actionSaveAll, SIGNAL(triggered()), MainWindow, SLOT(saveAll()));
        QObject::connect(tabSqlAreas, SIGNAL(customContextMenuRequested(QPoint)), MainWindow, SLOT(showContextMenuSqlTabBar(QPoint)));
        QObject::connect(actionCloseProject, SIGNAL(triggered()), MainWindow, SLOT(closeFiles()));
        QObject::connect(actionFileImportCsvClipboard, SIGNAL(triggered()), MainWindow, SLOT(importTableFromCSV()));
        QObject::connect(actionRowCounts, SIGNAL(triggered()), MainWindow, SLOT(newRowCountsTab()));
        QObject::connect(actionWiki, SIGNAL(triggered()), MainWindow, SLOT(openLinkWiki()));
        QObject::connect(actionBug_report, SIGNAL(triggered()), MainWindow, SLOT(openLinkBugReport()));
        QObject::connect(actionFeature_Request, SIGNAL(triggered()), MainWindow, SLOT(openLinkFeatureRequest()));
        QObject::connect(actionSqlCipherFaq, SIGNAL(triggered()), MainWindow, SLOT(openLinkSqlCipherFaq()));
        QObject::connect(actionWebsite, SIGNAL(triggered()), MainWindow, SLOT(openLinkWebsite()));
        QObject::connect(actionDonatePatreon, SIGNAL(triggered()), MainWindow, SLOT(openLinkDonatePatreon()));
        QObject::connect(actionRefreshStructure, SIGNAL(triggered()), MainWindow, SLOT(refresh()));

        mainTab->setCurrentIndex(0);
        tabSqlAreas->setCurrentIndex(-1);
        stackLog->setCurrentIndex(0);


        QMetaObject::connectSlotsByName(MainWindow);
    } // setupUi

    void retranslateUi(QMainWindow *MainWindow)
    {
        MainWindow->setWindowTitle(QCoreApplication::translate("MainWindow", "DB Browser for SQLite", nullptr));
        fileNewAction->setText(QCoreApplication::translate("MainWindow", "&New Database...", nullptr));
        fileNewAction->setIconText(QCoreApplication::translate("MainWindow", "&New Database", nullptr));
#if QT_CONFIG(tooltip)
        fileNewAction->setToolTip(QCoreApplication::translate("MainWindow", "Create a new database file", nullptr));
#endif // QT_CONFIG(tooltip)
#if QT_CONFIG(statustip)
        fileNewAction->setStatusTip(QCoreApplication::translate("MainWindow", "Create a new database file", nullptr));
#endif // QT_CONFIG(statustip)
#if QT_CONFIG(whatsthis)
        fileNewAction->setWhatsThis(QCoreApplication::translate("MainWindow", "This option is used to create a new database file.", nullptr));
#endif // QT_CONFIG(whatsthis)
#if QT_CONFIG(shortcut)
        fileNewAction->setShortcut(QCoreApplication::translate("MainWindow", "Ctrl+N", nullptr));
#endif // QT_CONFIG(shortcut)
        fileOpenAction->setText(QCoreApplication::translate("MainWindow", "&Open Database...", nullptr));
#if QT_CONFIG(tooltip)
        fileOpenAction->setToolTip(QCoreApplication::translate("MainWindow", "Open an existing database file", nullptr));
#endif // QT_CONFIG(tooltip)
#if QT_CONFIG(statustip)
        fileOpenAction->setStatusTip(QCoreApplication::translate("MainWindow", "Open an existing database file", nullptr));
#endif // QT_CONFIG(statustip)
#if QT_CONFIG(whatsthis)
        fileOpenAction->setWhatsThis(QCoreApplication::translate("MainWindow", "This option is used to open an existing database file.", nullptr));
#endif // QT_CONFIG(whatsthis)
#if QT_CONFIG(shortcut)
        fileOpenAction->setShortcut(QCoreApplication::translate("MainWindow", "Ctrl+O", nullptr));
#endif // QT_CONFIG(shortcut)
        fileCloseAction->setText(QCoreApplication::translate("MainWindow", "&Close Database", nullptr));
#if QT_CONFIG(tooltip)
        fileCloseAction->setToolTip(QCoreApplication::translate("MainWindow", "Close the current database file", nullptr));
#endif // QT_CONFIG(tooltip)
#if QT_CONFIG(statustip)
        fileCloseAction->setStatusTip(QCoreApplication::translate("MainWindow", "Close the current database file", nullptr));
#endif // QT_CONFIG(statustip)
#if QT_CONFIG(whatsthis)
        fileCloseAction->setWhatsThis(QCoreApplication::translate("MainWindow", "This button closes the connection to the currently open database file", nullptr));
#endif // QT_CONFIG(whatsthis)
#if QT_CONFIG(shortcut)
        fileCloseAction->setShortcut(QCoreApplication::translate("MainWindow", "Ctrl+F4", nullptr));
#endif // QT_CONFIG(shortcut)
        fileRevertAction->setText(QCoreApplication::translate("MainWindow", "&Revert Changes", nullptr));
#if QT_CONFIG(tooltip)
        fileRevertAction->setToolTip(QCoreApplication::translate("MainWindow", "Revert database to last saved state", nullptr));
#endif // QT_CONFIG(tooltip)
#if QT_CONFIG(statustip)
        fileRevertAction->setStatusTip(QCoreApplication::translate("MainWindow", "Revert database to last saved state", nullptr));
#endif // QT_CONFIG(statustip)
#if QT_CONFIG(whatsthis)
        fileRevertAction->setWhatsThis(QCoreApplication::translate("MainWindow", "This option is used to revert the current database file to its last saved state. All changes made since the last save operation are lost.", nullptr));
#endif // QT_CONFIG(whatsthis)
        undoAction->setText(QCoreApplication::translate("MainWindow", "&Undo", nullptr));
#if QT_CONFIG(tooltip)
        undoAction->setToolTip(QCoreApplication::translate("MainWindow", "Undo last change to the database", nullptr));
#endif // QT_CONFIG(tooltip)
#if QT_CONFIG(statustip)
        undoAction->setStatusTip(QCoreApplication::translate("MainWindow", "Undo last change to the database", nullptr));
#endif // QT_CONFIG(statustip)
#if QT_CONFIG(whatsthis)
        undoAction->setWhatsThis(QCoreApplication::translate("MainWindow", "This action undoes the last change performed to the database in the Database Browser or in Execute SQL. Redoing is not possible.", nullptr));
#endif // QT_CONFIG(whatsthis)
        fileSaveAction->setText(QCoreApplication::translate("MainWindow", "&Write Changes", nullptr));
#if QT_CONFIG(tooltip)
        fileSaveAction->setToolTip(QCoreApplication::translate("MainWindow", "Write changes to the database file", nullptr));
#endif // QT_CONFIG(tooltip)
#if QT_CONFIG(statustip)
        fileSaveAction->setStatusTip(QCoreApplication::translate("MainWindow", "Write changes to the database file", nullptr));
#endif // QT_CONFIG(statustip)
#if QT_CONFIG(whatsthis)
        fileSaveAction->setWhatsThis(QCoreApplication::translate("MainWindow", "This option is used to save changes to the database file.", nullptr));
#endif // QT_CONFIG(whatsthis)
#if QT_CONFIG(shortcut)
        fileSaveAction->setShortcut(QCoreApplication::translate("MainWindow", "Ctrl+S", nullptr));
#endif // QT_CONFIG(shortcut)
        fileCompactAction->setText(QCoreApplication::translate("MainWindow", "Compact &Database...", nullptr));
#if QT_CONFIG(tooltip)
        fileCompactAction->setToolTip(QCoreApplication::translate("MainWindow", "Compact the database file, removing space wasted by deleted records", nullptr));
#endif // QT_CONFIG(tooltip)
#if QT_CONFIG(statustip)
        fileCompactAction->setStatusTip(QCoreApplication::translate("MainWindow", "Compact the database file, removing space wasted by deleted records.", nullptr));
#endif // QT_CONFIG(statustip)
#if QT_CONFIG(whatsthis)
        fileCompactAction->setWhatsThis(QCoreApplication::translate("MainWindow", "Compact the database file, removing space wasted by deleted records.", nullptr));
#endif // QT_CONFIG(whatsthis)
        fileExitAction->setText(QCoreApplication::translate("MainWindow", "E&xit", nullptr));
#if QT_CONFIG(shortcut)
        fileExitAction->setShortcut(QCoreApplication::translate("MainWindow", "Ctrl+Q", nullptr));
#endif // QT_CONFIG(shortcut)
        fileImportSQLAction->setText(QCoreApplication::translate("MainWindow", "&Database from SQL file...", nullptr));
#if QT_CONFIG(tooltip)
        fileImportSQLAction->setToolTip(QCoreApplication::translate("MainWindow", "Import data from an .sql dump text file into a new or existing database.", nullptr));
#endif // QT_CONFIG(tooltip)
#if QT_CONFIG(whatsthis)
        fileImportSQLAction->setWhatsThis(QCoreApplication::translate("MainWindow", "This option lets you import data from an .sql dump text file into a new or existing database. SQL dump files can be created on most database engines, including MySQL and PostgreSQL.", nullptr));
#endif // QT_CONFIG(whatsthis)
        fileImportCSVAction->setText(QCoreApplication::translate("MainWindow", "&Table from CSV file...", nullptr));
#if QT_CONFIG(tooltip)
        fileImportCSVAction->setToolTip(QCoreApplication::translate("MainWindow", "Open a wizard that lets you import data from a comma separated text file into a database table.", nullptr));
#endif // QT_CONFIG(tooltip)
#if QT_CONFIG(whatsthis)
        fileImportCSVAction->setWhatsThis(QCoreApplication::translate("MainWindow", "Open a wizard that lets you import data from a comma separated text file into a database table. CSV files can be created on most database and spreadsheet applications.", nullptr));
#endif // QT_CONFIG(whatsthis)
        fileExportSQLAction->setText(QCoreApplication::translate("MainWindow", "&Database to SQL file...", nullptr));
#if QT_CONFIG(tooltip)
        fileExportSQLAction->setToolTip(QCoreApplication::translate("MainWindow", "Export a database to a .sql dump text file.", nullptr));
#endif // QT_CONFIG(tooltip)
#if QT_CONFIG(whatsthis)
        fileExportSQLAction->setWhatsThis(QCoreApplication::translate("MainWindow", "This option lets you export a database to a .sql dump text file. SQL dump files contain all data necessary to recreate the database on most database engines, including MySQL and PostgreSQL.", nullptr));
#endif // QT_CONFIG(whatsthis)
        fileExportCSVAction->setText(QCoreApplication::translate("MainWindow", "&Table(s) as CSV file...", nullptr));
#if QT_CONFIG(tooltip)
        fileExportCSVAction->setToolTip(QCoreApplication::translate("MainWindow", "Export a database table as a comma separated text file.", nullptr));
#endif // QT_CONFIG(tooltip)
#if QT_CONFIG(whatsthis)
        fileExportCSVAction->setWhatsThis(QCoreApplication::translate("MainWindow", "Export a database table as a comma separated text file, ready to be imported into other database or spreadsheet applications.", nullptr));
#endif // QT_CONFIG(whatsthis)
        editCreateTableAction->setText(QCoreApplication::translate("MainWindow", "&Create Table...", nullptr));
#if QT_CONFIG(whatsthis)
        editCreateTableAction->setWhatsThis(QCoreApplication::translate("MainWindow", "Open the Create Table wizard, where it is possible to define the name and fields for a new table in the database", nullptr));
#endif // QT_CONFIG(whatsthis)
        editDeleteObjectAction->setText(QCoreApplication::translate("MainWindow", "&Delete Table...", nullptr));
#if QT_CONFIG(tooltip)
        editDeleteObjectAction->setToolTip(QCoreApplication::translate("MainWindow", "Delete Table", nullptr));
#endif // QT_CONFIG(tooltip)
#if QT_CONFIG(whatsthis)
        editDeleteObjectAction->setWhatsThis(QCoreApplication::translate("MainWindow", "Open the Delete Table wizard, where you can select a database table to be dropped.", nullptr));
#endif // QT_CONFIG(whatsthis)
        editModifyObjectAction->setText(QCoreApplication::translate("MainWindow", "&Modify Table...", nullptr));
#if QT_CONFIG(whatsthis)
        editModifyObjectAction->setWhatsThis(QCoreApplication::translate("MainWindow", "Open the Modify Table wizard, where it is possible to rename an existing table. It is also possible to add or delete fields from a table, as well as modify field names and types.", nullptr));
#endif // QT_CONFIG(whatsthis)
        editCreateIndexAction->setText(QCoreApplication::translate("MainWindow", "Create &Index...", nullptr));
#if QT_CONFIG(whatsthis)
        editCreateIndexAction->setWhatsThis(QCoreApplication::translate("MainWindow", "Open the Create Index wizard, where it is possible to define a new index on an existing database table.", nullptr));
#endif // QT_CONFIG(whatsthis)
        viewPreferencesAction->setText(QCoreApplication::translate("MainWindow", "&Preferences...", nullptr));
#if QT_CONFIG(tooltip)
        viewPreferencesAction->setToolTip(QCoreApplication::translate("MainWindow", "Open the preferences window.", nullptr));
#endif // QT_CONFIG(tooltip)
#if QT_CONFIG(whatsthis)
        viewPreferencesAction->setWhatsThis(QCoreApplication::translate("MainWindow", "Open the preferences window.", nullptr));
#endif // QT_CONFIG(whatsthis)
        viewDBToolbarAction->setText(QCoreApplication::translate("MainWindow", "&DB Toolbar", nullptr));
#if QT_CONFIG(whatsthis)
        viewDBToolbarAction->setWhatsThis(QCoreApplication::translate("MainWindow", "Shows or hides the Database toolbar.", nullptr));
#endif // QT_CONFIG(whatsthis)
        helpWhatsThisAction->setText(QCoreApplication::translate("MainWindow", "W&hat's This?", nullptr));
#if QT_CONFIG(shortcut)
        helpWhatsThisAction->setShortcut(QCoreApplication::translate("MainWindow", "Shift+F1", nullptr));
#endif // QT_CONFIG(shortcut)
        helpAboutAction->setText(QCoreApplication::translate("MainWindow", "&About", nullptr));
        actionRecent_y_opened->setText(QCoreApplication::translate("MainWindow", "&Recently opened", nullptr));
        actionSqlOpenTab->setText(QCoreApplication::translate("MainWindow", "New &tab", nullptr));
#if QT_CONFIG(whatsthis)
        actionSqlOpenTab->setWhatsThis(QCoreApplication::translate("MainWindow", "This button opens a new tab for the SQL editor", nullptr));
#endif // QT_CONFIG(whatsthis)
#if QT_CONFIG(shortcut)
        actionSqlOpenTab->setShortcut(QCoreApplication::translate("MainWindow", "Ctrl+T", nullptr));
#endif // QT_CONFIG(shortcut)
        actionExecuteSql->setText(QCoreApplication::translate("MainWindow", "&Execute SQL", nullptr));
#if QT_CONFIG(tooltip)
        actionExecuteSql->setToolTip(QCoreApplication::translate("MainWindow", "Execute all/selected SQL", nullptr));
#endif // QT_CONFIG(tooltip)
#if QT_CONFIG(whatsthis)
        actionExecuteSql->setWhatsThis(QCoreApplication::translate("MainWindow", "This button executes the currently selected SQL statements. If no text is selected, all SQL statements are executed.", nullptr));
#endif // QT_CONFIG(whatsthis)
#if QT_CONFIG(shortcut)
        actionExecuteSql->setShortcut(QCoreApplication::translate("MainWindow", "Ctrl+Return", nullptr));
#endif // QT_CONFIG(shortcut)
        actionSqlOpenFile->setText(QCoreApplication::translate("MainWindow", "Open SQL file(s)", nullptr));
#if QT_CONFIG(whatsthis)
        actionSqlOpenFile->setWhatsThis(QCoreApplication::translate("MainWindow", "This button opens files containing SQL statements and loads them in new editor tabs", nullptr));
#endif // QT_CONFIG(whatsthis)
#if QT_CONFIG(shortcut)
        actionSqlOpenFile->setShortcut(QCoreApplication::translate("MainWindow", "Ctrl+Shift+T", nullptr));
#endif // QT_CONFIG(shortcut)
        actionSqlSaveFile->setText(QCoreApplication::translate("MainWindow", "Save SQL file", nullptr));
        actionLoadExtension->setText(QCoreApplication::translate("MainWindow", "&Load Extension...", nullptr));
        actionSqlExecuteLine->setText(QCoreApplication::translate("MainWindow", "Execute current line", nullptr));
        actionSqlExecuteLine->setIconText(QCoreApplication::translate("MainWindow", "Execute line", nullptr));
#if QT_CONFIG(tooltip)
        actionSqlExecuteLine->setToolTip(QCoreApplication::translate("MainWindow", "Execute current line", nullptr));
#endif // QT_CONFIG(tooltip)
#if QT_CONFIG(whatsthis)
        actionSqlExecuteLine->setWhatsThis(QCoreApplication::translate("MainWindow", "This button executes the SQL statement present in the current editor line", nullptr));
#endif // QT_CONFIG(whatsthis)
#if QT_CONFIG(shortcut)
        actionSqlExecuteLine->setShortcut(QCoreApplication::translate("MainWindow", "Shift+F5", nullptr));
#endif // QT_CONFIG(shortcut)
        actionExportCsvPopup->setText(QCoreApplication::translate("MainWindow", "Export as CSV file", nullptr));
#if QT_CONFIG(tooltip)
        actionExportCsvPopup->setToolTip(QCoreApplication::translate("MainWindow", "Export table as comma separated values file", nullptr));
#endif // QT_CONFIG(tooltip)
        actionWiki->setText(QCoreApplication::translate("MainWindow", "&Wiki", nullptr));
#if QT_CONFIG(shortcut)
        actionWiki->setShortcut(QCoreApplication::translate("MainWindow", "F1", nullptr));
#endif // QT_CONFIG(shortcut)
        actionBug_report->setText(QCoreApplication::translate("MainWindow", "Bug &Report...", nullptr));
        actionFeature_Request->setText(QCoreApplication::translate("MainWindow", "Feature Re&quest...", nullptr));
        actionWebsite->setText(QCoreApplication::translate("MainWindow", "Web&site", nullptr));
        actionDonatePatreon->setText(QCoreApplication::translate("MainWindow", "&Donate on Patreon...", nullptr));
        actionSaveProject->setText(QCoreApplication::translate("MainWindow", "Sa&ve Project", nullptr));
        actionSaveProject->setIconText(QCoreApplication::translate("MainWindow", "&Save Project", nullptr));
#if QT_CONFIG(tooltip)
        actionSaveProject->setToolTip(QCoreApplication::translate("MainWindow", "Save the current session to a file", nullptr));
#endif // QT_CONFIG(tooltip)
#if QT_CONFIG(statustip)
        actionSaveProject->setStatusTip(QCoreApplication::translate("MainWindow", "Save the current session to a file", nullptr));
#endif // QT_CONFIG(statustip)
#if QT_CONFIG(whatsthis)
        actionSaveProject->setWhatsThis(QCoreApplication::translate("MainWindow", "This button lets you save all the settings associated to the open DB to a DB Browser for SQLite project file", nullptr));
#endif // QT_CONFIG(whatsthis)
        actionOpenProject->setText(QCoreApplication::translate("MainWindow", "Open &Project...", nullptr));
        actionOpenProject->setIconText(QCoreApplication::translate("MainWindow", "Open &Project", nullptr));
#if QT_CONFIG(tooltip)
        actionOpenProject->setToolTip(QCoreApplication::translate("MainWindow", "Load a working session from a file", nullptr));
#endif // QT_CONFIG(tooltip)
#if QT_CONFIG(statustip)
        actionOpenProject->setStatusTip(QCoreApplication::translate("MainWindow", "Load a working session from a file", nullptr));
#endif // QT_CONFIG(statustip)
#if QT_CONFIG(whatsthis)
        actionOpenProject->setWhatsThis(QCoreApplication::translate("MainWindow", "This button lets you open a DB Browser for SQLite project file", nullptr));
#endif // QT_CONFIG(whatsthis)
        fileAttachAction->setText(QCoreApplication::translate("MainWindow", "&Attach Database...", nullptr));
#if QT_CONFIG(tooltip)
        fileAttachAction->setToolTip(QCoreApplication::translate("MainWindow", "Add another database file to the current database connection", nullptr));
#endif // QT_CONFIG(tooltip)
#if QT_CONFIG(statustip)
        fileAttachAction->setStatusTip(QCoreApplication::translate("MainWindow", "Add another database file to the current database connection", nullptr));
#endif // QT_CONFIG(statustip)
#if QT_CONFIG(whatsthis)
        fileAttachAction->setWhatsThis(QCoreApplication::translate("MainWindow", "This button lets you add another database file to the current database connection", nullptr));
#endif // QT_CONFIG(whatsthis)
        actionEncryption->setText(QCoreApplication::translate("MainWindow", "&Set Encryption...", nullptr));
        actionSqlSaveFileAs->setText(QCoreApplication::translate("MainWindow", "Save SQL file as", nullptr));
#if QT_CONFIG(tooltip)
        actionSqlSaveFileAs->setToolTip(QCoreApplication::translate("MainWindow", "Save SQL file as", nullptr));
#endif // QT_CONFIG(tooltip)
        actionSqlSaveFilePopup->setText(QCoreApplication::translate("MainWindow", "Save SQL file", nullptr));
#if QT_CONFIG(tooltip)
        actionSqlSaveFilePopup->setToolTip(QCoreApplication::translate("MainWindow", "Save SQL file", nullptr));
#endif // QT_CONFIG(tooltip)
#if QT_CONFIG(whatsthis)
        actionSqlSaveFilePopup->setWhatsThis(QCoreApplication::translate("MainWindow", "This button saves the content of the current SQL editor tab to a file", nullptr));
#endif // QT_CONFIG(whatsthis)
        actionEditBrowseTable->setText(QCoreApplication::translate("MainWindow", "&Browse Table", nullptr));
        actionEditCopyCreateStatement->setText(QCoreApplication::translate("MainWindow", "Copy Create statement", nullptr));
#if QT_CONFIG(tooltip)
        actionEditCopyCreateStatement->setToolTip(QCoreApplication::translate("MainWindow", "Copy the CREATE statement of the item to the clipboard", nullptr));
#endif // QT_CONFIG(tooltip)
        actionSqlCipherFaq->setText(QCoreApplication::translate("MainWindow", "SQLCipher &FAQ", nullptr));
#if QT_CONFIG(tooltip)
        actionSqlCipherFaq->setToolTip(QCoreApplication::translate("MainWindow", "Opens the SQLCipher FAQ in a browser window", nullptr));
#endif // QT_CONFIG(tooltip)
        fileExportJsonAction->setText(QCoreApplication::translate("MainWindow", "Table(&s) to JSON...", nullptr));
#if QT_CONFIG(tooltip)
        fileExportJsonAction->setToolTip(QCoreApplication::translate("MainWindow", "Export one or more table(s) to a JSON file", nullptr));
#endif // QT_CONFIG(tooltip)
        fileOpenReadOnlyAction->setText(QCoreApplication::translate("MainWindow", "Open Data&base Read Only...", nullptr));
#if QT_CONFIG(tooltip)
        fileOpenReadOnlyAction->setToolTip(QCoreApplication::translate("MainWindow", "Open an existing database file in read only mode", nullptr));
#endif // QT_CONFIG(tooltip)
#if QT_CONFIG(statustip)
        fileOpenReadOnlyAction->setStatusTip(QCoreApplication::translate("MainWindow", "Open an existing database file", nullptr));
#endif // QT_CONFIG(statustip)
#if QT_CONFIG(whatsthis)
        fileOpenReadOnlyAction->setWhatsThis(QCoreApplication::translate("MainWindow", "This option is used to open an existing database file.", nullptr));
#endif // QT_CONFIG(whatsthis)
#if QT_CONFIG(shortcut)
        fileOpenReadOnlyAction->setShortcut(QCoreApplication::translate("MainWindow", "Ctrl+Shift+O", nullptr));
#endif // QT_CONFIG(shortcut)
        actionSqlResultsSave->setText(QCoreApplication::translate("MainWindow", "Save results", nullptr));
#if QT_CONFIG(tooltip)
        actionSqlResultsSave->setToolTip(QCoreApplication::translate("MainWindow", "Save the results view", nullptr));
#endif // QT_CONFIG(tooltip)
#if QT_CONFIG(whatsthis)
        actionSqlResultsSave->setWhatsThis(QCoreApplication::translate("MainWindow", "This button lets you save the results of the last executed query", nullptr));
#endif // QT_CONFIG(whatsthis)
        actionSqlFind->setText(QCoreApplication::translate("MainWindow", "Find text in SQL editor", nullptr));
        actionSqlFind->setIconText(QCoreApplication::translate("MainWindow", "Find", nullptr));
#if QT_CONFIG(tooltip)
        actionSqlFind->setToolTip(QCoreApplication::translate("MainWindow", "Find text in SQL editor", nullptr));
#endif // QT_CONFIG(tooltip)
#if QT_CONFIG(whatsthis)
        actionSqlFind->setWhatsThis(QCoreApplication::translate("MainWindow", "This button opens the search bar of the editor", nullptr));
#endif // QT_CONFIG(whatsthis)
#if QT_CONFIG(shortcut)
        actionSqlFind->setShortcut(QCoreApplication::translate("MainWindow", "Ctrl+F", nullptr));
#endif // QT_CONFIG(shortcut)
        actionSqlFindReplace->setText(QCoreApplication::translate("MainWindow", "Find or replace text in SQL editor", nullptr));
        actionSqlFindReplace->setIconText(QCoreApplication::translate("MainWindow", "Find or replace", nullptr));
#if QT_CONFIG(tooltip)
        actionSqlFindReplace->setToolTip(QCoreApplication::translate("MainWindow", "Find or replace text in SQL editor", nullptr));
#endif // QT_CONFIG(tooltip)
#if QT_CONFIG(whatsthis)
        actionSqlFindReplace->setWhatsThis(QCoreApplication::translate("MainWindow", "This button opens the find/replace dialog for the current editor tab", nullptr));
#endif // QT_CONFIG(whatsthis)
#if QT_CONFIG(shortcut)
        actionSqlFindReplace->setShortcut(QCoreApplication::translate("MainWindow", "Ctrl+H", nullptr));
#endif // QT_CONFIG(shortcut)
        actionSqlResultsExportCsv->setText(QCoreApplication::translate("MainWindow", "Export to &CSV", nullptr));
        actionSqlResultsExportJson->setText(QCoreApplication::translate("MainWindow", "Export to &JSON", nullptr));
        actionSqlResultsSaveAsView->setText(QCoreApplication::translate("MainWindow", "Save as &view", nullptr));
#if QT_CONFIG(tooltip)
        actionSqlResultsSaveAsView->setToolTip(QCoreApplication::translate("MainWindow", "Save as view", nullptr));
#endif // QT_CONFIG(tooltip)
        viewProjectToolbarAction->setText(QCoreApplication::translate("MainWindow", "Project Toolbar", nullptr));
#if QT_CONFIG(whatsthis)
        viewProjectToolbarAction->setWhatsThis(QCoreApplication::translate("MainWindow", "Shows or hides the Project toolbar.", nullptr));
#endif // QT_CONFIG(whatsthis)
        viewExtraDBToolbarAction->setText(QCoreApplication::translate("MainWindow", "Extra DB Toolbar", nullptr));
        fileOpenActionPopup->setText(QCoreApplication::translate("MainWindow", "&Open Database...", nullptr));
        fileOpenActionPopup->setIconText(QCoreApplication::translate("MainWindow", "&Open Database", nullptr));
#if QT_CONFIG(tooltip)
        fileOpenActionPopup->setToolTip(QCoreApplication::translate("MainWindow", "Open an existing database file", nullptr));
#endif // QT_CONFIG(tooltip)
#if QT_CONFIG(statustip)
        fileOpenActionPopup->setStatusTip(QCoreApplication::translate("MainWindow", "Open an existing database file", nullptr));
#endif // QT_CONFIG(statustip)
#if QT_CONFIG(whatsthis)
        fileOpenActionPopup->setWhatsThis(QCoreApplication::translate("MainWindow", "This option is used to open an existing database file.", nullptr));
#endif // QT_CONFIG(whatsthis)
        fileNewInMemoryDatabaseAction->setText(QCoreApplication::translate("MainWindow", "New In-&Memory Database", nullptr));
        actionDropSelectQueryCheck->setText(QCoreApplication::translate("MainWindow", "Drag && Drop SELECT Query", nullptr));
#if QT_CONFIG(statustip)
        actionDropSelectQueryCheck->setStatusTip(QCoreApplication::translate("MainWindow", "When dragging fields from the same table or a single table, drop a SELECT query into the editor", nullptr));
#endif // QT_CONFIG(statustip)
#if QT_CONFIG(whatsthis)
        actionDropSelectQueryCheck->setWhatsThis(QCoreApplication::translate("MainWindow", "When dragging fields from the same table or a single table, drop a SELECT query into the editor", nullptr));
#endif // QT_CONFIG(whatsthis)
        actionDropQualifiedCheck->setText(QCoreApplication::translate("MainWindow", "Drag && Drop Qualified Names", nullptr));
#if QT_CONFIG(statustip)
        actionDropQualifiedCheck->setStatusTip(QCoreApplication::translate("MainWindow", "Use qualified names (e.g. \"Table\".\"Field\") when dragging the objects and dropping them into the editor ", nullptr));
#endif // QT_CONFIG(statustip)
#if QT_CONFIG(whatsthis)
        actionDropQualifiedCheck->setWhatsThis(QCoreApplication::translate("MainWindow", "Use qualified names (e.g. \"Table\".\"Field\") when dragging the objects and dropping them into the editor ", nullptr));
#endif // QT_CONFIG(whatsthis)
        actionEnquoteNamesCheck->setText(QCoreApplication::translate("MainWindow", "Drag && Drop Enquoted Names", nullptr));
#if QT_CONFIG(statustip)
        actionEnquoteNamesCheck->setStatusTip(QCoreApplication::translate("MainWindow", "Use escaped identifiers (e.g. \"Table1\") when dragging the objects and dropping them into the editor ", nullptr));
#endif // QT_CONFIG(statustip)
#if QT_CONFIG(whatsthis)
        actionEnquoteNamesCheck->setWhatsThis(QCoreApplication::translate("MainWindow", "Use escaped identifiers (e.g. \"Table1\") when dragging the objects and dropping them into the editor ", nullptr));
#endif // QT_CONFIG(whatsthis)
        actionIntegrityCheck->setText(QCoreApplication::translate("MainWindow", "&Integrity Check", nullptr));
#if QT_CONFIG(whatsthis)
        actionIntegrityCheck->setWhatsThis(QCoreApplication::translate("MainWindow", "Runs the integrity_check pragma over the opened database and returns the results in the Execute SQL tab. This pragma does an integrity check of the entire database.", nullptr));
#endif // QT_CONFIG(whatsthis)
        actionForeignKeyCheck->setText(QCoreApplication::translate("MainWindow", "&Foreign-Key Check", nullptr));
#if QT_CONFIG(whatsthis)
        actionForeignKeyCheck->setWhatsThis(QCoreApplication::translate("MainWindow", "Runs the foreign_key_check pragma over the opened database and returns the results in the Execute SQL tab", nullptr));
#endif // QT_CONFIG(whatsthis)
        actionQuickCheck->setText(QCoreApplication::translate("MainWindow", "&Quick Integrity Check", nullptr));
#if QT_CONFIG(tooltip)
        actionQuickCheck->setToolTip(QCoreApplication::translate("MainWindow", "Run a quick integrity check over the open DB", nullptr));
#endif // QT_CONFIG(tooltip)
#if QT_CONFIG(whatsthis)
        actionQuickCheck->setWhatsThis(QCoreApplication::translate("MainWindow", "Runs the quick_check pragma over the opened database and returns the results in the Execute SQL tab. This command does most of the checking of PRAGMA integrity_check but runs much faster.", nullptr));
#endif // QT_CONFIG(whatsthis)
        actionOptimize->setText(QCoreApplication::translate("MainWindow", "&Optimize", nullptr));
#if QT_CONFIG(tooltip)
        actionOptimize->setToolTip(QCoreApplication::translate("MainWindow", "Attempt to optimize the database", nullptr));
#endif // QT_CONFIG(tooltip)
#if QT_CONFIG(whatsthis)
        actionOptimize->setWhatsThis(QCoreApplication::translate("MainWindow", "Runs the optimize pragma over the opened database. This pragma might perform optimizations that will improve the performance of future queries.", nullptr));
#endif // QT_CONFIG(whatsthis)
        actionSqlPrint->setText(QCoreApplication::translate("MainWindow", "Print", nullptr));
#if QT_CONFIG(tooltip)
        actionSqlPrint->setToolTip(QCoreApplication::translate("MainWindow", "Print text from current SQL editor tab", nullptr));
#endif // QT_CONFIG(tooltip)
#if QT_CONFIG(statustip)
        actionSqlPrint->setStatusTip(QString());
#endif // QT_CONFIG(statustip)
#if QT_CONFIG(whatsthis)
        actionSqlPrint->setWhatsThis(QCoreApplication::translate("MainWindow", "Open a dialog for printing the text in the current SQL editor tab", nullptr));
#endif // QT_CONFIG(whatsthis)
#if QT_CONFIG(shortcut)
        actionSqlPrint->setShortcut(QCoreApplication::translate("MainWindow", "Ctrl+P", nullptr));
#endif // QT_CONFIG(shortcut)
        actionDbPrint->setText(QCoreApplication::translate("MainWindow", "Print", nullptr));
#if QT_CONFIG(tooltip)
        actionDbPrint->setToolTip(QCoreApplication::translate("MainWindow", "Print the structure of the opened database", nullptr));
#endif // QT_CONFIG(tooltip)
#if QT_CONFIG(statustip)
        actionDbPrint->setStatusTip(QString());
#endif // QT_CONFIG(statustip)
#if QT_CONFIG(whatsthis)
        actionDbPrint->setWhatsThis(QCoreApplication::translate("MainWindow", "Open a dialog for printing the structure of the opened database", nullptr));
#endif // QT_CONFIG(whatsthis)
#if QT_CONFIG(shortcut)
        actionDbPrint->setShortcut(QCoreApplication::translate("MainWindow", "Ctrl+P", nullptr));
#endif // QT_CONFIG(shortcut)
        actionSqlToggleComment->setText(QCoreApplication::translate("MainWindow", "Un/comment block of SQL code", nullptr));
        actionSqlToggleComment->setIconText(QCoreApplication::translate("MainWindow", "Un/comment block", nullptr));
#if QT_CONFIG(tooltip)
        actionSqlToggleComment->setToolTip(QCoreApplication::translate("MainWindow", "Comment or uncomment current line or selected block of code", nullptr));
#endif // QT_CONFIG(tooltip)
#if QT_CONFIG(whatsthis)
        actionSqlToggleComment->setWhatsThis(QCoreApplication::translate("MainWindow", "Comment or uncomment the selected lines or the current line, when there is no selection. All the block is toggled according to the first line.", nullptr));
#endif // QT_CONFIG(whatsthis)
#if QT_CONFIG(shortcut)
        actionSqlToggleComment->setShortcut(QCoreApplication::translate("MainWindow", "Ctrl+/", nullptr));
#endif // QT_CONFIG(shortcut)
        actionSqlStop->setText(QCoreApplication::translate("MainWindow", "Stop SQL execution", nullptr));
        actionSqlStop->setIconText(QCoreApplication::translate("MainWindow", "Stop execution", nullptr));
#if QT_CONFIG(tooltip)
        actionSqlStop->setToolTip(QCoreApplication::translate("MainWindow", "Stop the currently running SQL script", nullptr));
#endif // QT_CONFIG(tooltip)
        actionSaveProjectAs->setText(QCoreApplication::translate("MainWindow", "&Save Project As...", nullptr));
#if QT_CONFIG(tooltip)
        actionSaveProjectAs->setToolTip(QCoreApplication::translate("MainWindow", "Save the project in a file selected in a dialog", nullptr));
#endif // QT_CONFIG(tooltip)
#if QT_CONFIG(statustip)
        actionSaveProjectAs->setStatusTip(QCoreApplication::translate("MainWindow", "Save the project in a file selected in a dialog", nullptr));
#endif // QT_CONFIG(statustip)
#if QT_CONFIG(whatsthis)
        actionSaveProjectAs->setWhatsThis(QCoreApplication::translate("MainWindow", "Save the project in a file selected in a dialog", nullptr));
#endif // QT_CONFIG(whatsthis)
        actionSaveAll->setText(QCoreApplication::translate("MainWindow", "Save A&ll", nullptr));
#if QT_CONFIG(tooltip)
        actionSaveAll->setToolTip(QCoreApplication::translate("MainWindow", "Save DB file, project file and opened SQL files", nullptr));
#endif // QT_CONFIG(tooltip)
#if QT_CONFIG(statustip)
        actionSaveAll->setStatusTip(QCoreApplication::translate("MainWindow", "Save DB file, project file and opened SQL files", nullptr));
#endif // QT_CONFIG(statustip)
#if QT_CONFIG(whatsthis)
        actionSaveAll->setWhatsThis(QCoreApplication::translate("MainWindow", "Save DB file, project file and opened SQL files", nullptr));
#endif // QT_CONFIG(whatsthis)
#if QT_CONFIG(shortcut)
        actionSaveAll->setShortcut(QCoreApplication::translate("MainWindow", "Ctrl+Shift+S", nullptr));
#endif // QT_CONFIG(shortcut)
        actionPopupSchemaDockBrowseTable->setText(QCoreApplication::translate("MainWindow", "Browse Table", nullptr));
        actionCloseProject->setText(QCoreApplication::translate("MainWindow", "Close Pro&ject", nullptr));
#if QT_CONFIG(tooltip)
        actionCloseProject->setToolTip(QCoreApplication::translate("MainWindow", "Close project and database files and return to the initial state", nullptr));
#endif // QT_CONFIG(tooltip)
#if QT_CONFIG(statustip)
        actionCloseProject->setStatusTip(QCoreApplication::translate("MainWindow", "Close project and database files and return to the initial state", nullptr));
#endif // QT_CONFIG(statustip)
#if QT_CONFIG(shortcut)
        actionCloseProject->setShortcut(QCoreApplication::translate("MainWindow", "Ctrl+Shift+W", nullptr));
#endif // QT_CONFIG(shortcut)
        fileDetachAction->setText(QCoreApplication::translate("MainWindow", "Detach Database", nullptr));
#if QT_CONFIG(tooltip)
        fileDetachAction->setToolTip(QCoreApplication::translate("MainWindow", "Detach database file attached to the current database connection", nullptr));
#endif // QT_CONFIG(tooltip)
        actionPopupSchemaDockDetachDatabase->setText(QCoreApplication::translate("MainWindow", "Detach Database", nullptr));
#if QT_CONFIG(tooltip)
        actionPopupSchemaDockDetachDatabase->setToolTip(QCoreApplication::translate("MainWindow", "Detach database file attached to the current database connection", nullptr));
#endif // QT_CONFIG(tooltip)
        actionFileImportCsvClipboard->setText(QCoreApplication::translate("MainWindow", "Table from CSV data in Clipboard...", nullptr));
#if QT_CONFIG(tooltip)
        actionFileImportCsvClipboard->setToolTip(QCoreApplication::translate("MainWindow", "This treats the current clipboard contents as a CSV file and opens the same import wizard that is used for importing CSV data from a file.", nullptr));
#endif // QT_CONFIG(tooltip)
        actionRowCounts->setText(QCoreApplication::translate("MainWindow", "Show &Row Counts", nullptr));
#if QT_CONFIG(tooltip)
        actionRowCounts->setToolTip(QCoreApplication::translate("MainWindow", "This shows the number of rows for each table and view in the database.", nullptr));
#endif // QT_CONFIG(tooltip)
        fileSaveAsAction->setText(QCoreApplication::translate("MainWindow", "Save Database &As...", nullptr));
#if QT_CONFIG(tooltip)
        fileSaveAsAction->setToolTip(QCoreApplication::translate("MainWindow", "Save the current database as a different file", nullptr));
#endif // QT_CONFIG(tooltip)
        actionRefreshStructure->setText(QCoreApplication::translate("MainWindow", "Refresh", nullptr));
#if QT_CONFIG(tooltip)
        actionRefreshStructure->setToolTip(QCoreApplication::translate("MainWindow", "Reload the database structure", nullptr));
#endif // QT_CONFIG(tooltip)
#if QT_CONFIG(accessibility)
        structure->setAccessibleName(QCoreApplication::translate("MainWindow", "&Database Structure", nullptr));
#endif // QT_CONFIG(accessibility)
#if QT_CONFIG(whatsthis)
        dbTreeWidget->setWhatsThis(QCoreApplication::translate("MainWindow", "This is the structure of the opened database.\n"
"You can drag SQL statements from an object row and drop them into other applications or into another instance of 'DB Browser for SQLite'.\n"
"", nullptr));
#endif // QT_CONFIG(whatsthis)
        mainTab->setTabText(mainTab->indexOf(structure), QCoreApplication::translate("MainWindow", "&Database Structure", nullptr));
#if QT_CONFIG(accessibility)
        browser->setAccessibleName(QCoreApplication::translate("MainWindow", "&Browse Data", nullptr));
#endif // QT_CONFIG(accessibility)
        mainTab->setTabText(mainTab->indexOf(browser), QCoreApplication::translate("MainWindow", "&Browse Data", nullptr));
#if QT_CONFIG(accessibility)
        pragmas->setAccessibleName(QCoreApplication::translate("MainWindow", "Edit P&ragmas", nullptr));
#endif // QT_CONFIG(accessibility)
        labelPragmaTempStore->setText(QCoreApplication::translate("MainWindow", "Temp Store", nullptr));
        labelPragmaSecureDelete->setText(QCoreApplication::translate("MainWindow", "Secure Delete", nullptr));
        labelPragmaCaseSensitiveLike->setText(QCoreApplication::translate("MainWindow", "Case Sensitive Like", nullptr));
        labelPragmaJournalMode->setText(QCoreApplication::translate("MainWindow", "Journal Mode", nullptr));
        labelJournalSizeLimit->setText(QCoreApplication::translate("MainWindow", "Journal Size Limit", nullptr));
        labelPragmaRecursiveTriggers->setText(QCoreApplication::translate("MainWindow", "Recursive Triggers", nullptr));
        comboboxPragmaJournalMode->setItemText(0, QCoreApplication::translate("MainWindow", "Delete", nullptr));
        comboboxPragmaJournalMode->setItemText(1, QCoreApplication::translate("MainWindow", "Truncate", nullptr));
        comboboxPragmaJournalMode->setItemText(2, QCoreApplication::translate("MainWindow", "Persist", nullptr));
        comboboxPragmaJournalMode->setItemText(3, QCoreApplication::translate("MainWindow", "Memory", nullptr));
        comboboxPragmaJournalMode->setItemText(4, QCoreApplication::translate("MainWindow", "WAL", nullptr));
        comboboxPragmaJournalMode->setItemText(5, QCoreApplication::translate("MainWindow", "Off", nullptr));

        labelPragmaPageSize->setText(QCoreApplication::translate("MainWindow", "Page Size", nullptr));
        checkboxPragmaSecureDelete->setText(QString());
        labelPragmaForeignKeys->setText(QCoreApplication::translate("MainWindow", "Foreign Keys", nullptr));
        checkboxPragmaIgnoreCheckConstraints->setText(QString());
        checkboxPragmaCheckpointFullFsync->setText(QString());
        checkboxPragmaFullFsync->setText(QString());
        checkboxPragmaRecursiveTriggers->setText(QString());
        checkboxPragmaForeignKeys->setText(QString());
        checkboxPragmaAutomaticIndex->setText(QString());
        labelPragmaAutoVacuum->setText(QCoreApplication::translate("MainWindow", "Auto Vacuum", nullptr));
        labelPragmaMaxPageCount->setText(QCoreApplication::translate("MainWindow", "Max Page Count", nullptr));
        comboboxPragmaLockingMode->setItemText(0, QCoreApplication::translate("MainWindow", "Normal", nullptr));
        comboboxPragmaLockingMode->setItemText(1, QCoreApplication::translate("MainWindow", "Exclusive", nullptr));

        labelPragmaCheckpointFullFsync->setText(QCoreApplication::translate("MainWindow", "Checkpoint Full FSYNC", nullptr));
        comboboxPragmaSynchronous->setItemText(0, QCoreApplication::translate("MainWindow", "Off", nullptr));
        comboboxPragmaSynchronous->setItemText(1, QCoreApplication::translate("MainWindow", "Normal", nullptr));
        comboboxPragmaSynchronous->setItemText(2, QCoreApplication::translate("MainWindow", "Full", nullptr));

        comboboxPragmaTempStore->setItemText(0, QCoreApplication::translate("MainWindow", "Default", nullptr));
        comboboxPragmaTempStore->setItemText(1, QCoreApplication::translate("MainWindow", "File", nullptr));
        comboboxPragmaTempStore->setItemText(2, QCoreApplication::translate("MainWindow", "Memory", nullptr));

        labelPragmaAutomaticIndex->setText(QCoreApplication::translate("MainWindow", "Automatic Index", nullptr));
        labelPragmaIgnoreCheckConstraints->setText(QCoreApplication::translate("MainWindow", "Ignore Check Constraints", nullptr));
        labelPragmaFullFsync->setText(QCoreApplication::translate("MainWindow", "Full FSYNC", nullptr));
        labelPragmaWalAutoCheckpoint->setText(QCoreApplication::translate("MainWindow", "WAL Auto Checkpoint", nullptr));
        labelPragmaUserVersion->setText(QCoreApplication::translate("MainWindow", "User Version", nullptr));

        labelPragmaSynchronous->setText(QCoreApplication::translate("MainWindow", "Synchronous", nullptr));
#if QT_CONFIG(tooltip)
        checkboxPragmaCaseSensitiveLike->setToolTip(QCoreApplication::translate("MainWindow", "Warning: this pragma is not readable and this value has been inferred. Writing the pragma might overwrite a redefined LIKE provided by an SQLite extension.", nullptr));
#endif // QT_CONFIG(tooltip)
        checkboxPragmaCaseSensitiveLike->setText(QString());
        comboboxPragmaAutoVacuum->setItemText(0, QCoreApplication::translate("MainWindow", "None", nullptr));
        comboboxPragmaAutoVacuum->setItemText(1, QCoreApplication::translate("MainWindow", "Full", nullptr));
        comboboxPragmaAutoVacuum->setItemText(2, QCoreApplication::translate("MainWindow", "Incremental", nullptr));

        labelPragmaLockingMode->setText(QCoreApplication::translate("MainWindow", "Locking Mode", nullptr));
        mainTab->setTabText(mainTab->indexOf(pragmas), QCoreApplication::translate("MainWindow", "Edit P&ragmas", nullptr));
#if QT_CONFIG(accessibility)
        query->setAccessibleName(QCoreApplication::translate("MainWindow", "E&xecute SQL", nullptr));
#endif // QT_CONFIG(accessibility)
        toolbarSql->setWindowTitle(QCoreApplication::translate("MainWindow", "toolBar1", nullptr));
        mainTab->setTabText(mainTab->indexOf(query), QCoreApplication::translate("MainWindow", "E&xecute SQL", nullptr));
        fileMenu->setTitle(QCoreApplication::translate("MainWindow", "&File", nullptr));
        menuImport->setTitle(QCoreApplication::translate("MainWindow", "&Import", nullptr));
        menuExport->setTitle(QCoreApplication::translate("MainWindow", "&Export", nullptr));
        fileRecentFiles->setTitle(QCoreApplication::translate("MainWindow", "&Recent Files", nullptr));
        editMenu->setTitle(QCoreApplication::translate("MainWindow", "&Edit", nullptr));
        viewMenu->setTitle(QCoreApplication::translate("MainWindow", "&View", nullptr));
        helpMenu->setTitle(QCoreApplication::translate("MainWindow", "&Help", nullptr));
        menuTools->setTitle(QCoreApplication::translate("MainWindow", "Too&ls", nullptr));
        toolbarDB->setWindowTitle(QCoreApplication::translate("MainWindow", "DB Toolbar", nullptr));
        dockEdit->setWindowTitle(QCoreApplication::translate("MainWindow", "Edit Database &Cell", nullptr));
        dockLog->setWindowTitle(QCoreApplication::translate("MainWindow", "SQL &Log", nullptr));
        labelLogSubmittedBy->setText(QCoreApplication::translate("MainWindow", "Show S&QL submitted by", nullptr));
        comboLogSubmittedBy->setItemText(0, QCoreApplication::translate("MainWindow", "User", nullptr));
        comboLogSubmittedBy->setItemText(1, QCoreApplication::translate("MainWindow", "Application", nullptr));
        comboLogSubmittedBy->setItemText(2, QCoreApplication::translate("MainWindow", "Error Log", nullptr));

#if QT_CONFIG(whatsthis)
        buttonLogClear->setWhatsThis(QCoreApplication::translate("MainWindow", "This button clears the contents of the SQL logs", nullptr));
#endif // QT_CONFIG(whatsthis)
        buttonLogClear->setText(QCoreApplication::translate("MainWindow", "&Clear", nullptr));
#if QT_CONFIG(whatsthis)
        stackLog->setWhatsThis(QCoreApplication::translate("MainWindow", "This panel lets you examine a log of all SQL commands issued by the application or by yourself", nullptr));
#endif // QT_CONFIG(whatsthis)
        dockPlot->setWindowTitle(QCoreApplication::translate("MainWindow", "&Plot", nullptr));
        dockSchema->setWindowTitle(QCoreApplication::translate("MainWindow", "DB Sche&ma", nullptr));
#if QT_CONFIG(whatsthis)
        treeSchemaDock->setWhatsThis(QCoreApplication::translate("MainWindow", "This is the structure of the opened database.\n"
"You can drag multiple object names from the Name column and drop them into the SQL editor and you can adjust the properties of the dropped names using the context menu. This would help you in composing SQL statements.\n"
"You can drag SQL statements from the Schema column and drop them into the SQL editor or into other applications.\n"
"", nullptr));
#endif // QT_CONFIG(whatsthis)
        dockRemote->setWindowTitle(QCoreApplication::translate("MainWindow", "&Remote", nullptr));
        toolbarProject->setWindowTitle(QCoreApplication::translate("MainWindow", "Project Toolbar", nullptr));
        toolbarExtraDB->setWindowTitle(QCoreApplication::translate("MainWindow", "Extra DB toolbar", nullptr));
#if QT_CONFIG(tooltip)
        toolbarExtraDB->setToolTip(QCoreApplication::translate("MainWindow", "Close the current database file", nullptr));
#endif // QT_CONFIG(tooltip)
    } // retranslateUi

};

namespace Ui {
    class MainWindow: public Ui_MainWindow {};
} // namespace Ui

QT_END_NAMESPACE

#endif // UI_MAINWINDOW_H
