recoll / Code / Diff of /src/qtgui/spell

Diff of /src/qtgui/spell_w.cpp [9ba04f] .. [29d4d9]

Switch to unified view

-a/src/qtgui/spell_w.cpp
+b/src/qtgui/spell_w.cpp
 ...
  *   Free Software Foundation, Inc.,
  *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  */
 #include "autoconfig.h"
+#include <stdio.h>
+#include <unistd.h>
 #include <algorithm>
-#include <unistd.h>
 #include <list>
+#include <map>
-#include <stdio.h>
+#include <string>
+using std::list;
+using std::multimap;
+using std::string;
 #include <qmessagebox.h>
 #include <qpushbutton.h>
 #include <qlabel.h>
 #include <qlineedit.h>
 ...
 #include "debuglog.h"
 #include "recoll.h"
 #include "spell_w.h"
 #include "guiutils.h"
 #include "rcldb.h"
+#include "searchdata.h"
+#include "rclquery.h"
 #include "rclhelp.h"
+#include "wasatorcl.h"
+#include "execmd.h"
 #ifdef RCL_USE_ASPELL
 #include "rclaspell.h"
 #endif
 void SpellW::init()
+{
-    // Don't change the order, or fix the rest of the code...
+    m_c2t.clear();
-    /*0*/expTypeCMB->addItem(tr("Wildcards"));
+    expTypeCMB->addItem(tr("Wildcards"));
+    m_c2t.push_back(TYPECMB_WILD);
-    /*1*/expTypeCMB->addItem(tr("Regexp"));
+    expTypeCMB->addItem(tr("Regexp"));
+    m_c2t.push_back(TYPECMB_REG);
-    /*2*/expTypeCMB->addItem(tr("Stem expansion"));
+    expTypeCMB->addItem(tr("Stem expansion"));
+    m_c2t.push_back(TYPECMB_STEM);
 #ifdef RCL_USE_ASPELL
     bool noaspell = false;
     theconfig->getConfParam("noaspell", &noaspell);
-    if (!noaspell)
+    if (!noaspell) {
-    /*3*/expTypeCMB->addItem(tr("Spelling/Phonetic"));
+    expTypeCMB->addItem(tr("Spelling/Phonetic"));
+  m_c2t.push_back(TYPECMB_ASPELL);
+    }
 #endif
+    expTypeCMB->addItem(tr("Show index statistics"));
+    m_c2t.push_back(TYPECMB_STATS);
     int typ = prefs.termMatchType;
-    if (typ < 0 || typ > expTypeCMB->count())
+    vector<comboboxchoice>::const_iterator it =
-  typ = 0;
+  std::find(m_c2t.begin(), m_c2t.end(), typ);
+    if (it == m_c2t.end())
+  it = m_c2t.begin();
+    int cmbidx = it - m_c2t.begin();
-    expTypeCMB->setCurrentIndex(typ);
+    expTypeCMB->setCurrentIndex(cmbidx);
     // Stemming language combobox
     stemLangCMB->clear();
     vector<string> langs;
     if (!getStemLangs(langs)) {
 ...
     for (vector<string>::const_iterator it = langs.begin();
      it != langs.end(); it++) {
     stemLangCMB->
         addItem(QString::fromAscii(it->c_str(), it->length()));
+    }
-    stemLangCMB->setEnabled(expTypeCMB->currentIndex()==2);
     (void)new HelpClient(this);
     HelpClient::installMap((const char *)this->objectName().toUtf8(),
                "RCL.SEARCH.TERMEXPLORER");
 ...
     connect(baseWordLE, SIGNAL(returnPressed()), this, SLOT(doExpand()));
     connect(expandPB, SIGNAL(clicked()), this, SLOT(doExpand()));
     connect(dismissPB, SIGNAL(clicked()), this, SLOT(close()));
     connect(expTypeCMB, SIGNAL(activated(int)), this, SLOT(modeSet(int)));
-    QStringList labels(tr("Term"));
-    labels.push_back(tr("Doc. / Tot."));
-    resTW->setHorizontalHeaderLabels(labels);
     resTW->setShowGrid(0);
     resTW->horizontalHeader()->setResizeMode(0, QHeaderView::Stretch);
     resTW->verticalHeader()->setDefaultSectionSize(20);
     connect(resTW,
        SIGNAL(cellDoubleClicked(int, int)),
             this, SLOT(textDoubleClicked(int, int)));
     resTW->setColumnWidth(0, 200);
     resTW->setColumnWidth(1, 150);
     resTW->installEventFilter(this);
+    modeSet(cmbidx);
+}
 static const int maxexpand = 10000;
 /* Expand term according to current mode */
 void SpellW::doExpand()
+{
+    int idx = expTypeCMB->currentIndex();
+    if (idx < 0 || idx >= int(m_c2t.size()))
+  idx = 0;
+    comboboxchoice mode = m_c2t[idx];
     // Can't clear qt4 table widget: resets column headers too
     resTW->setRowCount(0);
-    if (baseWordLE->text().isEmpty())
+    if (baseWordLE->text().isEmpty() && mode != TYPECMB_STATS)
     return;
     string reason;
     if (!maybeOpenDb(reason)) {
     QMessageBox::critical(0, "Recoll", QString(reason.c_str()));
     LOGDEB(("SpellW::doExpand: db error: %s\n", reason.c_str()));
     return;
+    }
+    Rcl::Db::MatchType mt;
+    switch(mode) {
+    case TYPECMB_WILD: mt = Rcl::Db::ET_WILD; break;
+    case TYPECMB_REG: mt = Rcl::Db::ET_REGEXP; break;
+    case TYPECMB_STEM: mt = Rcl::Db::ET_STEM; break;
+    default: mt = Rcl::Db::ET_WILD;
+    }
+    Rcl::TermMatchResult res;
     string expr = string((const char *)baseWordLE->text().toUtf8());
-    list<string> suggs;
-    prefs.termMatchType = expTypeCMB->currentIndex();
+    switch (mode) {
+    case TYPECMB_WILD:
-    Rcl::Db::MatchType mt = Rcl::Db::ET_WILD;
+    default:
-    switch(expTypeCMB->currentIndex()) {
+    case TYPECMB_REG:
-    case 0: mt = Rcl::Db::ET_WILD; break;
+    case TYPECMB_STEM:
-    case 1:mt = Rcl::Db::ET_REGEXP; break;
-    case 2:mt = Rcl::Db::ET_STEM; break;
+    {
-    Rcl::TermMatchResult res;
-    switch (expTypeCMB->currentIndex()) {
-    case 0:
-    case 1:
-    case 2:
-    string l_stemlang = (const char*)stemLangCMB->currentText().toAscii();
+    string l_stemlang = qs2utf8s(stemLangCMB->currentText());
     if (!rcldb->termMatch(mt, l_stemlang, expr, res, maxexpand)) {
         LOGERR(("SpellW::doExpand:rcldb::termMatch failed\n"));
         return;
+    }
 ...
                  "%3 results")
                           .arg(res.dbdoccount).arg(res.dbavgdoclen, 0, 'f', 1)
               .arg(res.entries.size()));
+    }
-  break;
+    break;
 #ifdef RCL_USE_ASPELL
-    case 3: {
+    case TYPECMB_ASPELL:
+    {
     LOGDEB(("SpellW::doExpand: aspelling\n"));
     if (!aspell) {
         QMessageBox::warning(0, "Recoll",
                  tr("Aspell init failed. "
                     "Aspell not installed?"));
 ...
         res.entries.push_back(Rcl::TermMatchEntry(rclsugg));
+    }
 #endif // TESTING_XAPIAN_SPELL
         statsLBL->setText(tr("%1 results").arg(res.entries.size()));
+    }
-#endif
+    break;
+#endif // RCL_USE_ASPELL
+    case TYPECMB_STATS:
+    {
+  showStats();
+  return;
+    }
+    break;
+    }
     if (res.entries.empty()) {
         resTW->setItem(0, 0, new QTableWidgetItem(tr("No expansion found")));
 ...
                              new QTableWidgetItem(QString::fromAscii(num)));
+    }
+    }
+}
+void SpellW::showStats()
+{
+    statsLBL->setText("");
+    int row = 0;
+    Rcl::TermMatchResult res;
+    if (!rcldb->termMatch(Rcl::Db::ET_WILD, "", "azbogusaz", res, 1)) {
+  LOGERR(("SpellW::doExpand:rcldb::termMatch failed\n"));
+  return;
+    }
+    resTW->setRowCount(row+1);
+    resTW->setItem(row, 0,
+         new QTableWidgetItem(tr("Number of documents")));
+    resTW->setItem(row++, 1, new QTableWidgetItem(
+             QString::number(res.dbdoccount)));
+    resTW->setRowCount(row+1);
+    resTW->setItem(row, 0,
+         new QTableWidgetItem(tr("Average terms per document")));
+    resTW->setItem(row++, 1, new QTableWidgetItem(
+             QString::number(res.dbavgdoclen)));
+    resTW->setRowCount(row+1);
+    resTW->setItem(row, 0,
+         new QTableWidgetItem(tr("Smallest document length")));
+    resTW->setItem(row++, 1, new QTableWidgetItem(
+             QString::number(res.mindoclen)));
+    resTW->setRowCount(row+1);
+    resTW->setItem(row, 0,
+         new QTableWidgetItem(tr("Longest document length")));
+    resTW->setItem(row++, 1, new QTableWidgetItem(
+             QString::number(res.maxdoclen)));
+    if (!thestableconfig)
+  return;
+    ExecCmd cmd;
+    vector<string> args;
+    int status;
+    args.push_back("-sk");
+    args.push_back(thestableconfig->getDbDir());
+    string output;
+    status = cmd.doexec("du", args, 0, &output);
+    int dbkbytes = 0;
+    if (!status) {
+  dbkbytes = atoi(output.c_str());
+    }
+    resTW->setRowCount(row+1);
+    resTW->setItem(row, 0,
+         new QTableWidgetItem(tr("Database directory size")));
+    resTW->setItem(row++, 1, new QTableWidgetItem(
+             QString::fromUtf8(
+             displayableBytes(dbkbytes*1024).c_str())));
+    vector<string> allmimetypes = thestableconfig->getAllMimeTypes();
+    multimap<int, string> mtbycnt;
+    for (vector<string>::const_iterator it = allmimetypes.begin();
+   it != allmimetypes.end(); it++) {
+  string reason;
+  string q = string("mime:") + *it;
+  Rcl::SearchData *sd =
+      wasaStringToRcl(thestableconfig, "", q, reason);
+  RefCntr<Rcl::SearchData> rq(sd);
+  Rcl::Query query(rcldb);
+  if (!query.setQuery(rq)) {
+      LOGERR(("Query setup failed: %s",query.getReason().c_str()));
+      return;
+  }
+  int cnt = query.getResCnt();
+  mtbycnt.insert(pair<int,string>(cnt,*it));
+    }
+    resTW->setRowCount(row+1);
+    resTW->setItem(row, 0, new QTableWidgetItem(tr("MIME types:")));
+    resTW->setItem(row++, 1, new QTableWidgetItem(""));
+    for (multimap<int, string>::const_reverse_iterator it = mtbycnt.rbegin();
+   it != mtbycnt.rend(); it++) {
+  resTW->setRowCount(row+1);
+  resTW->setItem(row, 0, new QTableWidgetItem(
+             QString::fromUtf8(it->second.c_str())));
+  resTW->setItem(row++, 1, new QTableWidgetItem(
+             QString::number(it->first)));
+    }
+}
 void SpellW::wordChanged(const QString &text)
