From 4aed2c8219774f5d797760606b8489a92ddc5163 Mon Sep 17 00:00:00 2001 From: toma Date: Wed, 25 Nov 2009 17:56:58 +0000 Subject: Copy the KDE 3.5 branch to branches/trinity for new KDE 3.5 features. BUG:215923 git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/kdebase@1054174 283d02a7-25f6-0310-bc7c-ecb5cbfe19da --- khelpcenter/searchengine.cpp | 502 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 502 insertions(+) create mode 100644 khelpcenter/searchengine.cpp (limited to 'khelpcenter/searchengine.cpp') diff --git a/khelpcenter/searchengine.cpp b/khelpcenter/searchengine.cpp new file mode 100644 index 000000000..2156ee244 --- /dev/null +++ b/khelpcenter/searchengine.cpp @@ -0,0 +1,502 @@ +#include "stdlib.h" + +#include +#include +#include +#include +#include +#include +#include +#include + +#include "docmetainfo.h" +#include "formatter.h" +#include "view.h" +#include "searchhandler.h" +#include "prefs.h" + +#include "searchengine.h" + +namespace KHC +{ + +SearchTraverser::SearchTraverser( SearchEngine *engine, int level ) : + mMaxLevel( 999 ), mEngine( engine), mLevel( level ) +{ +#if 0 + kdDebug() << "SearchTraverser(): " << mLevel + << " 0x" << QString::number( int( this ), 16 ) << endl; +#endif +} + +SearchTraverser::~SearchTraverser() +{ +#if 0 + kdDebug() << "~SearchTraverser(): " << mLevel + << " 0x" << QString::number( int( this ), 16 ) << endl; +#endif + + QString section; + if ( parentEntry() ) { + section = parentEntry()->name(); + } else { + section = ("Unknown Section"); + } + + if ( !mResult.isEmpty() ) { + mEngine->view()->writeSearchResult( + mEngine->formatter()->sectionHeader( section ) ); + mEngine->view()->writeSearchResult( mResult ); + } +} + +void SearchTraverser::process( DocEntry * ) +{ + kdDebug() << "SearchTraverser::process()" << endl; +} + +void SearchTraverser::startProcess( DocEntry *entry ) +{ +// kdDebug() << "SearchTraverser::startProcess(): " << entry->name() << " " +// << "SEARCH: '" << entry->search() << "'" << endl; + + if ( !mEngine->canSearch( entry ) || !entry->searchEnabled() ) { + mNotifyee->endProcess( entry, this ); + return; + } + +// kdDebug() << "SearchTraverser::startProcess(): " << entry->identifier() +// << endl; + + SearchHandler *handler = mEngine->handler( entry->documentType() ); + + if ( !handler ) { + QString txt; + if ( entry->documentType().isEmpty() ) { + txt = i18n("Error: No document type specified."); + } else { + txt = i18n("Error: No search handler for document type '%1'.") + .arg( entry->documentType() ); + } + showSearchError( handler, entry, txt ); + return; + } + + connectHandler( handler ); + + handler->search( entry, mEngine->words(), mEngine->maxResults(), + mEngine->operation() ); + +// kdDebug() << "SearchTraverser::startProcess() done: " << entry->name() << endl; +} + +void SearchTraverser::connectHandler( SearchHandler *handler ) +{ + QMap::Iterator it; + it = mConnectCount.find( handler ); + int count = 0; + if ( it != mConnectCount.end() ) count = *it; + if ( count == 0 ) { + connect( handler, SIGNAL( searchError( SearchHandler *, DocEntry *, const QString & ) ), + SLOT( showSearchError( SearchHandler *, DocEntry *, const QString & ) ) ); + connect( handler, SIGNAL( searchFinished( SearchHandler *, DocEntry *, const QString & ) ), + SLOT( showSearchResult( SearchHandler *, DocEntry *, const QString & ) ) ); + } + mConnectCount[ handler ] = ++count; +} + +void SearchTraverser::disconnectHandler( SearchHandler *handler ) +{ + QMap::Iterator it; + it = mConnectCount.find( handler ); + if ( it == mConnectCount.end() ) { + kdError() << "SearchTraverser::disconnectHandler() handler not connected." + << endl; + } else { + int count = *it; + --count; + if ( count == 0 ) { + disconnect( handler, SIGNAL( searchError( SearchHandler *, DocEntry *, const QString & ) ), + this, SLOT( showSearchError( SearchHandler *, DocEntry *, const QString & ) ) ); + disconnect( handler, SIGNAL( searchFinished( SearchHandler *, DocEntry *, const QString & ) ), + this, SLOT( showSearchResult( SearchHandler *, DocEntry *, const QString & ) ) ); + } + mConnectCount[ handler ] = count; + } +} + +DocEntryTraverser *SearchTraverser::createChild( DocEntry *parentEntry ) +{ +// kdDebug() << "SearchTraverser::createChild() level " << mLevel << endl; + + if ( mLevel >= mMaxLevel ) { + ++mLevel; + return this; + } else { + DocEntryTraverser *t = new SearchTraverser( mEngine, mLevel + 1 ); + t->setParentEntry( parentEntry ); + return t; + } +} + +DocEntryTraverser *SearchTraverser::parentTraverser() +{ +// kdDebug() << "SearchTraverser::parentTraverser(): level: " << mLevel << endl; + + if ( mLevel > mMaxLevel ) { + return this; + } else { + return mParent; + } +} + +void SearchTraverser::deleteTraverser() +{ +// kdDebug() << "SearchTraverser::deleteTraverser()" << endl; + + if ( mLevel > mMaxLevel ) { + --mLevel; + } else { + delete this; + } +} + +void SearchTraverser::showSearchError( SearchHandler *handler, DocEntry *entry, const QString &error ) +{ +// kdDebug() << "SearchTraverser::showSearchError(): " << entry->name() +// << endl; + + mResult += mEngine->formatter()->docTitle( entry->name() ); + mResult += mEngine->formatter()->paragraph( error ); + + mEngine->logError( entry, error ); + + disconnectHandler( handler ); + + mNotifyee->endProcess( entry, this ); +} + +void SearchTraverser::showSearchResult( SearchHandler *handler, DocEntry *entry, const QString &result ) +{ +// kdDebug() << "SearchTraverser::showSearchResult(): " << entry->name() +// << endl; + + mResult += mEngine->formatter()->docTitle( entry->name() ); + mResult += mEngine->formatter()->processResult( result ); + + disconnectHandler( handler ); + + mNotifyee->endProcess( entry, this ); +} + +void SearchTraverser::finishTraversal() +{ +// kdDebug() << "SearchTraverser::finishTraversal()" << endl; + + mEngine->view()->writeSearchResult( mEngine->formatter()->footer() ); + mEngine->view()->endSearchResult(); + + mEngine->finishSearch(); +} + + +SearchEngine::SearchEngine( View *destination ) + : QObject(), + mProc( 0 ), mSearchRunning( false ), mView( destination ), + mRootTraverser( 0 ) +{ + mLang = KGlobal::locale()->language().left( 2 ); +} + +SearchEngine::~SearchEngine() +{ + delete mRootTraverser; +} + +bool SearchEngine::initSearchHandlers() +{ + QStringList resources = KGlobal::dirs()->findAllResources( + "appdata", "searchhandlers/*.desktop" ); + QStringList::ConstIterator it; + for( it = resources.begin(); it != resources.end(); ++it ) { + QString filename = *it; + kdDebug() << "SearchEngine::initSearchHandlers(): " << filename << endl; + SearchHandler *handler = SearchHandler::initFromFile( filename ); + if ( !handler || !handler->checkPaths() ) { + QString txt = i18n("Unable to initialize SearchHandler from file '%1'.") + .arg( filename ); + kdWarning() << txt << endl; +// KMessageBox::sorry( mView->widget(), txt ); + } else { + QStringList documentTypes = handler->documentTypes(); + QStringList::ConstIterator it; + for( it = documentTypes.begin(); it != documentTypes.end(); ++it ) { + mHandlers.insert( *it, handler ); + } + } + } + + if ( mHandlers.isEmpty() ) { + QString txt = i18n("No valid search handler found."); + kdWarning() << txt << endl; +// KMessageBox::sorry( mView->widget(), txt ); + return false; + } + + return true; +} + +void SearchEngine::searchStdout(KProcess *, char *buffer, int len) +{ + if ( !buffer || len == 0 ) + return; + + QString bufferStr; + char *p; + p = (char*) malloc( sizeof(char) * (len+1) ); + p = strncpy( p, buffer, len ); + p[len] = '\0'; + + mSearchResult += bufferStr.fromUtf8(p); + + free(p); +} + +void SearchEngine::searchStderr(KProcess *, char *buffer, int len) +{ + if ( !buffer || len == 0 ) + return; + + mStderr.append( QString::fromUtf8( buffer, len ) ); +} + +void SearchEngine::searchExited(KProcess *) +{ + kdDebug() << "Search terminated" << endl; + mSearchRunning = false; +} + +bool SearchEngine::search( QString words, QString method, int matches, + QString scope ) +{ + if ( mSearchRunning ) return false; + + // These should be removed + mWords = words; + mMethod = method; + mMatches = matches; + mScope = scope; + + // Saner variables to store search parameters: + mWordList = QStringList::split( " ", words ); + mMaxResults = matches; + if ( method == "or" ) mOperation = Or; + else mOperation = And; + + KConfig *cfg = KGlobal::config(); + cfg->setGroup( "Search" ); + QString commonSearchProgram = cfg->readPathEntry( "CommonProgram" ); + bool useCommon = cfg->readBoolEntry( "UseCommonProgram", false ); + + if ( commonSearchProgram.isEmpty() || !useCommon ) { + if ( !mView ) { + return false; + } + + QString txt = i18n("Search Results for '%1':").arg( QStyleSheet::escape(words) ); + + mStderr = "" + txt + "\n"; + + mView->beginSearchResult(); + mView->writeSearchResult( formatter()->header( i18n("Search Results") ) ); + mView->writeSearchResult( formatter()->title( txt ) ); + + if ( mRootTraverser ) { + kdDebug() << "SearchEngine::search(): mRootTraverser not null." << endl; + return false; + } + mRootTraverser = new SearchTraverser( this, 0 ); + DocMetaInfo::self()->startTraverseEntries( mRootTraverser ); + + return true; + } else { + QString lang = KGlobal::locale()->language().left(2); + + if ( lang.lower() == "c" || lang.lower() == "posix" ) + lang = "en"; + + // if the string contains '&' replace with a '+' and set search method to and + if (mWords.find("&") != -1) { + mWords.replace("&", " "); + method = "and"; + } + + // replace whitespace with a '+' + mWords = mWords.stripWhiteSpace(); + mWords = mWords.simplifyWhiteSpace(); + mWords.replace(QRegExp("\\s"), "+"); + + commonSearchProgram = substituteSearchQuery( commonSearchProgram ); + + kdDebug() << "Common Search: " << commonSearchProgram << endl; + + mProc = new KProcess(); + + QStringList cmd = QStringList::split( " ", commonSearchProgram ); + QStringList::ConstIterator it; + for( it = cmd.begin(); it != cmd.end(); ++it ) { + QString arg = *it; + if ( arg.left( 1 ) == "\"" && arg.right( 1 ) =="\"" ) { + arg = arg.mid( 1, arg.length() - 2 ); + } + *mProc << arg.utf8(); + } + + connect( mProc, SIGNAL( receivedStdout( KProcess *, char *, int ) ), + SLOT( searchStdout( KProcess *, char *, int ) ) ); + connect( mProc, SIGNAL( receivedStderr( KProcess *, char *, int ) ), + SLOT( searchStderr( KProcess *, char *, int ) ) ); + connect( mProc, SIGNAL( processExited( KProcess * ) ), + SLOT( searchExited( KProcess * ) ) ); + + mSearchRunning = true; + mSearchResult = ""; + mStderr = "" + commonSearchProgram + "\n\n"; + + mProc->start(KProcess::NotifyOnExit, KProcess::All); + + while (mSearchRunning && mProc->isRunning()) + kapp->processEvents(); + + if ( !mProc->normalExit() || mProc->exitStatus() != 0 ) { + kdError() << "Unable to run search program '" << commonSearchProgram + << "'" << endl; + delete mProc; + + return false; + } + + delete mProc; + + // modify the search result + mSearchResult = mSearchResult.replace("http://localhost/", "file:/"); + mSearchResult = mSearchResult.mid( mSearchResult.find( '<' ) ); + + mView->beginSearchResult(); + mView->writeSearchResult( mSearchResult ); + mView->endSearchResult(); + + emit searchFinished(); + } + + return true; +} + +QString SearchEngine::substituteSearchQuery( const QString &query ) +{ + QString result = query; + result.replace( "%k", mWords ); + result.replace( "%n", QString::number( mMatches ) ); + result.replace( "%m", mMethod ); + result.replace( "%l", mLang ); + result.replace( "%s", mScope ); + + return result; +} + +QString SearchEngine::substituteSearchQuery( const QString &query, + const QString &identifier, const QStringList &words, int maxResults, + Operation operation, const QString &lang ) +{ + QString result = query; + result.replace( "%i", identifier ); + result.replace( "%w", words.join( "+" ) ); + result.replace( "%m", QString::number( maxResults ) ); + QString o; + if ( operation == Or ) o = "or"; + else o = "and"; + result.replace( "%o", o ); + result.replace( "%d", Prefs::indexDirectory() ); + result.replace( "%l", lang ); + + return result; +} + +Formatter *SearchEngine::formatter() const +{ + return mView->formatter(); +} + +View *SearchEngine::view() const +{ + return mView; +} + +void SearchEngine::finishSearch() +{ + delete mRootTraverser; + mRootTraverser = 0; + + emit searchFinished(); +} + +QString SearchEngine::errorLog() const +{ + return mStderr; +} + +void SearchEngine::logError( DocEntry *entry, const QString &msg ) +{ + mStderr += entry->identifier() + ": " + msg; +} + +bool SearchEngine::isRunning() const +{ + return mSearchRunning; +} + +SearchHandler *SearchEngine::handler( const QString &documentType ) const +{ + QMap::ConstIterator it; + it = mHandlers.find( documentType ); + + if ( it == mHandlers.end() ) return 0; + else return *it; +} + +QStringList SearchEngine::words() const +{ + return mWordList; +} + +int SearchEngine::maxResults() const +{ + return mMaxResults; +} + +SearchEngine::Operation SearchEngine::operation() const +{ + return mOperation; +} + +bool SearchEngine::canSearch( DocEntry *entry ) +{ + return entry->docExists() && !entry->documentType().isEmpty() && + handler( entry->documentType() ); +} + +bool SearchEngine::needsIndex( DocEntry *entry ) +{ + if ( !canSearch( entry ) ) return false; + + SearchHandler *h = handler( entry->documentType() ); + if ( h->indexCommand( entry->identifier() ).isEmpty() ) return false; + + return true; +} + +} + +#include "searchengine.moc" + +// vim:ts=2:sw=2:et -- cgit v1.2.3