tris/recoll
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

GUI searching with saved query: restore external indexes from saved query

Browse Source
This commit is contained in:
Jean-Francois Dockes 2020-05-19 14:20:21 +02:00
parent dbf46f82d5
commit 5f76c2527d
9 changed files with 250 additions and 200 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
src/qtgui/guiutils.h
View File

@ -109,6 +109,9 @@ class PrefsPack {
// Extra query indexes. This are stored in the history file, not qt prefs // Extra query indexes. This are stored in the history file, not qt prefs
vector<string> allExtraDbs; vector<string> allExtraDbs;
vector<string> activeExtraDbs; vector<string> activeExtraDbs;
// Temporary value while we run a saved query. Erased right after use.
bool useTmpActiveExtraDbs{false};
vector<string> tmpActiveExtraDbs;
// Advanced search subdir restriction: we don't activate the last value // Advanced search subdir restriction: we don't activate the last value
// but just remember previously entered values // but just remember previously entered values
QStringList asearchSubdirHist; QStringList asearchSubdirHist;

20
src/qtgui/main.cpp
View File

@ -98,16 +98,22 @@ void startManual(const string& helpindex)
bool maybeOpenDb(string &reason, bool force, bool *maindberror) bool maybeOpenDb(string &reason, bool force, bool *maindberror)
{ {
LOGDEB2("maybeOpenDb: force " << force << "\n"); LOGDEB1("maybeOpenDb: force " << force << "\n");
if (force) { if (force || nullptr == rcldb) {
rcldb = std::shared_ptr<Rcl::Db>(new Rcl::Db(theconfig)); rcldb = std::shared_ptr<Rcl::Db>(new Rcl::Db(theconfig));
} }
rcldb->rmQueryDb(""); rcldb->rmQueryDb("");
for (const auto& dbdir : prefs.activeExtraDbs) { auto edbs = &prefs.activeExtraDbs;
LOGDEB("main: adding [" << dbdir << "]\n"); if (prefs.useTmpActiveExtraDbs) {
rcldb->addQueryDb(dbdir); edbs = &prefs.tmpActiveExtraDbs;
}
if (!edbs->empty()) {
rcldb->setExtraQueryDbs(*edbs);
} }
prefs.useTmpActiveExtraDbs = false;
prefs.tmpActiveExtraDbs.clear();
Rcl::Db::OpenError error; Rcl::Db::OpenError error;
if (!rcldb->isopen() && !rcldb->open(Rcl::Db::DbRO, &error)) { if (!rcldb->isopen() && !rcldb->open(Rcl::Db::DbRO, &error)) {
reason = "Could not open database"; reason = "Could not open database";
@ -130,7 +136,7 @@ bool getStemLangs(vector<string>& vlangs)
{ {
// Try from db // Try from db
string reason; string reason;
if (maybeOpenDb(reason)) { if (maybeOpenDb(reason, false)) {
vlangs = rcldb->getStemLangs(); vlangs = rcldb->getStemLangs();
LOGDEB0("getStemLangs: from index: " << stringsToString(vlangs) <<"\n"); LOGDEB0("getStemLangs: from index: " << stringsToString(vlangs) <<"\n");
return true; return true;
@ -385,7 +391,7 @@ int main(int argc, char **argv)
exit(1); exit(1);
} }
maybeOpenDb(reason); maybeOpenDb(reason, false);
if (op_flags & OPT_w) { if (op_flags & OPT_w) {
mainWindow->showMinimized(); mainWindow->showMinimized();

6
src/qtgui/rclmain_w.cpp
View File

@ -717,7 +717,7 @@ void RclMain::startSearch(std::shared_ptr<Rcl::SearchData> sdata, bool issimple)
string reason; string reason;
// If indexing is being performed, we reopen the db at each query. // If indexing is being performed, we reopen the db at each query.
if (!maybeOpenDb(reason, m_idxproc != 0)) { if (!maybeOpenDb(reason, m_idxproc != 0)) {
QMessageBox::critical(0, "Recoll", QString(reason.c_str())); QMessageBox::critical(0, "Recoll", u8s2qs(reason));
m_queryActive = false; m_queryActive = false;
restable->setEnabled(true); restable->setEnabled(true);
return; return;
@ -952,7 +952,7 @@ void RclMain::showSubDocs(Rcl::Doc doc)
{ {
LOGDEB("RclMain::showSubDocs\n"); LOGDEB("RclMain::showSubDocs\n");
string reason; string reason;
if (!maybeOpenDb(reason)) { if (!maybeOpenDb(reason, false)) {
QMessageBox::critical(0, "Recoll", QString(reason.c_str())); QMessageBox::critical(0, "Recoll", QString(reason.c_str()));
return; return;
} }
@ -1010,7 +1010,7 @@ void RclMain::showDocHistory()
curPreview = 0; curPreview = 0;
string reason; string reason;
if (!maybeOpenDb(reason)) { if (!maybeOpenDb(reason, false)) {
QMessageBox::critical(0, "Recoll", QString(reason.c_str())); QMessageBox::critical(0, "Recoll", QString(reason.c_str()));
return; return;
} }

3
src/qtgui/recoll.h
View File

@ -29,8 +29,7 @@
// Misc declarations in need of sharing between the UI files // Misc declarations in need of sharing between the UI files
// Open the database if needed. We now force a close/open by default // Open the database if needed. We now force a close/open by default
extern bool maybeOpenDb(std::string &reason, bool force = true, extern bool maybeOpenDb(std::string &reason, bool force, bool *maindberror = 0);
bool *maindberror = 0);
/** Retrieve configured stemming languages */ /** Retrieve configured stemming languages */
bool getStemLangs(vector<string>& langs); bool getStemLangs(vector<string>& langs);

328
src/qtgui/spell_w.cpp
View File

@ -77,21 +77,21 @@ void SpellW::init()
stemLangCMB->clear(); stemLangCMB->clear();
vector<string> langs; vector<string> langs;
if (!getStemLangs(langs)) { if (!getStemLangs(langs)) {
QMessageBox::warning(0, "Recoll", QMessageBox::warning(0, "Recoll",
tr("error retrieving stemming languages")); tr("error retrieving stemming languages"));
} }
for (vector<string>::const_iterator it = langs.begin(); for (vector<string>::const_iterator it = langs.begin();
it != langs.end(); it++) { it != langs.end(); it++) {
stemLangCMB->addItem(u8s2qs(*it)); stemLangCMB->addItem(u8s2qs(*it));
} }
(void)new HelpClient(this); (void)new HelpClient(this);
HelpClient::installMap((const char *)this->objectName().toUtf8(), HelpClient::installMap((const char *)this->objectName().toUtf8(),
"RCL.SEARCH.GUI.TERMEXPLORER"); "RCL.SEARCH.GUI.TERMEXPLORER");
// signals and slots connections // signals and slots connections
connect(baseWordLE, SIGNAL(textChanged(const QString&)), connect(baseWordLE, SIGNAL(textChanged(const QString&)),
this, SLOT(wordChanged(const QString&))); this, SLOT(wordChanged(const QString&)));
connect(baseWordLE, SIGNAL(returnPressed()), this, SLOT(doExpand())); connect(baseWordLE, SIGNAL(returnPressed()), this, SLOT(doExpand()));
connect(expandPB, SIGNAL(clicked()), this, SLOT(doExpand())); connect(expandPB, SIGNAL(clicked()), this, SLOT(doExpand()));
connect(dismissPB, SIGNAL(clicked()), this, SLOT(close())); connect(dismissPB, SIGNAL(clicked()), this, SLOT(close()));
@ -105,7 +105,7 @@ void SpellW::init()
#endif #endif
resTW->verticalHeader()->setDefaultSectionSize(20); resTW->verticalHeader()->setDefaultSectionSize(20);
connect(resTW, connect(resTW,
SIGNAL(cellDoubleClicked(int, int)), SIGNAL(cellDoubleClicked(int, int)),
this, SLOT(textDoubleClicked(int, int))); this, SLOT(textDoubleClicked(int, int)));
resTW->setColumnWidth(0, 200); resTW->setColumnWidth(0, 200);
@ -120,9 +120,9 @@ void SpellW::init()
int SpellW::cmbIdx(comboboxchoice mode) int SpellW::cmbIdx(comboboxchoice mode)
{ {
vector<comboboxchoice>::const_iterator it = vector<comboboxchoice>::const_iterator it =
std::find(m_c2t.begin(), m_c2t.end(), mode); std::find(m_c2t.begin(), m_c2t.end(), mode);
if (it == m_c2t.end()) if (it == m_c2t.end())
it = m_c2t.begin(); it = m_c2t.begin();
return it - m_c2t.begin(); return it - m_c2t.begin();
} }
@ -133,19 +133,19 @@ void SpellW::doExpand()
{ {
int idx = expTypeCMB->currentIndex(); int idx = expTypeCMB->currentIndex();
if (idx < 0 || idx >= int(m_c2t.size())) if (idx < 0 || idx >= int(m_c2t.size()))
idx = 0; idx = 0;
comboboxchoice mode = m_c2t[idx]; comboboxchoice mode = m_c2t[idx];
// Can't clear qt4 table widget: resets column headers too // Can't clear qt4 table widget: resets column headers too
resTW->setRowCount(0); resTW->setRowCount(0);
if (baseWordLE->text().isEmpty() && !wordlessMode(mode)) if (baseWordLE->text().isEmpty() && !wordlessMode(mode))
return; return;
string reason; string reason;
if (!maybeOpenDb(reason)) { if (!maybeOpenDb(reason, false)) {
QMessageBox::critical(0, "Recoll", QString(reason.c_str())); QMessageBox::critical(0, "Recoll", QString(reason.c_str()));
LOGDEB("SpellW::doExpand: db error: " << (reason) << "\n" ); LOGDEB("SpellW::doExpand: db error: " << (reason) << "\n" );
return; return;
} }
int mt; int mt;
@ -156,10 +156,10 @@ void SpellW::doExpand()
default: mt = Rcl::Db::ET_WILD; default: mt = Rcl::Db::ET_WILD;
} }
if (caseSensCB->isChecked()) { if (caseSensCB->isChecked()) {
mt |= Rcl::Db::ET_CASESENS; mt |= Rcl::Db::ET_CASESENS;
} }
if (diacSensCB->isChecked()) { if (diacSensCB->isChecked()) {
mt |= Rcl::Db::ET_DIACSENS; mt |= Rcl::Db::ET_DIACSENS;
} }
Rcl::TermMatchResult res; Rcl::TermMatchResult res;
string expr = string((const char *)baseWordLE->text().toUtf8()); string expr = string((const char *)baseWordLE->text().toUtf8());
@ -172,29 +172,29 @@ void SpellW::doExpand()
case TYPECMB_REG: case TYPECMB_REG:
case TYPECMB_STEM: case TYPECMB_STEM:
{ {
string l_stemlang = qs2utf8s(stemLangCMB->currentText()); string l_stemlang = qs2utf8s(stemLangCMB->currentText());
if (!rcldb->termMatch(mt, l_stemlang, expr, res, maxexpand)) { if (!rcldb->termMatch(mt, l_stemlang, expr, res, maxexpand)) {
LOGERR("SpellW::doExpand:rcldb::termMatch failed\n" ); LOGERR("SpellW::doExpand:rcldb::termMatch failed\n" );
return; return;
} }
statsLBL->setText(tr("Index: %1 documents, average length %2 terms." statsLBL->setText(tr("Index: %1 documents, average length %2 terms."
"%3 results") "%3 results")
.arg(dbs.dbdoccount).arg(dbs.dbavgdoclen, 0, 'f', 0) .arg(dbs.dbdoccount).arg(dbs.dbavgdoclen, 0, 'f', 0)
.arg(res.entries.size())); .arg(res.entries.size()));
} }
break; break;
case TYPECMB_SPELL: case TYPECMB_SPELL:
{ {
LOGDEB("SpellW::doExpand: spelling [" << expr << "]\n" ); LOGDEB("SpellW::doExpand: spelling [" << expr << "]\n" );
vector<string> suggs; vector<string> suggs;
if (!rcldb->getSpellingSuggestions(expr, suggs)) { if (!rcldb->getSpellingSuggestions(expr, suggs)) {
QMessageBox::warning(0, "Recoll", tr("Spell expansion error. ")); QMessageBox::warning(0, "Recoll", tr("Spell expansion error. "));
} }
for (const auto& it : suggs) { for (const auto& it : suggs) {
res.entries.push_back(Rcl::TermMatchEntry(it)); res.entries.push_back(Rcl::TermMatchEntry(it));
} }
statsLBL->setText(tr("%1 results").arg(res.entries.size())); statsLBL->setText(tr("%1 results").arg(res.entries.size()));
} }
@ -202,14 +202,14 @@ void SpellW::doExpand()
case TYPECMB_STATS: case TYPECMB_STATS:
{ {
showStats(); showStats();
return; return;
} }
break; break;
case TYPECMB_FAILED: case TYPECMB_FAILED:
{ {
showFailed(); showFailed();
return; return;
} }
break; break;
} }
@ -219,35 +219,35 @@ void SpellW::doExpand()
} else { } else {
int row = 0; int row = 0;
if (maxexpand > 0 && int(res.entries.size()) >= maxexpand) { if (maxexpand > 0 && int(res.entries.size()) >= maxexpand) {
resTW->setRowCount(row + 1); resTW->setRowCount(row + 1);
resTW->setSpan(row, 0, 1, 2); resTW->setSpan(row, 0, 1, 2);
resTW->setItem(row++, 0, resTW->setItem(row++, 0,
new QTableWidgetItem( new QTableWidgetItem(
tr("List was truncated alphabetically, " tr("List was truncated alphabetically, "
"some frequent "))); "some frequent ")));
resTW->setRowCount(row + 1); resTW->setRowCount(row + 1);
resTW->setSpan(row, 0, 1, 2); resTW->setSpan(row, 0, 1, 2);
resTW->setItem(row++, 0, new QTableWidgetItem( resTW->setItem(row++, 0, new QTableWidgetItem(
tr("terms may be missing. " tr("terms may be missing. "
"Try using a longer root."))); "Try using a longer root.")));
resTW->setRowCount(row + 1); resTW->setRowCount(row + 1);
resTW->setItem(row++, 0, new QTableWidgetItem("")); resTW->setItem(row++, 0, new QTableWidgetItem(""));
} }
for (vector<Rcl::TermMatchEntry>::iterator it = res.entries.begin(); for (vector<Rcl::TermMatchEntry>::iterator it = res.entries.begin();
it != res.entries.end(); it++) { it != res.entries.end(); it++) {
LOGDEB2("SpellW::expand: " << it->wcf << " [" << it->term << "]\n"); LOGDEB2("SpellW::expand: " << it->wcf << " [" << it->term << "]\n");
char num[30]; char num[30];
if (it->wcf) if (it->wcf)
sprintf(num, "%d / %d", it->docs, it->wcf); sprintf(num, "%d / %d", it->docs, it->wcf);
else else
num[0] = 0; num[0] = 0;
resTW->setRowCount(row+1); resTW->setRowCount(row+1);
resTW->setItem(row, 0, new QTableWidgetItem(u8s2qs(it->term))); resTW->setItem(row, 0, new QTableWidgetItem(u8s2qs(it->term)));
resTW->setItem(row++, 1, resTW->setItem(row++, 1,
new QTableWidgetItem(QString::fromUtf8(num))); new QTableWidgetItem(QString::fromUtf8(num)));
} }
} }
} }
@ -258,57 +258,57 @@ void SpellW::showStats()
Rcl::DbStats res; Rcl::DbStats res;
if (!rcldb->dbStats(res, false)) { if (!rcldb->dbStats(res, false)) {
LOGERR("SpellW::doExpand:rcldb::dbStats failed\n" ); LOGERR("SpellW::doExpand:rcldb::dbStats failed\n" );
return; return;
} }
resTW->setRowCount(row+1); resTW->setRowCount(row+1);
resTW->setItem(row, 0, resTW->setItem(row, 0,
new QTableWidgetItem(tr("Number of documents"))); new QTableWidgetItem(tr("Number of documents")));
resTW->setItem(row++, 1, new QTableWidgetItem( resTW->setItem(row++, 1, new QTableWidgetItem(
QString::number(res.dbdoccount))); QString::number(res.dbdoccount)));
resTW->setRowCount(row+1); resTW->setRowCount(row+1);
resTW->setItem(row, 0, resTW->setItem(row, 0,
new QTableWidgetItem(tr("Average terms per document"))); new QTableWidgetItem(tr("Average terms per document")));
resTW->setItem(row++, 1, new QTableWidgetItem( resTW->setItem(row++, 1, new QTableWidgetItem(
QString::number(res.dbavgdoclen, 'f', 0))); QString::number(res.dbavgdoclen, 'f', 0)));
resTW->setRowCount(row+1); resTW->setRowCount(row+1);
resTW->setItem(row, 0, resTW->setItem(row, 0,
new QTableWidgetItem(tr("Smallest document length (terms)"))); new QTableWidgetItem(tr("Smallest document length (terms)")));
resTW->setItem(row++, 1, new QTableWidgetItem( resTW->setItem(row++, 1, new QTableWidgetItem(
QString::number(res.mindoclen))); QString::number(res.mindoclen)));
resTW->setRowCount(row+1); resTW->setRowCount(row+1);
resTW->setItem(row, 0, resTW->setItem(row, 0,
new QTableWidgetItem(tr("Longest document length (terms)"))); new QTableWidgetItem(tr("Longest document length (terms)")));
resTW->setItem(row++, 1, new QTableWidgetItem( resTW->setItem(row++, 1, new QTableWidgetItem(
QString::number(res.maxdoclen))); QString::number(res.maxdoclen)));
if (!theconfig) if (!theconfig)
return; return;
DbIxStatus st; DbIxStatus st;
readIdxStatus(theconfig, st); readIdxStatus(theconfig, st);
resTW->setRowCount(row+1); resTW->setRowCount(row+1);
resTW->setItem(row, 0, resTW->setItem(row, 0,
new QTableWidgetItem(tr("Results from last indexing:"))); new QTableWidgetItem(tr("Results from last indexing:")));
resTW->setItem(row++, 1, new QTableWidgetItem("")); resTW->setItem(row++, 1, new QTableWidgetItem(""));
resTW->setRowCount(row+1); resTW->setRowCount(row+1);
resTW->setItem(row, 0, resTW->setItem(row, 0,
new QTableWidgetItem(tr(" Documents created/updated"))); new QTableWidgetItem(tr(" Documents created/updated")));
resTW->setItem(row++, 1, resTW->setItem(row++, 1,
new QTableWidgetItem(QString::number(st.docsdone))); new QTableWidgetItem(QString::number(st.docsdone)));
resTW->setRowCount(row+1); resTW->setRowCount(row+1);
resTW->setItem(row, 0, resTW->setItem(row, 0,
new QTableWidgetItem(tr(" Files tested"))); new QTableWidgetItem(tr(" Files tested")));
resTW->setItem(row++, 1, resTW->setItem(row++, 1,
new QTableWidgetItem(QString::number(st.filesdone))); new QTableWidgetItem(QString::number(st.filesdone)));
resTW->setRowCount(row+1); resTW->setRowCount(row+1);
resTW->setItem(row, 0, resTW->setItem(row, 0,
new QTableWidgetItem(tr(" Unindexed files"))); new QTableWidgetItem(tr(" Unindexed files")));
resTW->setItem(row++, 1, resTW->setItem(row++, 1,
new QTableWidgetItem(QString::number(st.fileerrors))); new QTableWidgetItem(QString::number(st.fileerrors)));
@ -316,41 +316,41 @@ void SpellW::showStats()
int64_t dbkbytes = fsTreeBytes(theconfig->getDbDir()) / 1024; int64_t dbkbytes = fsTreeBytes(theconfig->getDbDir()) / 1024;
if (dbkbytes < 0) { if (dbkbytes < 0) {
dbkbytes = 0; dbkbytes = 0;
} }
resTW->setRowCount(row+1); resTW->setRowCount(row+1);
resTW->setItem(row, 0, resTW->setItem(row, 0,
new QTableWidgetItem(tr("Database directory size"))); new QTableWidgetItem(tr("Database directory size")));
resTW->setItem(row++, 1, new QTableWidgetItem( resTW->setItem(row++, 1, new QTableWidgetItem(
u8s2qs(displayableBytes(dbkbytes*1024)))); u8s2qs(displayableBytes(dbkbytes*1024))));
vector<string> allmimetypes = theconfig->getAllMimeTypes(); vector<string> allmimetypes = theconfig->getAllMimeTypes();
multimap<int, string> mtbycnt; multimap<int, string> mtbycnt;
for (vector<string>::const_iterator it = allmimetypes.begin(); for (vector<string>::const_iterator it = allmimetypes.begin();
it != allmimetypes.end(); it++) { it != allmimetypes.end(); it++) {
string reason; string reason;
string q = string("mime:") + *it; string q = string("mime:") + *it;
Rcl::SearchData *sd = wasaStringToRcl(theconfig, "", q, reason); Rcl::SearchData *sd = wasaStringToRcl(theconfig, "", q, reason);
std::shared_ptr<Rcl::SearchData> rq(sd); std::shared_ptr<Rcl::SearchData> rq(sd);
Rcl::Query query(rcldb.get()); Rcl::Query query(rcldb.get());
if (!query.setQuery(rq)) { if (!query.setQuery(rq)) {
LOGERR("Query setup failed: " << (query.getReason()) << "" ); LOGERR("Query setup failed: " << (query.getReason()) << "" );
return; return;
} }
int cnt = query.getResCnt(); int cnt = query.getResCnt();
mtbycnt.insert(pair<int,string>(cnt,*it)); mtbycnt.insert(pair<int,string>(cnt,*it));
} }
resTW->setRowCount(row+1); resTW->setRowCount(row+1);
resTW->setItem(row, 0, new QTableWidgetItem(tr("MIME types:"))); resTW->setItem(row, 0, new QTableWidgetItem(tr("MIME types:")));
resTW->setItem(row++, 1, new QTableWidgetItem("")); resTW->setItem(row++, 1, new QTableWidgetItem(""));
for (multimap<int, string>::const_reverse_iterator it = mtbycnt.rbegin(); for (multimap<int, string>::const_reverse_iterator it = mtbycnt.rbegin();
it != mtbycnt.rend(); it++) { it != mtbycnt.rend(); it++) {
resTW->setRowCount(row+1); resTW->setRowCount(row+1);
resTW->setItem(row, 0, new QTableWidgetItem(QString(" ") + resTW->setItem(row, 0, new QTableWidgetItem(QString(" ") +
u8s2qs(it->second))); u8s2qs(it->second)));
resTW->setItem(row++, 1, new QTableWidgetItem( resTW->setItem(row++, 1, new QTableWidgetItem(
QString::number(it->first))); QString::number(it->first)));
} }
} }
@ -361,23 +361,23 @@ void SpellW::showFailed()
Rcl::DbStats res; Rcl::DbStats res;
if (!rcldb->dbStats(res, true)) { if (!rcldb->dbStats(res, true)) {
LOGERR("SpellW::doExpand:rcldb::dbStats failed\n" ); LOGERR("SpellW::doExpand:rcldb::dbStats failed\n" );
return; return;
} }
for (auto entry : res.failedurls) { for (auto entry : res.failedurls) {
resTW->setRowCount(row+1); resTW->setRowCount(row+1);
resTW->setItem(row, 0, new QTableWidgetItem(u8s2qs(entry))); resTW->setItem(row, 0, new QTableWidgetItem(u8s2qs(entry)));
resTW->setItem(row++, 1, new QTableWidgetItem("")); resTW->setItem(row++, 1, new QTableWidgetItem(""));
} }
} }
void SpellW::wordChanged(const QString &text) void SpellW::wordChanged(const QString &text)
{ {
if (text.isEmpty()) { if (text.isEmpty()) {
expandPB->setEnabled(false); expandPB->setEnabled(false);
resTW->setRowCount(0); resTW->setRowCount(0);
} else { } else {
expandPB->setEnabled(true); expandPB->setEnabled(true);
} }
} }
@ -392,7 +392,7 @@ void SpellW::textDoubleClicked(int row, int)
void SpellW::onModeChanged(int idx) void SpellW::onModeChanged(int idx)
{ {
if (idx < 0 || idx > int(m_c2t.size())) if (idx < 0 || idx > int(m_c2t.size()))
return; return;
comboboxchoice mode = m_c2t[idx]; comboboxchoice mode = m_c2t[idx];
setModeCommon(mode); setModeCommon(mode);
} }
@ -411,96 +411,96 @@ void SpellW::setModeCommon(comboboxchoice mode)
m_prevmode = mode; m_prevmode = mode;
resTW->setRowCount(0); resTW->setRowCount(0);
if (o_index_stripchars) { if (o_index_stripchars) {
caseSensCB->setEnabled(false); caseSensCB->setEnabled(false);
diacSensCB->setEnabled(false); diacSensCB->setEnabled(false);
} else { } else {
caseSensCB->setEnabled(true); caseSensCB->setEnabled(true);
diacSensCB->setEnabled(true); diacSensCB->setEnabled(true);
} }
if (mode == TYPECMB_STEM) { if (mode == TYPECMB_STEM) {
stemLangCMB->setEnabled(true); stemLangCMB->setEnabled(true);
diacSensCB->setChecked(false); diacSensCB->setChecked(false);
diacSensCB->setEnabled(false); diacSensCB->setEnabled(false);
caseSensCB->setChecked(false); caseSensCB->setChecked(false);
caseSensCB->setEnabled(false); caseSensCB->setEnabled(false);
} else { } else {
stemLangCMB->setEnabled(false); stemLangCMB->setEnabled(false);
} }
if (wordlessMode(mode)) { if (wordlessMode(mode)) {
baseWordLE->setEnabled(false); baseWordLE->setEnabled(false);
QStringList labels(tr("Item")); QStringList labels(tr("Item"));
labels.push_back(tr("Value")); labels.push_back(tr("Value"));
resTW->setHorizontalHeaderLabels(labels); resTW->setHorizontalHeaderLabels(labels);
diacSensCB->setEnabled(false); diacSensCB->setEnabled(false);
caseSensCB->setEnabled(false); caseSensCB->setEnabled(false);
doExpand(); doExpand();
} else { } else {
baseWordLE->setEnabled(true); baseWordLE->setEnabled(true);
QStringList labels(tr("Term")); QStringList labels(tr("Term"));
labels.push_back(tr("Doc. / Tot.")); labels.push_back(tr("Doc. / Tot."));
resTW->setHorizontalHeaderLabels(labels); resTW->setHorizontalHeaderLabels(labels);
prefs.termMatchType = mode; prefs.termMatchType = mode;
} }
} }
void SpellW::copy() void SpellW::copy()
{ {
QItemSelectionModel * selection = resTW->selectionModel(); QItemSelectionModel * selection = resTW->selectionModel();
QModelIndexList indexes = selection->selectedIndexes(); QModelIndexList indexes = selection->selectedIndexes();
if(indexes.size() < 1) if(indexes.size() < 1)
return; return;
// QModelIndex::operator < sorts first by row, then by column. // QModelIndex::operator < sorts first by row, then by column.
// this is what we need // this is what we need
std::sort(indexes.begin(), indexes.end()); std::sort(indexes.begin(), indexes.end());
// You need a pair of indexes to find the row changes // You need a pair of indexes to find the row changes
QModelIndex previous = indexes.first(); QModelIndex previous = indexes.first();
indexes.removeFirst(); indexes.removeFirst();
QString selected_text; QString selected_text;
QModelIndex current; QModelIndex current;
Q_FOREACH(current, indexes) Q_FOREACH(current, indexes)
{
QVariant data = resTW->model()->data(previous);
QString text = data.toString();
// At this point `text` contains the text in one cell
selected_text.append(text);
// If you are at the start of the row the row number of the previous index
// isn't the same. Text is followed by a row separator, which is a newline.
if (current.row() != previous.row())
{ {
selected_text.append(QLatin1Char('\n')); QVariant data = resTW->model()->data(previous);
QString text = data.toString();
// At this point `text` contains the text in one cell
selected_text.append(text);
// If you are at the start of the row the row number of the previous index
// isn't the same. Text is followed by a row separator, which is a newline.
if (current.row() != previous.row())
{
selected_text.append(QLatin1Char('\n'));
}
// Otherwise it's the same row, so append a column separator, which is a tab.
else
{
selected_text.append(QLatin1Char('\t'));
}
previous = current;
} }
// Otherwise it's the same row, so append a column separator, which is a tab.
else
{
selected_text.append(QLatin1Char('\t'));
}
previous = current;
}
// add last element // add last element
selected_text.append(resTW->model()->data(current).toString()); selected_text.append(resTW->model()->data(current).toString());
selected_text.append(QLatin1Char('\n')); selected_text.append(QLatin1Char('\n'));
qApp->clipboard()->setText(selected_text, QClipboard::Selection); qApp->clipboard()->setText(selected_text, QClipboard::Selection);
qApp->clipboard()->setText(selected_text, QClipboard::Clipboard); qApp->clipboard()->setText(selected_text, QClipboard::Clipboard);
} }
bool SpellW::eventFilter(QObject *target, QEvent *event) bool SpellW::eventFilter(QObject *target, QEvent *event)
{ {
if (event->type() != QEvent::KeyPress || if (event->type() != QEvent::KeyPress ||
(target != resTW && target != resTW->viewport())) (target != resTW && target != resTW->viewport()))
return false; return false;
QKeyEvent *keyEvent = (QKeyEvent *)event; QKeyEvent *keyEvent = (QKeyEvent *)event;
if(keyEvent->matches(QKeySequence::Copy) ) if(keyEvent->matches(QKeySequence::Copy) )
{ {
copy(); copy();
return true; return true;
} }
return false; return false;
} }

34
src/qtgui/ssearch_w.cpp
View File

@ -535,6 +535,20 @@ bool SSearch::startSimpleSearch(const string& u8, int maxexp)
return true; return true;
} }
bool SSearch::checkExtIndexes(const std::vector<std::string>& dbs)
{
std::string reason;
if (!maybeOpenDb(reason, false)) {
QMessageBox::critical(0, "Recoll", tr("Can't open index") +
u8s2qs(reason));
return false;
}
if (!rcldb->setExtraQueryDbs(dbs)) {
return false;
}
return true;
}
bool SSearch::fromXML(const SSearchDef& fxml) bool SSearch::fromXML(const SSearchDef& fxml)
{ {
string asString; string asString;
@ -565,14 +579,20 @@ bool SSearch::fromXML(const SSearchDef& fxml)
tr(" differ from current preferences (kept)")); tr(" differ from current preferences (kept)"));
} }
cur = set<string>(prefs.activeExtraDbs.begin(), prefs.activeExtraDbs.end());
stored = set<string>(fxml.extindexes.begin(), fxml.extindexes.end()); if (!checkExtIndexes(fxml.extindexes)) {
stringsToString(fxml.extindexes, asString); std::string asString;
if (cur != stored) { stringsToString(fxml.extindexes, asString);
QMessageBox::warning( QMessageBox::warning(
0, "Recoll", tr("External indexes for stored query: ") + 0, "Recoll",
QString::fromUtf8(asString.c_str()) + tr("Could not restore external indexes for stored query:<br> ") +
tr(" differ from current preferences (kept)")); (rcldb ? u8s2qs(rcldb->getReason()) : tr("???")) + QString("<br>") +
tr("Using current preferences."));
string s;
maybeOpenDb(s, true);
} else {
prefs.useTmpActiveExtraDbs = true;
prefs.tmpActiveExtraDbs = fxml.extindexes;
} }
if (prefs.ssearchAutoPhrase && !fxml.autophrase) { if (prefs.ssearchAutoPhrase && !fxml.autophrase) {

1
src/qtgui/ssearch_w.h
View File

@ -113,6 +113,7 @@ signals:
private: private:
int getPartialWord(QString& word); int getPartialWord(QString& word);
bool startSimpleSearch(const string& q, int maxexp = -1); bool startSimpleSearch(const string& q, int maxexp = -1);
bool checkExtIndexes(const std::vector<std::string>& dbs);
RclCompleterModel *m_completermodel{nullptr}; RclCompleterModel *m_completermodel{nullptr};
QCompleter *m_completer{nullptr}; QCompleter *m_completer{nullptr};

53
src/rcldb/rcldb.cpp
View File

@ -1055,23 +1055,6 @@ bool Db::i_close(bool final)
return false; return false;
} }
// Reopen the db with a changed list of additional dbs
bool Db::adjustdbs()
{
if (m_mode != DbRO) {
LOGERR("Db::adjustdbs: mode not RO\n");
return false;
}
if (m_ndb && m_ndb->m_isopen) {
if (!close())
return false;
if (!open(m_mode)) {
return false;
}
}
return true;
}
int Db::docCnt() int Db::docCnt()
{ {
int res = -1; int res = -1;
@ -1114,6 +1097,42 @@ int Db::termDocCnt(const string& _term)
return res; return res;
} }
// Reopen the db with a changed list of additional dbs
bool Db::adjustdbs()
{
if (m_mode != DbRO) {
LOGERR("Db::adjustdbs: mode not RO\n");
return false;
}
if (m_ndb && m_ndb->m_isopen) {
if (!close())
return false;
if (!open(m_mode)) {
return false;
}
}
return true;
}
// Set the extra indexes to the input list.
bool Db::setExtraQueryDbs(const std::vector<std::string>& dbs)
{
LOGDEB0("Db::setExtraQueryDbs: ndb " << m_ndb << " iswritable " <<
((m_ndb)?m_ndb->m_iswritable:0) << " dbs [" <<
stringsToString(dbs) << "]\n");
if (!m_ndb) {
return false;
}
if (m_ndb->m_iswritable) {
return false;
}
m_extraDbs.clear();
for (const auto& dir : dbs) {
m_extraDbs.push_back(path_canon(dir));
}
return adjustdbs();
}
bool Db::addQueryDb(const string &_dir) bool Db::addQueryDb(const string &_dir)
{ {
string dir = _dir; string dir = _dir;

2
src/rcldb/rcldb.h
View File

@ -338,6 +338,8 @@ public:
bool addQueryDb(const string &dir); bool addQueryDb(const string &dir);
/** Remove extra database. if dir == "", remove all. */ /** Remove extra database. if dir == "", remove all. */
bool rmQueryDb(const string &dir); bool rmQueryDb(const string &dir);
/** Set the extra indexes to the input list. */
bool setExtraQueryDbs(const std::vector<std::string>& dbs);
/** Check if document comes from the main index (this is used to /** Check if document comes from the main index (this is used to
decide if we can update the index for it */ decide if we can update the index for it */