+{
     if (text.isEmpty()) {
     expandPB->setEnabled(false);
         resTW->setRowCount(0);
 ...
     QTableWidgetItem *item = resTW->item(row, 0);
     if (item)
         emit(wordSelect(item->text()));
+}
-void SpellW::modeSet(int mode)
+void SpellW::modeSet(int idx)
+{
-    if (mode == 2)
+    if (idx < 0 || idx > int(m_c2t.size()))
+  return;
+    comboboxchoice mode = m_c2t[idx];
+    resTW->setRowCount(0);
+    if (mode == TYPECMB_STEM)
     stemLangCMB->setEnabled(true);
     else
     stemLangCMB->setEnabled(false);
+    if (mode == TYPECMB_STATS)
+  baseWordLE->setEnabled(false);
+    else
+  baseWordLE->setEnabled(true);
+    if (mode == TYPECMB_STATS) {
+  QStringList labels(tr("Item"));
+  labels.push_back(tr("Value"));
+  resTW->setHorizontalHeaderLabels(labels);
+  doExpand();
+    } else {
+  QStringList labels(tr("Term"));
+  labels.push_back(tr("Doc. / Tot."));
+  resTW->setHorizontalHeaderLabels(labels);
+  prefs.termMatchType = mode;
+    }
+}
 void SpellW::copy()
+{
   QItemSelectionModel * selection = resTW->selectionModel();