runtime/khelpcenter/searchengine.cpp

   1 #include "searchengine.h"
   2
   3 #include "stdlib.h"
   4
   5 #include <QTextDocument>
   6 #include <KApplication>
   7 #include <KConfig>
   8 #include <KDebug>
   9 #include <KStandardDirs>
  10 #include <KProcess>
  11 #include <KShell>
  12 #include <KLocale>
  13 #include <KMessageBox>
  14
  15 #include "docmetainfo.h"
  16 #include "formatter.h"
  17 #include "view.h"
  18 #include "searchhandler.h"
  19 #include "prefs.h"
  20
  21 namespace KHC
  22 {
  23
  24 SearchTraverser::SearchTraverser( SearchEngine *engine, int level ) :
  25   mMaxLevel( 999 ), mEngine( engine), mLevel( level )
  26 {
  27 #if 0
  28   kDebug() << "SearchTraverser(): " << mLevel
  29     << "  0x" << QString::number( int( this ), 16 ) << endl;
  30 #endif
  31 }
  32
  33 SearchTraverser::~SearchTraverser()
  34 {
  35 #if 0
  36     kDebug() << "~SearchTraverser(): " << mLevel
  37       << "  0x" << QString::number( int( this ), 16 ) << endl;
  38 #endif
  39
  40   QString section;
  41   if ( parentEntry() ) {
  42     section = parentEntry()->name();
  43   } else {
  44     section = ("Unknown Section");
  45   }
  46
  47   if ( !mResult.isEmpty() ) {
  48     mEngine->view()->writeSearchResult(
  49       mEngine->formatter()->sectionHeader( section ) );
  50     mEngine->view()->writeSearchResult( mResult );
  51   }
  52 }
  53
  54 void SearchTraverser::process( DocEntry * )
  55 {
  56   kDebug() << "SearchTraverser::process()";
  57 }
  58
  59 void SearchTraverser::startProcess( DocEntry *entry )
  60 {
  61 //  kDebug() << "SearchTraverser::startProcess(): " << entry->name() << "  "
  62 //    << "SEARCH: '" << entry->search() << "'" << endl;
  63
  64   if ( !mEngine->canSearch( entry ) || !entry->searchEnabled() ) {
  65     mNotifyee->endProcess( entry, this );
  66     return;
  67   }
  68
  69 //  kDebug() << "SearchTraverser::startProcess(): " << entry->identifier()
  70 //    << endl;
  71
  72   SearchHandler *handler = mEngine->handler( entry->documentType() );
  73
  74   if ( !handler ) {
  75     QString txt;
  76     if ( entry->documentType().isEmpty() ) {
  77       txt = i18n("Error: No document type specified.");
  78     } else {
  79       txt = i18n("Error: No search handler for document type '%1'.",
  80           entry->documentType() );
  81     }
  82     showSearchError( handler, entry, txt );
  83     return;
  84   }
  85
  86   connectHandler( handler );
  87
  88   handler->search( entry, mEngine->words(), mEngine->maxResults(),
  89     mEngine->operation() );
  90
  91 //  kDebug() << "SearchTraverser::startProcess() done: " << entry->name();
  92 }
  93
  94 void SearchTraverser::connectHandler( SearchHandler *handler )
  95 {
  96   QMap<SearchHandler *,int>::Iterator it;
  97   it = mConnectCount.find( handler );
  98   int count = 0;
  99   if ( it != mConnectCount.end() ) count = *it;
 100   if ( count == 0 ) {
 101     connect( handler, SIGNAL( searchError( SearchHandler *, DocEntry *, const QString & ) ),
 102       SLOT( showSearchError( SearchHandler *, DocEntry *, const QString & ) ) );
 103     connect( handler, SIGNAL( searchFinished( SearchHandler *, DocEntry *, const QString & ) ),
 104       SLOT( showSearchResult( SearchHandler *, DocEntry *, const QString & ) ) );
 105   }
 106   mConnectCount[ handler ] = ++count;
 107 }
 108
 109 void SearchTraverser::disconnectHandler( SearchHandler *handler )
 110 {
 111   QMap<SearchHandler *,int>::Iterator it;
 112   it = mConnectCount.find( handler );
 113   if ( it == mConnectCount.end() ) {
 114     kError() << "SearchTraverser::disconnectHandler() handler not connected."
 115       << endl;
 116   } else {
 117     int count = *it;
 118     --count;
 119     if ( count == 0 ) {
 120       disconnect( handler, SIGNAL( searchError( SearchHandler *, DocEntry *, const QString & ) ),
 121         this, SLOT( showSearchError( SearchHandler *, DocEntry *, const QString & ) ) );
 122       disconnect( handler, SIGNAL( searchFinished( SearchHandler *, DocEntry *, const QString & ) ),
 123         this, SLOT( showSearchResult( SearchHandler *, DocEntry *, const QString & ) ) );
 124     }
 125     mConnectCount[ handler ] = count;
 126   }
 127 }
 128
 129 DocEntryTraverser *SearchTraverser::createChild( DocEntry *parentEntry )
 130 {
 131 //  kDebug() << "SearchTraverser::createChild() level " << mLevel;
 132
 133   if ( mLevel >= mMaxLevel ) {
 134     ++mLevel;
 135     return this;
 136   } else {
 137     DocEntryTraverser *t = new SearchTraverser( mEngine, mLevel + 1 );
 138     t->setParentEntry( parentEntry );
 139     return t;
 140   }
 141 }
 142
 143 DocEntryTraverser *SearchTraverser::parentTraverser()
 144 {
 145 //  kDebug() << "SearchTraverser::parentTraverser(): level: " << mLevel;
 146
 147   if ( mLevel > mMaxLevel ) {
 148     return this;
 149   } else {
 150     return mParent;
 151   }
 152 }
 153
 154 void SearchTraverser::deleteTraverser()
 155 {
 156 //  kDebug() << "SearchTraverser::deleteTraverser()";
 157
 158   if ( mLevel > mMaxLevel ) {
 159     --mLevel;
 160   } else {
 161     delete this;
 162   }
 163 }
 164
 165 void SearchTraverser::showSearchError( SearchHandler *handler, DocEntry *entry, const QString &error )
 166 {
 167 //  kDebug() << "SearchTraverser::showSearchError(): " << entry->name()
 168 //    << endl;
 169
 170   mResult += mEngine->formatter()->docTitle( entry->name() );
 171   mResult += mEngine->formatter()->paragraph( error );
 172
 173   mEngine->logError( entry, error );
 174
 175   disconnectHandler( handler );
 176
 177   mNotifyee->endProcess( entry, this );
 178 }
 179
 180 void SearchTraverser::showSearchResult( SearchHandler *handler, DocEntry *entry, const QString &result )
 181 {
 182 //  kDebug() << "SearchTraverser::showSearchResult(): " << entry->name()
 183 //    << endl;
 184
 185   mResult += mEngine->formatter()->docTitle( entry->name() );
 186   mResult += mEngine->formatter()->processResult( result );
 187
 188   disconnectHandler( handler );
 189
 190   mNotifyee->endProcess( entry, this );
 191 }
 192
 193 void SearchTraverser::finishTraversal()
 194 {
 195 //  kDebug() << "SearchTraverser::finishTraversal()";
 196
 197   mEngine->view()->writeSearchResult( mEngine->formatter()->footer() );
 198   mEngine->view()->endSearchResult();
 199
 200   mEngine->finishSearch();
 201 }
 202
 203
 204 SearchEngine::SearchEngine( View *destination )
 205   : QObject(),
 206     mProc( 0 ), mSearchRunning( false ), mView( destination ),
 207     mRootTraverser( 0 )
 208 {
 209   mLang = KGlobal::locale()->language().left( 2 );
 210 }
 211
 212 SearchEngine::~SearchEngine()
 213 {
 214   delete mRootTraverser;
 215 }
 216
 217 bool SearchEngine::initSearchHandlers()
 218 {
 219   const QStringList resources = KGlobal::dirs()->findAllResources(
 220     "appdata", "searchhandlers/*.desktop" );
 221   QStringList::ConstIterator it;
 222   for( it = resources.constBegin(); it != resources.constEnd(); ++it ) {
 223     QString filename = *it;
 224     kDebug() << "SearchEngine::initSearchHandlers(): " << filename;
 225     SearchHandler *handler = SearchHandler::initFromFile( filename );
 226     if ( !handler || !handler->checkPaths() ) {
 227       QString txt = i18n("Unable to initialize SearchHandler from file '%1'.",
 228           filename );
 229       kWarning() << txt ;
 230 //      KMessageBox::sorry( mView->widget(), txt );
 231     } else {
 232       QStringList documentTypes = handler->documentTypes();
 233       QStringList::ConstIterator it;
 234       for( it = documentTypes.constBegin(); it != documentTypes.constEnd(); ++it ) {
 235         mHandlers.insert( *it, handler );
 236       }
 237     }
 238   }
 239
 240   if ( mHandlers.isEmpty() ) {
 241     QString txt = i18n("No valid search handler found.");
 242     kWarning() << txt ;
 243 //    KMessageBox::sorry( mView->widget(), txt );
 244     return false;
 245   }
 246
 247   return true;
 248 }
 249
 250 void SearchEngine::searchExited(int exitCode, QProcess::ExitStatus exitStatus)
 251 {
 252   kDebug() << "Search terminated";
 253   mSearchRunning = false;
 254 }
 255
 256 bool SearchEngine::search( const QString & words, const QString & method, int matches,
 257                            const QString & scope )
 258 {
 259   if ( mSearchRunning ) return false;
 260
 261   // These should be removed
 262   mWords = words;
 263   mMethod = method;
 264   mMatches = matches;
 265   mScope = scope;
 266
 267   // Saner variables to store search parameters:
 268   mWordList = words.split( " ");
 269   mMaxResults = matches;
 270   if ( method == "or" ) mOperation = Or;
 271   else mOperation = And;
 272
 273   KConfigGroup cfg(KGlobal::config(), "Search");
 274   QString commonSearchProgram = cfg.readPathEntry( "CommonProgram", QString() );
 275   bool useCommon = cfg.readEntry( "UseCommonProgram", false);
 276
 277   if ( commonSearchProgram.isEmpty() || !useCommon ) {
 278     if ( !mView ) {
 279       return false;
 280     }
 281
 282     QString txt = i18n("Search Results for '%1':", Qt::escape(words) );
 283
 284     mStderr = "<b>" + txt + "</b>\n";
 285
 286     mView->beginSearchResult();
 287     mView->writeSearchResult( formatter()->header( i18n("Search Results") ) );
 288     mView->writeSearchResult( formatter()->title( txt ) );
 289
 290     if ( mRootTraverser ) {
 291       kDebug() << "SearchEngine::search(): mRootTraverser not null.";
 292       return false;
 293     }
 294     mRootTraverser = new SearchTraverser( this, 0 );
 295     DocMetaInfo::self()->startTraverseEntries( mRootTraverser );
 296
 297     return true;
 298   } else {
 299     QString lang = KGlobal::locale()->language().left(2);
 300
 301     if ( lang.toLower() == "c" || lang.toLower() == "posix" )
 302           lang = "en";
 303
 304     // if the string contains '&' replace with a '+' and set search method to and
 305     if (mWords.indexOf("&") != -1) {
 306       mWords.replace("&", " ");
 307       mMethod = "and";
 308     }
 309
 310     // replace whitespace with a '+'
 311     mWords = mWords.trimmed();
 312     mWords = mWords.simplified();
 313     mWords.replace(QRegExp("\\s"), "+");
 314
 315     commonSearchProgram = substituteSearchQuery( commonSearchProgram );
 316
 317     kDebug() << "Common Search: " << commonSearchProgram;
 318
 319     mProc = new KProcess();
 320     *mProc << KShell::splitArgs(commonSearchProgram);
 321
 322     connect( mProc, SIGNAL( finished(int, QProcess::ExitStatus) ),
 323              this, SLOT( searchExited(int, QProcess::ExitStatus) ) );
 324
 325     mSearchRunning = true;
 326     mSearchResult = "";
 327     mStderr = "<b>" + commonSearchProgram + "</b>\n\n";
 328
 329     mProc->start();
 330     if (!mProc->waitForStarted()) {
 331       kError() << "could not start search program '" << commonSearchProgram
 332                 << "'" << endl;
 333       delete mProc;
 334       return false;
 335     }
 336
 337     while (mSearchRunning && mProc->state() == QProcess::Running)
 338       kapp->processEvents();
 339
 340     // no need to use signals/slots
 341     mStderr += mProc->readAllStandardError();
 342     mSearchResult += mProc->readAllStandardOutput();
 343
 344     if ( mProc->exitStatus() == KProcess::CrashExit || mProc->exitCode() != 0 ) {
 345       kError() << "Unable to run search program '" << commonSearchProgram
 346                 << "'" << endl;
 347       delete mProc;
 348
 349       return false;
 350     }
 351
 352     delete mProc;
 353
 354     // modify the search result
 355     mSearchResult = mSearchResult.replace("http://localhost/", "file:/");
 356     mSearchResult = mSearchResult.mid( mSearchResult.indexOf( '<' ) );
 357
 358     mView->beginSearchResult();
 359     mView->writeSearchResult( mSearchResult );
 360     mView->endSearchResult();
 361
 362     emit searchFinished();
 363   }
 364
 365   return true;
 366 }
 367
 368 QString SearchEngine::substituteSearchQuery( const QString &query )
 369 {
 370   QString result = query;
 371   result.replace( QLatin1String("%k"), mWords );
 372   result.replace( QLatin1String("%n"), QString::number( mMatches ) );
 373   result.replace( QLatin1String("%m"), mMethod );
 374   result.replace( QLatin1String("%l"), mLang );
 375   result.replace( QLatin1String("%s"), mScope );
 376
 377   return result;
 378 }
 379
 380 QString SearchEngine::substituteSearchQuery( const QString &query,
 381   const QString &identifier, const QStringList &words, int maxResults,
 382   Operation operation, const QString &lang )
 383 {
 384   QString result = query;
 385   result.replace( QLatin1String("%i"), identifier );
 386   result.replace( QLatin1String("%w"), words.join( "+" ) );
 387   result.replace( QLatin1String("%m"), QString::number( maxResults ) );
 388   QString o = QLatin1String(operation == Or ? "or" : "and");
 389   result.replace( QLatin1String("%o"), o );
 390   result.replace( QLatin1String("%d"), Prefs::indexDirectory() );
 391   result.replace( QLatin1String("%l"), lang );
 392
 393   return result;
 394 }
 395
 396 Formatter *SearchEngine::formatter() const
 397 {
 398   return mView->formatter();
 399 }
 400
 401 View *SearchEngine::view() const
 402 {
 403   return mView;
 404 }
 405
 406 void SearchEngine::finishSearch()
 407 {
 408   delete mRootTraverser;
 409   mRootTraverser = 0;
 410
 411   emit searchFinished();
 412 }
 413
 414 QString SearchEngine::errorLog() const
 415 {
 416   return mStderr;
 417 }
 418
 419 void SearchEngine::logError( DocEntry *entry, const QString &msg )
 420 {
 421   mStderr += entry->identifier() + QLatin1String(": ") + msg;
 422 }
 423
 424 bool SearchEngine::isRunning() const
 425 {
 426   return mSearchRunning;
 427 }
 428
 429 SearchHandler *SearchEngine::handler( const QString &documentType ) const
 430 {
 431   return mHandlers.value( documentType, 0 );
 432 }
 433
 434 QStringList SearchEngine::words() const
 435 {
 436   return mWordList;
 437 }
 438
 439 int SearchEngine::maxResults() const
 440 {
 441   return mMaxResults;
 442 }
 443
 444 SearchEngine::Operation SearchEngine::operation() const
 445 {
 446   return mOperation;
 447 }
 448
 449 bool SearchEngine::canSearch( DocEntry *entry )
 450 {
 451   return entry->docExists() && !entry->documentType().isEmpty() &&
 452     handler( entry->documentType() );
 453 }
 454
 455 bool SearchEngine::needsIndex( DocEntry *entry )
 456 {
 457   if ( !canSearch( entry ) ) return false;
 458
 459   SearchHandler *h = handler( entry->documentType() );
 460   if ( !h || h->indexCommand( entry->identifier() ).isEmpty() ) return false;
 461
 462   return true;
 463 }
 464
 465 }
 466
 467 #include "searchengine.moc"
 468
 469 // vim:ts=2:sw=2:et