1144 baris
33 KiB
C++
1144 baris
33 KiB
C++
#include <poppler-qt6.h>
|
|
#include <QLabel>
|
|
#include <QtDebug>
|
|
#include <QFileInfo>
|
|
#include <QDesktopServices>
|
|
#include <QUrl>
|
|
#include <QClipboard>
|
|
#include <QtGlobal>
|
|
#include <QSettings>
|
|
#include <QDateTime>
|
|
#include <QProcess>
|
|
#include <QComboBox>
|
|
#include <QtConcurrent/QtConcurrent>
|
|
#include <QMessageBox>
|
|
#include <QFileDialog>
|
|
#include <QScreen>
|
|
#include <QProgressDialog>
|
|
#include <QWidgetAction>
|
|
#include <QInputDialog>
|
|
#include "mainwindow.h"
|
|
#include "ui_mainwindow.h"
|
|
#include "clicklabel.h"
|
|
#include "../shared/sqlitesearch.h"
|
|
#include "../shared/looqsgeneralexception.h"
|
|
#include "../shared/common.h"
|
|
#include "aboutdialog.h"
|
|
|
|
MainWindow::MainWindow(QWidget *parent, QString socketPath)
|
|
: QMainWindow(parent), ui(new Ui::MainWindow), progressDialog(this)
|
|
{
|
|
this->progressDialog.cancel(); // because constructing it shows it, quite weird
|
|
ui->setupUi(this);
|
|
setWindowTitle(QCoreApplication::applicationName());
|
|
|
|
QSettings settings;
|
|
|
|
this->dbFactory = new DatabaseFactory(Common::databasePath());
|
|
|
|
db = this->dbFactory->forCurrentThread();
|
|
this->dbService = new SqliteDbService(*this->dbFactory);
|
|
this->indexSyncer = new IndexSyncer(*this->dbService);
|
|
this->indexSyncer->moveToThread(&this->syncerThread);
|
|
|
|
indexer = new Indexer(*(this->dbService));
|
|
indexer->setParent(this);
|
|
|
|
tagManager = new TagManager(*(this->dbService));
|
|
|
|
connectSignals();
|
|
ui->treeResultsList->setContextMenuPolicy(Qt::ContextMenuPolicy::CustomContextMenu);
|
|
ui->tabWidget->setCurrentIndex(0);
|
|
ui->statusBar->addWidget(ui->lblSearchResults);
|
|
ui->statusBar->addWidget(ui->previewProcessBar);
|
|
ui->previewProcessBar->hide();
|
|
ui->comboScale->setCurrentText(settings.value("currentScale").toString());
|
|
previewsPerPage = settings.value("previewsPerPage", 20).toInt();
|
|
ui->spinPreviewPage->setMinimum(1);
|
|
|
|
QStringList indexPaths = settings.value("indexPaths").toStringList();
|
|
ui->lstPaths->addItems(indexPaths);
|
|
|
|
QString ignorePatterns = settings.value("ignorePatterns").toString();
|
|
ui->txtIgnorePatterns->setText(ignorePatterns);
|
|
|
|
QStringList searchHistoryList = settings.value(SETTINGS_KEY_SEARCHHISTORY).toStringList();
|
|
this->searchHistory = searchHistoryList.toVector();
|
|
this->currentSearchHistoryIndex = this->searchHistory.size();
|
|
|
|
ui->spinPreviewPage->setValue(1);
|
|
ui->spinPreviewPage->setMinimum(1);
|
|
|
|
ui->btnOpenFailed->setVisible(false);
|
|
ui->comboPreviewFiles->setVisible(false);
|
|
|
|
auto policy = ui->btnOpenFailed->sizePolicy();
|
|
policy.setRetainSizeWhenHidden(true);
|
|
ui->btnOpenFailed->setSizePolicy(policy);
|
|
|
|
ui->txtSearch->installEventFilter(this);
|
|
ui->scrollArea->viewport()->installEventFilter(this);
|
|
|
|
this->previewCoordinator.setSocketPath(socketPath);
|
|
}
|
|
|
|
void MainWindow::addPathToIndex()
|
|
{
|
|
QString path = this->ui->txtPathScanAdd->text();
|
|
QFileInfo fileInfo{path};
|
|
if(!fileInfo.exists(path))
|
|
{
|
|
QMessageBox::critical(this, "Invalid path", "Path does not seem to exist");
|
|
return;
|
|
}
|
|
if(!fileInfo.isReadable())
|
|
{
|
|
QMessageBox::critical(this, "Invalid path", "Path cannot be read");
|
|
return;
|
|
}
|
|
this->ui->lstPaths->addItem(path);
|
|
this->ui->txtPathScanAdd->clear();
|
|
}
|
|
|
|
void MainWindow::connectSignals()
|
|
{
|
|
connect(ui->txtSearch, &QLineEdit::returnPressed, this, &MainWindow::lineEditReturnPressed);
|
|
connect(&searchWatcher, &QFutureWatcher<SearchResult>::finished, this,
|
|
[&]
|
|
{
|
|
try
|
|
{
|
|
this->ui->txtSearch->setEnabled(true);
|
|
auto results = searchWatcher.future().result();
|
|
handleSearchResults(results);
|
|
}
|
|
catch(LooqsGeneralException &e)
|
|
{
|
|
handleSearchError(e.message);
|
|
}
|
|
});
|
|
connect(ui->treeResultsList, &QTreeWidget::itemActivated, this, &MainWindow::treeSearchItemActivated);
|
|
connect(ui->treeResultsList, &QTreeWidget::customContextMenuRequested, this,
|
|
&MainWindow::showSearchResultsContextMenu);
|
|
connect(ui->tabWidget, &QTabWidget::currentChanged, this, &MainWindow::tabChanged);
|
|
connect(ui->comboScale, qOverload<int>(&QComboBox::currentIndexChanged), this, &MainWindow::comboScaleChanged);
|
|
connect(ui->spinPreviewPage, qOverload<int>(&QSpinBox::valueChanged), this,
|
|
&MainWindow::spinPreviewPageValueChanged);
|
|
|
|
connect(ui->btnAddPath, &QPushButton::clicked, this, &MainWindow::addPathToIndex);
|
|
connect(ui->txtPathScanAdd, &QLineEdit::returnPressed, this, &MainWindow::addPathToIndex);
|
|
connect(ui->btnStartIndexing, &QPushButton::clicked, this, &MainWindow::startIndexing);
|
|
|
|
connect(this->indexer, &Indexer::pathsCountChanged, this,
|
|
[&](int number)
|
|
{
|
|
ui->lblSearchResults->setText("Found paths: " + QString::number(number));
|
|
ui->lblPathsFoundValue->setText(QString::number(number));
|
|
ui->previewProcessBar->setMaximum(number);
|
|
});
|
|
connect(this->indexer, &Indexer::indexProgress, this,
|
|
|
|
[&](int number, unsigned int added, unsigned int skipped, unsigned int failed, unsigned int totalCount)
|
|
{
|
|
ui->lblSearchResults->setText("Processed " + QString::number(number) + " files");
|
|
ui->previewProcessBar->setValue(number);
|
|
ui->previewProcessBar->setMaximum(totalCount);
|
|
ui->lblAddedValue->setText(QString::number(added));
|
|
ui->lblSkippedValue->setText(QString::number(skipped));
|
|
ui->lblFailedValue->setText(QString::number(failed));
|
|
});
|
|
|
|
connect(this->indexer, &Indexer::finished, this, &MainWindow::finishIndexing);
|
|
|
|
connect(ui->lstPaths->selectionModel(), &QItemSelectionModel::selectionChanged, this,
|
|
[&](const QItemSelection & /*selected*/, const QItemSelection & /*deselected*/)
|
|
{ ui->btnDeletePath->setEnabled(this->ui->lstPaths->selectedItems().count() > 0); });
|
|
|
|
connect(ui->btnDeletePath, &QPushButton::clicked, this, [&] { qDeleteAll(ui->lstPaths->selectedItems()); });
|
|
connect(ui->btnChoosePath, &QPushButton::clicked, this,
|
|
[&]
|
|
{
|
|
QFileDialog dialog(nullptr);
|
|
dialog.setFileMode(QFileDialog::Directory);
|
|
dialog.setOptions(QFileDialog::ShowDirsOnly);
|
|
if(dialog.exec())
|
|
{
|
|
auto paths = dialog.selectedFiles();
|
|
if(paths.size() == 1)
|
|
{
|
|
ui->lstPaths->addItem(paths[0]);
|
|
}
|
|
}
|
|
});
|
|
connect(ui->menuAboutAction, &QAction::triggered, this,
|
|
[this](bool /*checked*/)
|
|
{
|
|
AboutDialog aboutDialog(this);
|
|
|
|
aboutDialog.exec();
|
|
});
|
|
connect(ui->menuAboutQtAction, &QAction::triggered, this,
|
|
[this](bool /*checked*/) { QMessageBox::aboutQt(this, "About Qt"); });
|
|
connect(ui->menuSyncIndexAction, &QAction::triggered, this, &MainWindow::startIndexSync);
|
|
connect(ui->menuOpenUserManualAction, &QAction::triggered, this,
|
|
[]() { QDesktopServices::openUrl(Common::userManualUrl()); });
|
|
|
|
connect(
|
|
indexSyncer, &IndexSyncer::finished, this,
|
|
[&](unsigned int totalUpdated, unsigned int totalDeleted, unsigned int totalErrored)
|
|
{
|
|
this->progressDialog.cancel();
|
|
|
|
QMessageBox::information(
|
|
this, "Syncing finished",
|
|
QString("Syncing finished\n\nTotal updated: %1\nTotal deleted: %2\nTotal errors: %3\n")
|
|
.arg(QString::number(totalUpdated), QString::number(totalDeleted), QString::number(totalErrored)));
|
|
});
|
|
connect(this, &MainWindow::beginIndexSync, indexSyncer, &IndexSyncer::sync);
|
|
connect(&this->progressDialog, &QProgressDialog::canceled, indexSyncer, &IndexSyncer::cancel);
|
|
connect(ui->btnSaveSettings, &QPushButton::clicked, this, &MainWindow::saveSettings);
|
|
connect(ui->btnOpenFailed, &QPushButton::clicked, this, &MainWindow::exportFailedPaths);
|
|
connect(
|
|
ui->comboPreviewFiles, qOverload<int>(&QComboBox::currentIndexChanged), this,
|
|
[&]()
|
|
{
|
|
if(this->previewTabActive())
|
|
{
|
|
makePreviews(1);
|
|
}
|
|
},
|
|
Qt::QueuedConnection);
|
|
connect(&previewCoordinator, &PreviewCoordinator::previewReady, this, &MainWindow::previewReceived,
|
|
Qt::QueuedConnection);
|
|
connect(&previewCoordinator, &PreviewCoordinator::completedGeneration, this,
|
|
[&]
|
|
{
|
|
this->ui->previewProcessBar->setValue(this->ui->previewProcessBar->maximum());
|
|
this->ui->spinPreviewPage->setEnabled(true);
|
|
this->ui->comboPreviewFiles->setEnabled(true);
|
|
ui->txtSearch->setEnabled(true);
|
|
});
|
|
connect(&previewCoordinator, &PreviewCoordinator::error, this,
|
|
[this](QString msg)
|
|
{
|
|
qCritical() << msg << Qt::endl;
|
|
QMessageBox::critical(this, "IPC error", msg);
|
|
});
|
|
connect(ui->radioMetadataOnly, &QRadioButton::toggled, this,
|
|
[this](bool toggled)
|
|
{
|
|
if(toggled)
|
|
{
|
|
this->ui->chkFillContentForContentless->setChecked(false);
|
|
};
|
|
});
|
|
}
|
|
|
|
void MainWindow::exportFailedPaths()
|
|
{
|
|
QString filename =
|
|
QString("/tmp/looqs_indexresult_failed_%1").arg(QDateTime::currentDateTime().toString("yyyy-MM-dd_hhmmss"));
|
|
QFile outFile(filename);
|
|
if(!outFile.open(QIODevice::WriteOnly | QIODevice::Text))
|
|
{
|
|
QMessageBox::critical(this, "Failed to write log file", "An error occured while trying to create log file");
|
|
return;
|
|
}
|
|
|
|
QTextStream stream(&outFile);
|
|
|
|
IndexResult result = this->indexer->getResult();
|
|
|
|
stream << "Failed to index the following paths:\n";
|
|
for(FileScanResult &fsr : result.failedResults())
|
|
{
|
|
stream << fsr.first << " " << SaveFileResultToString(fsr.second) << '\n';
|
|
}
|
|
|
|
QDesktopServices::openUrl(filename);
|
|
}
|
|
|
|
void MainWindow::startIndexSync()
|
|
{
|
|
progressDialog.setWindowTitle("Syncing");
|
|
progressDialog.setLabelText("Syncing - this might take a moment, please wait");
|
|
progressDialog.setWindowModality(Qt::ApplicationModal);
|
|
progressDialog.setMinimum(0);
|
|
progressDialog.setMaximum(0);
|
|
progressDialog.setValue(0);
|
|
progressDialog.open();
|
|
|
|
FileSaverOptions options;
|
|
options.keepGoing = true;
|
|
options.verbose = false;
|
|
|
|
indexSyncer->setFileSaverOptions(options);
|
|
indexSyncer->setDryRun(false);
|
|
indexSyncer->setRemoveDeletedFromIndex(true);
|
|
|
|
this->syncerThread.start();
|
|
|
|
emit beginIndexSync();
|
|
}
|
|
|
|
void MainWindow::spinPreviewPageValueChanged(int val)
|
|
{
|
|
makePreviews(val);
|
|
}
|
|
|
|
void MainWindow::startIndexing()
|
|
{
|
|
if(this->indexer->isRunning())
|
|
{
|
|
ui->btnStartIndexing->setEnabled(false);
|
|
|
|
ui->btnStartIndexing->setText("Start indexing");
|
|
this->indexer->requestCancellation();
|
|
return;
|
|
}
|
|
|
|
ui->previewsTab->setEnabled(false);
|
|
ui->resultsTab->setEnabled(false);
|
|
ui->settingsTab->setEnabled(false);
|
|
ui->txtPathScanAdd->setEnabled(false);
|
|
ui->btnAddPath->setEnabled(false);
|
|
ui->btnChoosePath->setEnabled(false);
|
|
ui->txtSearch->setEnabled(false);
|
|
ui->previewProcessBar->setValue(0);
|
|
ui->previewProcessBar->setVisible(true);
|
|
ui->btnOpenFailed->setVisible(false);
|
|
|
|
QVector<QString> paths;
|
|
QStringList pathSettingsValue;
|
|
for(int i = 0; i < ui->lstPaths->count(); i++)
|
|
{
|
|
QString path = ui->lstPaths->item(i)->text();
|
|
paths.append(path);
|
|
pathSettingsValue.append(path);
|
|
}
|
|
this->indexer->setTargetPaths(paths);
|
|
QString ignorePatterns = ui->txtIgnorePatterns->text();
|
|
this->indexer->setIgnorePattern(ignorePatterns.split(";"));
|
|
|
|
FileSaverOptions options;
|
|
options.fillExistingContentless =
|
|
ui->chkFillContentForContentless->isEnabled() && ui->chkFillContentForContentless->isChecked();
|
|
options.metadataOnly = ui->radioMetadataOnly->isChecked();
|
|
options.verbose = false;
|
|
options.keepGoing = true;
|
|
|
|
this->indexer->setFileSaverOptions(options);
|
|
this->indexer->beginIndexing();
|
|
QSettings settings;
|
|
settings.setValue("indexPaths", pathSettingsValue);
|
|
settings.setValue("ignorePatterns", ignorePatterns);
|
|
ui->btnStartIndexing->setText("Stop indexing");
|
|
}
|
|
|
|
void MainWindow::finishIndexing()
|
|
{
|
|
IndexResult result = this->indexer->getResult();
|
|
|
|
ui->lblSearchResults->setText("Indexing finished");
|
|
ui->previewProcessBar->setValue(ui->previewProcessBar->maximum());
|
|
ui->lblFailedValue->setText(QString::number(result.erroredPaths));
|
|
ui->lblSkippedValue->setText(QString::number(result.skippedPaths));
|
|
ui->lblAddedValue->setText(QString::number(result.addedPaths));
|
|
ui->btnStartIndexing->setEnabled(true);
|
|
ui->btnStartIndexing->setText("Start indexing");
|
|
ui->previewsTab->setEnabled(true);
|
|
ui->resultsTab->setEnabled(true);
|
|
ui->settingsTab->setEnabled(true);
|
|
ui->txtPathScanAdd->setEnabled(true);
|
|
ui->btnAddPath->setEnabled(true);
|
|
ui->btnChoosePath->setEnabled(true);
|
|
ui->txtSearch->setEnabled(true);
|
|
if(result.erroredPaths > 0)
|
|
{
|
|
ui->btnOpenFailed->setVisible(true);
|
|
}
|
|
}
|
|
|
|
void MainWindow::comboScaleChanged(int /*i*/)
|
|
{
|
|
QSettings scaleSetting;
|
|
scaleSetting.setValue("currentScale", ui->comboScale->currentText());
|
|
makePreviews(ui->spinPreviewPage->value());
|
|
}
|
|
|
|
bool MainWindow::previewTabActive()
|
|
{
|
|
return ui->tabWidget->currentIndex() == 1;
|
|
}
|
|
|
|
bool MainWindow::indexerTabActive()
|
|
{
|
|
return ui->tabWidget->currentIndex() == 2;
|
|
}
|
|
|
|
void MainWindow::processShortcut(int key)
|
|
{
|
|
if(key == Qt::Key_Tab || key == Qt::Key_Backtab)
|
|
{
|
|
int tabIndex = ui->tabWidget->currentIndex();
|
|
if(key == Qt::Key_Tab)
|
|
{
|
|
++tabIndex;
|
|
}
|
|
if(key == Qt::Key_Backtab)
|
|
{
|
|
--tabIndex;
|
|
}
|
|
tabIndex = tabIndex % ui->tabWidget->count();
|
|
if(tabIndex < 0)
|
|
{
|
|
tabIndex = ui->tabWidget->count() - 1;
|
|
}
|
|
ui->tabWidget->setCurrentIndex(tabIndex);
|
|
}
|
|
if(key == Qt::Key_L)
|
|
{
|
|
ui->txtSearch->setFocus();
|
|
ui->txtSearch->selectAll();
|
|
}
|
|
if(key == Qt::Key_W)
|
|
{
|
|
ui->txtSearch->setFocus();
|
|
QString currentText = ui->txtSearch->text().trimmed();
|
|
static QRegularExpression separatorRegex("[\\s\\)]");
|
|
int index = currentText.lastIndexOf(separatorRegex);
|
|
if(index != -1)
|
|
{
|
|
bool isFilter = (index == currentText.length() - 1);
|
|
currentText.remove(index + 1, currentText.length() - index - 1);
|
|
if(isFilter)
|
|
{
|
|
index = currentText.lastIndexOf(' ', index);
|
|
if(index == -1)
|
|
{
|
|
index = 0;
|
|
}
|
|
currentText.remove(index, currentText.length());
|
|
}
|
|
if(currentText.length() > 0)
|
|
{
|
|
currentText += ' ';
|
|
}
|
|
ui->txtSearch->setText(currentText);
|
|
}
|
|
else
|
|
{
|
|
ui->txtSearch->clear();
|
|
}
|
|
}
|
|
if(key == Qt::Key_F)
|
|
{
|
|
ui->txtSearch->setFocus();
|
|
QString currentText = ui->txtSearch->text().trimmed();
|
|
int index = currentText.lastIndexOf(')');
|
|
if(index != -1)
|
|
{
|
|
bool isFilter = (index == currentText.length() - 1);
|
|
if(!isFilter)
|
|
{
|
|
ui->txtSearch->setSelection(index + 2, ui->txtSearch->text().length() - index - 1);
|
|
}
|
|
else
|
|
{
|
|
int begin = currentText.lastIndexOf('(', index - 1);
|
|
if(begin != -1)
|
|
{
|
|
ui->txtSearch->setSelection(begin + 1, index - begin - 1);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
int spaceIndex = currentText.lastIndexOf(' ');
|
|
int colonIndex = currentText.lastIndexOf(':');
|
|
if(colonIndex > spaceIndex)
|
|
{
|
|
int target = currentText.indexOf(' ', colonIndex);
|
|
if(target == -1)
|
|
{
|
|
target = ui->txtSearch->text().size() - colonIndex;
|
|
}
|
|
ui->txtSearch->setSelection(colonIndex + 1, target - 1);
|
|
}
|
|
else
|
|
{
|
|
ui->txtSearch->setSelection(spaceIndex + 1, ui->txtSearch->text().size() - spaceIndex - 1);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
bool MainWindow::eventFilter(QObject *object, QEvent *event)
|
|
{
|
|
if(object == ui->txtSearch && !searchHistory.empty())
|
|
{
|
|
if(event->type() == QEvent::KeyPress)
|
|
{
|
|
QKeyEvent *keyEvent = static_cast<QKeyEvent *>(event);
|
|
if(keyEvent->key() == Qt::Key_Up)
|
|
{
|
|
if(this->currentSavedSearchText.isEmpty())
|
|
{
|
|
this->currentSavedSearchText = ui->txtSearch->text();
|
|
}
|
|
if(this->currentSearchHistoryIndex <= 0)
|
|
{
|
|
return true;
|
|
}
|
|
--this->currentSearchHistoryIndex;
|
|
QString text = this->searchHistory.at(this->currentSearchHistoryIndex);
|
|
ui->txtSearch->setText(text);
|
|
return true;
|
|
}
|
|
else if(keyEvent->key() == Qt::Key_Down)
|
|
{
|
|
if(this->currentSearchHistoryIndex == searchHistory.size() - 1)
|
|
{
|
|
if(!this->currentSavedSearchText.isEmpty())
|
|
{
|
|
ui->txtSearch->setText(this->currentSavedSearchText);
|
|
this->currentSavedSearchText.clear();
|
|
++this->currentSearchHistoryIndex;
|
|
}
|
|
return true;
|
|
}
|
|
if(this->currentSearchHistoryIndex < searchHistory.size() - 1)
|
|
{
|
|
++this->currentSearchHistoryIndex;
|
|
QString text = this->searchHistory.at(this->currentSearchHistoryIndex);
|
|
ui->txtSearch->setText(text);
|
|
}
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
this->currentSavedSearchText.clear();
|
|
/* Off by one on purpose so Key_Up decrements it again and lands at
|
|
* the last entry */
|
|
this->currentSearchHistoryIndex = this->searchHistory.size();
|
|
}
|
|
}
|
|
}
|
|
if(object == ui->scrollArea->viewport())
|
|
{
|
|
if(event->type() == QEvent::Wheel)
|
|
{
|
|
QWheelEvent *wheelEvent = static_cast<QWheelEvent *>(event);
|
|
if(wheelEvent->modifiers() & Qt::ControlModifier)
|
|
{
|
|
if(wheelEvent->angleDelta().y() > 0)
|
|
{
|
|
if(ui->comboScale->currentIndex() < ui->comboScale->count() - 1)
|
|
{
|
|
ui->comboScale->setCurrentIndex(ui->comboScale->currentIndex() + 1);
|
|
}
|
|
}
|
|
|
|
else
|
|
{
|
|
if(ui->comboScale->currentIndex() > 0)
|
|
{
|
|
ui->comboScale->setCurrentIndex(ui->comboScale->currentIndex() - 1);
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return QMainWindow::eventFilter(object, event);
|
|
}
|
|
|
|
void MainWindow::keyPressEvent(QKeyEvent *event)
|
|
{
|
|
bool quit =
|
|
((event->modifiers() & Qt::ControlModifier && event->key() == Qt::Key_Q) || event->key() == Qt::Key_Escape);
|
|
if(quit)
|
|
{
|
|
qApp->quit();
|
|
return;
|
|
}
|
|
|
|
if(event->modifiers() & Qt::ControlModifier)
|
|
{
|
|
processShortcut(event->key());
|
|
return;
|
|
}
|
|
|
|
QWidget::keyPressEvent(event);
|
|
}
|
|
|
|
void MainWindow::tabChanged()
|
|
{
|
|
if(ui->tabWidget->currentIndex() == 0)
|
|
{
|
|
ui->previewProcessBar->hide();
|
|
}
|
|
else
|
|
{
|
|
if(ui->previewProcessBar->value() > 0)
|
|
{
|
|
ui->previewProcessBar->show();
|
|
}
|
|
}
|
|
if(previewTabActive())
|
|
{
|
|
if(previewDirty)
|
|
{
|
|
makePreviews(ui->spinPreviewPage->value());
|
|
}
|
|
}
|
|
/* Settings tab active */
|
|
if(ui->tabWidget->currentIndex() == 3)
|
|
{
|
|
initSettingsTabs();
|
|
}
|
|
}
|
|
|
|
void MainWindow::initSettingsTabs()
|
|
{
|
|
QSettings settings;
|
|
|
|
QString pdfViewerCmd = settings.value(SETTINGS_KEY_PDFVIEWER).toString();
|
|
QString excludedPaths = Common::excludedPaths().join(';');
|
|
QString mountPaths = Common::mountPaths().join(';');
|
|
QString databasePath = Common::databasePath();
|
|
int numPagesPerPreview = settings.value(SETTINGS_KEY_PREVIEWSPERPAGE, 20).toInt();
|
|
|
|
ui->txtSettingPdfPreviewerCmd->setText(pdfViewerCmd);
|
|
ui->txtSettingIgnoredPaths->setText(excludedPaths);
|
|
ui->txtSettingMountPaths->setText(mountPaths);
|
|
ui->spinSettingNumerPerPages->setValue(numPagesPerPreview);
|
|
ui->txtSettingDatabasePath->setText(databasePath);
|
|
bool horizontalScroll = settings.value(SETTINGS_KEY_PREVIEWS_SCROLL_HORIZONTALLY).toBool();
|
|
ui->radioScrollHorizontally->setChecked(horizontalScroll);
|
|
ui->radioScrollVertically->setChecked(!horizontalScroll);
|
|
}
|
|
|
|
void MainWindow::saveSettings()
|
|
{
|
|
if(ui->chkRemoveOldDb->isChecked())
|
|
{
|
|
bool result = QFile::remove(Common::databasePath());
|
|
if(!result)
|
|
{
|
|
QMessageBox::critical(this, "Error removing database",
|
|
"Failed to remove old database. Settings not saved.");
|
|
return;
|
|
}
|
|
}
|
|
|
|
QSettings settings;
|
|
|
|
QString pdfViewerCmd = ui->txtSettingPdfPreviewerCmd->text();
|
|
QStringList excludedPaths = ui->txtSettingIgnoredPaths->text().split(';');
|
|
QStringList mountPaths = ui->txtSettingMountPaths->text().split(';');
|
|
QString databasePath = ui->txtSettingDatabasePath->text();
|
|
|
|
settings.setValue(SETTINGS_KEY_PDFVIEWER, pdfViewerCmd);
|
|
settings.setValue(SETTINGS_KEY_EXCLUDEDPATHS, excludedPaths);
|
|
settings.setValue(SETTINGS_KEY_MOUNTPATHS, mountPaths);
|
|
settings.setValue(SETTINGS_KEY_PREVIEWSPERPAGE, ui->spinSettingNumerPerPages->value());
|
|
settings.setValue(SETTINGS_KEY_DBPATH, databasePath);
|
|
settings.setValue(SETTINGS_KEY_PREVIEWS_SCROLL_HORIZONTALLY, ui->radioScrollHorizontally->isChecked());
|
|
|
|
settings.sync();
|
|
|
|
QProcess::startDetached(qApp->arguments()[0], qApp->arguments().mid(1));
|
|
qApp->quit();
|
|
}
|
|
|
|
void MainWindow::previewReceived()
|
|
{
|
|
this->ui->previewProcessBar->setValue(this->ui->previewProcessBar->value() + 1);
|
|
QBoxLayout *layout = static_cast<QBoxLayout *>(ui->scrollAreaWidgetContents->layout());
|
|
int index = layout->count();
|
|
if(index > 0)
|
|
{
|
|
--index;
|
|
}
|
|
QSharedPointer<PreviewResult> preview = this->previewCoordinator.resultAt(index);
|
|
|
|
if(!preview.isNull() && preview->hasPreview())
|
|
{
|
|
QString docPath = preview->getDocumentPath();
|
|
auto previewPage = preview->getPage();
|
|
ClickLabel *headerLabel = new ClickLabel();
|
|
headerLabel->setText(QString("Path: ") + preview->getDocumentPath());
|
|
|
|
ClickLabel *label = dynamic_cast<ClickLabel *>(preview->createPreviewWidget());
|
|
label->setMaximumWidth(QApplication::primaryScreen()->availableGeometry().width() - 200);
|
|
|
|
QVBoxLayout *previewLayout = new QVBoxLayout();
|
|
|
|
QFont font = label->font();
|
|
font.setPointSize(QApplication::font().pointSize() * currentSelectedScale() / 100);
|
|
label->setFont(font);
|
|
headerLabel->setFont(font);
|
|
|
|
auto leftClickHandler = [this, docPath, previewPage]() { openDocument(docPath, previewPage); };
|
|
auto rightClickhandler = [this, docPath, previewPage]()
|
|
{
|
|
QFileInfo fileInfo{docPath};
|
|
QMenu menu("labeRightClick", this);
|
|
createSearchResultMenu(menu, fileInfo);
|
|
menu.addAction("Copy page number", this,
|
|
[previewPage] { QGuiApplication::clipboard()->setText(QString::number(previewPage)); });
|
|
menu.exec(QCursor::pos());
|
|
};
|
|
|
|
connect(label, &ClickLabel::leftClick, leftClickHandler);
|
|
connect(label, &ClickLabel::rightClick, rightClickhandler);
|
|
|
|
connect(headerLabel, &ClickLabel::rightClick, rightClickhandler);
|
|
|
|
previewLayout->addWidget(label);
|
|
|
|
previewLayout->addWidget(headerLabel);
|
|
|
|
previewLayout->setContentsMargins(0, 0, 0, 0);
|
|
previewLayout->insertStretch(0, 1);
|
|
previewLayout->insertStretch(-1, 1);
|
|
previewLayout->setAlignment(Qt::AlignCenter);
|
|
QWidget *previewWidget = new QWidget();
|
|
|
|
previewWidget->setLayout(previewLayout);
|
|
|
|
layout->insertWidget(index, previewWidget);
|
|
}
|
|
}
|
|
|
|
void MainWindow::lineEditReturnPressed()
|
|
{
|
|
QString q = ui->txtSearch->text();
|
|
if(!LooqsQuery::checkParanthesis(q))
|
|
{
|
|
ui->lblSearchResults->setText("Invalid paranthesis");
|
|
return;
|
|
}
|
|
if(ui->tabWidget->currentIndex() > 1)
|
|
{
|
|
ui->tabWidget->setCurrentIndex(0);
|
|
}
|
|
// TODO: validate q;
|
|
while(this->searchHistory.size() > 30)
|
|
{
|
|
this->searchHistory.removeFirst();
|
|
}
|
|
this->searchHistory.append(q);
|
|
this->currentSearchHistoryIndex = this->searchHistory.size();
|
|
this->currentSavedSearchText.clear();
|
|
|
|
ui->treeResultsList->clear();
|
|
ui->lblSearchResults->setText("Searching...");
|
|
this->ui->txtSearch->setEnabled(false);
|
|
QFuture<QVector<SearchResult>> searchFuture = QtConcurrent::run(
|
|
[&, q]()
|
|
{
|
|
SqliteSearch searcher(db);
|
|
QVector<SearchResult> results;
|
|
LooqsQuery tmpQuery = LooqsQuery::build(q, TokenType::WORD, true);
|
|
|
|
LooqsQuery pathsQuery = tmpQuery;
|
|
|
|
this->contentSearchQuery = tmpQuery;
|
|
|
|
bool addContentSearch = false;
|
|
bool addPathSearch = false;
|
|
|
|
auto createFinalTokens = [&tmpQuery](TokenType replacementToken)
|
|
{
|
|
QVector<Token> tokens = tmpQuery.getTokens();
|
|
for(Token &token : tokens)
|
|
{
|
|
if(token.type == TokenType::WORD)
|
|
{
|
|
token.type = replacementToken;
|
|
}
|
|
}
|
|
return tokens;
|
|
};
|
|
|
|
/* An explicit search, no lone words. We just pass it on */
|
|
if(!(tmpQuery.getTokensMask() & TokenType::WORD))
|
|
{
|
|
if(tmpQuery.hasContentSearch())
|
|
{
|
|
addContentSearch = true;
|
|
}
|
|
else
|
|
{
|
|
addPathSearch = true;
|
|
}
|
|
}
|
|
/* A path search, and lone words, e. g. p:("docs") invoice */
|
|
else if(tmpQuery.hasPathSearch() && (tmpQuery.getTokensMask() & TokenType::WORD))
|
|
{
|
|
this->contentSearchQuery = tmpQuery;
|
|
this->contentSearchQuery.setTokens(createFinalTokens(TokenType::FILTER_CONTENT_CONTAINS));
|
|
addContentSearch = true;
|
|
addPathSearch = false;
|
|
}
|
|
/* A content search and lone words, e. g. c:("to be or not") ebooks */
|
|
else if(tmpQuery.hasContentSearch() && (tmpQuery.getTokensMask() & TokenType::WORD))
|
|
{
|
|
this->contentSearchQuery = LooqsQuery::build(q, TokenType::FILTER_PATH_CONTAINS, false);
|
|
addContentSearch = true;
|
|
addPathSearch = false;
|
|
}
|
|
/* "Simply lone words, so search both" */
|
|
else if(!tmpQuery.hasPathSearch() && !tmpQuery.hasContentSearch())
|
|
{
|
|
this->contentSearchQuery.setTokens(createFinalTokens(TokenType::FILTER_CONTENT_CONTAINS));
|
|
pathsQuery = LooqsQuery::build(q, TokenType::FILTER_PATH_CONTAINS, false);
|
|
addContentSearch = true;
|
|
addPathSearch = true;
|
|
}
|
|
if(addPathSearch)
|
|
{
|
|
if(pathsQuery.getLimit() == -1)
|
|
{
|
|
pathsQuery.setLimit(1000);
|
|
}
|
|
results.append(searcher.search(pathsQuery));
|
|
}
|
|
if(addContentSearch)
|
|
{
|
|
if(this->contentSearchQuery.getLimit() == -1)
|
|
{
|
|
this->contentSearchQuery.setLimit(1000);
|
|
}
|
|
results.append(searcher.search(this->contentSearchQuery));
|
|
}
|
|
else
|
|
{
|
|
this->contentSearchQuery.setTokens({});
|
|
}
|
|
return results;
|
|
});
|
|
searchWatcher.setFuture(searchFuture);
|
|
}
|
|
|
|
void MainWindow::handleSearchResults(const QVector<SearchResult> &results)
|
|
{
|
|
qDeleteAll(ui->scrollAreaWidgetContents->children());
|
|
|
|
ui->treeResultsList->clear();
|
|
ui->comboPreviewFiles->clear();
|
|
ui->comboPreviewFiles->addItem("All previews");
|
|
ui->comboPreviewFiles->setVisible(true);
|
|
ui->lblTotalPreviewPagesCount->setText("");
|
|
|
|
this->previewCoordinator.init(results);
|
|
|
|
bool hasDeleted = false;
|
|
QHash<QString, bool> seenMap;
|
|
for(const SearchResult &result : results)
|
|
{
|
|
const QString &absPath = result.fileData.absPath;
|
|
QFileInfo pathInfo(absPath);
|
|
|
|
if(!seenMap.contains(absPath))
|
|
{
|
|
QString fileName = pathInfo.fileName();
|
|
QTreeWidgetItem *item = new QTreeWidgetItem(ui->treeResultsList);
|
|
|
|
QDateTime dt = QDateTime::fromSecsSinceEpoch(result.fileData.mtime);
|
|
item->setIcon(0, iconProvider.icon(pathInfo));
|
|
item->setText(0, fileName);
|
|
item->setText(1, absPath);
|
|
item->setText(2, dt.toString(Qt::ISODate));
|
|
item->setText(3, this->locale().formattedDataSize(result.fileData.size));
|
|
}
|
|
bool exists = pathInfo.exists();
|
|
if(!exists)
|
|
{
|
|
hasDeleted = true;
|
|
}
|
|
seenMap[absPath] = true;
|
|
}
|
|
|
|
seenMap.clear();
|
|
for(const SearchResult &result : this->previewCoordinator.getPreviewableSearchResults())
|
|
{
|
|
const QString &absPath = result.fileData.absPath;
|
|
if(!seenMap.contains(absPath))
|
|
{
|
|
ui->comboPreviewFiles->addItem(absPath);
|
|
}
|
|
seenMap[absPath] = true;
|
|
}
|
|
|
|
ui->treeResultsList->resizeColumnToContents(0);
|
|
ui->treeResultsList->resizeColumnToContents(1);
|
|
ui->treeResultsList->resizeColumnToContents(2);
|
|
|
|
previewDirty = this->previewCoordinator.previewableCount() > 0;
|
|
|
|
ui->spinPreviewPage->setValue(1);
|
|
|
|
if(previewTabActive() && previewDirty)
|
|
{
|
|
makePreviews(1);
|
|
}
|
|
|
|
ui->tabWidget->setTabEnabled(1, previewDirty);
|
|
|
|
QString statusText = "Results: " + QString::number(results.size()) + " files";
|
|
statusText += ", previewable: " + QString::number(this->previewCoordinator.previewableCount());
|
|
if(hasDeleted)
|
|
{
|
|
statusText += " WARNING: Some files are inaccessible. No preview available for those. Index may be out of sync";
|
|
}
|
|
ui->lblSearchResults->setText(statusText);
|
|
}
|
|
|
|
int MainWindow::currentSelectedScale()
|
|
{
|
|
QString scaleText = ui->comboScale->currentText();
|
|
scaleText.chop(1);
|
|
return scaleText.toInt();
|
|
}
|
|
|
|
void MainWindow::makePreviews(int page)
|
|
{
|
|
if(this->previewCoordinator.previewableCount() == 0)
|
|
{
|
|
return;
|
|
}
|
|
qDeleteAll(ui->scrollAreaWidgetContents->children());
|
|
|
|
QSettings settings;
|
|
bool horizontalScroll = settings.value(SETTINGS_KEY_PREVIEWS_SCROLL_HORIZONTALLY, false).toBool();
|
|
if(horizontalScroll)
|
|
{
|
|
ui->scrollAreaWidgetContents->setLayout(new QHBoxLayout());
|
|
}
|
|
else
|
|
{
|
|
ui->scrollAreaWidgetContents->setLayout(new QVBoxLayout());
|
|
ui->scrollAreaWidgetContents->layout()->setAlignment(Qt::AlignCenter);
|
|
}
|
|
ui->previewProcessBar->setMaximum(this->previewCoordinator.previewableCount());
|
|
|
|
QVector<QString> wordsToHighlight;
|
|
static QRegularExpression extractor(R"#("([^"]*)"|([^\s]+))#");
|
|
for(const Token &token : this->contentSearchQuery.getTokens())
|
|
{
|
|
if(token.type == FILTER_CONTENT_CONTAINS)
|
|
{
|
|
QRegularExpressionMatchIterator i = extractor.globalMatch(token.value);
|
|
while(i.hasNext())
|
|
{
|
|
QRegularExpressionMatch m = i.next();
|
|
QString value = m.captured(1);
|
|
if(value.isEmpty())
|
|
{
|
|
value = m.captured(2);
|
|
}
|
|
wordsToHighlight.append(value);
|
|
}
|
|
}
|
|
}
|
|
int length = previewsPerPage;
|
|
int beginOffset = page * previewsPerPage - previewsPerPage;
|
|
if(beginOffset < 0)
|
|
{
|
|
// Should not happen actually
|
|
beginOffset = 0;
|
|
}
|
|
|
|
int currentScale = currentSelectedScale();
|
|
RenderConfig renderConfig;
|
|
renderConfig.scaleX = QGuiApplication::primaryScreen()->physicalDotsPerInchX() * (currentScale / 100.);
|
|
renderConfig.scaleY = QGuiApplication::primaryScreen()->physicalDotsPerInchY() * (currentScale / 100.);
|
|
renderConfig.wordsToHighlight = wordsToHighlight;
|
|
|
|
QVector<RenderTarget> targets;
|
|
for(const SearchResult &sr : this->previewCoordinator.getPreviewableSearchResults())
|
|
{
|
|
if(ui->comboPreviewFiles->currentIndex() != 0)
|
|
{
|
|
if(sr.fileData.absPath != ui->comboPreviewFiles->currentText())
|
|
{
|
|
continue;
|
|
}
|
|
}
|
|
RenderTarget renderTarget;
|
|
renderTarget.path = sr.fileData.absPath;
|
|
renderTarget.page = (int)sr.page;
|
|
|
|
targets.append(renderTarget);
|
|
}
|
|
int numpages = ceil(static_cast<double>(targets.size()) / previewsPerPage);
|
|
ui->spinPreviewPage->setMaximum(numpages);
|
|
targets = targets.mid(beginOffset, length);
|
|
|
|
ui->lblTotalPreviewPagesCount->setText(QString::number(numpages));
|
|
ui->previewProcessBar->setMaximum(targets.count());
|
|
ui->previewProcessBar->setMinimum(0);
|
|
ui->previewProcessBar->setValue(0);
|
|
ui->previewProcessBar->setVisible(this->previewCoordinator.previewableCount() > 0);
|
|
this->ui->spinPreviewPage->setEnabled(false);
|
|
this->ui->comboPreviewFiles->setEnabled(false);
|
|
this->ui->txtSearch->setEnabled(false);
|
|
|
|
this->previewCoordinator.startGeneration(renderConfig, targets);
|
|
}
|
|
|
|
void MainWindow::handleSearchError(QString error)
|
|
{
|
|
ui->lblSearchResults->setText("Error:" + error);
|
|
}
|
|
|
|
void MainWindow::createSearchResultMenu(QMenu &menu, const QFileInfo &fileInfo)
|
|
{
|
|
menu.addAction("Copy filename to clipboard", this,
|
|
[&fileInfo] { QGuiApplication::clipboard()->setText(fileInfo.fileName()); });
|
|
menu.addAction("Copy full path to clipboard", this,
|
|
[&fileInfo] { QGuiApplication::clipboard()->setText(fileInfo.absoluteFilePath()); });
|
|
menu.addAction("Open containing folder", this, [this, &fileInfo] { this->openFile(fileInfo.absolutePath()); });
|
|
|
|
auto previewables = this->previewCoordinator.getPreviewableSearchResults();
|
|
auto result =
|
|
std::find_if(previewables.begin(), previewables.end(),
|
|
[&fileInfo](SearchResult &a) { return fileInfo.absoluteFilePath() == a.fileData.absPath; });
|
|
|
|
if(result != previewables.end())
|
|
{
|
|
menu.addAction("Show previews for this file", this,
|
|
[this, &fileInfo]
|
|
{
|
|
ui->tabWidget->setCurrentIndex(1);
|
|
this->ui->comboPreviewFiles->setCurrentText(fileInfo.absoluteFilePath());
|
|
});
|
|
}
|
|
|
|
QMenu *tagMenu = menu.addMenu("Tag file with: ");
|
|
QVector<QString> allTags = this->dbService->getTags();
|
|
QHash<QString, bool> fileTags;
|
|
|
|
QString path = fileInfo.absoluteFilePath();
|
|
|
|
for(const QString &fileTag : this->dbService->getTagsForPath(path))
|
|
{
|
|
fileTags[fileTag] = true;
|
|
}
|
|
|
|
for(const QString &tag : allTags)
|
|
{
|
|
QCheckBox *checkBox = new QCheckBox(tagMenu);
|
|
QWidgetAction *checkableAction = new QWidgetAction(tagMenu);
|
|
checkableAction->setDefaultWidget(checkBox);
|
|
checkBox->setText(tag);
|
|
checkBox->setChecked(fileTags.contains(tag));
|
|
tagMenu->addAction(checkableAction);
|
|
|
|
connect(checkBox, &QCheckBox::stateChanged, this,
|
|
[this, checkBox, path]
|
|
{
|
|
QVector<QString> currentTags = this->dbService->getTagsForPath(path);
|
|
QString checkBoxText = checkBox->text();
|
|
if(checkBox->isChecked())
|
|
{
|
|
if(!this->tagManager->addTagsToPath(path, {checkBoxText}))
|
|
{
|
|
QMessageBox::critical(this, "Error while adding tag",
|
|
"An error occured while trying to add the tag");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if(!this->tagManager->removeTagsForPath(path, {checkBoxText}))
|
|
{
|
|
QMessageBox::critical(this, "Error while removing tag",
|
|
"An error occured while trying to remove the tag");
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
tagMenu->addAction("Add new tags", this,
|
|
[this, path]
|
|
{
|
|
bool ok;
|
|
QString text =
|
|
QInputDialog::getText(this, tr("Enter new tags"), tr("New tags (comma separated):"),
|
|
QLineEdit::Normal, "", &ok);
|
|
|
|
if(ok && !this->tagManager->addTagsToPath(path, text, ','))
|
|
{
|
|
QMessageBox::critical(this, "Error while trying to add tags",
|
|
"An error occured while trying to add tags");
|
|
}
|
|
});
|
|
}
|
|
|
|
void MainWindow::openDocument(QString path, int num)
|
|
{
|
|
QSettings settings;
|
|
QString command = settings.value("pdfviewer").toString();
|
|
if(path.endsWith(".pdf") && command != "" && command.contains("%p") && command.contains("%f"))
|
|
{
|
|
QStringList splitted = command.split(" ");
|
|
if(splitted.size() > 1)
|
|
{
|
|
QString cmd = splitted[0];
|
|
QStringList args = splitted.mid(1);
|
|
args.replaceInStrings("%f", path);
|
|
args.replaceInStrings("%p", QString::number(num));
|
|
QProcess::startDetached(cmd, args);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
QDesktopServices::openUrl(QUrl::fromLocalFile(path));
|
|
}
|
|
}
|
|
|
|
void MainWindow::openFile(QString path)
|
|
{
|
|
QDesktopServices::openUrl(QUrl::fromLocalFile(path));
|
|
}
|
|
|
|
void MainWindow::treeSearchItemActivated(QTreeWidgetItem *item, int /*i*/)
|
|
{
|
|
openFile(item->text(1));
|
|
}
|
|
|
|
void MainWindow::showSearchResultsContextMenu(const QPoint &point)
|
|
{
|
|
QTreeWidgetItem *item = ui->treeResultsList->itemAt(point);
|
|
if(item == nullptr)
|
|
{
|
|
return;
|
|
}
|
|
QFileInfo pathinfo(item->text(1));
|
|
QMenu menu("SearchResults", this);
|
|
createSearchResultMenu(menu, pathinfo);
|
|
menu.exec(QCursor::pos());
|
|
}
|
|
|
|
MainWindow::~MainWindow()
|
|
{
|
|
syncerThread.terminate();
|
|
delete this->indexSyncer;
|
|
delete this->dbService;
|
|
delete this->dbFactory;
|
|
delete this->indexer;
|
|
delete this->tagManager;
|
|
delete ui;
|
|
}
|
|
|
|
void MainWindow::closeEvent(QCloseEvent * /*event*/)
|
|
{
|
|
QStringList list = this->searchHistory.toList();
|
|
QSettings settings;
|
|
settings.setValue(SETTINGS_KEY_SEARCHHISTORY, list);
|
|
settings.sync();
|
|
}
|