X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FBufferView.cpp;h=e31efcf673d433a52ab8efef42dca41d8335cb33;hb=cf14e814124ccbc8155fa1dde98d03be319c0e87;hp=19547ef56448e1d43245a3d973e0a250fff81cd0;hpb=e30f3d76d2bee0011ceaeb5f0cc221156458cbad;p=lyx.git

diff --git a/src/BufferView.cpp b/src/BufferView.cpp
index 19547ef564..e31efcf673 100644
--- a/src/BufferView.cpp
+++ b/src/BufferView.cpp
@@ -65,11 +65,13 @@
 #include "insets/InsetText.h"
 
 #include "mathed/MathData.h"
+#include "mathed/InsetMathNest.h"
 
 #include "frontends/alert.h"
 #include "frontends/Application.h"
 #include "frontends/Delegates.h"
 #include "frontends/FontMetrics.h"
+#include "frontends/NullPainter.h"
 #include "frontends/Painter.h"
 #include "frontends/Selection.h"
 
@@ -80,6 +82,7 @@
 #include "support/gettext.h"
 #include "support/lassert.h"
 #include "support/lstrings.h"
+#include "support/lyxlib.h"
 #include "support/Package.h"
 #include "support/types.h"
 
@@ -107,7 +110,7 @@ T * getInsetByCode(Cursor const & cur, InsetCode code)
 	Inset * inset = it.nextInset();
 	if (inset && inset->lyxCode() == code)
 		return static_cast<T*>(inset);
-	return 0;
+	return nullptr;
 }
 
 
