# kate Library API Documentation

Overview | Class Hierarchy | Classes | Classes (annotated) | Members | Namespaces | Source Files

# katesearch.cpp

    00001 /* This file is part of the KDE libraries
    00002    Copyright (C) 2003 Clarence Dang <dang@kde.org>
    00003    Copyright (C) 2002 John Firebaugh <jfirebaugh@kde.org>
    00004    Copyright (C) 2001-2004 Christoph Cullmann <cullmann@kde.org>
    00005    Copyright (C) 2001 Joseph Wenninger <jowenn@kde.org>
    00006    Copyright (C) 1999 Jochen Wilhelmy <digisnap@cs.tu-berlin.de>
    00007
    00008    This library is free software; you can redistribute it and/or
    00009    modify it under the terms of the GNU Library General Public
    00010    License version 2 as published by the Free Software Foundation.
    00011
    00012    This library is distributed in the hope that it will be useful,
    00013    but WITHOUT ANY WARRANTY; without even the implied warranty of
    00014    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    00015    Library General Public License for more details.
    00016
    00017    You should have received a copy of the GNU Library General Public License
    00018    along with this library; see the file COPYING.LIB.  If not, write to
    00019    the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
    00020    Boston, MA 02111-1307, USA.
    00021 */
    00022
    00023 #include "katesearch.h"
    00024 #include "katesearch.moc"
    00025
    00026 #include "kateview.h"
    00027 #include "katedocument.h"
    00028 #include "katesupercursor.h"
    00029 #include "katearbitraryhighlight.h"
    00030 #include "kateconfig.h"
    00031
    00032 #include <klocale.h>
    00033 #include <kstdaction.h>
    00034 #include <kmessagebox.h>
    00035 #include <kstringhandler.h>
    00036 #include <kdebug.h>
    00037 #include <kfinddialog.h>
    00038 #include <kreplacedialog.h>
    00039
    00040 #include <qlayout.h>
    00041 #include <qlabel.h>
    00042
    00043 //BEGIN KateSearch
    00044 QStringList KateSearch::s_searchList  = QStringList();
    00045 QStringList KateSearch::s_replaceList = QStringList();
    00046 QString KateSearch::s_pattern = QString();
    00047 static const bool arbitraryHLExample = false;
    00048
    00049 KateSearch::KateSearch( KateView* view )
    00050   : QObject( view, "kate search" )
    00051   , m_view( view )
    00052   , m_doc( view->doc() )
    00053   , replacePrompt( new KateReplacePrompt( view ) )
    00054 {
    00055   m_arbitraryHLList = new KateSuperRangeList();
    00056   if (arbitraryHLExample) m_doc->arbitraryHL()->addHighlightToView(m_arbitraryHLList, m_view);
    00057
    00058   connect(replacePrompt,SIGNAL(clicked()),this,SLOT(replaceSlot()));
    00059 }
    00060
    00061 KateSearch::~KateSearch()
    00062 {
    00063   delete m_arbitraryHLList;
    00064 }
    00065
    00066 void KateSearch::createActions( KActionCollection* ac )
    00067 {
    00068   KStdAction::find( this, SLOT(find()), ac )->setWhatsThis(
    00069     i18n("Look up the first occurrence of a piece of text or regular expression."));
    00070   KStdAction::findNext( this, SLOT(slotFindNext()), ac )->setWhatsThis(
    00071     i18n("Look up the next occurrence of the search phrase."));
    00072   KStdAction::findPrev( this, SLOT(slotFindPrev()), ac, "edit_find_prev" )->setWhatsThis(
    00073     i18n("Look up the previous occurrence of the search phrase."));
    00074   KStdAction::replace( this, SLOT(replace()), ac )->setWhatsThis(
    00075     i18n("Look up a piece of text or regular expression and replace the result with some given text."));
    00076 }
    00077
    00078 void KateSearch::addToList( QStringList& list, const QString& s )
    00079 {
    00080   if( list.count() > 0 ) {
    00081     QStringList::Iterator it = list.find( s );
    00082     if( *it != 0L )
    00083       list.remove( it );
    00084     if( list.count() >= 16 )
    00085       list.remove( list.fromLast() );
    00086   }
    00087   list.prepend( s );
    00088 }
    00089
    00090 void KateSearch::find()
    00091 {
    00092   // if multiline selection around, search in it
    00093   long searchf = KateViewConfig::global()->searchFlags();
    00094   if (m_doc->hasSelection() && m_doc->selStartLine() != m_doc->selEndLine())
    00095     searchf |= KFindDialog::SelectedText;
    00096
    00097   KFindDialog *findDialog = new KFindDialog (  m_view, "", searchf,
    00098                                                s_searchList, m_doc->hasSelection() );
    00099
    00100   findDialog->setPattern (getSearchText());
    00101
    00102
    00103   if( findDialog->exec() == QDialog::Accepted ) {
    00104     s_searchList =  findDialog->findHistory () ;
    00105     // Do *not* remove the QString() wrapping, it fixes a nasty crash
    00106     find( QString(s_searchList.first()), findDialog->options(), true, true );
    00107   }
    00108
    00109   delete findDialog;
    00110   m_view->repaintText ();
    00111 }
    00112
    00113 void KateSearch::find( const QString &pattern, long flags, bool add, bool shownotfound )
    00114 {
    00115   KateViewConfig::global()->setSearchFlags( flags );
    00116   if( add )
    00117     addToList( s_searchList, pattern );
    00118
    00119    s_pattern = pattern;
    00120
    00121   SearchFlags searchFlags;
    00122
    00123   searchFlags.caseSensitive = KateViewConfig::global()->searchFlags() & KFindDialog::CaseSensitive;
    00124   searchFlags.wholeWords = KateViewConfig::global()->searchFlags() & KFindDialog::WholeWordsOnly;
    00125   searchFlags.fromBeginning = !(KateViewConfig::global()->searchFlags() & KFindDialog::FromCursor)
    00126       && !(KateViewConfig::global()->searchFlags() & KFindDialog::SelectedText);
    00127   searchFlags.backward = KateViewConfig::global()->searchFlags() & KFindDialog::FindBackwards;
    00128   searchFlags.selected = KateViewConfig::global()->searchFlags() & KFindDialog::SelectedText;
    00129   searchFlags.prompt = false;
    00130   searchFlags.replace = false;
    00131   searchFlags.finished = false;
    00132   searchFlags.regExp = KateViewConfig::global()->searchFlags() & KFindDialog::RegularExpression;
    00133
    00134   if ( searchFlags.selected )
    00135   {
    00136     s.selBegin = KateTextCursor( doc()->selStartLine(), doc()->selStartCol() );
    00137     s.selEnd   = KateTextCursor( doc()->selEndLine(),   doc()->selEndCol()   );
    00138     s.cursor   = s.flags.backward ? s.selEnd : s.selBegin;
    00139   } else {
    00140     s.cursor = getCursor();
    00141   }
    00142
    00143   s.wrappedEnd = s.cursor;
    00144   s.wrapped = false;
    00145   s.showNotFound = shownotfound;
    00146
    00147   search( searchFlags );
    00148 }
    00149
    00150 void KateSearch::replace()
    00151 {
    00152   if (!doc()->isReadWrite()) return;
    00153
    00154   // if multiline selection around, search in it
    00155   long searchf = KateViewConfig::global()->searchFlags();
    00156   if (m_doc->hasSelection() && m_doc->selStartLine() != m_doc->selEndLine())
    00157     searchf |= KFindDialog::SelectedText;
    00158
    00159   KReplaceDialog *replaceDialog = new KReplaceDialog (  m_view, "", searchf,
    00160                                                s_searchList, s_replaceList, m_doc->hasSelection() );
    00161
    00162   replaceDialog->setPattern (getSearchText());
    00163
    00164   if( replaceDialog->exec() == QDialog::Accepted ) {
    00165     long opts = replaceDialog->options();
    00166     m_replacement = replaceDialog->replacement();
    00167     s_searchList = replaceDialog->findHistory () ;
    00168     s_replaceList = replaceDialog->replacementHistory () ;
    00169
    00170     // Do *not* remove the QString() wrapping, it fixes a nasty crash
    00171     replace( QString(s_searchList.first()), m_replacement, opts );
    00172   }
    00173
    00174   delete replaceDialog;
    00175   m_view->update ();
    00176 }
    00177
    00178 void KateSearch::replace( const QString& pattern, const QString &replacement, long flags )
    00179 {
    00180   if (!doc()->isReadWrite()) return;
    00181
    00182   addToList( s_searchList, pattern );
    00183    s_pattern = pattern;
    00184   addToList( s_replaceList, replacement );
    00185   m_replacement = replacement;
    00186   KateViewConfig::global()->setSearchFlags( flags );
    00187
    00188   SearchFlags searchFlags;
    00189   searchFlags.caseSensitive = KateViewConfig::global()->searchFlags() & KFindDialog::CaseSensitive;
    00190   searchFlags.wholeWords = KateViewConfig::global()->searchFlags() & KFindDialog::WholeWordsOnly;
    00191   searchFlags.fromBeginning = !(KateViewConfig::global()->searchFlags() & KFindDialog::FromCursor)
    00192       && !(KateViewConfig::global()->searchFlags() & KFindDialog::SelectedText);
    00193   searchFlags.backward = KateViewConfig::global()->searchFlags() & KFindDialog::FindBackwards;
    00194   searchFlags.selected = KateViewConfig::global()->searchFlags() & KFindDialog::SelectedText;
    00195   searchFlags.prompt = KateViewConfig::global()->searchFlags() & KReplaceDialog::PromptOnReplace;
    00196   searchFlags.replace = true;
    00197   searchFlags.finished = false;
    00198   searchFlags.regExp = KateViewConfig::global()->searchFlags() & KFindDialog::RegularExpression;
    00199   searchFlags.useBackRefs = KateViewConfig::global()->searchFlags() & KReplaceDialog::BackReference;
    00200   if ( searchFlags.selected )
    00201   {
    00202     s.selBegin = KateTextCursor( doc()->selStartLine(), doc()->selStartCol() );
    00203     s.selEnd   = KateTextCursor( doc()->selEndLine(),   doc()->selEndCol()   );
    00204     s.cursor   = s.flags.backward ? s.selEnd : s.selBegin;
    00205   } else {
    00206     s.cursor = getCursor();
    00207   }
    00208
    00209   s.wrappedEnd = s.cursor;
    00210   s.wrapped = false;
    00211
    00212   search( searchFlags );
    00213 }
    00214
    00215 void KateSearch::findAgain( bool back )
    00216 {
    00217   SearchFlags searchFlags;
    00218   searchFlags.caseSensitive = KateViewConfig::global()->searchFlags() & KFindDialog::CaseSensitive;
    00219   searchFlags.wholeWords = KateViewConfig::global()->searchFlags() & KFindDialog::WholeWordsOnly;
    00220   searchFlags.fromBeginning = !(KateViewConfig::global()->searchFlags() & KFindDialog::FromCursor)
    00221                                && !(KateViewConfig::global()->searchFlags() & KFindDialog::SelectedText);
    00222   searchFlags.backward = KateViewConfig::global()->searchFlags() & KFindDialog::FindBackwards;
    00223   searchFlags.selected = KateViewConfig::global()->searchFlags() & KFindDialog::SelectedText;
    00224   searchFlags.prompt = KateViewConfig::global()->searchFlags() & KReplaceDialog::PromptOnReplace;
    00225   searchFlags.replace = false;
    00226   searchFlags.finished = false;
    00227   searchFlags.regExp = KateViewConfig::global()->searchFlags() & KFindDialog::RegularExpression;
    00228
    00229   searchFlags.backward = searchFlags.backward != back;
    00230   searchFlags.fromBeginning = false;
    00231   searchFlags.prompt = true; // ### why is the above assignment there?
    00232   s.cursor = getCursor();
    00233
    00234   search( searchFlags );
    00235 }
    00236
    00237 void KateSearch::search( SearchFlags flags )
    00238 {
    00239   s.flags = flags;
    00240
    00241   if( s.flags.fromBeginning ) {
    00242     if( !s.flags.backward ) {
    00243       s.cursor.setPos(0, 0);
    00244     } else {
    00245       s.cursor.setLine(doc()->numLines() - 1);
    00246       s.cursor.setCol(doc()->lineLength( s.cursor.line() ));
    00247     }
    00248   }
    00249
    00250   if((!s.flags.backward &&
    00251        s.cursor.col() == 0 &&
    00252        s.cursor.line() == 0 ) ||
    00253      ( s.flags.backward &&
    00254        s.cursor.col() == doc()->lineLength( s.cursor.line() ) &&
    00255        s.cursor.line() == (((int)doc()->numLines()) - 1) ) ) {
    00256     s.flags.finished = true;
    00257   }
    00258
    00259   if( s.flags.replace ) {
    00260     replaces = 0;
    00261     if( s.flags.prompt )
    00262       promptReplace();
    00263     else
    00264       replaceAll();
    00265   } else {
    00266     findAgain();
    00267   }
    00268 }
    00269
    00270 void KateSearch::wrapSearch()
    00271 {
    00272   if( s.flags.selected )
    00273   {
    00274       s.cursor = s.flags.backward ? s.selEnd : s.selBegin;
    00275   }
    00276   else
    00277   {
    00278     if( !s.flags.backward ) {
    00279       s.cursor.setPos(0, 0);
    00280     } else {
    00281       s.cursor.setLine(doc()->numLines() - 1);
    00282       s.cursor.setCol(doc()->lineLength( s.cursor.line() ) );
    00283     }
    00284   }
    00285
    00286   // oh, we wrapped around one time allready now !
    00287   // only check that on replace
    00288   s.wrapped = s.flags.replace;
    00289
    00290   replaces = 0;
    00291   s.flags.finished = true;
    00292 }
    00293
    00294 void KateSearch::findAgain()
    00295 {
    00296   if(  s_pattern.isEmpty() ) {
    00297     find();
    00298     return;
    00299   }
    00300
    00301   if ( doSearch(  s_pattern ) ) {
    00302     exposeFound( s.cursor, s.matchedLength );
    00303   } else if( !s.flags.finished ) {
    00304     if( askContinue() ) {
    00305       wrapSearch();
    00306       findAgain();
    00307     } else {
    00308       if (arbitraryHLExample) m_arbitraryHLList->clear();
    00309     }
    00310   } else {
    00311     if (arbitraryHLExample) m_arbitraryHLList->clear();
    00312     if ( s.showNotFound )
    00313       KMessageBox::sorry( view(),
    00314         i18n("Search string '%1' not found!")
    00315              .arg( KStringHandler::csqueeze(  s_pattern ) ),
    00316         i18n("Find"));
    00317   }
    00318 }
    00319
    00320 void KateSearch::replaceAll()
    00321 {
    00322   doc()->editStart ();
    00323
    00324   while( doSearch(  s_pattern ) )
    00325     replaceOne();
    00326
    00327   doc()->editEnd ();
    00328
    00329   if( !s.flags.finished ) {
    00330     if( askContinue() ) {
    00331       wrapSearch();
    00332       replaceAll();
    00333     }
    00334   } else {
    00335     KMessageBox::information( view(),
    00336         i18n("%n replacement made.","%n replacements made.",replaces),
    00337         i18n("Replace") );
    00338   }
    00339 }
    00340
    00341 void KateSearch::promptReplace()
    00342 {
    00343   if ( doSearch(  s_pattern ) ) {
    00344     exposeFound( s.cursor, s.matchedLength );
    00345     replacePrompt->show();
    00346     replacePrompt->setFocus ();
    00347   } else if( !s.flags.finished && askContinue() ) {
    00348     wrapSearch();
    00349     promptReplace();
    00350   } else {
    00351     if (arbitraryHLExample) m_arbitraryHLList->clear();
    00352     replacePrompt->hide();
    00353     KMessageBox::information( view(),
    00354         i18n("%n replacement made.","%n replacements made.",replaces),
    00355         i18n("Replace") );
    00356   }
    00357 }
    00358
    00359 void KateSearch::replaceOne()
    00360 {
    00361   QString replaceWith = m_replacement;
    00362   if ( s.flags.regExp && s.flags.useBackRefs ) {
    00363     // replace each "(?!\)\d+" with the corresponding capture
    00364     QRegExp br("\\\\(\\d+)");
    00365     int pos = br.search( replaceWith );
    00366     int ncaps = m_re.numCaptures();
    00367     while ( pos >= 0 ) {
    00368       QString sc;
    00369       if ( !pos ||  replaceWith.at( pos-1) != '\\' ) {
    00370         int ccap = br.cap(1).toInt();
    00371         if (ccap <= ncaps ) {
    00372           sc = m_re.cap( ccap );
    00373           replaceWith.replace( pos, br.matchedLength(), sc );
    00374         }
    00375         else {
    00376           kdDebug()<<"KateSearch::replaceOne(): you don't have "<<ccap<<" backreferences in regexp '"<<m_re.pattern()<<"'"<<endl;
    00377         }
    00378       }
    00379       pos = br.search( replaceWith, pos+QMAX(br.matchedLength(), (int)sc.length()) );
    00380     }
    00381   }
    00382
    00383   doc()->editStart();
    00384   doc()->removeText( s.cursor.line(), s.cursor.col(),
    00385       s.cursor.line(), s.cursor.col() + s.matchedLength );
    00386   doc()->insertText( s.cursor.line(), s.cursor.col(), replaceWith );
    00387   doc()->editEnd(),
    00388
    00389   replaces++;
    00390
    00391   // if we inserted newlines, we better adjust.
    00392   uint newlines = replaceWith.contains('\n');
    00393   if ( newlines )
    00394   {
    00395     if ( ! s.flags.backward )
    00396     {
    00397       s.cursor.setLine( s.cursor.line() + newlines );
    00398       s.cursor.setCol( replaceWith.length() - replaceWith.findRev('\n') );
    00399     }
    00400     // selection?
    00401     if ( s.flags.selected )
    00402       s.selEnd.setLine( s.selEnd.line() + newlines );
    00403   }
    00404
    00405
    00406   // adjust selection endcursor if needed
    00407   if( s.flags.selected && s.cursor.line() == s.selEnd.line() )
    00408   {
    00409     s.selEnd.setCol(s.selEnd.col() + replaceWith.length() - s.matchedLength );
    00410   }
    00411
    00412   // adjust wrap cursor if needed
    00413   if( s.cursor.line() == s.wrappedEnd.line() && s.cursor.col() <= s.wrappedEnd.col())
    00414   {
    00415     s.wrappedEnd.setCol(s.wrappedEnd.col() + replaceWith.length() - s.matchedLength );
    00416   }
    00417
    00418   if( !s.flags.backward ) {
    00419     s.cursor.setCol(s.cursor.col() + replaceWith.length());
    00420   } else if( s.cursor.col() > 0 ) {
    00421     s.cursor.setCol(s.cursor.col() - 1);
    00422   } else {
    00423     s.cursor.setLine(s.cursor.line() - 1);
    00424     if( s.cursor.line() >= 0 ) {
    00425       s.cursor.setCol(doc()->lineLength( s.cursor.line() ));
    00426     }
    00427   }
    00428 }
    00429
    00430 void KateSearch::skipOne()
    00431 {
    00432   if( !s.flags.backward ) {
    00433     s.cursor.setCol(s.cursor.col() + s.matchedLength);
    00434   } else if( s.cursor.col() > 0 ) {
    00435     s.cursor.setCol(s.cursor.col() - 1);
    00436   } else {
    00437     s.cursor.setLine(s.cursor.line() - 1);
    00438     if( s.cursor.line() >= 0 ) {
    00439       s.cursor.setCol(doc()->lineLength(s.cursor.line()));
    00440     }
    00441   }
    00442 }
    00443
    00444 void KateSearch::replaceSlot() {
    00445   switch( (Dialog_results)replacePrompt->result() ) {
    00446   case srCancel: replacePrompt->hide();                break;
    00447   case srAll:    replacePrompt->hide(); replaceAll();  break;
    00448   case srYes:    replaceOne(); promptReplace();        break;
    00449   case srLast:   replacePrompt->hide(), replaceOne();  break;
    00450   case srNo:     skipOne();    promptReplace();        break;
    00451   }
    00452 }
    00453
    00454 bool KateSearch::askContinue()
    00455 {
    00456   QString made =
    00457      i18n( "%n replacement made.",
    00458            "%n replacements made.",
    00459            replaces );
    00460
    00461   QString reached = !s.flags.backward ?
    00462      i18n( "End of document reached." ) :
    00463      i18n( "Beginning of document reached." );
    00464
    00465   if (KateViewConfig::global()->searchFlags() & KFindDialog::SelectedText)
    00466   {
    00467     reached = !s.flags.backward ?
    00468      i18n( "End of selection reached." ) :
    00469      i18n( "Beginning of selection reached." );
    00470   }
    00471
    00472   QString question = !s.flags.backward ?
    00473      i18n( "Continue from the beginning?" ) :
    00474      i18n( "Continue from the end?" );
    00475
    00476   QString text = s.flags.replace ?
    00477      made + "\n" + reached + "\n" + question :
    00478      reached + "\n" + question;
    00479
    00480   return KMessageBox::Yes == KMessageBox::questionYesNo(
    00481      view(), text, s.flags.replace ? i18n("Replace") : i18n("Find"),
    00482      KStdGuiItem::cont(), i18n("&Stop") );
    00483 }
    00484
    00485 QString KateSearch::getSearchText()
    00486 {
    00487   // SelectionOnly: use selection
    00488   // WordOnly: use word under cursor
    00489   // SelectionWord: use selection if available, else use word under cursor
    00490   // WordSelection: use word if available, else use selection
    00491   QString str;
    00492
    00493   int getFrom = view()->config()->textToSearchMode();
    00494   switch (getFrom)
    00495   {
    00496   case KateViewConfig::SelectionOnly: // (Windows)
    00497     //kdDebug() << "getSearchText(): SelectionOnly" << endl;
    00498     if( doc()->hasSelection() )
    00499       str = doc()->selection();
    00500     break;
    00501
    00502   case KateViewConfig::SelectionWord: // (classic Kate behavior)
    00503     //kdDebug() << "getSearchText(): SelectionWord" << endl;
    00504     if( doc()->hasSelection() )
    00505       str = doc()->selection();
    00506     else
    00507       str = view()->currentWord();
    00508     break;
    00509
    00510   case KateViewConfig::WordOnly: // (weird?)
    00511     //kdDebug() << "getSearchText(): WordOnly" << endl;
    00512     str = view()->currentWord();
    00513     break;
    00514
    00515   case KateViewConfig::WordSelection: // (persistent selection lover)
    00516     //kdDebug() << "getSearchText(): WordSelection" << endl;
    00517     str = view()->currentWord();
    00518     if (str.isEmpty() && doc()->hasSelection() )
    00519       str = doc()->selection();
    00520     break;
    00521
    00522   default: // (nowhere)
    00523     //kdDebug() << "getSearchText(): Nowhere" << endl;
    00524     break;
    00525   }
    00526
    00527   str.replace( QRegExp("^\\n"), "" );
    00528   str.replace( QRegExp("\\n.*"), "" );
    00529
    00530   return str;
    00531 }
    00532
    00533 KateTextCursor KateSearch::getCursor()
    00534 {
    00535   return KateTextCursor(view()->cursorLine(), view()->cursorColumnReal());
    00536 }
    00537
    00538 bool KateSearch::doSearch( const QString& text )
    00539 {
    00540 /*
    00541   rodda: Still Working on this... :)
    00542
    00543   bool result = false;
    00544
    00545   if (m_searchResults.count()) {
    00546     m_resultIndex++;
    00547     if (m_resultIndex < (int)m_searchResults.count()) {
    00548       s = m_searchResults[m_resultIndex];
    00549       result = true;
    00550     }
    00551
    00552   } else {
    00553     int temp = 0;
    00554     do {*/
    00555
    00556 #if 0
    00557   static int oldLine = -1;
    00558   static int oldCol = -1;
    00559 #endif
    00560
    00561   uint line = s.cursor.line();
    00562   uint col = s.cursor.col();// + (result ? s.matchedLength : 0);
    00563   bool backward = s.flags.backward;
    00564   bool caseSensitive = s.flags.caseSensitive;
    00565   bool regExp = s.flags.regExp;
    00566   bool wholeWords = s.flags.wholeWords;
    00567   uint foundLine, foundCol, matchLen;
    00568   bool found = false;
    00569   //kdDebug() << "Searching at " << line << ", " << col << endl;
    00570 //   kdDebug()<<"KateSearch::doSearch: "<<line<<", "<<col<<", "<<backward<<endl;
    00571
    00572   do {
    00573       if( regExp ) {
    00574         m_re = QRegExp( text, caseSensitive );
    00575         found = doc()->searchText( line, col, m_re,
    00576                                   &foundLine, &foundCol,
    00577                                   &matchLen, backward );
    00578       } else if ( wholeWords ) {
    00579         QRegExp re( "\\b" + text + "\\b", caseSensitive );
    00580         found = doc()->searchText( line, col, re,
    00581                                   &foundLine, &foundCol,
    00582                                   &matchLen, backward );
    00583       } else {
    00584         found = doc()->searchText( line, col, text,
    00585                                   &foundLine, &foundCol,
    00586                                   &matchLen, caseSensitive, backward );
    00587       }
    00588
    00589     if ( found && s.flags.selected )
    00590     {
    00591       if ( !s.flags.backward && KateTextCursor( foundLine, foundCol ) >= s.selEnd
    00592         ||  s.flags.backward && KateTextCursor( foundLine, foundCol ) < s.selBegin )
    00593         found = false;
    00594       else if (m_doc->blockSelectionMode())
    00595       {
    00596         if ((int)foundCol < s.selEnd.col() && (int)foundCol >= s.selBegin.col())
    00597           break;
    00598       }
    00599     }
    00600
    00601     line = foundLine;
    00602     col = foundCol+1;
    00603   }
    00604   while (m_doc->blockSelectionMode() && found);
    00605
    00606   if( !found ) return false;
    00607
    00608   // save the search result
    00609   s.cursor.setPos(foundLine, foundCol);
    00610   s.matchedLength = matchLen;
    00611
    00612   // we allready wrapped around one time
    00613   if (s.wrapped)
    00614   {
    00615     if (s.flags.backward)
    00616     {
    00617       if ( (s.cursor.line() < s.wrappedEnd.line())
    00618            || ( (s.cursor.line() == s.wrappedEnd.line()) && ((s.cursor.col()+matchLen) <= uint(s.wrappedEnd.col())) ) )
    00619         return false;
    00620     }
    00621     else
    00622     {
    00623       if ( (s.cursor.line() > s.wrappedEnd.line())
    00624            || ( (s.cursor.line() == s.wrappedEnd.line()) && (s.cursor.col() > s.wrappedEnd.col()) ) )
    00625         return false;
    00626     }
    00627   }
    00628
    00629 //   kdDebug() << "Found at " << s.cursor.line() << ", " << s.cursor.col() << endl;
    00630
    00631
    00632   //m_searchResults.append(s);
    00633
    00634   if (arbitraryHLExample)  {
    00635     KateArbitraryHighlightRange* hl = new KateArbitraryHighlightRange(new KateSuperCursor(m_doc, true, s.cursor), new KateSuperCursor(m_doc, true, s.cursor.line(), s.cursor.col() + s.matchedLength), this);
    00636     hl->setBold();
    00637     hl->setTextColor(Qt::white);
    00638     hl->setBGColor(Qt::black);
    00639     // destroy the highlight upon change
    00640     connect(hl, SIGNAL(contentsChanged()), hl, SIGNAL(eliminated()));
    00641     m_arbitraryHLList->append(hl);
    00642   }
    00643
    00644   return true;
    00645
    00646     /* rodda: more of my search highlighting work
    00647
    00648     } while (++temp < 100);
    00649
    00650     if (result) {
    00651       s = m_searchResults.first();
    00652       m_resultIndex = 0;
    00653     }
    00654   }
    00655
    00656   return result;*/
    00657 }
    00658
    00659 void KateSearch::exposeFound( KateTextCursor &cursor, int slen )
    00660 {
    00661   view()->setCursorPositionInternal ( cursor.line(), cursor.col() + slen, 1 );
    00662   doc()->setSelection( cursor.line(), cursor.col(), cursor.line(), cursor.col() + slen );
    00663 }
    00664 //END KateSearch
    00665
    00666 //BEGIN KateReplacePrompt
    00667 // this dialog is not modal
    00668 KateReplacePrompt::KateReplacePrompt ( QWidget *parent )
    00669   : KDialogBase ( parent, 0L, false, i18n( "Replace Confirmation" ),
    00670                   User3 | User2 | User1 | Close | Ok , Ok, true,
    00671                   i18n("Replace &All"), i18n("Re&place && Close"), i18n("&Replace") )
    00672 {
    00673   setButtonOK( i18n("&Find Next") );
    00674   QWidget *page = new QWidget(this);
    00675   setMainWidget(page);
    00676
    00677   QBoxLayout *topLayout = new QVBoxLayout( page, 0, spacingHint() );
    00678   QLabel *label = new QLabel(i18n("Found an occurrence of your search term. What do you want to do?"),page);
    00679   topLayout->addWidget(label );
    00680 }
    00681
    00682 void KateReplacePrompt::slotOk ()
    00683 { // Search Next
    00684   done(KateSearch::srNo);
    00685 }
    00686
    00687 void KateReplacePrompt::slotClose ()
    00688 { // Close
    00689   done(KateSearch::srCancel);
    00690 }
    00691
    00692 void KateReplacePrompt::slotUser1 ()
    00693 { // Replace All
    00694   done(KateSearch::srAll);
    00695 }
    00696
    00697 void KateReplacePrompt::slotUser2 ()
    00698 { // Replace & Close
    00699   done(KateSearch::srLast);
    00700 }
    00701
    00702 void KateReplacePrompt::slotUser3 ()
    00703 { // Replace
    00704   done(KateSearch::srYes);
    00705 }
    00706
    00707 void KateReplacePrompt::done (int result)
    00708 {
    00709   setResult(result);
    00710
    00711   emit clicked();
    00712 }
    00713 //END KateReplacePrompt
    00714
    00715 //BEGIN SearchCommand
    00716 bool SearchCommand::exec(class Kate::View *view, const QString &cmd, QString &msg)
    00717 {
    00718   QString flags, pattern, replacement;
    00719   if ( cmd.startsWith( "find" ) )
    00720   {
    00721
    00722     static QRegExp re_find("find(?::([bcersw]*))?\\s+(.+)");
    00723     if ( re_find.search( cmd ) < 0 )
    00724     {
    00725       msg = i18n("Usage: find[:[bcersw]] PATTERN");
    00726       return false;
    00727     }
    00728     flags = re_find.cap( 1 );
    00729     pattern = re_find.cap( 2 );
    00730   }
    00731
    00732   else if ( cmd.startsWith( "ifind" ) )
    00733   {
    00734     static QRegExp re_ifind("ifind(?::([bcrs]*))?\\s+(.*)");
    00735     if ( re_ifind.search( cmd ) < 0 )
    00736     {
    00737       msg = i18n("Usage: ifind[:[bcrs]] PATTERN");
    00738       return false;
    00739     }
    00740     ifindClear();
    00741     return true;
    00742   }
    00743
    00744   else if ( cmd.startsWith( "replace" ) )
    00745   {
    00746     // Try if the pattern and replacement is quoted, using a quote character ["']
    00747     static QRegExp re_rep("replace(?::([bceprsw]*))?\\s+([\"'])((?:[^\\\\\\\\2]|\\\\.)*)\\2\\s+\\2((?:[^\\\\\\\\2]|\\\\.)*)\\2\\s*$");
    00748     // Or one quoted argument
    00749     QRegExp re_rep1("replace(?::([bceprsw]*))?\\s+([\"'])((?:[^\\\\\\\\2]|\\\\.)*)\\2\\s*$");
    00750     // Else, it's just one or two (space separated) words
    00751     QRegExp re_rep2("replace(?::([bceprsw]*))?\\s+(\\S+)(.*)");
    00752 #define unbackslash(s) p=0;\
    00753 while ( (p = pattern.find( '\\' + delim, p )) > -1 )\
    00754 {\
    00755   if ( !p || pattern[p-1] != '\\' )\
    00756     pattern.remove( p, 1 );\
    00757   p++;\
    00758 }
    00759
    00760     if ( re_rep.search( cmd ) >= 0 )
    00761     {
    00762       flags = re_rep.cap(1);
    00763       pattern = re_rep.cap( 3 );
    00764       replacement = re_rep.cap( 4 );
    00765
    00766       int p(0);
    00767       // unbackslash backslashed delimiter strings
    00768       // in pattern ..
    00769       QString delim = re_rep.cap( 2 );
    00770       unbackslash(pattern);
    00771       // .. and in replacement
    00772       unbackslash(replacement);
    00773     }
    00774     else if ( re_rep1.search( cmd ) >= 0 )
    00775     {
    00776       flags = re_rep1.cap(1);
    00777       pattern = re_rep1.cap( 3 );
    00778
    00779       int p(0);
    00780       QString delim = re_rep1.cap( 2 );
    00781       unbackslash(pattern);
    00782     }
    00783     else if ( re_rep2.search( cmd ) >= 0 )
    00784     {
    00785       flags = re_rep2.cap( 1 );
    00786       pattern = re_rep2.cap( 2 );
    00787       replacement = re_rep2.cap( 3 ).stripWhiteSpace();
    00788     }
    00789     else
    00790     {
    00791       msg = i18n("Usage: replace[:[bceprsw]] PATTERN [REPLACEMENT]");
    00792       return false;
    00793     }
    00794     kdDebug()<<"replace '"<<pattern<<"' with '"<<replacement<<"'"<<endl;
    00795 #undef unbackslash
    00796   }
    00797
    00798   long f = 0;
    00799   if ( flags.contains( 'b' ) ) f |= KFindDialog::FindBackwards;
    00800   if ( flags.contains( 'c' ) ) f |= KFindDialog::FromCursor;
    00801   if ( flags.contains( 'e' ) ) f |= KFindDialog::SelectedText;
    00802   if ( flags.contains( 'r' ) ) f |= KFindDialog::RegularExpression;
    00803   if ( flags.contains( 'p' ) ) f |= KReplaceDialog::PromptOnReplace;
    00804   if ( flags.contains( 's' ) ) f |= KFindDialog::CaseSensitive;
    00805   if ( flags.contains( 'w' ) ) f |= KFindDialog::WholeWordsOnly;
    00806
    00807   if ( cmd.startsWith( "find" ) )
    00808   {
    00809     ((KateView*)view)->find( pattern, f );
    00810     return true;
    00811   }
    00812   else if ( cmd.startsWith( "replace" ) )
    00813   {
    00814     f |= KReplaceDialog::BackReference; // mandatory here?
    00815     ((KateView*)view)->replace( pattern, replacement, f );
    00816     return true;
    00817   }
    00818
    00819   return false;
    00820 }
    00821
    00822 bool SearchCommand::help(class Kate::View *, const QString &cmd, QString &msg)
    00823 {
    00824   if ( cmd == "find" )
    00825     msg = i18n("<p>Usage: <code>find[:bcersw] PATTERN</code></p>");
    00826
    00827   else if ( cmd == "ifind" )
    00828     msg = i18n("<p>Usage: <code>ifind:[:bcrs] PATTERN</code>"
    00829         "<br>ifind does incremental or 'as-you-type' search</p>");
    00830
    00831   else
    00832     msg = i18n("<p>Usage: <code>replace[:bceprsw] PATTERN REPLACEMENT</code></p>");
    00833
    00834   msg += i18n(
    00835       "<h4><caption>Options</h4><p>"
    00836       "<b>b</b> - Search backward"
    00837       "<br><b>c</b> - Search from cursor"
    00838       "<br><b>r</b> - Pattern is a regular expression"
    00839       "<br><b>s</b> - Case sensitive search"
    00840              );
    00841
    00842   if ( cmd == "find" )
    00843     msg += i18n(
    00844         "<br><b>e</b> - Search in selected text only"
    00845         "<br><b>w</b> - Search whole words only"
    00846                );
    00847
    00848   if ( cmd == "replace" )
    00849     msg += i18n(
    00850         "<br><b>p</b> - Prompt for replace</p>"
    00851         "<p>If REPLACEMENT is not present, an empty string is used.</p>"
    00852         "<p>If you want to have whitespace in your PATTERN, you need to "
    00853         "quote both PATTERN and REPLACEMENT with either single or double "
    00854         "quotes. To have the quote characters in the strings, prepend them "
    00855         "with a backslash.");
    00856
    00857   msg += "</p>";
    00858   return true;
    00859 }
    00860
    00861 QStringList SearchCommand::cmds()
    00862 {
    00863   QStringList l;
    00864   l << "find" << "replace" << "ifind";
    00865   return l;
    00866 }
    00867
    00868 bool SearchCommand::wantsToProcessText( const QString &cmdname )
    00869 {
    00870   return  cmdname == "ifind";
    00871 }
    00872
    00873 void SearchCommand::processText( Kate::View *view, const QString &cmd )
    00874 {
    00875   static QRegExp re_ifind("ifind(?::([bcrs]*))?\\s(.*)");
    00876   if ( re_ifind.search( cmd ) > -1 )
    00877   {
    00878     QString flags = re_ifind.cap( 1 );
    00879     QString pattern = re_ifind.cap( 2 );
    00880
    00881
    00882     // if there is no setup, or the text length is 0, set up the properties
    00883     if ( ! m_ifindFlags || pattern.isEmpty() )
    00884       ifindInit( flags );
    00885     // if there is no fromCursor, add it if this is not the first character
    00886     else if ( ! ( m_ifindFlags & KFindDialog::FromCursor ) && ! pattern.isEmpty() )
    00887       m_ifindFlags |= KFindDialog::FromCursor;
    00888
    00889     // search..
    00890     if ( ! pattern.isEmpty() )
    00891     {
    00892       KateView *v = (KateView*)view;
    00893
    00894       // If it *looks like* we are continuing, place the cursor
    00895       // at the beginning of the selection, so that the search continues.
    00896       // ### check more carefully, like is  the cursor currently at the end
    00897       // of the selection.
    00898       if ( pattern.startsWith( v->getDoc()->selection() ) &&
    00899            v->getDoc()->selection().length() + 1 == pattern.length() )
    00900         v->setCursorPositionInternal( v->getDoc()->selStartLine(), v->getDoc()->selStartCol() );
    00901
    00902       v->find( pattern, m_ifindFlags, false );
    00903     }
    00904   }
    00905 }
    00906
    00907 void SearchCommand::ifindInit( const QString &flags )
    00908 {
    00909   long f = 0;
    00910   if ( flags.contains( 'b' ) ) f |= KFindDialog::FindBackwards;
    00911   if ( flags.contains( 'c' ) ) f |= KFindDialog::FromCursor;
    00912   if ( flags.contains( 'r' ) ) f |= KFindDialog::RegularExpression;
    00913   if ( flags.contains( 's' ) ) f |= KFindDialog::CaseSensitive;
    00914   m_ifindFlags = f;
    00915 }
    00916
    00917 void SearchCommand::ifindClear()
    00918 {
    00919   m_ifindFlags = 0;
    00920 }
    00921 //END SearchCommand
    00922
    00923 // kate: space-indent on; indent-width 2; replace-tabs on;

This file is part of the documentation for kate Library Version 3.4.1.
Documentation copyright © 1996-2004 the KDE developers.
Generated on Sat Jun 11 20:36:38 2005 by doxygen 1.4.1 written by Dimitri van Heesch, © 1997-2003