X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FCursor.cpp;h=572e062876d461d8680adb218b857e59c51eddc2;hb=4df7d8ab1ae443119057562fb76c2e438c053eef;hp=70d31860f662fde0fb094a809f60eabbf2d5a24b;hpb=17dd64586252db85b4b8268b400afe4402ec5024;p=lyx.git diff --git a/src/Cursor.cpp b/src/Cursor.cpp index 70d31860f6..572e062876 100644 --- a/src/Cursor.cpp +++ b/src/Cursor.cpp @@ -6,7 +6,7 @@ * \author Alejandro Aguilar Sierra * \author Alfredo Braunstein * \author Dov Feldstern - * \author André Pönitz + * \author André Pönitz * \author Stefan Schimanski * * Full author contact details are available in file CREDITS. @@ -205,10 +205,9 @@ bool bruteFind3(Cursor & cur, int x, int y, bool up) // << " xlow: " << xlow << " xhigh: " << xhigh // << " ylow: " << ylow << " yhigh: " << yhigh // << endl; - Inset & inset = bv.buffer().inset(); - DocIterator it = doc_iterator_begin(inset); + DocIterator it = doc_iterator_begin(cur.buffer()); it.pit() = from; - DocIterator et = doc_iterator_end(inset); + DocIterator et = doc_iterator_end(cur.buffer()); double best_dist = numeric_limits::max(); DocIterator best_cursor = et; @@ -249,13 +248,12 @@ bool bruteFind3(Cursor & cur, int x, int y, bool up) docstring parbreak(Paragraph const & par) { - odocstringstream ods; - ods << '\n'; + odocstringstream os; + os << '\n'; // only add blank line if we're not in an ERT or Listings inset - if (par.ownerCode() != ERT_CODE - && par.ownerCode() != LISTINGS_CODE) - ods << '\n'; - return ods.str(); + if (par.ownerCode() != ERT_CODE && par.ownerCode() != LISTINGS_CODE) + os << '\n'; + return os.str(); } } // namespace anon @@ -264,7 +262,8 @@ docstring parbreak(Paragraph const & par) // be careful: this is called from the bv's constructor, too, so // bv functions are not yet available! Cursor::Cursor(BufferView & bv) - : DocIterator(), bv_(&bv), anchor_(), x_target_(-1), textTargetOffset_(0), + : DocIterator(&bv.buffer()), bv_(&bv), anchor_(), + x_target_(-1), textTargetOffset_(0), selection_(false), mark_(false), logicalpos_(false), current_font(inherit_font) {} @@ -274,7 +273,7 @@ void Cursor::reset(Inset & inset) { clear(); push_back(CursorSlice(inset)); - anchor_ = doc_iterator_begin(inset); + anchor_ = doc_iterator_begin(&inset.buffer(), &inset); anchor_.clear(); clearTargetX(); selection_ = false; @@ -322,6 +321,15 @@ void Cursor::dispatch(FuncRequest const & cmd0) // object will be used again. if (!disp_.dispatched()) { LYXERR(Debug::DEBUG, "RESTORING OLD CURSOR!"); + // We might have invalidated the cursor when removing an empty + // paragraph while the cursor could not be moved out the inset + // while we initially thought we could. This might happen when + // a multiline inset becomes an inline inset when the second + // paragraph is removed. + if (safe.pit() > safe.lastpit()) { + safe.pit() = safe.lastpit(); + safe.pos() = safe.lastpos(); + } operator=(safe); disp_.update(Update::None); disp_.dispatched(false); @@ -346,13 +354,6 @@ BufferView & Cursor::bv() const } -Buffer & Cursor::buffer() const -{ - LASSERT(bv_, /**/); - return bv_->buffer(); -} - - void Cursor::pop() { LASSERT(depth() >= 1, /**/); @@ -363,13 +364,13 @@ void Cursor::pop() void Cursor::push(Inset & p) { push_back(CursorSlice(p)); - p.setBuffer(bv_->buffer()); + p.setBuffer(*buffer()); } void Cursor::pushBackward(Inset & p) { - LASSERT(!empty(), /**/); + LASSERT(!empty(), return); //lyxerr << "Entering inset " << t << " front" << endl; push(p); p.idxFirst(*this); @@ -378,7 +379,7 @@ void Cursor::pushBackward(Inset & p) bool Cursor::popBackward() { - LASSERT(!empty(), /**/); + LASSERT(!empty(), return false); if (depth() == 1) return false; pop(); @@ -388,7 +389,7 @@ bool Cursor::popBackward() bool Cursor::popForward() { - LASSERT(!empty(), /**/); + LASSERT(!empty(), return false); //lyxerr << "Leaving inset from in back" << endl; const pos_type lp = (depth() > 1) ? (*this)[depth() - 2].lastpos() : 0; if (depth() == 1) @@ -434,6 +435,12 @@ void Cursor::resetAnchor() } +void Cursor::setCursorToAnchor() +{ + if (selection()) + setCursor(anchor_); +} + bool Cursor::posBackward() { @@ -499,7 +506,7 @@ bool Cursor::posVisRight(bool skip_inset) // currently to the left of 'right_pos'). In order to move to the // right, it depends whether or not the character at 'right_pos' is RTL. new_pos_is_RTL = paragraph().getFontSettings( - bv().buffer().params(), right_pos).isVisibleRightToLeft(); + buffer()->params(), right_pos).isVisibleRightToLeft(); // If the character at 'right_pos' *is* LTR, then in order to move to // the right of it, we need to be *after* 'right_pos', i.e., move to // position 'right_pos' + 1. @@ -507,13 +514,14 @@ bool Cursor::posVisRight(bool skip_inset) new_cur.pos() = right_pos + 1; // set the boundary to true in two situations: if ( - // 1. if new_pos is now lastpos (which means that we're moving - // right to the end of an LTR chunk which is at the end of an - // RTL paragraph); - new_cur.pos() == lastpos() + // 1. if new_pos is now lastpos, and we're in an RTL paragraph + // (this means that we're moving right to the end of an LTR chunk + // which is at the end of an RTL paragraph); + (new_cur.pos() == lastpos() + && paragraph().isRTL(buffer()->params())) // 2. if the position *after* right_pos is RTL (we want to be // *after* right_pos, not before right_pos + 1!) - || paragraph().getFontSettings(bv().buffer().params(), + || paragraph().getFontSettings(buffer()->params(), new_cur.pos()).isVisibleRightToLeft() ) new_cur.boundary(true); @@ -532,7 +540,8 @@ bool Cursor::posVisRight(bool skip_inset) bool moved = (new_cur.pos() != pos() || new_cur.pit() != pit() - || new_cur.boundary() != boundary()); + || new_cur.boundary() != boundary() + || &new_cur.inset() != &inset()); if (moved) { LYXERR(Debug::RTL, "moving to: " << new_cur.pos() @@ -590,7 +599,7 @@ bool Cursor::posVisLeft(bool skip_inset) // currently to the right of 'left_pos'). In order to move to the // left, it depends whether or not the character at 'left_pos' is RTL. new_pos_is_RTL = paragraph().getFontSettings( - bv().buffer().params(), left_pos).isVisibleRightToLeft(); + buffer()->params(), left_pos).isVisibleRightToLeft(); // If the character at 'left_pos' *is* RTL, then in order to move to // the left of it, we need to be *after* 'left_pos', i.e., move to // position 'left_pos' + 1. @@ -598,13 +607,14 @@ bool Cursor::posVisLeft(bool skip_inset) new_cur.pos() = left_pos + 1; // set the boundary to true in two situations: if ( - // 1. if new_pos is now lastpos (which means that we're moving left - // to the end of an RTL chunk which is at the end of an LTR - // paragraph); - new_cur.pos() == lastpos() + // 1. if new_pos is now lastpos and we're in an LTR paragraph + // (this means that we're moving left to the end of an RTL chunk + // which is at the end of an LTR paragraph); + (new_cur.pos() == lastpos() + && !paragraph().isRTL(buffer()->params())) // 2. if the position *after* left_pos is not RTL (we want to be // *after* left_pos, not before left_pos + 1!) - || !paragraph().getFontSettings(bv().buffer().params(), + || !paragraph().getFontSettings(buffer()->params(), new_cur.pos()).isVisibleRightToLeft() ) new_cur.boundary(true); @@ -639,7 +649,7 @@ void Cursor::getSurroundingPos(pos_type & left_pos, pos_type & right_pos) { // preparing bidi tables Paragraph const & par = paragraph(); - Buffer const & buf = buffer(); + Buffer const & buf = *buffer(); Row const & row = textRow(); Bidi bidi; bidi.computeTables(par, buf, row); @@ -649,7 +659,7 @@ void Cursor::getSurroundingPos(pos_type & left_pos, pos_type & right_pos) // The cursor is painted *before* the character at pos(), or, if 'boundary' // is true, *after* the character at (pos() - 1). So we already have one // known position around the cursor: - pos_type known_pos = boundary() ? pos() - 1 : pos(); + pos_type const known_pos = boundary() && pos() > 0 ? pos() - 1 : pos(); // edge case: if we're at the end of the paragraph, things are a little // different (because lastpos is a position which does not really "exist" @@ -658,8 +668,8 @@ void Cursor::getSurroundingPos(pos_type & left_pos, pos_type & right_pos) if (par.isRTL(buf.params())) { left_pos = -1; right_pos = bidi.vis2log(row.pos()); - } - else { // LTR paragraph + } else { + // LTR paragraph right_pos = -1; left_pos = bidi.vis2log(row.endpos() - 1); } @@ -674,11 +684,10 @@ void Cursor::getSurroundingPos(pos_type & left_pos, pos_type & right_pos) // For an RTL character, "before" means "to the right" and "after" means // "to the left"; and for LTR, it's the reverse. So, 'known_pos' is to the // right of the cursor if (RTL && boundary) or (!RTL && !boundary): - bool known_pos_on_right = (cur_is_RTL == boundary()); + bool const known_pos_on_right = cur_is_RTL == boundary(); // So we now know one of the positions surrounding the cursor. Let's - // determine the other one: - + // determine the other one: if (known_pos_on_right) { right_pos = known_pos; // *visual* position of 'left_pos': @@ -692,9 +701,9 @@ void Cursor::getSurroundingPos(pos_type & left_pos, pos_type & right_pos) if (bidi.inRange(v_left_pos) && bidi.vis2log(v_left_pos) + 1 == row.endpos() && row.endpos() < lastpos() - && par.isSeparator(bidi.vis2log(v_left_pos))) { + && par.isSeparator(bidi.vis2log(v_left_pos))) --v_left_pos; - } + // calculate the logical position of 'left_pos', if in row if (!bidi.inRange(v_left_pos)) left_pos = -1; @@ -704,14 +713,14 @@ void Cursor::getSurroundingPos(pos_type & left_pos, pos_type & right_pos) // separator", set 'right_pos' to the *next* position to the right. if (right_pos + 1 == row.endpos() && row.endpos() < lastpos() && par.isSeparator(right_pos)) { - pos_type v_right_pos = bidi.log2vis(right_pos) + 1; + pos_type const v_right_pos = bidi.log2vis(right_pos) + 1; if (!bidi.inRange(v_right_pos)) right_pos = -1; else right_pos = bidi.vis2log(v_right_pos); } - } - else { // known_pos is on the left + } else { + // known_pos is on the left left_pos = known_pos; // *visual* position of 'right_pos' pos_type v_right_pos = bidi.log2vis(left_pos) + 1; @@ -720,9 +729,9 @@ void Cursor::getSurroundingPos(pos_type & left_pos, pos_type & right_pos) if (bidi.inRange(v_right_pos) && bidi.vis2log(v_right_pos) + 1 == row.endpos() && row.endpos() < lastpos() - && par.isSeparator(bidi.vis2log(v_right_pos))) { + && par.isSeparator(bidi.vis2log(v_right_pos))) ++v_right_pos; - } + // calculate the logical position of 'right_pos', if in row if (!bidi.inRange(v_right_pos)) right_pos = -1; @@ -732,7 +741,7 @@ void Cursor::getSurroundingPos(pos_type & left_pos, pos_type & right_pos) // separator", set 'left_pos' to the *next* position to the left. if (left_pos + 1 == row.endpos() && row.endpos() < lastpos() && par.isSeparator(left_pos)) { - pos_type v_left_pos = bidi.log2vis(left_pos) - 1; + pos_type const v_left_pos = bidi.log2vis(left_pos) - 1; if (!bidi.inRange(v_left_pos)) left_pos = -1; else @@ -746,7 +755,7 @@ void Cursor::getSurroundingPos(pos_type & left_pos, pos_type & right_pos) bool Cursor::posVisToNewRow(bool movingLeft) { Paragraph const & par = paragraph(); - Buffer const & buf = buffer(); + Buffer const & buf = *buffer(); Row const & row = textRow(); bool par_is_LTR = !par.isRTL(buf.params()); @@ -800,7 +809,7 @@ void Cursor::posVisToRowExtremity(bool left) { // prepare bidi tables Paragraph const & par = paragraph(); - Buffer const & buf = buffer(); + Buffer const & buf = *buffer(); Row const & row = textRow(); Bidi bidi; bidi.computeTables(par, buf, row); @@ -839,32 +848,31 @@ void Cursor::posVisToRowExtremity(bool left) // this non-separator-but-last-position-in-row is an inset, then // we *do* want to stay to the left of it anyway: this is the // "boundary" which we simulate at insets. + // Another exception is when row.endpos() is 0. - bool right_of_pos = false; // do we want to be to the right of pos? - + // do we want to be to the right of pos? // as explained above, if at last pos in row, stay to the right - if ((pos() == row.endpos() - 1) && !par.isInset(pos())) - right_of_pos = true; + bool const right_of_pos = row.endpos() > 0 + && pos() == row.endpos() - 1 && !par.isInset(pos()); // Now we know if we want to be to the left or to the right of pos, // let's make sure we are where we want to be. - bool new_pos_is_RTL = + bool const new_pos_is_RTL = par.getFontSettings(buf.params(), pos()).isVisibleRightToLeft(); - if (new_pos_is_RTL == !right_of_pos) { + if (new_pos_is_RTL != right_of_pos) { ++pos(); boundary(true); } - } - } - else { // move to rightmost position + } else { + // move to rightmost position // if this is an LTR paragraph, and we're at the last row in the // paragraph, move to lastpos if (!par.isRTL(buf.params()) && row.endpos() == lastpos()) pos() = lastpos(); else { - pos() = bidi.vis2log(row.endpos() - 1); + pos() = row.endpos() > 0 ? bidi.vis2log(row.endpos() - 1) : 0; // Moving to the rightmost position in the row, the cursor should // normally be placed to the *right* of the rightmost position. @@ -889,16 +897,17 @@ void Cursor::posVisToRowExtremity(bool left) // this non-separator-but-last-position-in-row is an inset, then // we *do* want to stay to the right of it anyway: this is the // "boundary" which we simulate at insets. + // Another exception is when row.endpos() is 0. - bool left_of_pos = false; // do we want to be to the left of pos? - - // as explained above, if at last pos in row, stay to the left - if ((pos() == row.endpos() - 1) && !par.isInset(pos())) - left_of_pos = true; + // do we want to be to the left of pos? + // as explained above, if at last pos in row, stay to the left, + // unless the last position is the same as the first. + bool const left_of_pos = row.endpos() > 0 + && pos() == row.endpos() - 1 && !par.isInset(pos()); // Now we know if we want to be to the left or to the right of pos, // let's make sure we are where we want to be. - bool new_pos_is_RTL = + bool const new_pos_is_RTL = par.getFontSettings(buf.params(), pos()).isVisibleRightToLeft(); if (new_pos_is_RTL == left_of_pos) { @@ -944,7 +953,14 @@ DocIterator Cursor::selectionBegin() const { if (!selection()) return *this; - DocIterator di = (anchor() < top() ? anchor_ : *this); + + DocIterator di; + // FIXME: This is a work-around for the problem that + // CursorSlice doesn't keep track of the boundary. + if (anchor() == top()) + di = anchor_.boundary() > boundary() ? anchor_ : *this; + else + di = anchor() < top() ? anchor_ : *this; di.resize(depth()); return di; } @@ -954,7 +970,15 @@ DocIterator Cursor::selectionEnd() const { if (!selection()) return *this; - DocIterator di = (anchor() > top() ? anchor_ : *this); + + DocIterator di; + // FIXME: This is a work-around for the problem that + // CursorSlice doesn't keep track of the boundary. + if (anchor() == top()) + di = anchor_.boundary() < boundary() ? anchor_ : *this; + else + di = anchor() > top() ? anchor_ : *this; + if (di.depth() > depth()) { di.resize(depth()); ++di.pos(); @@ -965,20 +989,20 @@ DocIterator Cursor::selectionEnd() const void Cursor::setSelection() { - selection() = true; + 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()) - selection() = false; + setSelection(false); } void Cursor::setSelection(DocIterator const & where, int n) { setCursor(where); - selection() = true; + setSelection(true); anchor_ = where; pos() += n; } @@ -986,8 +1010,8 @@ void Cursor::setSelection(DocIterator const & where, int n) void Cursor::clearSelection() { - selection() = false; - mark() = false; + setSelection(false); + setMark(false); resetAnchor(); } @@ -1050,7 +1074,7 @@ bool Cursor::selHandle(bool sel) cap::saveSelection(*this); resetAnchor(); - selection() = sel; + setSelection(sel); return true; } @@ -1227,10 +1251,10 @@ void Cursor::insert(Inset * inset0) } -void Cursor::niceInsert(docstring const & t) +void Cursor::niceInsert(docstring const & t, Parse::flags f) { MathData ar; - asArray(t, ar); + asArray(t, ar, f); if (ar.size() == 1) niceInsert(ar[0]); else @@ -1309,7 +1333,7 @@ bool Cursor::backspace() // let's require two backspaces for 'big stuff' and // highlight on the first resetAnchor(); - selection() = true; + setSelection(true); --pos(); } else { --pos(); @@ -1357,7 +1381,7 @@ bool Cursor::erase() // 'clever' UI hack: only erase large items if previously slected if (pos() != lastpos() && nextAtom()->nargs() > 0) { resetAnchor(); - selection() = true; + setSelection(true); ++pos(); } else { plainErase(); @@ -1428,7 +1452,7 @@ bool Cursor::macroModeClose() // macros here are still unfolded (in init mode in fact). So // we have to resolve the macro here manually and check its arity // to put the selection behind it if arity > 0. - MacroData const * data = buffer().getMacro(atomAsMacro->name()); + MacroData const * data = buffer()->getMacro(atomAsMacro->name()); if (selection.size() > 0 && data && data->numargs() - data->optionals() > 0) { macroArg = true; atomAsMacro->setDisplayMode(MathMacro::DISPLAY_INTERACTIVE_INIT, 1); @@ -1685,6 +1709,28 @@ bool Cursor::upDownInMath(bool up) } +bool Cursor::atFirstOrLastRow(bool up) +{ + TextMetrics const & tm = bv_->textMetrics(text()); + ParagraphMetrics const & pm = tm.parMetrics(pit()); + + int row; + if (pos() && boundary()) + row = pm.pos2row(pos() - 1); + else + row = pm.pos2row(pos()); + + if (up) { + if (pit() == 0 && row == 0) + return true; + } else { + if (pit() + 1 >= int(text()->paragraphs().size()) && + row + 1 >= int(pm.rows().size())) + return true; + } + return false; +} + bool Cursor::upDownInText(bool up, bool & updateNeeded) { LASSERT(text(), /**/); @@ -1738,14 +1784,33 @@ bool Cursor::upDownInText(bool up, bool & updateNeeded) else row = pm.pos2row(pos()); - // are we not at the start or end? - if (up) { - if (pit() == 0 && row == 0) - return false; - } else { - if (pit() + 1 >= int(text()->paragraphs().size()) && - row + 1 >= int(pm.rows().size())) - return false; + if (atFirstOrLastRow(up)) { + // Is there a place for the cursor to go ? If yes, we + // can execute the DEPM, otherwise we should keep the + // paragraph to host the cursor. + Cursor dummy = *this; + bool valid_destination = false; + for(; dummy.depth(); dummy.pop()) + if (!dummy.atFirstOrLastRow(up)) { + valid_destination = true; + break; + } + + // will a next dispatch follow and if there is a new + // dispatch will it move the cursor out ? + if (depth() > 1 && valid_destination) { + // The cursor hasn't changed yet. This happens when + // you e.g. move out of an inset. And to give the + // DEPM the possibility of doing something we must + // provide it with two different cursors. (Lgb, vfr) + dummy = *this; + dummy.pos() = dummy.pos() == 0 ? dummy.lastpos() : 0; + dummy.pit() = dummy.pit() == 0 ? dummy.lastpit() : 0; + + updateNeeded |= bv().checkDepm(dummy, *this); + updateTextTargetOffset(); + } + return false; } // with and without selection are handled differently @@ -1759,16 +1824,16 @@ bool Cursor::upDownInText(bool up, bool & updateNeeded) tm.editXY(*this, xo, yo + textRow().descent() + 1); clearSelection(); - // This happens when you move out of an inset. - // And to give the DEPM the possibility of doing - // something we must provide it with two different - // cursors. (Lgb) + // This happens when you move out of an inset. + // And to give the DEPM the possibility of doing + // something we must provide it with two different + // cursors. (Lgb) Cursor dummy = *this; if (dummy == old) ++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 { @@ -1814,6 +1879,8 @@ void Cursor::handleFont(string const & font) safe = cap::grabAndEraseSelection(*this); } + recordUndoInset(); + if (lastpos() != 0) { // something left in the cell if (pos() == 0) { @@ -1833,8 +1900,9 @@ void Cursor::handleFont(string const & font) } } else { // nothing left in the cell - pullArg(); + popBackward(); plainErase(); + resetAnchor(); } insert(safe); } @@ -1989,7 +2057,7 @@ Font Cursor::getFont() const } // get font at the position - Font font = par.getFont(bv().buffer().params(), pos, + Font font = par.getFont(buffer()->params(), pos, outerFont(sl.pit(), text.paragraphs())); return font; @@ -2006,7 +2074,7 @@ bool Cursor::fixIfBroken() } -bool notifyCursorLeaves(Cursor const & old, Cursor & cur) +bool notifyCursorLeavesOrEnters(Cursor const & old, Cursor & cur) { // find inset in common size_type i; @@ -2017,19 +2085,25 @@ bool notifyCursorLeaves(Cursor const & old, Cursor & cur) // update words if we just moved to another paragraph if (i == old.depth() && i == cur.depth() - && !cur.buffer().isClean() + && !cur.buffer()->isClean() && cur.inTexted() && old.inTexted() && cur.pit() != old.pit()) { - old.paragraph().updateWords(old.top()); - return false; + old.paragraph().updateWords(); } - + // notify everything on top of the common part in old cursor, // but stop if the inset claims the cursor to be invalid now - for (; i < old.depth(); ++i) { + for (size_type j = i; j < old.depth(); ++j) { Cursor insetPos = old; - insetPos.cutOff(i); - if (old[i].inset().notifyCursorLeaves(insetPos, cur)) + insetPos.cutOff(j); + if (old[j].inset().notifyCursorLeaves(insetPos, cur)) + return true; + } + + // notify everything on top of the common part in new cursor, + // but stop if the inset claims the cursor to be invalid now + for (; i < cur.depth(); ++i) { + if (cur[i].inset().notifyCursorEnters(cur)) return true; } @@ -2066,7 +2140,7 @@ void Cursor::setCurrentFont() } // get font - BufferParams const & bufparams = buffer().params(); + BufferParams const & bufparams = buffer()->params(); current_font = par.getFontSettings(bufparams, cpos); real_current_font = tm.displayFont(cpit, cpos); @@ -2087,7 +2161,7 @@ bool Cursor::textUndo() { DocIterator dit = *this; // Undo::textUndo() will modify dit. - if (!bv_->buffer().undo().textUndo(dit)) + if (!buffer()->undo().textUndo(dit)) return false; // Set cursor setCursor(dit); @@ -2101,7 +2175,7 @@ bool Cursor::textRedo() { DocIterator dit = *this; // Undo::textRedo() will modify dit. - if (!bv_->buffer().undo().textRedo(dit)) + if (!buffer()->undo().textRedo(dit)) return false; // Set cursor setCursor(dit); @@ -2113,49 +2187,49 @@ bool Cursor::textRedo() void Cursor::finishUndo() const { - bv_->buffer().undo().finishUndo(); + buffer()->undo().finishUndo(); } void Cursor::beginUndoGroup() const { - bv_->buffer().undo().beginUndoGroup(); + buffer()->undo().beginUndoGroup(); } void Cursor::endUndoGroup() const { - bv_->buffer().undo().endUndoGroup(); + buffer()->undo().endUndoGroup(); } void Cursor::recordUndo(UndoKind kind, pit_type from, pit_type to) const { - bv_->buffer().undo().recordUndo(*this, kind, from, to); + buffer()->undo().recordUndo(*this, kind, from, to); } void Cursor::recordUndo(UndoKind kind, pit_type from) const { - bv_->buffer().undo().recordUndo(*this, kind, from); + buffer()->undo().recordUndo(*this, kind, from); } void Cursor::recordUndo(UndoKind kind) const { - bv_->buffer().undo().recordUndo(*this, kind); + buffer()->undo().recordUndo(*this, kind); } void Cursor::recordUndoInset(UndoKind kind) const { - bv_->buffer().undo().recordUndoInset(*this, kind); + buffer()->undo().recordUndoInset(*this, kind); } void Cursor::recordUndoFullDocument() const { - bv_->buffer().undo().recordUndoFullDocument(*this); + buffer()->undo().recordUndoFullDocument(*this); } @@ -2166,19 +2240,21 @@ void Cursor::recordUndoSelection() const recordUndoInset(); else recordUndo(); - } else - bv_->buffer().undo().recordUndo(*this, ATOMIC_UNDO, + } else { + buffer()->undo().recordUndo(*this, ATOMIC_UNDO, selBegin().pit(), selEnd().pit()); + } } void Cursor::checkBufferStructure() { - if (paragraph().layout().toclevel == Layout::NOT_IN_TOC) - return; - Buffer const * master = buffer().masterBuffer(); - master->tocBackend().updateItem(ParConstIterator(*this)); - master->structureChanged(); + Buffer const * master = buffer()->masterBuffer(); + master->tocBackend().updateItem(*this); + if (master != buffer() && !master->hasGuiDelegate()) + // In case the master has no gui associated with it, + // the TocItem is not updated (part of bug 5699). + buffer()->tocBackend().updateItem(*this); }