@@ -162,7 +165,7 @@ bool findInset(DocIterator & dit, vector<InsetCode> const & codes,
 
 	if (!findNextInset(tmpdit, codes, contents)) {
 		if (dit.depth() != 1 || dit.pit() != 0 || dit.pos() != 0) {
-			Inset * inset = &tmpdit.bottom().inset();
+			inset = &tmpdit.bottom().inset();
 			tmpdit = doc_iterator_begin(&inset->buffer(), inset);
 			if (!findNextInset(tmpdit, codes, contents))
 				return false;
@@ -227,14 +230,14 @@ enum ScreenUpdateStrategy {
 
 struct BufferView::Private
 {
-	Private(BufferView & bv) : update_strategy_(NoScreenUpdate),
-		wh_(0), cursor_(bv),
-		anchor_pit_(0), anchor_ypos_(0),
-		inlineCompletionUniqueChars_(0),
-		last_inset_(0), clickable_inset_(false),
-		mouse_position_cache_(),
-		bookmark_edit_position_(-1), gui_(0),
-		horiz_scroll_offset_(0)
+	Private(BufferView & bv) :
+		update_strategy_(FullScreenUpdate),
+		update_flags_(Update::Force),
+		cursor_(bv), anchor_pit_(0), anchor_ypos_(0),
+		wh_(0), inlineCompletionUniqueChars_(0),
+		last_inset_(nullptr), mouse_position_cache_(),
+		gui_(nullptr), bookmark_edit_position_(-1),
+		horiz_scroll_offset_(0), clickable_inset_(false)
 	{
 		xsel_cache_.set = false;
 	}
@@ -244,10 +247,13 @@ struct BufferView::Private
 	///
 	ScreenUpdateStrategy update_strategy_;
 	///
+	Update::flags update_flags_;
+	///
 	CoordCache coord_cache_;
+	///
+	typedef map<MathData const *, MathRow> MathRows;
+	MathRows math_rows_;
 
-	/// Estimated average par height for scrollbar.
-	int wh_;
 	/// this is used to handle XSelection events in the right manner.
 	struct {
 		CursorSlice cursor;
@@ -260,6 +266,8 @@ struct BufferView::Private
 	pit_type anchor_pit_;
 	///
 	int anchor_ypos_;
+	/// Estimated average par height for scrollbar.
+	int wh_;
 	///
 	vector<int> par_height_;
 
@@ -278,17 +286,12 @@ struct BufferView::Private
 	  * Not owned, so don't delete.
 	  */
 	Inset const * last_inset_;
-	/// are we hovering something that we can click
-	bool clickable_inset_;
 
 	/// position of the mouse at the time of the last mouse move
 	/// This is used to update the hovering status of inset in
 	/// cases where the buffer is scrolled, but the mouse didn't move.
 	Point mouse_position_cache_;
 
-	// cache for id of the paragraph which was edited the last time
-	int bookmark_edit_position_;
-
 	mutable TextMetricsCache text_metrics_;
 
 	/// Whom to notify.
@@ -304,13 +307,15 @@ struct BufferView::Private
 
 	/// When the row where the cursor lies is scrolled, this
 	/// contains the scroll offset
+	// cache for id of the paragraph which was edited the last time
+	int bookmark_edit_position_;
+
 	int horiz_scroll_offset_;
 	/// a slice pointing to the start of the row where the cursor
 	/// is (at last draw time)
 	CursorSlice current_row_slice_;
-	/// a slice pointing to the start of the row where cursor was
-	/// at previous draw event
-	CursorSlice last_row_slice_;
+	/// are we hovering something that we can click
+	bool clickable_inset_;
 };
 
 
@@ -338,9 +343,10 @@ BufferView::~BufferView()
 	// That is to say, if a cursor is in a nested inset, it will be
 	// restore to the left of the top level inset.
 	LastFilePosSection::FilePos fp;
+	fp.file = buffer_.fileName();
 	fp.pit = d->cursor_.bottom().pit();
 	fp.pos = d->cursor_.bottom().pos();
-	theSession().lastFilePos().save(buffer_.fileName(), fp);
+	theSession().lastFilePos().save(fp);
 
 	if (d->last_inset_)
 		d->last_inset_->setMouseHover(this, false);
@@ -351,8 +357,8 @@ BufferView::~BufferView()
 
 int BufferView::rightMargin() const
 {
-	// The value used to be hardcoded to 10, which is 0.1in at 100dpi
-	int const default_margin = Length(0.1, Length::IN).inPixels(0);
+	// The value used to be hardcoded to 10
+	int const default_margin = zoomedPixels(10);
 	// The additional test for the case the outliner is opened.
 	if (!full_screen_ || !lyxrc.full_screen_limit
 	    || width_ < lyxrc.full_screen_width + 2 * default_margin)
@@ -375,6 +381,21 @@ int BufferView::inPixels(Length const & len) const
 }
 
 
+int BufferView::zoomedPixels(int pix) const
+{
+	// FIXME: the dpi setting should really depend on the BufferView
+	// (think different monitors).
+
+	// Zoom factor specified by user in percent
+	double const zoom = lyxrc.currentZoom / 100.0; // [percent]
+
+	// DPI setting for monitor relative to 100dpi
+	double const dpizoom = lyxrc.dpi / 100.0; // [per 100dpi]
+
+	return support::iround(pix * zoom * dpizoom);
+}
+
+
 bool BufferView::isTopScreen() const
 {
 	return 0 == d->scrollbarParameters_.min;
@@ -411,6 +432,20 @@ CoordCache const & BufferView::coordCache() const
 }
 
 
+MathRow const & BufferView::mathRow(MathData const * cell) const
+{
+	auto it = d->math_rows_.find(cell);
+	LATTEST(it != d->math_rows_.end());
+	return it->second;
+}
+
+
+void BufferView::setMathRow(MathData const * cell, MathRow const & mrow)
+{
+	d->math_rows_[cell] = mrow;
+}
+
+
 Buffer & BufferView::buffer()
 {
 	return buffer_;
@@ -438,79 +473,96 @@ bool BufferView::needsFitCursor() const
 }
 
 
-void BufferView::processUpdateFlags(Update::flags flags)
+namespace {
+
+// this is for debugging only.
+string flagsAsString(Update::flags flags)
 {
-	// This is close to a hot-path.
-	LYXERR(Debug::PAINTING, "BufferView::processUpdateFlags()"
-		<< "[fitcursor = " << (flags & Update::FitCursor)
-		<< ", forceupdate = " << (flags & Update::Force)
-		<< ", singlepar = " << (flags & Update::SinglePar)
-		<< "]  buffer: " << &buffer_);
+	if (flags == Update::None)
+		return "None ";
+	return string((flags & Update::FitCursor) ? "FitCursor " : "")
+		+ ((flags & Update::Force) ? "Force " : "")
+		+ ((flags & Update::ForceDraw) ? "ForceDraw " : "")
+		+ ((flags & Update::SinglePar) ? "SinglePar " : "")
+		+ ((flags & Update::Decoration) ? "Decoration " : "");
+}
 
-	// FIXME Does this really need doing here? It's done in updateBuffer, and
-	// if the Buffer doesn't need updating, then do the macros?
-	buffer_.updateMacros();
+}
 
-	// Now do the first drawing step if needed. This consists on updating
-	// the CoordCache in updateMetrics().
-	// The second drawing step is done in WorkArea::redraw() if needed.
-	// FIXME: is this still true now that Buffer::changed() is used all over?
+void BufferView::processUpdateFlags(Update::flags flags)
+{
+	LYXERR(Debug::PAINTING, "BufferView::processUpdateFlags( "
+		   << flagsAsString(flags) << ")  buffer: " << &buffer_);
 
 	// Case when no explicit update is requested.
-	if (!flags) {
-		// no need to redraw anything.
-		d->update_strategy_ = NoScreenUpdate;
+	if (flags == Update::None)
 		return;
-	}
 
-	if (flags == Update::Decoration) {
-		d->update_strategy_ = DecorationUpdate;
-		buffer_.changed(false);
-		return;
+	/* FIXME We would like to avoid doing this here, since it is very
+	 * expensive and is called in updateBuffer already. However, even
+	 * inserting a plain character can invalidate the overly fragile
+	 * tables of child documents built by updateMacros. Some work is
+	 * needed to avoid doing that when not necessary.
+	 */
+	buffer_.updateMacros();
+
+	// First check whether the metrics and inset positions should be updated
+	if (flags & Update::Force) {
+		// This will update the CoordCache items and replace Force
+		// with ForceDraw in flags.
+		updateMetrics(flags);
 	}
 
-	if (flags == Update::FitCursor
-		|| flags == (Update::Decoration | Update::FitCursor)) {
-		// tell the frontend to update the screen if needed.
+	// Detect whether we can only repaint a single paragraph (if we
+	// are not already redrawing all).
+	// We handle this before FitCursor because the later will require
+	// correct metrics at cursor position.
+	if (!(flags & Update::ForceDraw)
+	    && (flags & Update::SinglePar)
+		&& !singleParUpdate())
+			updateMetrics(flags);
+
+	// Then make sure that the screen contains the cursor if needed
+	if (flags & Update::FitCursor) {
 		if (needsFitCursor()) {
-			showCursor();
-			return;
+			// First try to make the selection start visible
+			// (which is just the cursor when there is no selection)
+			scrollToCursor(d->cursor_.selectionBegin(), false);
+			// Is the cursor visible? (only useful if cursor is at end of selection)
+			if (needsFitCursor())
+				// then try to make cursor visible instead
+				scrollToCursor(d->cursor_, false);
+			// Metrics have to be recomputed (maybe again)
+			updateMetrics(flags);
 		}
-		if (flags & Update::Decoration) {
-			d->update_strategy_ = DecorationUpdate;
-			buffer_.changed(false);
-			return;
-		}
-		// no screen update is needed in principle, but this
-		// could change if cursor row needs horizontal scrolling.
-		d->update_strategy_ = NoScreenUpdate;
-		buffer_.changed(false);
-		return;
+		flags = flags & ~Update::FitCursor;
 	}
 
-	bool const full_metrics = flags & Update::Force || !singleParUpdate();
+	// Add flags to the the update flags. These will be reset to None
+	// after the redraw is actually done
+	d->update_flags_ = d->update_flags_ | flags;
+	LYXERR(Debug::PAINTING, "Cumulative flags: " << flagsAsString(flags));
 
-	if (full_metrics)
-		// We have to update the full screen metrics.
-		updateMetrics();
+	// Now compute the update strategy
+	// Possibly values in flag are None, SinglePar, Decoration, ForceDraw
+	LATTEST((d->update_flags_ & ~(Update::None | Update::SinglePar
+	                              | Update::Decoration | Update::ForceDraw)) == 0);
 
-	if (!(flags & Update::FitCursor)) {
-		// Nothing to do anymore. Trigger a redraw and return
-		buffer_.changed(false);
-		return;
-	}
-
-	// updateMetrics() does not update paragraph position
-	// This is done at draw() time. So we need a redraw!
-	buffer_.changed(false);
-
-	if (needsFitCursor()) {
-		// The cursor is off screen so ensure it is visible.
-		// refresh it:
-		showCursor();
+	if (d->update_flags_ & Update::ForceDraw)
+		d->update_strategy_ = FullScreenUpdate;
+	else if (d->update_flags_ & Update::Decoration)
+		d->update_strategy_ = DecorationUpdate;
+	else if (d->update_flags_ & Update::SinglePar)
+		d->update_strategy_ = SingleParUpdate;
+	else {
+		// no need to redraw anything.
+		d->update_strategy_ = NoScreenUpdate;
 	}
 
 	updateHoveredInset();
+
+	// Trigger a redraw.
+	buffer_.changed(false);
 }
 
 
@@ -625,8 +677,7 @@ void BufferView::scrollDocView(int const value, bool update)
 	// If the offset is less than 2 screen height, prefer to scroll instead.
 	if (abs(value) <= 2 * height_) {
 		d->anchor_ypos_ -= value;
-		buffer_.changed(true);
-		updateHoveredInset();
+		processUpdateFlags(Update::Force);
 		return;
 	}
 
@@ -787,7 +838,7 @@ bool BufferView::moveToPosition(pit_type bottom_pit, pos_type bottom_pos,
 		if (!dit.atEnd()) {
 			dit.pos() = min(dit.paragraph().size(), top_pos);
 			// Some slices of the iterator may not be
-			// reachable (e.g. closed collapsable inset)
+			// reachable (e.g. closed collapsible inset)
 			// so the dociterator may need to be
 			// shortened. Otherwise, setCursor may crash
 			// lyx when the cursor can not be set to these
@@ -823,12 +874,7 @@ bool BufferView::moveToPosition(pit_type bottom_pit, pos_type bottom_pos,
 		d->cursor_.setCurrentFont();
 		// Do not forget to reset the anchor (see #9912)
 		d->cursor_.resetAnchor();
-		// To center the screen on this new position we need the
-		// paragraph position which is computed at draw() time.
-		// So we need a redraw!
-		buffer_.changed(false);
-		if (needsFitCursor())
-			showCursor();
+		processUpdateFlags(Update::Force | Update::FitCursor);
 	}
 
 	return success;
@@ -870,19 +916,15 @@ void BufferView::showCursor()
 void BufferView::showCursor(DocIterator const & dit,
 	bool recenter, bool update)
 {
-	if (scrollToCursor(dit, recenter) && update) {
-		buffer_.changed(true);
-		updateHoveredInset();
-	}
+	if (scrollToCursor(dit, recenter) && update)
+		processUpdateFlags(Update::Force);
 }
 
 
 void BufferView::scrollToCursor()
 {
-	if (scrollToCursor(d->cursor_, false)) {
-		buffer_.changed(true);
-		updateHoveredInset();
-	}
+	if (scrollToCursor(d->cursor_, false))
+		processUpdateFlags(Update::Force);
 }
 
 
@@ -920,7 +962,7 @@ bool BufferView::scrollToCursor(DocIterator const & dit, bool const recenter)
 		int offset = coordOffset(dit).y_;
 		int ypos = pm.position() + offset;
 		Dimension const & row_dim =
-			pm.getRow(cs.pos(), dit.boundary()).dimension();
+			pm.getRow(cs.pos(), dit.boundary()).dim();
 		int scrolled = 0;
 		if (recenter)
 			scrolled = scroll(ypos - height_/2);
@@ -964,7 +1006,7 @@ bool BufferView::scrollToCursor(DocIterator const & dit, bool const recenter)
 	d->anchor_pit_ = bot_pit;
 	CursorSlice const & cs = dit.innerTextSlice();
 	Dimension const & row_dim =
-		pm.getRow(cs.pos(), dit.boundary()).dimension();
+		pm.getRow(cs.pos(), dit.boundary()).dim();
 
 	if (recenter)
 		d->anchor_ypos_ = height_/2;
@@ -1128,6 +1170,10 @@ bool BufferView::getStatus(FuncRequest const & cmd, FuncStatus & flag)
 		flag.setEnabled(true);
 		break;
 
+	case LFUN_GRAPHICS_UNIFY:
+		flag.setEnabled(cur.countInsetsInSelection(GRAPHICS_CODE)>1);
+		break;
+
 	case LFUN_WORD_FINDADV: {
 		FindAndReplaceOptions opt;
 		istringstream iss(to_utf8(cmd.argument()));
@@ -1218,13 +1264,16 @@ bool BufferView::getStatus(FuncRequest const & cmd, FuncStatus & flag)
 Inset * BufferView::editedInset(string const & name) const
 {
 	map<string, Inset *>::const_iterator it = d->edited_insets_.find(name);
-	return it == d->edited_insets_.end() ? 0 : it->second;
+	return it == d->edited_insets_.end() ? nullptr : it->second;
 }
 
 
 void BufferView::editInset(string const & name, Inset * inset)
 {
-	d->edited_insets_[name] = inset;
+	if (inset)
+		d->edited_insets_[name] = inset;
+	else
+		d->edited_insets_.erase(name);
 }
 
 
@@ -1326,7 +1375,7 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr)
 		//  without calling recordUndo. Fix this before using
 		//  recordUndoBufferParams().
 		cur.recordUndoFullBuffer();
-		buffer_.params().setBaseClass(argument);
+		buffer_.params().setBaseClass(argument, buffer_.layoutPos());
 		makeDocumentClass();
 		dr.screenUpdate(Update::Force);
 		dr.forceBufferUpdate();
@@ -1350,48 +1399,55 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr)
 	case LFUN_LAYOUT_RELOAD: {
 		LayoutFileIndex bc = buffer_.params().baseClassID();
 		LayoutFileList::get().reset(bc);
-		buffer_.params().setBaseClass(bc);
+		buffer_.params().setBaseClass(bc, buffer_.layoutPos());
 		makeDocumentClass();
 		dr.screenUpdate(Update::Force);
 		dr.forceBufferUpdate();
 		break;
 	}
 
-	case LFUN_UNDO:
+	case LFUN_UNDO: {
 		dr.setMessage(_("Undo"));
 		cur.clearSelection();
-		if (!cur.textUndo())
+		// We need to find out if the bibliography information
+		// has changed. See bug #11055.
+		// So these should not be references...
+		string const engine = buffer().params().citeEngine();
+		CiteEngineType const enginetype = buffer().params().citeEngineType();
+		if (!cur.undoAction())
 			dr.setMessage(_("No further undo information"));
-		else
+		else {
 			dr.screenUpdate(Update::Force | Update::FitCursor);
-		dr.forceBufferUpdate();
-		// we only need to do this if we have deleted or restored a
-		// BiBTeX inset. but there is no other place to do it. one
-		// obvious idea is to try to do it in a copy constructor for
-		// InsetBibTeX, but when that is invoked, the buffer_ member
-		// is not yet set. another idea is to look at the InsetLists
-		// of the various paragraphs. but we'd have to recurse through
-		// the contained insets to make that work. it doesn't seem to
-		// be worth it, as this will not happen that often.
-		buffer().invalidateBibfileCache();
-		buffer().removeBiblioTempFiles();
+			dr.forceBufferUpdate();
+			if (buffer().params().citeEngine() != engine ||
+			    buffer().params().citeEngineType() != enginetype)
+				buffer().invalidateCiteLabels();
+		}
 		break;
+	}
 
-	case LFUN_REDO:
+	case LFUN_REDO: {
 		dr.setMessage(_("Redo"));
 		cur.clearSelection();
-		if (!cur.textRedo())
+		// We need to find out if the bibliography information
+		// has changed. See bug #11055.
+		// So these should not be references...
+		string const engine = buffer().params().citeEngine();
+		CiteEngineType const enginetype = buffer().params().citeEngineType();
+		if (!cur.redoAction())
 			dr.setMessage(_("No further redo information"));
-		else
+		else {
 			dr.screenUpdate(Update::Force | Update::FitCursor);
-		dr.forceBufferUpdate();
-		// see above
-		buffer().invalidateBibfileCache();
-		buffer().removeBiblioTempFiles();
+			dr.forceBufferUpdate();
+			if (buffer().params().citeEngine() != engine ||
+			    buffer().params().citeEngineType() != enginetype)
+				buffer().invalidateCiteLabels();
+		}
 		break;
+	}
 
 	case LFUN_FONT_STATE:
-		dr.setMessage(cur.currentState());
+		dr.setMessage(cur.currentState(false));
 		break;
 
 	case LFUN_BOOKMARK_SAVE:
@@ -1430,14 +1486,14 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr)
 		for (Buffer * b = &buffer_; i == 0 || b != &buffer_;
 			b = theBufferList().next(b)) {
 
-			Cursor cur(*this);
-			cur.setCursor(b->getParFromID(id));
-			if (cur.atEnd()) {
+			Cursor curs(*this);
+			curs.setCursor(b->getParFromID(id));
+			if (curs.atEnd()) {
 				LYXERR(Debug::INFO, "No matching paragraph found! [" << id << "].");
 				++i;
 				continue;
 			}
-			LYXERR(Debug::INFO, "Paragraph " << cur.paragraph().id()
+			LYXERR(Debug::INFO, "Paragraph " << curs.paragraph().id()
 				<< " found in buffer `"
 				<< b->absFileName() << "'.");
 
@@ -1445,8 +1501,8 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr)
 				bool success;
 				if (str_id_end.empty() || str_pos_end.empty()) {
 					// Set the cursor
-					cur.pos() = pos;
-					mouseSetCursor(cur);
+					curs.pos() = pos;
+					mouseSetCursor(curs);
 					success = true;
 				} else {
 					int const id_end = convert<int>(str_id_end);
@@ -1481,12 +1537,18 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr)
 
 	case LFUN_CHANGE_NEXT:
 		findNextChange(this);
+		if (cur.inset().isTable())
+			// In tables, there might be whole changed rows or columns
+			cur.dispatch(cmd);
 		// FIXME: Move this LFUN to Buffer so that we don't have to do this:
 		dr.screenUpdate(Update::Force | Update::FitCursor);
 		break;
 
 	case LFUN_CHANGE_PREVIOUS:
 		findPreviousChange(this);
+		if (cur.inset().isTable())
+			// In tables, there might be whole changed rows or columns
+			cur.dispatch(cmd);
 		// FIXME: Move this LFUN to Buffer so that we don't have to do this:
 		dr.screenUpdate(Update::Force | Update::FitCursor);
 		break;
@@ -1499,32 +1561,43 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr)
 		}
 		break;
 
-	case LFUN_ALL_CHANGES_ACCEPT:
+	case LFUN_ALL_CHANGES_ACCEPT: {
 		// select complete document
 		cur.reset();
 		cur.selHandle(true);
 		buffer_.text().cursorBottom(cur);
 		// accept everything in a single step to support atomic undo
+		// temporarily disable track changes in order to end with really
+		// no new (e.g., DPSM-caused) changes (see #7487)
+		bool const track = buffer_.params().track_changes;
+		buffer_.params().track_changes = false;
 		buffer_.text().acceptOrRejectChanges(cur, Text::ACCEPT);
+		buffer_.params().track_changes = track;
 		cur.resetAnchor();
 		// FIXME: Move this LFUN to Buffer so that we don't have to do this:
 		dr.screenUpdate(Update::Force | Update::FitCursor);
 		dr.forceBufferUpdate();
 		break;
+	}
 
-	case LFUN_ALL_CHANGES_REJECT:
+	case LFUN_ALL_CHANGES_REJECT: {
 		// select complete document
 		cur.reset();
 		cur.selHandle(true);
 		buffer_.text().cursorBottom(cur);
 		// reject everything in a single step to support atomic undo
-		// Note: reject does not work recursively; the user may have to repeat the operation
+		// temporarily disable track changes in order to end with really
+		// no new (e.g., DPSM-caused) changes (see #7487)
+		bool const track = buffer_.params().track_changes;
+		buffer_.params().track_changes = false;
 		buffer_.text().acceptOrRejectChanges(cur, Text::REJECT);
+		buffer_.params().track_changes = track;
 		cur.resetAnchor();
 		// FIXME: Move this LFUN to Buffer so that we don't have to do this:
 		dr.screenUpdate(Update::Force | Update::FitCursor);
 		dr.forceBufferUpdate();
 		break;
+	}
 
 	case LFUN_WORD_FIND_FORWARD:
 	case LFUN_WORD_FIND_BACKWARD: {
@@ -1640,10 +1713,8 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr)
 		InsetBibtex * inset = getInsetByCode<InsetBibtex>(tmpcur,
 						BIBTEX_CODE);
 		if (inset) {
-			if (inset->addDatabase(cmd.argument())) {
-				buffer_.invalidateBibfileCache();
+			if (inset->addDatabase(cmd.argument()))
 				dr.forceBufferUpdate();
-			}
 		}
 		break;
 	}
@@ -1654,11 +1725,48 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr)
 		InsetBibtex * inset = getInsetByCode<InsetBibtex>(tmpcur,
 						BIBTEX_CODE);
 		if (inset) {
-			if (inset->delDatabase(cmd.argument())) {
-				buffer_.invalidateBibfileCache();
+			if (inset->delDatabase(cmd.argument()))
 				dr.forceBufferUpdate();
+		}
+		break;
+	}
+
+	case LFUN_GRAPHICS_UNIFY: {
+
+		cur.recordUndoFullBuffer();
+
+		DocIterator from, to;
+		from = cur.selectionBegin();
+		to = cur.selectionEnd();
+
+		string const newId = cmd.getArg(0);
+		bool fetchId = newId.empty(); //if we wait for groupId from first graphics inset
+
+		InsetGraphicsParams grp_par;
+		if (!fetchId)
+			InsetGraphics::string2params(graphics::getGroupParams(buffer_, newId), buffer_, grp_par);
+
+		if (!from.nextInset())	//move to closest inset
+			from.forwardInset();
+
+		while (!from.empty() && from < to) {
+			Inset * inset = from.nextInset();
+			if (!inset)
+				break;
+			InsetGraphics * ig = inset->asInsetGraphics();
+			if (ig) {
+				InsetGraphicsParams inspar = ig->getParams();
+				if (fetchId) {
+				        grp_par = inspar;
+					fetchId = false;
+				} else {
+					grp_par.filename = inspar.filename;
+					ig->setParams(grp_par);
+				}
 			}
+			from.forwardInset();
 		}
+		dr.screenUpdate(Update::Force); //needed if triggered from context menu
 		break;
 	}
 
@@ -1721,8 +1829,8 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr)
 		bool const in_texted = cur.inTexted();
 		cur.setCursor(doc_iterator_begin(cur.buffer()));
 		cur.selHandle(false);
-		buffer_.changed(true);
-		updateHoveredInset();
+		// Force an immediate computation of metrics because we need it below
+		processUpdateFlags(Update::Force);
 
 		d->text_metrics_[&buffer_.text()].editXY(cur, p.x_, p.y_,
 			true, act == LFUN_SCREEN_UP);
@@ -1756,8 +1864,7 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr)
 			if (scroll_value)
 				scroll(scroll_step * scroll_value);
 		}
-		buffer_.changed(true);
-		updateHoveredInset();
+		dr.screenUpdate(Update::ForceDraw);
 		dr.forceBufferUpdate();
 		break;
 	}
@@ -1820,10 +1927,12 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr)
 			// At least one complete cell is selected and inset is a table.
 			// Select all cells
 			cur.idx() = 0;
+			cur.pit() = 0;
 			cur.pos() = 0;
 			cur.resetAnchor();
 			cur.selection(true);
 			cur.idx() = cur.lastidx();
+			cur.pit() = cur.lastpit();
 			cur.pos() = cur.lastpos();
 		} else {
 			// select current cell
@@ -1840,6 +1949,33 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr)
 	}
 
 
