X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Flyxfind.cpp;h=4c8846c5eb8c7c0db7b036d6f9de14503381e8ff;hb=fa8dae4201fc25da685a21de0f8968678df8f119;hp=97753fdb8da08c3950cacef33404d5d4f3cd0910;hpb=3fe55bccc4a79153b1fbdc1c4abb55b308942f5c;p=lyx.git diff --git a/src/lyxfind.cpp b/src/lyxfind.cpp index 97753fdb8d..4c8846c5eb 100644 --- a/src/lyxfind.cpp +++ b/src/lyxfind.cpp @@ -67,7 +67,7 @@ bool parse_bool(docstring & howto) } -class MatchString : public binary_function +class MatchString : public binary_function { public: MatchString(docstring const & str, bool cs, bool mw) @@ -76,7 +76,7 @@ public: // returns true if the specified string is at the specified position // del specifies whether deleted strings in ct mode will be considered - bool operator()(Paragraph const & par, pos_type pos, bool del = true) const + int operator()(Paragraph const & par, pos_type pos, bool del = true) const { return par.find(str, case_sens, whole_words, pos, del); } @@ -91,27 +91,31 @@ private: }; -bool findForward(DocIterator & cur, MatchString const & match, +int findForward(DocIterator & cur, MatchString const & match, bool find_del = true) { for (; cur; cur.forwardChar()) - if (cur.inTexted() && - match(cur.paragraph(), cur.pos(), find_del)) - return true; - return false; + if (cur.inTexted()) { + int len = match(cur.paragraph(), cur.pos(), find_del); + if (len > 0) + return len; + } + return 0; } -bool findBackwards(DocIterator & cur, MatchString const & match, +int findBackwards(DocIterator & cur, MatchString const & match, bool find_del = true) { while (cur) { cur.backwardChar(); - if (cur.inTexted() && - match(cur.paragraph(), cur.pos(), find_del)) - return true; + if (cur.inTexted()) { + int len = match(cur.paragraph(), cur.pos(), find_del); + if (len > 0) + return len; + } } - return false; + return 0; } @@ -152,13 +156,13 @@ bool findOne(BufferView * bv, docstring const & searchstr, MatchString const match(searchstr, case_sens, whole); - bool found = forward ? findForward(cur, match, find_del) : + int match_len = forward ? findForward(cur, match, find_del) : findBackwards(cur, match, find_del); - if (found) - bv->putSelectionAt(cur, searchstr.length(), !forward); + if (match_len > 0) + bv->putSelectionAt(cur, match_len, !forward); - return found; + return match_len > 0; } @@ -181,12 +185,13 @@ int replaceAll(BufferView * bv, Cursor cur(*bv); cur.setCursor(doc_iterator_begin(&buf)); - while (findForward(cur, match, false)) { + int match_len = findForward(cur, match, false); + while (match_len > 0) { // Backup current cursor position and font. pos_type const pos = cur.pos(); Font const font = cur.paragraph().getFontSettings(buf.params(), pos); cur.recordUndo(); - int striked = ssize - cur.paragraph().eraseChars(pos, pos + ssize, + int striked = ssize - cur.paragraph().eraseChars(pos, pos + match_len, buf.params().trackChanges); cur.paragraph().insert(pos, replacestr, font, Change(buf.params().trackChanges ? @@ -194,6 +199,7 @@ int replaceAll(BufferView * bv, for (int i = 0; i < rsize + striked; ++i) cur.forwardChar(); ++num; + match_len = findForward(cur, match, false); } bv->putSelectionAt(doc_iterator_begin(&buf), 0, false); @@ -207,48 +213,69 @@ int replaceAll(BufferView * bv, } -bool stringSelected(BufferView * bv, docstring & searchstr, - bool case_sens, bool whole, bool forward) +// the idea here is that we are going to replace the string that +// is selected IF it is the search string. +// if there is a selection, but it is not the search string, then +// we basically ignore it. (FIXME We ought to replace only within +// the selection.) +// if there is no selection, then: +// (i) if some search string has been provided, then we find it. +// (think of how the dialog works when you hit "replace" the +// first time.) +// (ii) if no search string has been provided, then we treat the +// word the cursor is in as the search string. (why? i have no +// idea.) but this only works in text? +// +// returns the number of replacements made (one, if any) and +// whether anything at all was done. +pair replaceOne(BufferView * bv, docstring searchstr, + docstring const & replacestr, bool case_sens, + bool whole, bool forward) { - // if nothing selected and searched string is empty, this - // means that we want to search current word at cursor position, - // but only if we are in texted() mode. - if (!bv->cursor().selection() && searchstr.empty() - && bv->cursor().inTexted()) { - bv->cursor().innerText()->selectWord(bv->cursor(), WHOLE_WORD); - searchstr = bv->cursor().selectionAsString(false); - return true; + Cursor & cur = bv->cursor(); + if (!cur.selection()) { + // no selection, non-empty search string: find it + if (!searchstr.empty()) { + findOne(bv, searchstr, case_sens, whole, forward); + return pair(true, 0); + } + // empty search string + if (!cur.inTexted()) + // bail in math + return pair(false, 0); + // select current word and treat it as the search string + cur.innerText()->selectWord(cur, WHOLE_WORD); + searchstr = cur.selectionAsString(false); } - - // if nothing selected or selection does not equal search string - // then search and select next occurence and return - docstring const str2 = bv->cursor().selectionAsString(false); - if ((case_sens && searchstr != str2) - || compare_no_case(searchstr, str2) != 0) { + + // if we still don't have a search string, report the error + // and abort. + if (!searchAllowed(searchstr)) + return pair(false, 0); + + bool have_selection = cur.selection(); + docstring const selected = cur.selectionAsString(false); + bool match = + case_sens ? searchstr == selected + : compare_no_case(searchstr, selected) == 0; + + // no selection or current selection is not search word: + // just find the search word + if (!have_selection || !match) { findOne(bv, searchstr, case_sens, whole, forward); - return false; + return pair(true, 0); } - return true; -} - - -int replaceOne(BufferView * bv, docstring & searchstr, - docstring const & replacestr, bool case_sens, - bool whole, bool forward) -{ - if (!stringSelected(bv, searchstr, case_sens, whole, forward)) - return 0; - - if (!searchAllowed(searchstr) || bv->buffer().isReadonly()) - return 0; + // we're now actually ready to replace. if the buffer is + // read-only, we can't, though. + if (bv->buffer().isReadonly()) + return pair(false, 0); - Cursor & cur = bv->cursor(); cap::replaceSelectionWithString(cur, replacestr, forward); bv->buffer().markDirty(); findOne(bv, searchstr, case_sens, whole, forward, false); - return 1; + return pair(true, 1); } } // namespace anon @@ -302,14 +329,12 @@ bool lyxfind(BufferView * bv, FuncRequest const & ev) } -bool lyxreplace(BufferView * bv, FuncRequest const & ev, bool has_deleted) +bool lyxreplace(BufferView * bv, + FuncRequest const & ev, bool has_deleted) { if (!bv || ev.action() != LFUN_WORD_REPLACE) return false; - // assume we didn't do anything - bool retval = false; - // data is of the form // " // @@ -324,24 +349,32 @@ bool lyxreplace(BufferView * bv, FuncRequest const & ev, bool has_deleted) bool all = parse_bool(howto); bool forward = parse_bool(howto); + int replace_count = 0; + bool update = false; + if (!has_deleted) { - int const replace_count = all - ? replaceAll(bv, search, rplc, casesensitive, matchword) - : replaceOne(bv, search, rplc, casesensitive, matchword, forward); + if (all) { + replace_count = replaceAll(bv, search, rplc, casesensitive, matchword); + update = replace_count > 0; + } else { + pair rv = + replaceOne(bv, search, rplc, casesensitive, matchword, forward); + update = rv.first; + replace_count = rv.second; + } Buffer const & buf = bv->buffer(); - if (replace_count == 0) { + if (!update) { // emit message signal. buf.message(_("String not found!")); } else { - retval = true; - if (replace_count == 1) { - // emit message signal. + if (replace_count == 0) { + buf.message(_("String found.")); + } else if (replace_count == 1) { buf.message(_("String has been replaced.")); } else { docstring const str = bformat(_("%1$d strings have been replaced."), replace_count); - // emit message signal. buf.message(str); } } @@ -349,11 +382,11 @@ bool lyxreplace(BufferView * bv, FuncRequest const & ev, bool has_deleted) // if we have deleted characters, we do not replace at all, but // rather search for the next occurence if (findOne(bv, search, casesensitive, matchword, forward)) - retval = true; + update = true; else bv->message(_("String not found!")); } - return retval; + return update; } @@ -739,15 +772,23 @@ int MatchStringAdv::findAux(DocIterator const & cur, int len, bool at_begin) con string str = normalize(docstr); LYXERR(Debug::FIND, "After normalization: '" << str << "'"); if (! opt.regexp) { + LYXERR(Debug::FIND, "Searching in normal mode: par_as_string='" << par_as_string << "', str='" << str << "'"); if (at_begin) { + LYXERR(Debug::FIND, "size=" << par_as_string.size() << ", substr='" << str.substr(0, par_as_string.size()) << "'"); if (str.substr(0, par_as_string.size()) == par_as_string) return par_as_string.size(); } else { - size_t pos = str.find(par_as_string); + string t = par_as_string; + while (regex_replace(t, t, "\\\\(emph|textbf|subsubsection|subsection|section|subparagraph|paragraph|part)\\{", "") + || regex_replace(t, t, "^\\$", "") + || regex_replace(t, t, "^\\\\\\[ ", "")) + LYXERR(Debug::FIND, " after removing leading $, \\[ , \\emph{, \\textbf{, etc.: " << t); + size_t pos = str.find(t); if (pos != string::npos) return par_as_string.size(); } } else { + LYXERR(Debug::FIND, "Searching in regexp mode"); // Try all possible regexp matches, //until one that verifies the braces match test is found regex const *p_regexp = at_begin ? ®exp : ®exp2; @@ -757,11 +798,11 @@ int MatchStringAdv::findAux(DocIterator const & cur, int len, bool at_begin) con match_results const & m = *re_it; // Check braces on the segment that matched the entire regexp expression, // plus the last subexpression, if a (.*?) was inserted in the constructor. - if (! braces_match(m[0].first, m[0].second, open_braces)) + if (!braces_match(m[0].first, m[0].second, open_braces)) return 0; // Check braces on segments that matched all (.*?) subexpressions. for (size_t i = 1; i < m.size(); ++i) - if (! braces_match(m[i].first, m[i].second)) + if (!braces_match(m[i].first, m[i].second)) return false; // Exclude from the returned match length any length // due to close wildcards added at end of regexp @@ -814,7 +855,7 @@ string MatchStringAdv::normalize(docstring const & s) const t.replace(pos, 1, " "); // Remove stale empty \emph{}, \textbf{} and similar blocks from latexify LYXERR(Debug::FIND, "Removing stale empty \\emph{}, \\textbf{}, \\*section{} macros from: " << t); - while (regex_replace(t, t, "\\\\(emph|textbf|subsubsection|subsection|section|subparagraph|paragraph)(\\{\\})+", "")) + while (regex_replace(t, t, "\\\\(emph|textbf|subsubsection|subsection|section|subparagraph|paragraph|part)(\\{\\})+", "")) LYXERR(Debug::FIND, " further removing stale empty \\emph{}, \\textbf{} macros from: " << t); return t; } @@ -1083,16 +1124,6 @@ FindAndReplaceOptions::FindAndReplaceOptions(docstring const & search, bool case namespace { -/** Checks if the supplied character is lower-case */ -static bool isLowerCase(char_type ch) { - return lowercase(ch) == ch; -} - - -/** Checks if the supplied character is upper-case */ -static bool isUpperCase(char_type ch) { - return uppercase(ch) == ch; -} /** Check if 'len' letters following cursor are all non-lowercase */ @@ -1203,6 +1234,7 @@ static void findAdvReplace(BufferView * bv, FindAndReplaceOptions const & opt, M bv->buffer().markDirty(); cur.pos() -= repl_buffer.paragraphs().begin()->size(); bv->putSelectionAt(DocIterator(cur), repl_buffer.paragraphs().begin()->size(), !opt.forward); + bv->processUpdateFlags(Update::Force); }