X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;ds=sidebyside;f=src%2FCursor.cpp;h=b20e981b32c506cab09c2e7cc34e1989bc0a55b9;hb=ab8a290040dc28f39ebb230ab4b8a43467df0906;hp=3edf97065d34c4965be9b023a66cd07f503a36cb;hpb=2b9e44cb0110201ca4d6320266e6550160ee99b3;p=lyx.git diff --git a/src/Cursor.cpp b/src/Cursor.cpp index 3edf97065d..b20e981b32 100644 --- a/src/Cursor.cpp +++ b/src/Cursor.cpp @@ -26,7 +26,8 @@ #include "FuncCode.h" #include "FuncRequest.h" #include "Language.h" -#include "LyXFunc.h" // only for setMessage() +#include "Layout.h" +#include "LyXAction.h" #include "LyXRC.h" #include "Paragraph.h" #include "ParIterator.h" @@ -49,11 +50,12 @@ #include "mathed/MathData.h" #include "mathed/MathMacro.h" -#include +#include "support/bind.h" #include #include #include +#include using namespace std; @@ -93,20 +95,18 @@ DocIterator bruteFind2(Cursor const & c, int x, int y) int xo; int yo; Inset const * inset = &it.inset(); - map const & data = - c.bv().coordCache().getInsets().getData(); - map::const_iterator I = data.find(inset); + CoordCache const & cache = c.bv().coordCache(); // FIXME: in the case where the inset is not in the cache, this // means that no part of it is visible on screen. In this case // we don't do elaborate search and we just return the forwarded // DocIterator at its beginning. - if (I == data.end()) { + if (!cache.getInsets().has(inset)) { it.top().pos() = 0; return it; } - Point o = I->second.pos; + Point const o = cache.getInsets().xy(inset); inset->cursorPos(c.bv(), it.top(), c.boundary(), xo, yo); // Convert to absolute xo += o.x_; @@ -152,7 +152,7 @@ bool bruteFind(Cursor & cursor, else ++et.pit(); - double best_dist = numeric_limits::max();; + double best_dist = numeric_limits::max(); DocIterator best_cursor = et; for ( ; it != et; it.forwardPos(true)) { @@ -214,8 +214,10 @@ bool bruteFind3(Cursor & cur, int x, int y, bool up) for ( ; it != et; it.forwardPos()) { // avoid invalid nesting when selecting if (bv.cursorStatus(it) == CUR_INSIDE - && (!cur.selection() || positionable(it, cur.anchor_))) { - Point p = bv.getPos(it, false); + && (!cur.selection() || positionable(it, cur.realAnchor()))) { + // If this function is ever used again, check whether this + // is the same as "bv.getPos(it, false)" with boundary = false. + Point p = bv.getPos(it); int xo = p.x_; int yo = p.y_; if (xlow <= xo && xo <= xhigh && ylow <= yo && yo <= yhigh) { @@ -253,16 +255,16 @@ bool bruteFind3(Cursor & cur, int x, int y, bool up) Cursor::Cursor(BufferView & bv) : DocIterator(&bv.buffer()), bv_(&bv), anchor_(), x_target_(-1), textTargetOffset_(0), - selection_(false), mark_(false), logicalpos_(false), - current_font(inherit_font) + selection_(false), mark_(false), word_selection_(false), + logicalpos_(false), current_font(inherit_font) {} -void Cursor::reset(Inset & inset) +void Cursor::reset() { clear(); - push_back(CursorSlice(inset)); - anchor_ = doc_iterator_begin(&inset.buffer(), &inset); + push_back(CursorSlice(buffer()->inset())); + anchor_ = doc_iterator_begin(buffer()); anchor_.clear(); clearTargetX(); selection_ = false; @@ -277,6 +279,49 @@ void Cursor::setCursor(DocIterator const & cur) } +bool Cursor::getStatus(FuncRequest const & cmd, FuncStatus & status) const +{ + Cursor cur = *this; + + // Try to fix cursor in case it is broken. + cur.fixIfBroken(); + + // Is this a function that acts on inset at point? + Inset * inset = cur.nextInset(); + if (lyxaction.funcHasFlag(cmd.action(), LyXAction::AtPoint) + && inset && inset->getStatus(cur, cmd, status)) + return true; + + // This is, of course, a mess. Better create a new doc iterator and use + // this in Inset::getStatus. This might require an additional + // BufferView * arg, though (which should be avoided) + //Cursor safe = *this; + bool res = false; + for ( ; cur.depth(); cur.pop()) { + //lyxerr << "\nCursor::getStatus: cmd: " << cmd << endl << *this << endl; + LASSERT(cur.idx() <= cur.lastidx(), /**/); + LASSERT(cur.pit() <= cur.lastpit(), /**/); + LASSERT(cur.pos() <= cur.lastpos(), /**/); + + // The inset's getStatus() will return 'true' if it made + // a definitive decision on whether it want to handle the + // request or not. The result of this decision is put into + // the 'status' parameter. + if (cur.inset().getStatus(cur, cmd, status)) { + res = true; + break; + } + } + return res; +} + + +void Cursor::saveBeforeDispatchPosXY() +{ + getPos(beforeDispatchPosX_, beforeDispatchPosY_); +} + + void Cursor::dispatch(FuncRequest const & cmd0) { LYXERR(Debug::DEBUG, "cmd: " << cmd0 << '\n' << *this); @@ -286,7 +331,26 @@ void Cursor::dispatch(FuncRequest const & cmd0) fixIfBroken(); FuncRequest cmd = cmd0; Cursor safe = *this; - + Cursor old = *this; + disp_ = DispatchResult(); + + buffer()->undo().beginUndoGroup(); + + // Is this a function that acts on inset at point? + if (lyxaction.funcHasFlag(cmd.action(), LyXAction::AtPoint) + && nextInset()) { + disp_.dispatched(true); + disp_.screenUpdate(Update::FitCursor | Update::Force); + FuncRequest tmpcmd = cmd; + LYXERR(Debug::DEBUG, "Cursor::dispatch: (AtPoint) cmd: " + << cmd0 << endl << *this); + nextInset()->dispatch(*this, tmpcmd); + if (disp_.dispatched()) { + buffer()->undo().endUndoGroup(); + return; + } + } + // store some values to be used inside of the handlers beforeDispatchCursor_ = *this; for (; depth(); pop(), boundary(false)) { @@ -299,7 +363,7 @@ void Cursor::dispatch(FuncRequest const & cmd0) // The common case is 'LFUN handled, need update', so make the // LFUN handler's life easier by assuming this as default value. // The handler can reset the update and val flags if necessary. - disp_.update(Update::FitCursor | Update::Force); + disp_.screenUpdate(Update::FitCursor | Update::Force); disp_.dispatched(true); inset().dispatch(*this, cmd); if (disp_.dispatched()) @@ -320,17 +384,30 @@ void Cursor::dispatch(FuncRequest const & cmd0) safe.pos() = safe.lastpos(); } operator=(safe); - disp_.update(Update::None); + disp_.screenUpdate(Update::None); disp_.dispatched(false); } else { // restore the previous one because nested Cursor::dispatch calls // are possible which would change it beforeDispatchCursor_ = safe.beforeDispatchCursor_; } + buffer()->undo().endUndoGroup(); + + // notify insets we just left + if (*this != old) { + old.beginUndoGroup(); + old.fixIfBroken(); + bool badcursor = notifyCursorLeavesOrEnters(old, *this); + if (badcursor) { + fixIfBroken(); + bv().resetInlineCompletionPos(); + } + old.endUndoGroup(); + } } -DispatchResult Cursor::result() const +DispatchResult const & Cursor::result() const { return disp_; } @@ -406,7 +483,7 @@ int Cursor::currentMode() void Cursor::getPos(int & x, int & y) const { - Point p = bv().getPos(*this, boundary()); + Point p = bv().getPos(*this); x = p.x_; y = p.y_; } @@ -424,13 +501,81 @@ Row const & Cursor::textRow() const void Cursor::resetAnchor() { anchor_ = *this; + checkNewWordPosition(); } void Cursor::setCursorToAnchor() { - if (selection()) - setCursor(anchor_); + if (selection()) { + DocIterator normal = anchor_; + while (depth() < normal.depth()) + normal.pop_back(); + if (depth() < anchor_.depth() && top() <= anchor_[depth() - 1]) + ++normal.pos(); + setCursor(normal); + } +} + + +void Cursor::markNewWordPosition() +{ + if (lyxrc.spellcheck_continuously && inTexted() && new_word_.empty()) { + FontSpan nw = locateWord(WHOLE_WORD); + if (nw.size() == 1) { + LYXERR(Debug::DEBUG, "start new word: " + << " par: " << pit() + << " pos: " << nw.first); + new_word_ = *this; + } + } +} + + +void Cursor::clearNewWordPosition() +{ + if (!new_word_.empty()) { + LYXERR(Debug::DEBUG, "clear new word: " + << " par: " << pit() + << " pos: " << pos()); + new_word_.resize(0); + } +} + + +void Cursor::checkNewWordPosition() +{ + if (!lyxrc.spellcheck_continuously || new_word_.empty()) + return ; + if (!inTexted()) + clearNewWordPosition(); + else { + // forget the position of the current new word if + // 1) the paragraph changes or + // 2) the count of nested insets changes or + // 3) the cursor pos is out of paragraph bound + if (pit() != new_word_.pit() || + depth() != new_word_.depth() || + new_word_.pos() > new_word_.lastpos()) { + clearNewWordPosition(); + } else if (new_word_.fixIfBroken()) + // 4) or the remembered position was "broken" + clearNewWordPosition(); + else { + FontSpan nw = locateWord(WHOLE_WORD); + if (nw.size()) { + FontSpan ow = new_word_.locateWord(WHOLE_WORD); + if (nw.intersect(ow).empty()) + clearNewWordPosition(); + else + LYXERR(Debug::DEBUG, "new word: " + << " par: " << pit() + << " pos: " << nw.first << ".." << nw.last); + } else { + clearNewWordPosition(); + } + } + } } @@ -913,7 +1058,7 @@ void Cursor::posVisToRowExtremity(bool left) } -CursorSlice Cursor::anchor() const +CursorSlice Cursor::normalAnchor() const { if (!selection()) return top(); @@ -927,11 +1072,17 @@ CursorSlice Cursor::anchor() const } +DocIterator & Cursor::realAnchor() +{ + return anchor_; +} + + CursorSlice Cursor::selBegin() const { if (!selection()) return top(); - return anchor() < top() ? anchor() : top(); + return normalAnchor() < top() ? normalAnchor() : top(); } @@ -939,7 +1090,7 @@ CursorSlice Cursor::selEnd() const { if (!selection()) return top(); - return anchor() > top() ? anchor() : top(); + return normalAnchor() > top() ? normalAnchor() : top(); } @@ -951,10 +1102,10 @@ DocIterator Cursor::selectionBegin() const DocIterator di; // FIXME: This is a work-around for the problem that // CursorSlice doesn't keep track of the boundary. - if (anchor() == top()) + if (normalAnchor() == top()) di = anchor_.boundary() > boundary() ? anchor_ : *this; else - di = anchor() < top() ? anchor_ : *this; + di = normalAnchor() < top() ? anchor_ : *this; di.resize(depth()); return di; } @@ -968,10 +1119,10 @@ DocIterator Cursor::selectionEnd() const DocIterator di; // FIXME: This is a work-around for the problem that // CursorSlice doesn't keep track of the boundary. - if (anchor() == top()) + if (normalAnchor() == top()) di = anchor_.boundary() < boundary() ? anchor_ : *this; else - di = anchor() > top() ? anchor_ : *this; + di = normalAnchor() > top() ? anchor_ : *this; if (di.depth() > depth()) { di.resize(depth()); @@ -986,9 +1137,9 @@ void Cursor::setSelection() setSelection(true); // A selection with no contents is not a selection // FIXME: doesnt look ok - if (idx() == anchor().idx() && - pit() == anchor().pit() && - pos() == anchor().pos()) + if (idx() == normalAnchor().idx() && + pit() == normalAnchor().pit() && + pos() == normalAnchor().pos()) setSelection(false); } @@ -1005,6 +1156,7 @@ void Cursor::setSelection(DocIterator const & where, int n) void Cursor::clearSelection() { setSelection(false); + setWordSelection(false); setMark(false); resetAnchor(); } @@ -1123,9 +1275,6 @@ LyXErr & operator<<(LyXErr & os, Cursor const & cur) namespace lyx { -//#define FILEDEBUG 1 - - bool Cursor::isInside(Inset const * p) const { for (size_t i = 0; i != depth(); ++i) @@ -1199,13 +1348,14 @@ void Cursor::plainInsert(MathAtom const & t) ++pos(); inset().setBuffer(bv_->buffer()); inset().initView(); + forceBufferUpdate(); } void Cursor::insert(docstring const & str) { for_each(str.begin(), str.end(), - boost::bind(static_cast + bind(static_cast (&Cursor::insert), this, _1)); } @@ -1236,23 +1386,26 @@ void Cursor::insert(Inset * inset0) { LASSERT(inset0, /**/); if (inMathed()) - insert(MathAtom(inset0)); + insert(MathAtom(inset0->asInsetMath())); else { text()->insertInset(*this, inset0); inset0->setBuffer(bv_->buffer()); inset0->initView(); + if (inset0->isLabeled()) + forceBufferUpdate(); } } -void Cursor::niceInsert(docstring const & t, Parse::flags f) +int Cursor::niceInsert(docstring const & t, Parse::flags f, bool enter) { - MathData ar; + MathData ar(buffer()); asArray(t, ar, f); - if (ar.size() == 1) + if (ar.size() == 1 && (enter || selection())) niceInsert(ar[0]); else insert(ar); + return ar.size(); } @@ -1261,16 +1414,25 @@ void Cursor::niceInsert(MathAtom const & t) macroModeClose(); docstring const safe = cap::grabAndEraseSelection(*this); plainInsert(t); - // enter the new inset and move the contents of the selection if possible + // If possible, enter the new inset and move the contents of the selection if (t->isActive()) { posBackward(); // be careful here: don't use 'pushBackward(t)' as this we need to // push the clone, not the original pushBackward(*nextInset()); // We may not use niceInsert here (recursion) - MathData ar; + MathData ar(buffer()); asArray(safe, ar); insert(ar); + } else if (t->asMacro() && !safe.empty()) { + MathData ar(buffer()); + asArray(safe, ar); + docstring const name = t->asMacro()->name(); + MacroData const * data = buffer()->getMacro(name); + if (data && data->numargs() - data->optionals() > 0) { + plainInsert(MathAtom(new InsetMathBrace(ar))); + posBackward(); + } } } @@ -1282,6 +1444,8 @@ void Cursor::insert(MathData const & ar) cap::eraseSelection(*this); cell().insert(pos(), ar); pos() += ar.size(); + // FIXME audit setBuffer calls + inset().setBuffer(bv_->buffer()); } @@ -1419,7 +1583,7 @@ bool Cursor::macroModeClose() return false; InsetMathUnknown * p = activeMacro(); p->finalize(); - MathData selection; + MathData selection(buffer()); asArray(p->selection(), selection); docstring const s = p->name(); --pos(); @@ -1431,13 +1595,14 @@ bool Cursor::macroModeClose() // trigger updates of macros, at least, if no full // updates take place anyway - updateFlags(Update::Force); + screenUpdateFlags(Update::Force); docstring const name = s.substr(1); InsetMathNest * const in = inset().asInsetMath()->asNestInset(); if (in && in->interpretString(*this, s)) return true; - MathAtom atom = createInsetMath(name); + MathAtom atom = buffer()->getMacro(name, *this, false) ? + MathAtom(new MathMacro(buffer(), name)) : createInsetMath(name, buffer()); // try to put argument into macro, if we just inserted a macro bool macroArg = false; @@ -1463,7 +1628,7 @@ bool Cursor::macroModeClose() // finally put the macro argument behind, if needed if (macroArg) { - if (selection.size() > 1) + if (selection.size() > 1 || selection[0]->asScriptInset()) plainInsert(MathAtom(new InsetMathBrace(selection))); else insert(selection); @@ -1520,7 +1685,7 @@ bool Cursor::inMacroMode() const { if (!inMathed()) return false; - if (pos() == 0) + if (pos() == 0 || cell().empty()) return false; InsetMathUnknown const * p = prevAtom()->asUnknownInset(); return p && !p->final(); @@ -1596,8 +1761,8 @@ bool Cursor::upDownInMath(bool up) int xo = 0; int yo = 0; getPos(xo, yo); - xo = theLyXFunc().cursorBeforeDispatchX(); - + xo = beforeDispatchPosX_; + // check if we had something else in mind, if not, this is the future // target if (x_target_ == -1) @@ -1646,7 +1811,7 @@ bool Cursor::upDownInMath(bool up) int x; int y; getPos(x, y); - int oy = theLyXFunc().cursorBeforeDispatchY(); + int oy = beforeDispatchPosY_; if ((!up && y <= oy) || (up && y >= oy)) operator=(old); @@ -1667,7 +1832,7 @@ bool Cursor::upDownInMath(bool up) int x; int y; getPos(x, y); - int oy = theLyXFunc().cursorBeforeDispatchY(); + int oy = beforeDispatchPosY_; if ((!up && y <= oy) || (up && y >= oy)) operator=(old); @@ -1691,7 +1856,7 @@ bool Cursor::upDownInMath(bool up) //lyxerr << "updown: popBackward succeeded" << endl; int xnew; int ynew; - int yold = theLyXFunc().cursorBeforeDispatchY(); + int yold = beforeDispatchPosY_; getPos(xnew, ynew); if (up ? ynew < yold : ynew > yold) return true; @@ -1733,7 +1898,7 @@ bool Cursor::upDownInText(bool up, bool & updateNeeded) int xo = 0; int yo = 0; getPos(xo, yo); - xo = theLyXFunc().cursorBeforeDispatchX(); + xo = beforeDispatchPosX_; // update the targetX - this is here before the "return false" // to set a new target which can be used by InsetTexts above @@ -1803,13 +1968,15 @@ bool Cursor::upDownInText(bool up, bool & updateNeeded) updateNeeded |= bv().checkDepm(dummy, *this); updateTextTargetOffset(); + if (updateNeeded) + forceBufferUpdate(); } return false; } // with and without selection are handled differently if (!selection()) { - int yo = bv().getPos(*this, boundary()).y_; + int yo = bv().getPos(*this).y_; Cursor old = *this; // To next/previous row if (up) @@ -1827,38 +1994,53 @@ bool Cursor::upDownInText(bool up, bool & updateNeeded) ++dummy.pos(); if (bv().checkDepm(dummy, old)) { updateNeeded = true; - // Make sure that cur gets back whatever happened to dummy(Lgb) + // Make sure that cur gets back whatever happened to dummy (Lgb) operator=(dummy); } } else { - // if there is a selection, we stay out of any inset, and just jump to the right position: + // if there is a selection, we stay out of any inset, + // and just jump to the right position: Cursor old = *this; + int next_row = row; if (up) { if (row > 0) { - top().pos() = min(tm.x2pos(pit(), row - 1, xo), top().lastpos()); + --next_row; } else if (pit() > 0) { --pit(); TextMetrics & tm = bv_->textMetrics(text()); if (!tm.contains(pit())) tm.newParMetricsUp(); ParagraphMetrics const & pmcur = tm.parMetrics(pit()); - top().pos() = min(tm.x2pos(pit(), pmcur.rows().size() - 1, xo), top().lastpos()); + next_row = pmcur.rows().size() - 1; } } else { if (row + 1 < int(pm.rows().size())) { - top().pos() = min(tm.x2pos(pit(), row + 1, xo), top().lastpos()); + ++next_row; } else if (pit() + 1 < int(text()->paragraphs().size())) { ++pit(); TextMetrics & tm = bv_->textMetrics(text()); if (!tm.contains(pit())) tm.newParMetricsDown(); - top().pos() = min(tm.x2pos(pit(), 0, xo), top().lastpos()); + next_row = 0; } } + top().pos() = min(tm.x2pos(pit(), next_row, xo), top().lastpos()); + + int const xpos = tm.x2pos(pit(), next_row, xo); + bool const at_end_row = xpos == tm.x2pos(pit(), next_row, tm.width()); + bool const at_beg_row = xpos == tm.x2pos(pit(), next_row, 0); + + if (at_end_row && at_beg_row) + // make sure the cursor ends up on this row + boundary(false); + else + boundary(at_end_row); updateNeeded |= bv().checkDepm(*this, old); } + if (updateNeeded) + forceBufferUpdate(); updateTextTargetOffset(); return true; } @@ -1886,8 +2068,8 @@ void Cursor::handleFont(string const & font) } else { // cursor in between. split cell MathData::iterator bt = cell().begin(); - MathAtom at = createInsetMath(from_utf8(font)); - at.nucleus()->cell(0) = MathData(bt, bt + pos()); + MathAtom at = createInsetMath(from_utf8(font), buffer()); + at.nucleus()->cell(0) = MathData(buffer(), bt, bt + pos()); cell().erase(bt, bt + pos()); popBackward(); plainInsert(at); @@ -1904,25 +2086,29 @@ void Cursor::handleFont(string const & font) void Cursor::message(docstring const & msg) const { - theLyXFunc().setMessage(msg); + disp_.setMessage(msg); } void Cursor::errorMessage(docstring const & msg) const { - theLyXFunc().setErrorMessage(msg); + disp_.setMessage(msg); + disp_.setError(true); } -static docstring parbreak(InsetCode code) +namespace { +docstring parbreak(Cursor const * cur) { odocstringstream os; os << '\n'; - // only add blank line if we're not in an ERT or Listings inset - if (code != ERT_CODE && code != LISTINGS_CODE) + // only add blank line if we're not in a ParbreakIsNewline situation + if (!cur->inset().getLayout().parbreakIsNewline() + && !cur->paragraph().layout().parbreak_is_newline) os << '\n'; return os.str(); } +} docstring Cursor::selectionAsString(bool with_label) const @@ -1958,13 +2144,13 @@ docstring Cursor::selectionAsString(bool with_label) const // First paragraph in selection docstring result = pars[startpit]. asString(startpos, pars[startpit].size(), label) - + parbreak(inset().lyxCode()); + + parbreak(this); // The paragraphs in between (if any) for (pit_type pit = startpit + 1; pit != endpit; ++pit) { Paragraph const & par = pars[pit]; result += par.asString(0, par.size(), label) - + parbreak(inset().lyxCode()); + + parbreak(this); } // Last paragraph in selection @@ -2002,32 +2188,50 @@ Encoding const * Cursor::getEncoding() const CursorSlice const & sl = innerTextSlice(); Text const & text = *sl.text(); Font font = text.getPar(sl.pit()).getFont( - bv().buffer().params(), sl.pos(), outerFont(sl.pit(), text.paragraphs())); + bv().buffer().params(), sl.pos(), text.outerFont(sl.pit())); return font.language()->encoding(); } -void Cursor::undispatched() +void Cursor::undispatched() const { disp_.dispatched(false); } -void Cursor::dispatched() +void Cursor::dispatched() const { disp_.dispatched(true); } -void Cursor::updateFlags(Update::flags f) +void Cursor::screenUpdateFlags(Update::flags f) const +{ + disp_.screenUpdate(f); +} + + +void Cursor::forceBufferUpdate() const +{ + disp_.forceBufferUpdate(); +} + + +void Cursor::clearBufferUpdate() const { - disp_.update(f); + disp_.clearBufferUpdate(); } -void Cursor::noUpdate() +bool Cursor::needBufferUpdate() const { - disp_.update(Update::None); + return disp_.needBufferUpdate(); +} + + +void Cursor::noScreenUpdate() const +{ + disp_.screenUpdate(Update::None); } @@ -2059,7 +2263,7 @@ Font Cursor::getFont() const // get font at the position Font font = par.getFont(buffer()->params(), pos, - outerFont(sl.pit(), text.paragraphs())); + text.outerFont(sl.pit())); return font; } @@ -2067,9 +2271,13 @@ Font Cursor::getFont() const bool Cursor::fixIfBroken() { - if (DocIterator::fixIfBroken()) { - clearSelection(); - return true; + bool const broken_cursor = DocIterator::fixIfBroken(); + bool const broken_anchor = anchor_.fixIfBroken(); + + if (broken_cursor || broken_anchor) { + clearNewWordPosition(); + clearSelection(); + return true; } return false; } @@ -2095,9 +2303,9 @@ bool notifyCursorLeavesOrEnters(Cursor const & old, Cursor & cur) // notify everything on top of the common part in old cursor, // but stop if the inset claims the cursor to be invalid now for (size_type j = i; j < old.depth(); ++j) { - Cursor insetPos = old; - insetPos.cutOff(j); - if (old[j].inset().notifyCursorLeaves(insetPos, cur)) + Cursor inset_pos = old; + inset_pos.cutOff(j); + if (old[j].inset().notifyCursorLeaves(inset_pos, cur)) return true; } @@ -2222,9 +2430,9 @@ void Cursor::recordUndo(UndoKind kind) const } -void Cursor::recordUndoInset(UndoKind kind) const +void Cursor::recordUndoInset(UndoKind kind, Inset const * inset) const { - buffer()->undo().recordUndoInset(*this, kind); + buffer()->undo().recordUndoInset(*this, kind, inset); }