+	case LFUN_UNICODE_INSERT: {
+		if (cmd.argument().empty())
+			break;
+
+		FuncCode code = cur.inset().currentMode() == Inset::MATH_MODE ?
+			LFUN_MATH_INSERT : LFUN_SELF_INSERT;
+		int i = 0;
+		while (true) {
+			docstring const arg = from_utf8(cmd.getArg(i));
+			if (arg.empty())
+				break;
+			if (!isHex(arg)) {
+				LYXERR0("Not a hexstring: " << arg);
+				++i;
+				continue;
+			}
+			char_type c = hexToInt(arg);
+			if (c >= 32 && c < 0x10ffff) {
+				LYXERR(Debug::KEY, "Inserting c: " << c);
+				lyx::dispatch(FuncRequest(code, docstring(1, c)));
+			}
+			++i;
+		}
+		break;
+	}
+
+
 	// This would be in Buffer class if only Cursor did not
 	// require a bufferview
 	case LFUN_INSET_FORALL: {
@@ -1850,20 +1986,20 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr)
 		// an arbitrary number to limit number of iterations
 		const int max_iter = 100000;
 		int iterations = 0;
-		Cursor & cur = d->cursor_;
-		Cursor const savecur = cur;
-		cur.reset();
-		if (!cur.nextInset())
-			cur.forwardInset();
-		cur.beginUndoGroup();
-		while(cur && iterations < max_iter) {
-			Inset * const ins = cur.nextInset();
+		Cursor & curs = d->cursor_;
+		Cursor const savecur = curs;
+		curs.reset();
+		if (!curs.nextInset())
+			curs.forwardInset();
+		curs.beginUndoGroup();
+		while(curs && iterations < max_iter) {
+			Inset * const ins = curs.nextInset();
 			if (!ins)
 				break;
 			docstring insname = ins->layoutName();
 			while (!insname.empty()) {
 				if (insname == name || name == from_utf8("*")) {
-					cur.recordUndo();
+					curs.recordUndo();
 					lyx::dispatch(fr, dr);
 					++iterations;
 					break;
@@ -1874,11 +2010,11 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr)
 				insname = insname.substr(0, i);
 			}
 			// if we did not delete the inset, skip it
-			if (!cur.nextInset() || cur.nextInset() == ins)
-				cur.forwardInset();
+			if (!curs.nextInset() || curs.nextInset() == ins)
+				curs.forwardInset();
 		}
-		cur = savecur;
-		cur.fixIfBroken();
+		curs = savecur;
+		curs.fixIfBroken();
 		/** This is a dummy undo record only to remember the cursor
 		 * that has just been set; this will be used on a redo action
 		 * (see ticket #10097)
@@ -1886,8 +2022,8 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr)
 		 * FIXME: a better fix would be to have a way to set the
 		 * cursor value directly, but I am not sure it is worth it.
 		 */
-		cur.recordUndo();
-		cur.endUndoGroup();
+		curs.recordUndo();
+		curs.endUndoGroup();
 		dr.screenUpdate(Update::Force);
 		dr.forceBufferUpdate();
 
@@ -1913,14 +2049,9 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr)
 			Alert::warning(_("Branch already exists"), drtmp.message());
 			break;
 		}
