#include "Cursor.h"
#include "CutAndPaste.h"
#include "FuncRequest.h"
-#include "LyXFunc.h"
+#include "LyX.h"
#include "output_latex.h"
#include "OutputParams.h"
#include "Paragraph.h"
if (!searchAllowed(bv, searchstr) || buf.isReadonly())
return 0;
+ DocIterator cur_orig(bv->cursor());
+
MatchString const match(searchstr, cs, mw);
int num = 0;
++num;
}
- buf.updateLabels();
+ buf.updateBuffer();
bv->putSelectionAt(doc_iterator_begin(&buf), 0, false);
if (num)
buf.markDirty();
+
+ cur_orig.fixIfBroken();
+ bv->setCursor(cur_orig);
+
return num;
}
bool cs, bool mw, bool fw)
{
// if nothing selected and searched string is empty, this
- // means that we want to search current word at cursor position.
- if (!bv->cursor().selection() && searchstr.empty()) {
+ // 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;
bool find(BufferView * bv, FuncRequest const & ev)
{
- if (!bv || ev.action != LFUN_WORD_FIND)
+ if (!bv || ev.action() != LFUN_WORD_FIND)
return false;
//lyxerr << "find called, cmd: " << ev << endl;
void replace(BufferView * bv, FuncRequest const & ev, bool has_deleted)
{
- if (!bv || ev.action != LFUN_WORD_REPLACE)
+ if (!bv || ev.action() != LFUN_WORD_REPLACE)
return;
// data is of the form
if (bv->cursor().selection()) {
// set the cursor at the beginning or at the end of the selection
// before searching. Otherwise, the current change will be found.
- if (next != (bv->cursor().top() > bv->cursor().anchor()))
+ if (next != (bv->cursor().top() > bv->cursor().normalAnchor()))
bv->cursor().setCursorToAnchor();
}
if (next) {
for (; !tip.at_end(); tip.forwardPos()) {
Change change = tip.paragraph().lookupChange(tip.pos());
- if (change != orig_change)
+ if (!change.isSimilarTo(orig_change))
break;
}
} else {
for (; !tip.at_begin();) {
tip.backwardPos();
Change change = tip.paragraph().lookupChange(tip.pos());
- if (change != orig_change) {
+ if (!change.isSimilarTo(orig_change)) {
// take a step forward to correctly set the selection
tip.forwardPos();
break;
{
size_t pos = 0;
while (pos < s.size()) {
- size_t new_pos = s.find("\\regexp{", pos);
- if (new_pos == string::npos)
- new_pos = s.size();
- LYXERR(Debug::FIND, "new_pos: " << new_pos);
- string t = apply_escapes(s.substr(pos, new_pos - pos), get_lyx_unescapes());
- LYXERR(Debug::FIND, "t : " << t);
- t = apply_escapes(t, get_regexp_escapes());
- s.replace(pos, new_pos - pos, t);
- new_pos = pos + t.size();
- LYXERR(Debug::FIND, "Regexp after escaping: " << s);
- LYXERR(Debug::FIND, "new_pos: " << new_pos);
- if (new_pos == s.size())
- break;
- size_t end_pos = find_matching_brace(s, new_pos + 7);
- LYXERR(Debug::FIND, "end_pos: " << end_pos);
- t = apply_escapes(s.substr(new_pos + 8, end_pos - (new_pos + 8)), get_lyx_unescapes());
- LYXERR(Debug::FIND, "t : " << t);
- if (end_pos == s.size()) {
- s.replace(new_pos, end_pos - new_pos, t);
- pos = s.size();
- LYXERR(Debug::FIND, "Regexp after \\regexp{} removal: " << s);
- break;
- }
- s.replace(new_pos, end_pos + 1 - new_pos, t);
+ size_t new_pos = s.find("\\regexp{{{", pos);
+ if (new_pos == string::npos)
+ new_pos = s.size();
+ LYXERR(Debug::FIND, "new_pos: " << new_pos);
+ string t = apply_escapes(s.substr(pos, new_pos - pos), get_lyx_unescapes());
+ LYXERR(Debug::FIND, "t : " << t);
+ t = apply_escapes(t, get_regexp_escapes());
+ LYXERR(Debug::FIND, "t : " << t);
+ s.replace(pos, new_pos - pos, t);
+ new_pos = pos + t.size();
+ LYXERR(Debug::FIND, "Regexp after escaping: " << s);
+ LYXERR(Debug::FIND, "new_pos: " << new_pos);
+ if (new_pos == s.size())
+ break;
+ size_t end_pos = s.find("}}}", new_pos + 10); // find_matching_brace(s, new_pos + 7);
+ LYXERR(Debug::FIND, "end_pos: " << end_pos);
+ t = apply_escapes(s.substr(new_pos + 10, end_pos - (new_pos + 10)), get_lyx_unescapes());
+ LYXERR(Debug::FIND, "t : " << t);
+ if (end_pos == s.size()) {
+ s.replace(new_pos, end_pos - new_pos, t);
+ pos = s.size();
LYXERR(Debug::FIND, "Regexp after \\regexp{} removal: " << s);
- pos = new_pos + t.size();
- LYXERR(Debug::FIND, "pos: " << pos);
+ break;
+ }
+ s.replace(new_pos, end_pos + 3 - new_pos, t);
+ LYXERR(Debug::FIND, "Regexp after \\regexp{} removal: " << s);
+ pos = new_pos + t.size();
+ LYXERR(Debug::FIND, "pos: " << pos);
}
return s;
}
** Number of open braces that must remain open at the end for the verification to succeed.
**/
bool braces_match(string::const_iterator const & beg,
- string::const_iterator const & end, int unmatched = 0)
+ string::const_iterator const & end,
+ int unmatched = 0)
{
int open_pars = 0;
string::const_iterator it = beg;
break;
} while (true);
LYXERR(Debug::FIND, "Open braces: " << open_braces);
- LASSERT(braces_match(par_as_string.begin(), par_as_string.end(), open_braces), /* */);
LYXERR(Debug::FIND, "Built MatchStringAdv object: par_as_string = '" << par_as_string << "'");
} else {
par_as_string = escape_for_regex(par_as_string);
LYXERR(Debug::FIND, "par_as_string now is '" << par_as_string << "'");
LYXERR(Debug::FIND, "Open braces: " << open_braces);
LYXERR(Debug::FIND, "Close .*? : " << close_wildcards);
- LASSERT(braces_match(par_as_string.begin(), par_as_string.end(), open_braces), /* */);
LYXERR(Debug::FIND, "Replaced text (to be used as regex): " << par_as_string);
// If entered regexp must match at begin of searched string buffer
regexp = boost::regex(string("\\`") + par_as_string);
ParagraphList::const_iterator pit = cur.innerText()->paragraphs().begin();
for (int i = 0; i < cur.pit(); ++i)
++pit;
-// ParagraphList::const_iterator pit_end = pit;
-// ++pit_end;
-// lyx::latexParagraphs(buf, cur.innerText()->paragraphs(), ods, texrow, runparams, string(), pit, pit_end);
pos_type const endpos = (len == -1 || cur.pos() + len > int(pit->size()))
? pit->size() : cur.pos() + len;
TeXOnePar(buf, *cur.innerText(), pit, ods, texrow, runparams, string(),
for (MathData::const_iterator it = md.begin() + cs.pos(); it != it_end; ++it)
ods << *it;
- // MathData md = cur.cell();
- // MathData::const_iterator it_end = ( ( len == -1 || cur.pos() + len > int(md.size()) ) ? md.end() : md.begin() + cur.pos() + len );
- // for (MathData::const_iterator it = md.begin() + cur.pos(); it != it_end; ++it) {
- // MathAtom const & ma = *it;
- // ma.nucleus()->latex(buf, ods, runparams);
- // }
-
// Retrieve the math environment type, and add '$' or '$]'
// or others (\end{equation}) accordingly
for (int s = cur.depth() - 1; s >= 0; --s) {
// Compute the match length
int len = 1;
+ if (cur.pos() + len > cur.lastpos())
+ return 0;
LYXERR(Debug::FIND, "verifying unmatch with len = " << len);
while (cur.pos() + len <= cur.lastpos() && match(cur, len) == 0) {
++len;
void findMostBackwards(DocIterator & cur, MatchStringAdv const & match, int & len)
{
DocIterator cur_begin = doc_iterator_begin(cur.buffer());
- len = findAdvFinalize(cur, match);
- if (cur != cur_begin) {
- Inset & inset = cur.inset();
- int old_len;
- DocIterator old_cur;
- DocIterator dit2;
- do {
- old_cur = cur;
- old_len = len;
- cur.backwardPos();
- LYXERR(Debug::FIND, "findMostBackwards(): old_cur="
- << old_cur << ", old_len=" << len << ", cur=" << cur);
- dit2 = cur;
- } while (cur != cur_begin && &cur.inset() == &inset && match(cur)
- && (len = findAdvFinalize(dit2, match)) > old_len);
- cur = old_cur;
- len = old_len;
+ DocIterator tmp_cur = cur;
+ len = findAdvFinalize(tmp_cur, match);
+ Inset & inset = cur.inset();
+ for (; cur != cur_begin; cur.backwardPos()) {
+ LYXERR(Debug::FIND, "findMostBackwards(): cur=" << cur);
+ DocIterator new_cur = cur;
+ new_cur.backwardPos();
+ if (new_cur == cur || &new_cur.inset() != &inset || !match(new_cur))
+ break;
+ int new_len = findAdvFinalize(new_cur, match);
+ if (new_len == len)
+ break;
+ len = new_len;
}
- LYXERR(Debug::FIND, "findMostBackwards(): cur=" << cur);
+ LYXERR(Debug::FIND, "findMostBackwards(): exiting with cur=" << cur);
}
if (! cur)
return 0;
// Backup of original position
- DocIterator cur_orig(cur);
DocIterator cur_begin = doc_iterator_begin(cur.buffer());
if (cur == cur_begin)
return 0;
+ cur.backwardPos();
+ DocIterator cur_orig(cur);
bool found_match;
bool pit_changed = false;
found_match = false;
cur.pos() = cur_orig.pos();
LYXERR(Debug::FIND, "findBackAdv2: cur: " << cur);
DocIterator cur_prev_iter;
- while (true) {
+ do {
found_match = match(cur);
LYXERR(Debug::FIND, "findBackAdv3: found_match="
<< found_match << ", cur: " << cur);
if (found_match) {
int len;
findMostBackwards(cur, match, len);
- if (cur < cur_orig)
- return len;
+ return len;
}
- // Prevent infinite loop at begin of document
- if (cur == cur_begin || cur == cur_prev_iter)
+ // Stop if begin of document reached
+ if (cur == cur_begin)
break;
cur_prev_iter = cur;
cur.backwardPos();
- }
+ } while (true);
}
if (cur == cur_begin)
break;
}
+///
+static void findAdvReplace(BufferView * bv, FindAndReplaceOptions const & opt, MatchStringAdv & matchAdv)
+{
+ Cursor & cur = bv->cursor();
+ if (opt.replace == docstring(from_utf8(LYX_FR_NULL_STRING)))
+ return;
+ DocIterator sel_beg = cur.selectionBegin();
+ DocIterator sel_end = cur.selectionEnd();
+ if (&sel_beg.inset() != &sel_end.inset()
+ || sel_beg.pit() != sel_end.pit())
+ return;
+ int sel_len = sel_end.pos() - sel_beg.pos();
+ LYXERR(Debug::FIND, "sel_beg: " << sel_beg << ", sel_end: " << sel_end
+ << ", sel_len: " << sel_len << endl);
+ if (sel_len == 0)
+ return;
+ LASSERT(sel_len > 0, /**/);
+
+ if (!matchAdv(sel_beg, sel_len))
+ return;
+
+ string lyx = to_utf8(opt.replace);
+ // FIXME: Seems so stupid to me to rebuild a buffer here,
+ // when we already have one (replace_work_area_.buffer())
+ Buffer repl_buffer("", false);
+ repl_buffer.setUnnamed(true);
+ LASSERT(repl_buffer.readString(lyx), /**/);
+ repl_buffer.changeLanguage(
+ repl_buffer.language(),
+ cur.getFont().language());
+ if (opt.keep_case && sel_len >= 2) {
+ if (cur.inTexted()) {
+ if (firstUppercase(cur))
+ changeFirstCase(repl_buffer, text_uppercase, text_lowercase);
+ else if (allNonLowercase(cur, sel_len))
+ changeFirstCase(repl_buffer, text_uppercase, text_uppercase);
+ }
+ }
+ cap::cutSelection(cur, false, false);
+ if (!cur.inMathed()) {
+ LYXERR(Debug::FIND, "Replacing by pasteParagraphList()ing repl_buffer");
+ cap::pasteParagraphList(cur, repl_buffer.paragraphs(),
+ repl_buffer.params().documentClassPtr(),
+ bv->buffer().errorList("Paste"));
+ } else {
+ odocstringstream ods;
+ OutputParams runparams(&repl_buffer.params().encoding());
+ runparams.nice = false;
+ runparams.flavor = OutputParams::LATEX;
+ runparams.linelen = 8000; //lyxrc.plaintext_linelen;
+ runparams.dryrun = true;
+ TexRow texrow;
+ TeXOnePar(repl_buffer, repl_buffer.text(),
+ repl_buffer.paragraphs().begin(), ods, texrow, runparams);
+ //repl_buffer.getSourceCode(ods, 0, repl_buffer.paragraphs().size(), false);
+ docstring repl_latex = ods.str();
+ LYXERR(Debug::FIND, "Latexified replace_buffer: '" << repl_latex << "'");
+ string s;
+ regex_replace(to_utf8(repl_latex), s, "\\$(.*)\\$", "$1");
+ regex_replace(s, s, "\\\\\\[(.*)\\\\\\]", "$1");
+ repl_latex = from_utf8(s);
+ LYXERR(Debug::FIND, "Replacing by niceInsert()ing latex: '" << repl_latex << "'");
+ cur.niceInsert(repl_latex);
+ }
+ bv->buffer().markDirty();
+ cur.pos() -= repl_buffer.paragraphs().begin()->size();
+ bv->putSelectionAt(DocIterator(cur), repl_buffer.paragraphs().begin()->size(), !opt.forward);
+}
+
+
/// Perform a FindAdv operation.
bool findAdv(BufferView * bv, FindAndReplaceOptions const & opt)
{
- DocIterator cur = bv->cursor();
- int match_len = 0;
+ DocIterator cur;
+ int match_len;
if (opt.search.empty()) {
- bv->message(_("Search text is empty!"));
- return false;
+ bv->message(_("Search text is empty!"));
+ return false;
}
- MatchStringAdv matchAdv(bv->buffer(), opt);
try {
+ MatchStringAdv matchAdv(bv->buffer(), opt);
+ findAdvReplace(bv, opt, matchAdv);
+ cur = bv->cursor();
if (opt.forward)
match_len = findForwardAdv(cur, matchAdv);
else
return false;
}
- LYXERR(Debug::FIND, "Putting selection at buf=" << matchAdv.p_buf
- << "cur=" << cur << " with len: " << match_len);
+ bv->message(_("Match found!"));
- bv->putSelectionAt(cur, match_len, ! opt.forward);
- if (opt.replace == docstring(from_utf8(LYX_FR_NULL_STRING))) {
- bv->message(_("Match found!"));
- } else {
- string lyx = to_utf8(opt.replace);
- // FIXME: Seems so stupid to me to rebuild a buffer here,
- // when we already have one (replace_work_area_.buffer())
- Buffer repl_buffer("", false);
- repl_buffer.setUnnamed(true);
- if (repl_buffer.readString(lyx)) {
- if (opt.keep_case && match_len >= 2) {
- if (cur.inTexted()) {
- if (firstUppercase(cur))
- changeFirstCase(repl_buffer, text_uppercase, text_lowercase);
- else if (allNonLowercase(cur, match_len))
- changeFirstCase(repl_buffer, text_uppercase, text_uppercase);
- }
- }
- cap::cutSelection(bv->cursor(), false, false);
- if (! cur.inMathed()) {
- LYXERR(Debug::FIND, "Replacing by pasteParagraphList()ing repl_buffer");
- cap::pasteParagraphList(bv->cursor(), repl_buffer.paragraphs(),
- repl_buffer.params().documentClassPtr(),
- bv->buffer().errorList("Paste"));
- } else {
- odocstringstream ods;
- OutputParams runparams(&repl_buffer.params().encoding());
- runparams.nice = false;
- runparams.flavor = OutputParams::LATEX;
- runparams.linelen = 8000; //lyxrc.plaintext_linelen;
- runparams.dryrun = true;
- TexRow texrow;
- TeXOnePar(repl_buffer, repl_buffer.text(),
- repl_buffer.paragraphs().begin(), ods, texrow, runparams);
- //repl_buffer.getSourceCode(ods, 0, repl_buffer.paragraphs().size(), false);
- docstring repl_latex = ods.str();
- LYXERR(Debug::FIND, "Latexified replace_buffer: '" << repl_latex << "'");
- string s;
- regex_replace(to_utf8(repl_latex), s, "\\$(.*)\\$", "$1");
- regex_replace(s, s, "\\\\\\[(.*)\\\\\\]", "$1");
- repl_latex = from_utf8(s);
- LYXERR(Debug::FIND, "Replacing by niceInsert()ing latex: '" << repl_latex << "'");
- bv->cursor().niceInsert(repl_latex);
- }
- bv->putSelectionAt(cur, repl_buffer.paragraphs().begin()->size(), ! opt.forward);
- bv->message(_("Match found and replaced !"));
- } else
- LASSERT(false, /**/);
- }
+ LYXERR(Debug::FIND, "Putting selection at cur=" << cur << " with len: " << match_len);
+ bv->putSelectionAt(cur, match_len, !opt.forward);
return true;
}