X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Flyxfind.C;h=932cbec30e0a31df48b9cd37ab980a076802070f;hb=8765ab59cdddad67284007813ef25934ea0042ce;hp=70e9b64e8a607dfe67b5a0de3da22618ea170185;hpb=84b462dd370fc1d9c7ebe218917a02c234e676d8;p=lyx.git diff --git a/src/lyxfind.C b/src/lyxfind.C index 70e9b64e8a..932cbec30e 100644 --- a/src/lyxfind.C +++ b/src/lyxfind.C @@ -16,190 +16,196 @@ #include "lyxfind.h" #include "buffer.h" +#include "cursor.h" +#include "CutAndPaste.h" +#include "buffer_funcs.h" #include "BufferView.h" #include "debug.h" -#include "iterators.h" +#include "funcrequest.h" #include "gettext.h" #include "lyxtext.h" #include "paragraph.h" -#include "PosIterator.h" +#include "pariterator.h" #include "undo.h" #include "frontends/Alert.h" -#include "insets/insettext.h" +#include "support/convert.h" +#include "support/docstream.h" -#include "support/textutils.h" - -using lyx::support::lowercase; -using lyx::support::uppercase; -using bv_funcs::put_selection_at; +namespace lyx { -using std::string; +using support::lowercase; +using support::uppercase; +using support::split; +using std::advance; -namespace lyx { -namespace find { namespace { -class MatchString +bool parse_bool(docstring & howto) +{ + if (howto.empty()) + return false; + docstring var; + howto = split(howto, var, ' '); + return (var == "1"); +} + + +class MatchString : public std::binary_function { public: - MatchString(string const & str, bool cs, bool mw) - : str(str), cs(cs), mw(mw) {}; -// returns true if the specified string is at the specified position + MatchString(docstring const & str, bool cs, bool mw) + : str(str), cs(cs), mw(mw) + {} + + // returns true if the specified string is at the specified position bool operator()(Paragraph const & par, pos_type pos) const - { - string::size_type size = str.length(); + { + docstring::size_type const size = str.length(); pos_type i = 0; pos_type const parsize = par.size(); - while ((pos + i < parsize) - && (string::size_type(i) < size) - && (cs ? (str[i] == par.getChar(pos + i)) - : (uppercase(str[i]) == uppercase(par.getChar(pos + i))))) { - ++i; + for (i = 0; pos + i < parsize; ++i) { + if (docstring::size_type(i) >= size) + break; + if (cs && str[i] != par.getChar(pos + i)) + break; + if (!cs && uppercase(str[i]) != uppercase(par.getChar(pos + i))) + break; } - if (size == string::size_type(i)) { - // if necessary, check whether string matches word - if (!mw) - return true; - if ((pos <= 0 || !IsLetterCharOrDigit(par.getChar(pos - 1))) - && (pos + pos_type(size) >= parsize - || !IsLetterCharOrDigit(par.getChar(pos + size)))) { - return true; - } + + if (size != docstring::size_type(i)) + return false; + + // if necessary, check whether string matches word + if (mw) { + if (pos > 0 && par.isLetter(pos - 1)) + return false; + if (pos + pos_type(size) < parsize + && par.isLetter(pos + size)) + return false; } - return false; + + return true; } - + private: - string str; + // search string + docstring str; + // case sensitive bool cs; + // match whole words only bool mw; }; -bool findForward(PosIterator & cur, PosIterator const & end, - MatchString const & match) +bool findForward(DocIterator & cur, MatchString const & match) { - for (; cur != end; ++cur) { - if (match(*cur.pit(), cur.pos())) + for (; cur; cur.forwardChar()) + if (cur.inTexted() && match(cur.paragraph(), cur.pos())) return true; - } return false; } -bool findBackwards(PosIterator & cur, PosIterator const & beg, - MatchString const & match) +bool findBackwards(DocIterator & cur, MatchString const & match) { - while (beg != cur) { - --cur; - if (match(*cur.pit(), cur.pos())) + while (cur) { + cur.backwardChar(); + if (cur.inTexted() && match(cur.paragraph(), cur.pos())) return true; } return false; } -bool findChange(PosIterator & cur, PosIterator const & end) +bool findChange(DocIterator & cur) { - for (; cur != end; ++cur) { - if ((!cur.pit()->size() || !cur.at_end()) - && cur.pit()->lookupChange(cur.pos()) != Change::UNCHANGED) + for (; cur; cur.forwardPos()) + if (cur.inTexted() && !cur.paragraph().isUnchanged(cur.pos())) return true; - } return false; } -bool searchAllowed(BufferView * bv, string const & str) +bool searchAllowed(BufferView * bv, docstring const & str) { if (str.empty()) { - Alert::error(_("Search error"), _("Search string is empty")); + frontend::Alert::error(_("Search error"), + _("Search string is empty")); return false; } - return bv->available(); + return bv->buffer(); } -} // namespace anon - - -bool find(BufferView * bv, string const & searchstr, - bool cs, bool mw, bool fw) +bool find(BufferView * bv, docstring const & searchstr, bool cs, bool mw, bool fw) { if (!searchAllowed(bv, searchstr)) return false; - PosIterator cur = PosIterator(*bv); + DocIterator cur = bv->cursor(); MatchString const match(searchstr, cs, mw); - PosIterator const end = bv->buffer()->pos_iterator_end(); - PosIterator const beg = bv->buffer()->pos_iterator_begin(); - - bool found = fw ? findForward(cur, end, match) - : findBackwards(cur, beg, match); + bool found = fw ? findForward(cur, match) : findBackwards(cur, match); if (found) - put_selection_at(bv, cur, searchstr.length(), !fw); + bv->putSelectionAt(cur, searchstr.length(), !fw); return found; } int replaceAll(BufferView * bv, - string const & searchstr, string const & replacestr, + docstring const & searchstr, docstring const & replacestr, bool cs, bool mw) { Buffer & buf = *bv->buffer(); if (!searchAllowed(bv, searchstr) || buf.isReadonly()) return 0; - - recordUndo(Undo::ATOMIC, bv->text(), 0, buf.paragraphs().size() - 1); - - PosIterator cur = buf.pos_iterator_begin(); - PosIterator const end = buf.pos_iterator_end(); + + recordUndoFullDocument(bv); + MatchString const match(searchstr, cs, mw); int num = 0; int const rsize = replacestr.size(); int const ssize = searchstr.size(); - while (findForward(cur, end, match)) { + DocIterator cur = doc_iterator_begin(buf.inset()); + while (findForward(cur, match)) { pos_type pos = cur.pos(); LyXFont const font - = cur.pit()->getFontSettings(buf.params(), pos); - int striked = ssize - cur.pit()->erase(pos, pos + ssize); - cur.pit()->insert(pos, replacestr, font); - advance(cur, rsize + striked); + = cur.paragraph().getFontSettings(buf.params(), pos); + int striked = ssize - cur.paragraph().eraseChars(pos, pos + ssize, + buf.params().trackChanges); + cur.paragraph().insert(pos, replacestr, font, + Change(buf.params().trackChanges ? + Change::INSERTED : Change::UNCHANGED)); + for (int i = 0; i < rsize + striked; ++i) + cur.forwardChar(); ++num; } - PosIterator beg = buf.pos_iterator_begin(); - bv->text()->init(bv); - put_selection_at(bv, beg, 0, false); + updateLabels(buf); + bv->putSelectionAt(doc_iterator_begin(buf.inset()), 0, false); if (num) buf.markDirty(); return num; } -namespace { - -bool stringSelected(BufferView * bv, - string const & searchstr, +bool stringSelected(BufferView * bv, docstring const & searchstr, bool cs, bool mw, bool fw) { - LyXText * text = bv->getLyXText(); // if nothing selected or selection does not equal search // string search and select next occurance and return - string const & str1 = searchstr; - string const str2 = text->selectionAsString(*bv->buffer(), - false); + docstring const & str1 = searchstr; + docstring const str2 = bv->cursor().selectionAsString(false); if ((cs && str1 != str2) || lowercase(str1) != lowercase(str2)) { find(bv, searchstr, cs, mw, fw); return false; @@ -208,12 +214,9 @@ bool stringSelected(BufferView * bv, return true; } -} //namespace anon - -int replace(BufferView * bv, - string const & searchstr, string const & replacestr, - bool cs, bool mw, bool fw) +int replace(BufferView * bv, docstring const & searchstr, + docstring const & replacestr, bool cs, bool mw, bool fw) { if (!searchAllowed(bv, searchstr) || bv->buffer()->isReadonly()) return 0; @@ -221,52 +224,149 @@ int replace(BufferView * bv, if (!stringSelected(bv, searchstr, cs, mw, fw)) return 0; - LyXText * text = bv->getLyXText(); - - text->replaceSelectionWithString(replacestr); - text->setSelectionRange(replacestr.length()); - text->cursor = fw ? text->selection.end : text->selection.start; - + LCursor & cur = bv->cursor(); + cap::replaceSelectionWithString(cur, replacestr, fw); bv->buffer()->markDirty(); find(bv, searchstr, cs, mw, fw); bv->update(); - + return 1; } +} // namespace anon + + +docstring const find2string(docstring const & search, + bool casesensitive, bool matchword, bool forward) +{ + odocstringstream ss; + ss << search << '\n' + << int(casesensitive) << ' ' + << int(matchword) << ' ' + << int(forward); + return ss.str(); +} + + +docstring const replace2string(docstring const & search, docstring const & replace, + bool casesensitive, bool matchword, + bool all, bool forward) +{ + odocstringstream ss; + ss << search << '\n' + << replace << '\n' + << int(casesensitive) << ' ' + << int(matchword) << ' ' + << int(all) << ' ' + << int(forward); + return ss.str(); +} + + +void find(BufferView * bv, FuncRequest const & ev) +{ + if (!bv || ev.action != LFUN_WORD_FIND) + return; + + //lyxerr << "find called, cmd: " << ev << std::endl; + + // data is of the form + // " + // " + docstring search; + docstring howto = split(ev.argument(), search, '\n'); + + bool casesensitive = parse_bool(howto); + bool matchword = parse_bool(howto); + bool forward = parse_bool(howto); + + bool const found = find(bv, search, + casesensitive, matchword, forward); + + if (!found) + // emit message signal. + bv->message(_("String not found!")); +} + + +void replace(BufferView * bv, FuncRequest const & ev) +{ + if (!bv || ev.action != LFUN_WORD_REPLACE) + return; + + // data is of the form + // " + // + // " + docstring search; + docstring rplc; + docstring howto = split(ev.argument(), search, '\n'); + howto = split(howto, rplc, '\n'); + + bool casesensitive = parse_bool(howto); + bool matchword = parse_bool(howto); + bool all = parse_bool(howto); + bool forward = parse_bool(howto); + + Buffer * buf = bv->buffer(); + + int const replace_count = all + ? replaceAll(bv, search, rplc, casesensitive, matchword) + : replace(bv, search, rplc, casesensitive, matchword, forward); + + if (replace_count == 0) { + // emit message signal. + buf->message(_("String not found!")); + } else { + if (replace_count == 1) { + // emit message signal. + buf->message(_("String has been replaced.")); + } else { + docstring str = convert(replace_count); + str += _(" strings have been replaced."); + // emit message signal. + buf->message(str); + } + } +} + bool findNextChange(BufferView * bv) { - if (!bv->available()) + if (!bv->buffer()) return false; - PosIterator cur = PosIterator(*bv); - PosIterator const endit = bv->buffer()->pos_iterator_end(); + DocIterator cur = bv->cursor(); - if (!findChange(cur, endit)) + if (!findChange(cur)) return false; - - ParagraphList::iterator pit = cur.pit(); - pos_type pos = cur.pos(); - - Change orig_change = pit->lookupChangeFull(pos); - pos_type parsize = pit->size(); - pos_type end = pos; - - for (; end != parsize; ++end) { - Change change = pit->lookupChangeFull(end); + + bv->cursor().setCursor(cur); + bv->cursor().resetAnchor(); + + Change orig_change = cur.paragraph().lookupChange(cur.pos()); + + DocIterator et = doc_iterator_end(cur.inset()); + DocIterator ok = cur; // see below + for (; cur != et; cur.forwardPosNoDescend()) { + ok = cur; + Change change = cur.paragraph().lookupChange(cur.pos()); if (change != orig_change) { - // slight UI optimisation: for replacements, we get - // text like : _old_new. Consider that as one change. - if (!(orig_change.type == Change::DELETED && - change.type == Change::INSERTED)) - break; + break; } } - pos_type length = end - pos; - put_selection_at(bv, cur, length, true); + + // avoid crash (assertion violation) if the imaginary end-of-par + // character of the last paragraph of the document is marked as changed + if (cur == et) { + cur = ok; + } + + // Now put cursor to end of selection: + bv->cursor().setCursor(cur); + bv->cursor().setSelection(); + return true; } -} // find namespace } // lyx namespace