-		BranchList & branch_list = buffer_.params().branchlist();
-		vector<docstring> const branches =
-			getVectorFromString(branch_name, branch_list.separator());
-		for (vector<docstring>::const_iterator it = branches.begin();
-		     it != branches.end(); ++it) {
-			branch_name = *it;
-			lyx::dispatch(FuncRequest(LFUN_BRANCH_INSERT, branch_name));
-		}
+		docstring const sep = buffer_.params().branchlist().separator();
+		for (docstring const & branch : getVectorFromString(branch_name, sep))
+			lyx::dispatch(FuncRequest(LFUN_BRANCH_INSERT, branch));
 		break;
 	}
 
@@ -1987,6 +2118,8 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr)
 		icp["key"] = from_utf8(arg);
 		if (!opt1.empty())
 			icp["before"] = from_utf8(opt1);
+		icp["literal"] = 
+			from_ascii(InsetCitation::last_literal ? "true" : "false");
 		string icstr = InsetCommand::params2string(icp);
 		FuncRequest fr(LFUN_INSET_INSERT, icstr);
 		lyx::dispatch(fr);
@@ -2071,7 +2204,7 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr)
 }
 
 
-docstring const BufferView::requestSelection()
+docstring BufferView::requestSelection()
 {
 	Cursor & cur = d->cursor_;
 
@@ -2128,7 +2261,7 @@ Inset const * BufferView::getCoveringInset(Text const & text,
 	TextMetrics & tm = d->text_metrics_[&text];
 	Inset * inset = tm.checkInsetHit(x, y);
 	if (!inset)
-		return 0;
+		return nullptr;
 
 	if (!inset->descendable(*this))
 		// No need to go further down if the inset is not
@@ -2169,7 +2302,7 @@ void BufferView::updateHoveredInset() const
 	if (d->last_inset_) {
 		// Remove the hint on the last hovered inset (if any).
 		need_redraw |= d->last_inset_->setMouseHover(this, false);
-		d->last_inset_ = 0;
+		d->last_inset_ = nullptr;
 	}
 
 	if (covering_inset && covering_inset->setMouseHover(this, true)) {
@@ -2200,7 +2333,7 @@ void BufferView::clearLastInset(Inset * inset) const
 		LYXERR0("Wrong last_inset!");
 		LATTEST(false);
 	}
-	d->last_inset_ = 0;
+	d->last_inset_ = nullptr;
 }
 
 
@@ -2407,22 +2540,26 @@ bool BufferView::setCursorFromInset(Inset const * inset)
 
 void BufferView::gotoLabel(docstring const & label)
 {
-	ListOfBuffers bufs = buffer().allRelatives();
-	ListOfBuffers::iterator it = bufs.begin();
-	for (; it != bufs.end(); ++it) {
-		Buffer const * buf = *it;
-
+	FuncRequest action;
+	bool have_inactive = false;
+	for (Buffer const * buf : buffer().allRelatives()) {
 		// find label
-		shared_ptr<Toc> toc = buf->tocBackend().toc("label");
-		Toc::const_iterator toc_it = toc->begin();
-		Toc::const_iterator end = toc->end();
-		for (; toc_it != end; ++toc_it) {
-			if (label == toc_it->str()) {
-				lyx::dispatch(toc_it->action());
+		for (TocItem const & item : *buf->tocBackend().toc("label")) {
+			if (label == item.str() && item.isOutput()) {
+				lyx::dispatch(item.action());
 				return;
 			}
+			// If we find an inactive label, save it for the case
+			// that no active one is there
+			if (label == item.str() && !have_inactive) {
+				have_inactive = true;
+				action = item.action();
+			}
 		}
 	}
+	// We only found an inactive label. Go there.
+	if (have_inactive)
+		lyx::dispatch(action);
 }
 
 
@@ -2437,8 +2574,9 @@ TextMetrics & BufferView::textMetrics(Text const * t)
 	LBUFERR(t);
 	TextMetricsCache::iterator tmc_it  = d->text_metrics_.find(t);
 	if (tmc_it == d->text_metrics_.end()) {
-		tmc_it = d->text_metrics_.insert(
-			make_pair(t, TextMetrics(this, const_cast<Text *>(t)))).first;
+		tmc_it = d->text_metrics_.emplace(std::piecewise_construct,
+		         	std::forward_as_tuple(t),
+		         	std::forward_as_tuple(this, const_cast<Text *>(t))).first;
 	}
 	return tmc_it->second;
 }
@@ -2494,7 +2632,7 @@ bool BufferView::checkDepm(Cursor & cur, Cursor & old)
 		return false;
 
 	bool need_anchor_change = false;
-	bool changed = d->cursor_.text()->deleteEmptyParagraphMechanism(cur, old,
+	bool changed = Text::deleteEmptyParagraphMechanism(cur, old,
 		need_anchor_change);
 
 	if (need_anchor_change)
@@ -2623,12 +2761,6 @@ Cursor const & BufferView::cursor() const
 }
 
 
-pit_type BufferView::anchor_ref() const
-{
-	return d->anchor_pit_;
-}
-
-
 bool BufferView::singleParUpdate()
 {
 	Text & buftext = buffer_.text();
@@ -2651,7 +2783,7 @@ bool BufferView::singleParUpdate()
 		// the singlePar optimisation.
 		return false;
 
-	d->update_strategy_ = SingleParUpdate;
+	tm.updatePosCache(bottom_pit);
 
 	LYXERR(Debug::PAINTING, "\ny1: " << pm.position() - pm.ascent()
 		<< " y2: " << pm.position() + pm.descent()
@@ -2662,6 +2794,13 @@ bool BufferView::singleParUpdate()
 
 
 void BufferView::updateMetrics()
+{
+	updateMetrics(d->update_flags_);
+	d->update_strategy_ = FullScreenUpdate;
+}
+
+
+void BufferView::updateMetrics(Update::flags & update_flags)
 {
 	if (height_ == 0 || width_ == 0)
 		return;
@@ -2671,6 +2810,7 @@ void BufferView::updateMetrics()
 
 	// Clear out the position cache in case of full screen redraw,
 	d->coord_cache_.clear();
+	d->math_rows_.clear();
 
 	// Clear out paragraph metrics to avoid having invalid metrics
 	// in the cache from paragraphs not relayouted below
@@ -2698,12 +2838,13 @@ void BufferView::updateMetrics()
 		// Complete buffer visible? Then it's easy.
 		if (scrollRange == 0)
 			d->anchor_ypos_ = anchor_pm.ascent();
-
-		// FIXME: Some clever handling needed to show
-		// the _first_ paragraph up to the top if the cursor is
-		// in the first line.
+		else {
+			// avoid empty space above the first row
+			d->anchor_ypos_ = min(d->anchor_ypos_, anchor_pm.ascent());
+		}
 	}
 	anchor_pm.setPosition(d->anchor_ypos_);
+	tm.updatePosCache(d->anchor_pit_);
 
 	LYXERR(Debug::PAINTING, "metrics: "
 		<< " anchor pit = " << d->anchor_pit_
@@ -2719,6 +2860,7 @@ void BufferView::updateMetrics()
 		y1 -= pm.descent();
 		// Save the paragraph position in the cache.
 		pm.setPosition(y1);
+		tm.updatePosCache(pit1);
 		y1 -= pm.ascent();
 	}
 
@@ -2732,6 +2874,7 @@ void BufferView::updateMetrics()
 		y2 += pm.ascent();
 		// Save the paragraph position in the cache.
 		pm.setPosition(y2);
+		tm.updatePosCache(pit2);
 		y2 += pm.descent();
 	}
 
@@ -2743,7 +2886,11 @@ void BufferView::updateMetrics()
 		<< " pit1 = " << pit1
 		<< " pit2 = " << pit2);
 
-	d->update_strategy_ = FullScreenUpdate;
+	// metrics is done, full drawing is necessary now
+	update_flags = (update_flags & ~Update::Force) | Update::ForceDraw;
+
+	// Now update the positions of insets in the cache.
+	updatePosCache();
 
 	if (lyxerr.debugging(Debug::WORKAREA)) {
 		LYXERR(Debug::WORKAREA, "BufferView::updateMetrics");
@@ -2752,7 +2899,16 @@ void BufferView::updateMetrics()
 }
 
 
-void BufferView::insertLyXFile(FileName const & fname)
+void BufferView::updatePosCache()
+{
+	// this is the "nodraw" drawing stage: only set the positions of the
+	// insets in metrics cache.
+	frontend::NullPainter np;
+	draw(np, false);
+}
+
+
+void BufferView::insertLyXFile(FileName const & fname, bool const ignorelang)
 {
 	LASSERT(d->cursor_.inTexted(), return);
 
@@ -2770,8 +2926,12 @@ void BufferView::insertLyXFile(FileName const & fname)
 		ErrorList & el = buffer_.errorList("Parse");
 		// Copy the inserted document error list into the current buffer one.
 		el = buf.errorList("Parse");
+		ParagraphList & pars = buf.paragraphs();
+		if (ignorelang)
+			// set main language of imported file to context language
+			buf.changeLanguage(buf.language(), d->cursor_.getFont().language());
 		buffer_.undo().recordUndo(d->cursor_);
-		cap::pasteParagraphList(d->cursor_, buf.paragraphs(),
+		cap::pasteParagraphList(d->cursor_, pars,
 					     buf.params().documentClassPtr(), el);
 		res = _("Document %1$s inserted.");
 	} else {
@@ -2886,24 +3046,36 @@ bool BufferView::paragraphVisible(DocIterator const & dit) const
 }
 
 
-void BufferView::cursorPosAndHeight(Point & p, int & h) const
+void BufferView::caretPosAndHeight(Point & p, int & h) const
 {
+	int asc, des;
 	Cursor const & cur = cursor();
-	Font const font = cur.real_current_font;
-	frontend::FontMetrics const & fm = theFontMetrics(font);
-	int const asc = fm.maxAscent();
-	int const des = fm.maxDescent();
+	if (cur.inMathed()) {
+		MathRow const & mrow = mathRow(&cur.cell());
+		asc = mrow.caret_ascent;
+		des = mrow.caret_descent;
+	} else {
+		Font const font = cur.real_current_font;
+		frontend::FontMetrics const & fm = theFontMetrics(font);
+		asc = fm.maxAscent();
+		des = fm.maxDescent();
+	}
 	h = asc + des;
 	p = getPos(cur);
 	p.y_ -= asc;
 }
 
 
-bool BufferView::cursorInView(Point const & p, int h) const
+bool BufferView::caretInView() const
 {
-	Cursor const & cur = cursor();
+	if (!paragraphVisible(cursor()))
+		return false;
+	Point p;
+	int h;
+	caretPosAndHeight(p, h);
+
 	// does the cursor touch the screen ?
-	if (p.y_ + h < 0 || p.y_ >= workHeight() || !paragraphVisible(cur))
+	if (p.y_ + h < 0 || p.y_ >= workHeight())
 		return false;
 	return true;
 }
@@ -2928,30 +3100,24 @@ int BufferView::horizScrollOffset(Text const * text,
 }
 
 
-bool BufferView::hadHorizScrollOffset(Text const * text,
-                                      pit_type pit, pos_type pos) const
-{
-	return !d->last_row_slice_.empty()
-	       && &text->inset() == d->last_row_slice_.inset().asInsetText()
-	       && pit ==  d->last_row_slice_.pit()
-	       && pos ==  d->last_row_slice_.pos();
-}
-
-
 void BufferView::setCurrentRowSlice(CursorSlice const & rowSlice)
 {
 	// nothing to do if the cursor was already on this row
-	if (d->current_row_slice_ == rowSlice) {
-		d->last_row_slice_ = CursorSlice();
+	if (d->current_row_slice_ == rowSlice)
 		return;
-	}
 
 	// if the (previous) current row was scrolled, we have to
 	// remember it in order to repaint it next time.
-	if (d->horiz_scroll_offset_ != 0)
-		d->last_row_slice_ = d->current_row_slice_;
-	else
-		d->last_row_slice_ = CursorSlice();
+	if (d->horiz_scroll_offset_ != 0) {
+		// search the old row in cache and mark it changed
+		for (auto & tm_pair : d->text_metrics_) {
+			if (&tm_pair.first->inset() == rowSlice.inset().asInsetText()) {
+				tm_pair.second.setRowChanged(rowSlice.pit(), rowSlice.pos());
+				// We found it, no need to continue.
+				break;
+			}
+		}
+	}
 
 	// Since we changed row, the scroll offset is not valid anymore
 	d->horiz_scroll_offset_ = 0;
@@ -2959,7 +3125,7 @@ void BufferView::setCurrentRowSlice(CursorSlice const & rowSlice)
 }
 
 
-void BufferView::checkCursorScrollOffset(PainterInfo & pi)
+void BufferView::checkCursorScrollOffset()
 {
 	CursorSlice rowSlice = d->cursor_.bottom();
 	TextMetrics const & tm = textMetrics(rowSlice.text());
@@ -2976,35 +3142,6 @@ void BufferView::checkCursorScrollOffset(PainterInfo & pi)
 	// Set the row on which the cursor lives.
 	setCurrentRowSlice(rowSlice);
 
-	// If insets referred to by cursor are not all in the cache, the positions
-	// need to be recomputed.
-	if (!d->cursor_.inCoordCache()) {
-		/** FIXME: the code below adds an extraneous computation of
-		 * inset positions, and can therefore be bad for performance
-		 * (think for example about a very large tabular inset.
-		 * Redawing the row where it is means redrawing the whole
-		 * screen).
-		 *
-		 * The bug that this fixes is the following: assume that there
-		 * is a very large math inset. Upon entering the inset, when
-		 * pressing `End', the row is not scrolled and the cursor is
-		 * not visible. The extra row computation makes sure that the
-		 * inset positions are correctly computed and set in the
-		 * cache. This would not happen if we did not have two-stage
-		 * drawing.
-		 *
-		 * A proper fix would be to always have proper inset positions
-		 * at this point.
-		 */
-		// Force the recomputation of inset positions
-		bool const drawing = pi.pain.isDrawingEnabled();
-		pi.pain.setDrawingEnabled(false);
-		// No need to care about vertical position.
-		RowPainter rp(pi, buffer().text(), row, -d->horiz_scroll_offset_, 0);
-		rp.paintText();
-		pi.pain.setDrawingEnabled(drawing);
-	}
-
 	// Current x position of the cursor in pixels
 	int cur_x = getPos(d->cursor_).x_;
 
@@ -3037,8 +3174,7 @@ void BufferView::checkCursorScrollOffset(PainterInfo & pi)
 		       << d->horiz_scroll_offset_ << " to " << offset);
 
 	if (d->update_strategy_ == NoScreenUpdate
-	    && (offset != d->horiz_scroll_offset_
-		|| !d->last_row_slice_.empty())) {
+	    && offset != d->horiz_scroll_offset_) {
 		// FIXME: if one uses SingleParUpdate, then home/end
 		// will not work on long rows. Why?
 		d->update_strategy_ = FullScreenUpdate;
@@ -3048,12 +3184,12 @@ void BufferView::checkCursorScrollOffset(PainterInfo & pi)
 }
 
 
-void BufferView::draw(frontend::Painter & pain)
+void BufferView::draw(frontend::Painter & pain, bool paint_caret)
 {
 	if (height_ == 0 || width_ == 0)
 		return;
-	LYXERR(Debug::PAINTING, "\t\t*** START DRAWING ***");
-
+	LYXERR(Debug::PAINTING, (pain.isNull() ? "\t\t--- START NODRAW ---"
+	                         : "\t\t*** START DRAWING ***"));
 	Text & text = buffer_.text();
 	TextMetrics const & tm = d->text_metrics_[&text];
 	int const y = tm.first().second->position();
@@ -3061,17 +3197,22 @@ void BufferView::draw(frontend::Painter & pain)
 
 	// Check whether the row where the cursor lives needs to be scrolled.
 	// Update the drawing strategy if needed.
-	checkCursorScrollOffset(pi);
+	checkCursorScrollOffset();
 
 	switch (d->update_strategy_) {
 
 	case NoScreenUpdate:
-		// If no screen painting is actually needed, only some the different
-		// coordinates of insets and paragraphs needs to be updated.
+		// no screen painting is actually needed. In nodraw stage
+		// however, the different coordinates of insets and paragraphs
+		// needs to be updated.
 		LYXERR(Debug::PAINTING, "Strategy: NoScreenUpdate");
-		pi.full_repaint = true;
-		pi.pain.setDrawingEnabled(false);
-		tm.draw(pi, 0, y);
+		if (pain.isNull()) {
+			pi.full_repaint = true;
+			tm.draw(pi, 0, y);
+		} else {
+			pi.full_repaint = false;
+			tm.draw(pi, 0, y);
+		}
 		break;
 
 	case SingleParUpdate:
@@ -3116,7 +3257,8 @@ void BufferView::draw(frontend::Painter & pain)
 		}
 		break;
 	}
-	LYXERR(Debug::PAINTING, "\n\t\t*** END DRAWING  ***");
+	LYXERR(Debug::PAINTING, (pain.isNull() ? "\t\t --- END NODRAW ---"
+	                        : "\t\t *** END DRAWING ***"));
 
 	// The scrollbar needs an update.
 	updateScrollbar();
@@ -3127,13 +3269,29 @@ void BufferView::draw(frontend::Painter & pain)
 	for (pit_type pit = firstpm.first; pit <= lastpm.first; ++pit) {
 		ParagraphMetrics const & pm = tm.parMetrics(pit);
 		if (pm.position() + pm.descent() > 0) {
+			if (d->anchor_pit_ != pit
+			    || d->anchor_ypos_ != pm.position())
+				LYXERR(Debug::PAINTING, "Found new anchor pit = " << d->anchor_pit_
+				       << "  anchor ypos = " << d->anchor_ypos_);
 			d->anchor_pit_ = pit;
 			d->anchor_ypos_ = pm.position();
 			break;
 		}
 	}
-	LYXERR(Debug::PAINTING, "Found new anchor pit = " << d->anchor_pit_
-		<< "  anchor ypos = " << d->anchor_ypos_);
+	if (!pain.isNull()) {
+		// reset the update flags, everything has been done
+		d->update_flags_ = Update::None;
+	}
+
+	// If a caret has to be painted, mark its text row as dirty to
+	//make sure that it will be repainted on next redraw.
+	/* FIXME: investigate whether this can be avoided when the cursor did not
+	 * move at all
+	 */
+	if (paint_caret) {
+		Row const & caret_row = d->cursor_.textRow();
+		caret_row.changed(true);
+	}
 }