X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FBufferView.cpp;h=77ab989d193962f602d96435b8c0fbc1f41e0128;hb=28be7d552f62cc02fa86d7f79201d089bfb2d7b5;hp=cb2b7fba0362c78ddd39f94e4879f44b6d9c4a84;hpb=9f62413b103b74dbbd223388101b537a4988cae2;p=lyx.git

diff --git a/src/BufferView.cpp b/src/BufferView.cpp
index cb2b7fba03..77ab989d19 100644
--- a/src/BufferView.cpp
+++ b/src/BufferView.cpp
@@ -35,6 +35,7 @@
 #include "Language.h"
 #include "LaTeXFeatures.h"
 #include "LayoutFile.h"
+#include "Length.h"
 #include "Lexer.h"
 #include "LyX.h"
 #include "LyXAction.h"
@@ -45,6 +46,7 @@
 #include "Paragraph.h"
 #include "ParagraphParameters.h"
 #include "ParIterator.h"
+#include "RowPainter.h"
 #include "Session.h"
 #include "Text.h"
 #include "TextClass.h"
@@ -62,6 +64,8 @@
 #include "insets/InsetRef.h"
 #include "insets/InsetText.h"
 
+#include "mathed/MathData.h"
+
 #include "frontends/alert.h"
 #include "frontends/Application.h"
 #include "frontends/Delegates.h"
@@ -116,12 +120,12 @@ bool findNextInset(DocIterator & dit, vector<InsetCode> const & codes,
 	while (tmpdit) {
 		Inset const * inset = tmpdit.nextInset();
 		if (inset) {
-			bool const valid_code = std::find(codes.begin(), codes.end(), 
+			bool const valid_code = std::find(codes.begin(), codes.end(),
 				inset->lyxCode()) != codes.end();
 			InsetCommand const * ic = inset->asInsetCommand();
 			bool const same_or_no_contents =  contents.empty()
 				|| (ic && (ic->getFirstNonOptParam() == contents));
-			
+
 			if (valid_code && same_or_no_contents) {
 				dit = tmpdit;
 				return true;
@@ -223,13 +227,17 @@ enum ScreenUpdateStrategy {
 
 struct BufferView::Private
 {
-	Private(BufferView & bv): wh_(0), cursor_(bv),
+	Private(BufferView & bv) : update_strategy_(NoScreenUpdate),
+		wh_(0), cursor_(bv),
 		anchor_pit_(0), anchor_ypos_(0),
 		inlineCompletionUniqueChars_(0),
-		last_inset_(0), clickable_inset_(false), 
+		last_inset_(0), clickable_inset_(false),
 		mouse_position_cache_(),
-		bookmark_edit_position_(-1), gui_(0)
-	{}
+		bookmark_edit_position_(-1), gui_(0),
+		horiz_scroll_offset_(0)
+	{
+		xsel_cache_.set = false;
+	}
 
 	///
 	ScrollbarParameters scrollbarParameters_;
@@ -293,6 +301,16 @@ struct BufferView::Private
 
 	///
 	map<string, Inset *> edited_insets_;
+
+	/// When the row where the cursor lies is scrolled, this
+	/// contains the scroll offset
+	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_;
 };
 
 
@@ -323,9 +341,9 @@ BufferView::~BufferView()
 	fp.pit = d->cursor_.bottom().pit();
 	fp.pos = d->cursor_.bottom().pos();
 	theSession().lastFilePos().save(buffer_.fileName(), fp);
-	
+
 	if (d->last_inset_)
-		d->last_inset_->setMouseHover(this, false);	
+		d->last_inset_->setMouseHover(this, false);
 
 	delete d;
 }
@@ -333,11 +351,12 @@ 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 additional test for the case the outliner is opened.
-	if (!full_screen_ ||
-		!lyxrc.full_screen_limit ||
-		width_ < lyxrc.full_screen_width + 20)
-			return 10;
+	if (!full_screen_ || !lyxrc.full_screen_limit
+	    || width_ < lyxrc.full_screen_width + 2 * default_margin)
+		return default_margin;
 
 	return (width_ - lyxrc.full_screen_width) / 2;
 }
@@ -349,15 +368,22 @@ int BufferView::leftMargin() const
 }
 
 
+int BufferView::inPixels(Length const & len) const
+{
+	Font const font = buffer().params().getFont();
+	return len.inPixels(workWidth(), theFontMetrics(font).em());
+}
+
+
 bool BufferView::isTopScreen() const
 {
-	return d->scrollbarParameters_.position == d->scrollbarParameters_.min;
+	return 0 == d->scrollbarParameters_.min;
 }
 
 
 bool BufferView::isBottomScreen() const
 {
-	return d->scrollbarParameters_.position == d->scrollbarParameters_.max;
+	return 0 == d->scrollbarParameters_.max;
 }
 
 
@@ -397,7 +423,7 @@ Buffer const & BufferView::buffer() const
 }
 
 
-bool BufferView::fitCursor()
+bool BufferView::needsFitCursor() const
 {
 	if (cursorStatus(d->cursor_) == CUR_INSIDE) {
 		frontend::FontMetrics const & fm =
@@ -415,7 +441,7 @@ bool BufferView::fitCursor()
 void BufferView::processUpdateFlags(Update::flags flags)
 {
 	// This is close to a hot-path.
-	LYXERR(Debug::DEBUG, "BufferView::processUpdateFlags()"
+	LYXERR(Debug::PAINTING, "BufferView::processUpdateFlags()"
 		<< "[fitcursor = " << (flags & Update::FitCursor)
 		<< ", forceupdate = " << (flags & Update::Force)
 		<< ", singlepar = " << (flags & Update::SinglePar)
@@ -428,6 +454,7 @@ void BufferView::processUpdateFlags(Update::flags flags)
 	// 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?
 
 	// Case when no explicit update is requested.
 	if (!flags) {
@@ -445,7 +472,7 @@ void BufferView::processUpdateFlags(Update::flags flags)
 	if (flags == Update::FitCursor
 		|| flags == (Update::Decoration | Update::FitCursor)) {
 		// tell the frontend to update the screen if needed.
-		if (fitCursor()) {
+		if (needsFitCursor()) {
 			showCursor();
 			return;
 		}
@@ -454,8 +481,10 @@ void BufferView::processUpdateFlags(Update::flags flags)
 			buffer_.changed(false);
 			return;
 		}
-		// no screen update is needed.
+		// 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;
 	}
 
@@ -475,7 +504,7 @@ void BufferView::processUpdateFlags(Update::flags flags)
 	// This is done at draw() time. So we need a redraw!
 	buffer_.changed(false);
 
-	if (fitCursor()) {
+	if (needsFitCursor()) {
 		// The cursor is off screen so ensure it is visible.
 		// refresh it:
 		showCursor();
@@ -496,7 +525,7 @@ void BufferView::updateScrollbar()
 	d->scrollbarParameters_.page_step = height_;
 
 	Text & t = buffer_.text();
-	TextMetrics & tm = d->text_metrics_[&t];		
+	TextMetrics & tm = d->text_metrics_[&t];
 
 	LYXERR(Debug::GUI, " Updating scrollbar: height: "
 		<< t.paragraphs().size()
@@ -537,12 +566,17 @@ void BufferView::updateScrollbar()
 	for (size_t i = last.first + 1; i != parsize; ++i)
 		d->scrollbarParameters_.max += d->par_height_[i];
 
-	d->scrollbarParameters_.position = 0;
 	// The reference is the top position so we remove one page.
 	if (lyxrc.scroll_below_document)
 		d->scrollbarParameters_.max -= minVisiblePart();
 	else
 		d->scrollbarParameters_.max -= d->scrollbarParameters_.page_step;
+
+	// 0 must be inside the range as it denotes the current position
+	if (d->scrollbarParameters_.max < 0)
+		d->scrollbarParameters_.max = 0;
+	if (d->scrollbarParameters_.min > 0)
+		d->scrollbarParameters_.min = 0;
 }
 
 
@@ -578,17 +612,19 @@ string BufferView::contextMenu(int x, int y) const
 }
 
 
-void BufferView::scrollDocView(int value, bool update)
+
+void BufferView::scrollDocView(int const value, bool update)
 {
-	int const offset = value - d->scrollbarParameters_.position;
+	// The scrollbar values are relative to the top of the screen, therefore the
+	// offset is equal to the target value.
 
 	// No scrolling at all? No need to redraw anything
-	if (offset == 0)
+	if (value == 0)
 		return;
 
 	// If the offset is less than 2 screen height, prefer to scroll instead.
-	if (abs(offset) <= 2 * height_) {
-		d->anchor_ypos_ -= offset;
+	if (abs(value) <= 2 * height_) {
+		d->anchor_ypos_ -= value;
 		buffer_.changed(true);
 		updateHoveredInset();
 		return;
@@ -656,7 +692,7 @@ void BufferView::setCursorFromScrollbar()
 	case CUR_INSIDE:
 		int const y = getPos(oldcur).y_;
 		newy = min(last, max(y, first));
-		if (y == newy) 
+		if (y == newy)
 			return;
 	}
 	// We reset the cursor because cursorStatus() does not
@@ -684,6 +720,8 @@ Change const BufferView::getCurrentChange() const
 		return Change(Change::UNCHANGED);
 
 	DocIterator dit = d->cursor_.selectionBegin();
+	// The selected content might have been changed (see #7685)
+	dit = dit.getInnerText();
 	return dit.paragraph().lookupChange(dit.pos());
 }
 
@@ -772,7 +810,7 @@ bool BufferView::moveToPosition(pit_type bottom_pit, pos_type bottom_pos,
 	// the bookmark.
 	if (bottom_pit < int(buffer_.paragraphs().size())) {
 		dit = doc_iterator_begin(&buffer_);
-				
+
 		dit.pit() = bottom_pit;
 		dit.pos() = min(bottom_pos, dit.paragraph().size());
 		success = true;
@@ -783,11 +821,13 @@ bool BufferView::moveToPosition(pit_type bottom_pit, pos_type bottom_pos,
 		setCursor(dit);
 		// set the current font.
 		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 (fitCursor())
+		if (needsFitCursor())
 			showCursor();
 	}
 
@@ -797,14 +837,12 @@ bool BufferView::moveToPosition(pit_type bottom_pit, pos_type bottom_pos,
 
 void BufferView::translateAndInsert(char_type c, Text * t, Cursor & cur)
 {
-	if (lyxrc.rtl_support) {
-		if (d->cursor_.real_current_font.isRightToLeft()) {
-			if (d->intl_.keymap == Intl::PRIMARY)
-				d->intl_.keyMapSec();
-		} else {
-			if (d->intl_.keymap == Intl::SECONDARY)
-				d->intl_.keyMapPrim();
-		}
+	if (d->cursor_.real_current_font.isRightToLeft()) {
+		if (d->intl_.keymap == Intl::PRIMARY)
+			d->intl_.keyMapSec();
+	} else {
+		if (d->intl_.keymap == Intl::SECONDARY)
+			d->intl_.keyMapPrim();
 	}
 
 	d->intl_.getTransManager().translateAndInsert(c, t, cur);
@@ -848,7 +886,7 @@ void BufferView::scrollToCursor()
 }
 
 
-bool BufferView::scrollToCursor(DocIterator const & dit, bool recenter)
+bool BufferView::scrollToCursor(DocIterator const & dit, bool const recenter)
 {
 	// We are not properly started yet, delay until resizing is
 	// done.
@@ -876,7 +914,7 @@ bool BufferView::scrollToCursor(DocIterator const & dit, bool recenter)
 
 	if (tm.contains(bot_pit)) {
 		ParagraphMetrics const & pm = tm.parMetrics(bot_pit);
-		LASSERT(!pm.rows().empty(), /**/);
+		LBUFERR(!pm.rows().empty());
 		// FIXME: smooth scrolling doesn't work in mathed.
 		CursorSlice const & cs = dit.innerTextSlice();
 		int offset = coordOffset(dit).y_;
@@ -954,7 +992,7 @@ void BufferView::makeDocumentClass()
 void BufferView::updateDocumentClass(DocumentClassConstPtr olddc)
 {
 	message(_("Converting document to new document class..."));
-	
+
 	StableDocIterator backcur(d->cursor_);
 	ErrorList & el = buffer_.errorList("Class Switch");
 	cap::switchBetweenClasses(
@@ -967,7 +1005,7 @@ void BufferView::updateDocumentClass(DocumentClassConstPtr olddc)
 }
 
 
-/** Return the change status at cursor position, taking in account the
+/** Return the change status at cursor position, taking into account the
  * status at each level of the document iterator (a table in a deleted
  * footnote is deleted).
  * When \param outer is true, the top slice is not looked at.
@@ -997,7 +1035,10 @@ bool BufferView::getStatus(FuncRequest const & cmd, FuncStatus & flag)
 	if (buffer_.isReadonly()
 	    && !lyxaction.funcHasFlag(act, LyXAction::ReadOnly)
 	    && !lyxaction.funcHasFlag(act, LyXAction::NoBuffer)) {
-		flag.message(from_utf8(N_("Document is read-only")));
+		if (buffer_.hasReadonlyFlag())
+			flag.message(from_utf8(N_("Document is read-only")));
+		else
+			flag.message(from_utf8(N_("Document has been modified externally")));
 		flag.setEnabled(false);
 		return true;
 	}
@@ -1079,11 +1120,11 @@ bool BufferView::getStatus(FuncRequest const & cmd, FuncStatus & flag)
 	case LFUN_BIBTEX_DATABASE_ADD:
 	case LFUN_BIBTEX_DATABASE_DEL:
 	case LFUN_STATISTICS:
-	case LFUN_BRANCH_ADD_INSERT:
 	case LFUN_KEYMAP_OFF:
 	case LFUN_KEYMAP_PRIMARY:
 	case LFUN_KEYMAP_SECONDARY:
 	case LFUN_KEYMAP_TOGGLE:
+	case LFUN_INSET_SELECT_ALL:
 		flag.setEnabled(true);
 		break;
 
@@ -1093,45 +1134,21 @@ bool BufferView::getStatus(FuncRequest const & cmd, FuncStatus & flag)
 		iss >> opt;
 		flag.setEnabled(opt.repl_buf_name.empty()
 				|| !buffer_.isReadonly());
+		break;
 	}
 
-	case LFUN_LABEL_GOTO: {
+	case LFUN_LABEL_GOTO:
 		flag.setEnabled(!cmd.argument().empty()
 		    || getInsetByCode<InsetRef>(cur, REF_CODE));
 		break;
-	}
-
-	case LFUN_CHANGES_TRACK:
-		flag.setEnabled(true);
-		flag.setOnOff(buffer_.params().trackChanges);
-		break;
-
-	case LFUN_CHANGES_OUTPUT:
-		flag.setEnabled(true);
-		flag.setOnOff(buffer_.params().outputChanges);
-		break;
 
 	case LFUN_CHANGES_MERGE:
 	case LFUN_CHANGE_NEXT:
 	case LFUN_CHANGE_PREVIOUS:
 	case LFUN_ALL_CHANGES_ACCEPT:
 	case LFUN_ALL_CHANGES_REJECT:
-		// TODO: context-sensitive enabling of LFUNs
-		// In principle, these command should only be enabled if there
-		// is a change in the document. However, without proper
-		// optimizations, this will inevitably result in poor performance.
-		flag.setEnabled(true);
-		break;
-
-	case LFUN_BUFFER_TOGGLE_COMPRESSION: {
-		flag.setOnOff(buffer_.params().compressed);
+		flag.setEnabled(buffer_.areChangesPresent());
 		break;
-	}
-
-	case LFUN_BUFFER_TOGGLE_OUTPUT_SYNC: {
-		flag.setOnOff(buffer_.params().output_sync);
-		break;
-	}
 
 	case LFUN_SCREEN_UP:
 	case LFUN_SCREEN_DOWN:
@@ -1154,6 +1171,10 @@ bool BufferView::getStatus(FuncRequest const & cmd, FuncStatus & flag)
 		flag.setEnabled(cur.inset().allowParagraphCustomization(cur.idx()));
 		break;
 
+	case LFUN_BRANCH_ADD_INSERT:
+		flag.setEnabled(!(cur.inTexted() && cur.paragraph().isPassThru()));
+		break;
+
 	case LFUN_DIALOG_SHOW_NEW_INSET:
 		// FIXME: this is wrong, but I do not understand the
 		// intent (JMarc)
@@ -1186,22 +1207,6 @@ bool BufferView::getStatus(FuncRequest const & cmd, FuncStatus & flag)
 		break;
 	}
 
-	// FIXME We do not really want this here, but at present we need to
-	// handle their dispatch here, for reasons explained there, so we'll
-	// handle this here, too, for consistency.
-	case LFUN_BRANCH_ACTIVATE:
-	case LFUN_BRANCH_DEACTIVATE:
-	case LFUN_BRANCH_MASTER_ACTIVATE:
-	case LFUN_BRANCH_MASTER_DEACTIVATE: {
-		bool const master = (cmd.action() == LFUN_BRANCH_MASTER_ACTIVATE
-				    || cmd.action() == LFUN_BRANCH_MASTER_DEACTIVATE);
-		BranchList const & branchList = master ? buffer().masterBuffer()->params().branchlist()
-						       : buffer().params().branchlist();
-		docstring const branchName = cmd.argument();
-		flag.setEnabled(!branchName.empty() && branchList.find(branchName));
-		break;
-	}
-
 	default:
 		return false;
 	}
@@ -1229,9 +1234,10 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr)
 
 	string const argument = to_utf8(cmd.argument());
 	Cursor & cur = d->cursor_;
+	Cursor old = cur;
 
 	// Don't dispatch function that does not apply to internal buffers.
-	if (buffer_.isInternal() 
+	if (buffer_.isInternal()
 	    && lyxaction.funcHasFlag(cmd.action(), LyXAction::NoInternal))
 		return;
 
@@ -1244,7 +1250,7 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr)
 
 	case LFUN_BUFFER_PARAMS_APPLY: {
 		DocumentClassConstPtr olddc = buffer_.params().documentClassPtr();
-		cur.recordUndoFullDocument();
+		cur.recordUndoBufferParams();
 		istringstream ss(to_utf8(cmd.argument()));
 		Lexer lex;
 		lex.setStream(ss);
@@ -1255,7 +1261,7 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr)
 						<< (unknown_tokens == 1 ? "" : "s"));
 		}
 		updateDocumentClass(olddc);
-			
+
 		// We are most certainly here because of a change in the document
 		// It is then better to make sure that all dialogs are in sync with
 		// current document settings.
@@ -1263,9 +1269,12 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr)
 		dr.forceBufferUpdate();
 		break;
 	}
-		
+
 	case LFUN_LAYOUT_MODULES_CLEAR: {
-		cur.recordUndoFullDocument();
+		// FIXME: this modifies the document in cap::switchBetweenClasses
+		//  without calling recordUndo. Fix this before using
+		//  recordUndoBufferParams().
+		cur.recordUndoFullBuffer();
 		buffer_.params().clearLayoutModules();
 		makeDocumentClass();
 		dr.screenUpdate(Update::Force);
@@ -1276,12 +1285,15 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr)
 	case LFUN_LAYOUT_MODULE_ADD: {
 		BufferParams const & params = buffer_.params();
 		if (!params.layoutModuleCanBeAdded(argument)) {
-			LYXERR0("Module `" << argument << 
+			LYXERR0("Module `" << argument <<
 				"' cannot be added due to failed requirements or "
 				"conflicts with installed modules.");
 			break;
 		}
-		cur.recordUndoFullDocument();
+		// FIXME: this modifies the document in cap::switchBetweenClasses
+		//  without calling recordUndo. Fix this before using
+		//  recordUndoBufferParams().
+		cur.recordUndoFullBuffer();
 		buffer_.params().addLayoutModule(argument);
 		makeDocumentClass();
 		dr.screenUpdate(Update::Force);
@@ -1290,9 +1302,9 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr)
 	}
 
 	case LFUN_TEXTCLASS_APPLY: {
-		// since this shortcircuits, the second call is made only if 
+		// since this shortcircuits, the second call is made only if
 		// the first fails
-		bool const success = 
+		bool const success =
 			LayoutFileList::get().load(argument, buffer_.temppath()) ||
 			LayoutFileList::get().load(argument, buffer_.filePath());
 		if (!success) {
@@ -1310,7 +1322,10 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr)
 			break;
 
 		// Save the old, possibly modular, layout for use in conversion.
-		cur.recordUndoFullDocument();
+		// FIXME: this modifies the document in cap::switchBetweenClasses
+		//  without calling recordUndo. Fix this before using
+		//  recordUndoBufferParams().
+		cur.recordUndoFullBuffer();
 		buffer_.params().setBaseClass(argument);
 		makeDocumentClass();
 		dr.screenUpdate(Update::Force);
@@ -1319,12 +1334,12 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr)
 	}
 
 	case LFUN_TEXTCLASS_LOAD: {
-		// since this shortcircuits, the second call is made only if 
+		// since this shortcircuits, the second call is made only if
 		// the first fails
-		bool const success = 
+		bool const success =
 			LayoutFileList::get().load(argument, buffer_.temppath()) ||
 			LayoutFileList::get().load(argument, buffer_.filePath());
-		if (!success) {			
+		if (!success) {
 			docstring s = bformat(_("The document class `%1$s' "
 						 "could not be loaded."), from_utf8(argument));
 			frontend::Alert::error(_("Could not load class"), s);
@@ -1350,6 +1365,16 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr)
 		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();
 		break;
 
 	case LFUN_REDO:
@@ -1360,6 +1385,9 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr)
 		else
 			dr.screenUpdate(Update::Force | Update::FitCursor);
 		dr.forceBufferUpdate();
+		// see above
+		buffer().invalidateBibfileCache();
+		buffer().removeBiblioTempFiles();
 		break;
 
 	case LFUN_FONT_STATE:
@@ -1390,29 +1418,44 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr)
 		}
 		break;
 	}
-	
+
 	case LFUN_PARAGRAPH_GOTO: {
 		int const id = convert<int>(cmd.getArg(0));
-		int const pos = convert<int>(cmd.getArg(1));
+		pos_type const pos = convert<int>(cmd.getArg(1));
+		if (id < 0)
+			break;
+		string const str_id_end = cmd.getArg(2);
+		string const str_pos_end = cmd.getArg(3);
 		int i = 0;
 		for (Buffer * b = &buffer_; i == 0 || b != &buffer_;
 			b = theBufferList().next(b)) {
 
-			DocIterator dit = b->getParFromID(id);
-			if (dit.atEnd()) {
+			Cursor cur(*this);
+			cur.setCursor(b->getParFromID(id));
+			if (cur.atEnd()) {
 				LYXERR(Debug::INFO, "No matching paragraph found! [" << id << "].");
 				++i;
 				continue;
 			}
-			LYXERR(Debug::INFO, "Paragraph " << dit.paragraph().id()
+			LYXERR(Debug::INFO, "Paragraph " << cur.paragraph().id()
 				<< " found in buffer `"
 				<< b->absFileName() << "'.");
 
 			if (b == &buffer_) {
-				// Set the cursor
-				dit.pos() = pos;
-				setCursor(dit);
-				dr.screenUpdate(Update::Force | Update::FitCursor);
+				bool success;
+				if (str_id_end.empty() || str_pos_end.empty()) {
+					// Set the cursor
+					cur.pos() = pos;
+					mouseSetCursor(cur);
+					success = true;
+				} else {
+					int const id_end = convert<int>(str_id_end);
+					pos_type const pos_end = convert<int>(str_pos_end);
+					success = setCursorFromEntries({id, pos},
+					                               {id_end, pos_end});
+				}
+				if (success)
+					dr.screenUpdate(Update::Force | Update::FitCursor);
 			} else {
 				// Switch to other buffer view and resend cmd
 				lyx::dispatch(FuncRequest(
@@ -1436,39 +1479,12 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr)
 		break;
 	}
 
-	case LFUN_CHANGES_TRACK:
-		buffer_.params().trackChanges = !buffer_.params().trackChanges;
-		break;
-
-	case LFUN_CHANGES_OUTPUT:
-		buffer_.params().outputChanges = !buffer_.params().outputChanges;
-		if (buffer_.params().outputChanges) {
-			bool dvipost    = LaTeXFeatures::isAvailable("dvipost");
-			bool xcolorulem = LaTeXFeatures::isAvailable("ulem") &&
-					  LaTeXFeatures::isAvailable("xcolor");
-
-			if (!dvipost && !xcolorulem) {
-				Alert::warning(_("Changes not shown in LaTeX output"),
-					       _("Changes will not be highlighted in LaTeX output, "
-						 "because neither dvipost nor xcolor/ulem are installed.\n"
-						 "Please install these packages or redefine "
-						 "\\lyxadded and \\lyxdeleted in the LaTeX preamble."));
-			} else if (!xcolorulem) {
-				Alert::warning(_("Changes not shown in LaTeX output"),
-					       _("Changes will not be highlighted in LaTeX output "
-						 "when using pdflatex, because xcolor and ulem are not installed.\n"
-						 "Please install both packages or redefine "
-						 "\\lyxadded and \\lyxdeleted in the LaTeX preamble."));
-			}
-		}
-		break;
-
 	case LFUN_CHANGE_NEXT:
 		findNextChange(this);
 		// 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);
 		// FIXME: Move this LFUN to Buffer so that we don't have to do this:
@@ -1512,6 +1528,8 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr)
 
 	case LFUN_WORD_FIND_FORWARD:
 	case LFUN_WORD_FIND_BACKWARD: {
+		// FIXME THREAD
+		// Would it maybe be better if this variable were view specific anyway?
 		static docstring last_search;
 		docstring searched_string;
 
@@ -1544,8 +1562,7 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr)
 		}
 		if (lyxfind(this, req))
 			dr.screenUpdate(Update::Force | Update::FitCursor);
-		else
-			message(_("String not found!"));
+
 		d->search_request_cache_ = req;
 		break;
 	}
@@ -1598,7 +1615,7 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr)
 		break;
 
 	case LFUN_MARK_TOGGLE:
-		cur.setSelection(false);
+		cur.selection(false);
 		if (cur.mark()) {
 			cur.setMark(false);
 			dr.setMessage(from_utf8(N_("Mark removed")));
@@ -1612,7 +1629,7 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr)
 	case LFUN_SCREEN_SHOW_CURSOR:
 		showCursor();
 		break;
-	
+
 	case LFUN_SCREEN_RECENTER:
 		recenter();
 		break;
@@ -1640,7 +1657,7 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr)
 			if (inset->delDatabase(cmd.argument())) {
 				buffer_.invalidateBibfileCache();
 				dr.forceBufferUpdate();
-			}				
+			}
 		}
 		break;
 	}
@@ -1685,15 +1702,6 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr)
 	}
 		break;
 
-	case LFUN_BUFFER_TOGGLE_COMPRESSION:
-		// turn compression on/off
-		buffer_.params().compressed = !buffer_.params().compressed;
-		break;
-
-	case LFUN_BUFFER_TOGGLE_OUTPUT_SYNC:
-		buffer_.params().output_sync = !buffer_.params().output_sync;
-		break;
-
 	case LFUN_SCREEN_UP:
 	case LFUN_SCREEN_DOWN: {
 		Point p = getPos(cur);
@@ -1710,7 +1718,6 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr)
 			p = Point(0, 0);
 		if (act == LFUN_SCREEN_DOWN && scrolled < height_)
 			p = Point(width_, height_);
-		Cursor old = cur;
 		bool const in_texted = cur.inTexted();
 		cur.setCursor(doc_iterator_begin(cur.buffer()));
 		cur.selHandle(false);
@@ -1718,13 +1725,13 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr)
 		updateHoveredInset();
 
 		d->text_metrics_[&buffer_.text()].editXY(cur, p.x_, p.y_,
-			true, act == LFUN_SCREEN_UP); 
+			true, act == LFUN_SCREEN_UP);
 		//FIXME: what to do with cur.x_target()?
 		bool update = in_texted && cur.bv().checkDepm(cur, old);
 		cur.finishUndo();
 
 		if (update || cur.mark())
-			dr.screenUpdate(Update::Force | Update::FitCursor);	
+			dr.screenUpdate(Update::Force | Update::FitCursor);
 		if (update)
 			dr.forceBufferUpdate();
 		break;
@@ -1792,6 +1799,47 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr)
 	}
 
 
+	case LFUN_INSET_SELECT_ALL: {
+		// true if all cells are selected
+		bool const all_selected = cur.depth() > 1
+		    && cur.selBegin().at_begin()
+		    && cur.selEnd().at_end();
+		// true if some cells are selected
+		bool const cells_selected = cur.depth() > 1
+		    && cur.selBegin().at_cell_begin()
+			&& cur.selEnd().at_cell_end();
+		if (all_selected || (cells_selected && !cur.inset().isTable())) {
+			// All the contents of the inset if selected, or only at
+			// least one cell but inset is not a table.
+			// Select the inset from outside.
+			cur.pop();
+			cur.resetAnchor();
+			cur.selection(true);
+			cur.posForward();
+		} else if (cells_selected) {
+			// At least one complete cell is selected and inset is a table.
+			// Select all cells
+			cur.idx() = 0;
+			cur.pos() = 0;
+			cur.resetAnchor();
+			cur.selection(true);
+			cur.idx() = cur.lastidx();
+			cur.pos() = cur.lastpos();
+		} else {
+			// select current cell
+			cur.pit() = 0;
+			cur.pos() = 0;
+			cur.resetAnchor();
+			cur.selection(true);
+			cur.pit() = cur.lastpit();
+			cur.pos() = cur.lastpos();
+		}
+		cur.setCurrentFont();
+		dr.screenUpdate(Update::Force);
+		break;
+	}
+
+
 	// This would be in Buffer class if only Cursor did not
 	// require a bufferview
 	case LFUN_INSET_FORALL: {
@@ -1809,7 +1857,7 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr)
 			cur.forwardInset();
 		cur.beginUndoGroup();
 		while(cur && iterations < max_iter) {
-			Inset * ins = cur.nextInset();
+			Inset * const ins = cur.nextInset();
 			if (!ins)
 				break;
 			docstring insname = ins->layoutName();
@@ -1825,11 +1873,21 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr)
 					break;
 				insname = insname.substr(0, i);
 			}
-			cur.forwardInset();
+			// if we did not delete the inset, skip it
+			if (!cur.nextInset() || cur.nextInset() == ins)
+				cur.forwardInset();
 		}
-		cur.endUndoGroup();
 		cur = savecur;
 		cur.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)
+
+		 * 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();
 		dr.screenUpdate(Update::Force);
 		dr.forceBufferUpdate();
 
@@ -1888,7 +1946,7 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr)
 		if (decodeInsetParam(name, data, buffer_))
 			lyx::dispatch(FuncRequest(LFUN_DIALOG_SHOW, name + " " + data));
 		else
-			lyxerr << "Inset type '" << name << 
+			lyxerr << "Inset type '" << name <<
 			"' not recognized in LFUN_DIALOG_SHOW_NEW_INSET" <<  endl;
 		break;
 	}
@@ -1909,12 +1967,12 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr)
 			opt1 = token(argument, '|', 1);
 		}
 
-		// if our cursor is direclty in front of or behind a citation inset,
+		// if our cursor is directly in front of or behind a citation inset,
 		// we will instead add the new key to it.
 		Inset * inset = cur.nextInset();
 		if (!inset || inset->lyxCode() != CITE_CODE)
 			inset = cur.prevInset();
-		if (inset->lyxCode() == CITE_CODE) {
+		if (inset && inset->lyxCode() == CITE_CODE) {
 			InsetCitation * icite = static_cast<InsetCitation *>(inset);
 			if (icite->addKey(arg)) {
 				dr.forceBufferUpdate();
@@ -1967,7 +2025,7 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr)
 		if (!newL || oldL == newL)
 			break;
 		if (oldL->rightToLeft() == newL->rightToLeft()) {
-			cur.recordUndoFullDocument();
+			cur.recordUndoFullBuffer();
 			buffer_.changeLanguage(oldL, newL);
 			cur.setCurrentFont();
 			dr.forceBufferUpdate();
@@ -1986,48 +2044,6 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr)
 		break;
 	}
 
-	// FIXME We do not really want this here, but it has to be at present
-	// because we need a cursor for the recordUndoFullDocument call. What
-	// we would really like is a recordUndoBufferParams call that did not
-	// need a cursor, but we do not have that yet.
-	// So, if this does get fixed, this code can be moved back to Buffer.cpp,
-	// and the corresponding code in getStatus() should be moved back, too.
-	case LFUN_BRANCH_ACTIVATE:
-	case LFUN_BRANCH_DEACTIVATE:
-	case LFUN_BRANCH_MASTER_ACTIVATE:
-	case LFUN_BRANCH_MASTER_DEACTIVATE: {
-		bool const master = (cmd.action() == LFUN_BRANCH_MASTER_ACTIVATE
-				     || cmd.action() == LFUN_BRANCH_MASTER_DEACTIVATE);
-		Buffer * buf = master ? const_cast<Buffer *>(buffer().masterBuffer())
-				      : &buffer();
-
-		docstring const branch_name = cmd.argument();
-		// the case without a branch name is handled elsewhere
-		if (branch_name.empty()) {
-			dispatched = false;
-			break;
-		}
-		Branch * branch = buf->params().branchlist().find(branch_name);
-		if (!branch) {
-			LYXERR0("Branch " << branch_name << " does not exist.");
-			dr.setError(true);
-			docstring const msg =
-				bformat(_("Branch \"%1$s\" does not exist."), branch_name);
-			dr.setMessage(msg);
-			break;
-		}
-		bool activate = (cmd.action() == LFUN_BRANCH_ACTIVATE
-				 || cmd.action() == LFUN_BRANCH_MASTER_ACTIVATE);
-		if (branch->isSelected() != activate) {
-			branch->setSelected(activate);
-			cur.recordUndoFullDocument();
-			dr.setError(false);
-			dr.screenUpdate(Update::Force);
-			dr.forceBufferUpdate();
-		}
-		break;
-	}
-
 	default:
 		// OK, so try the Buffer itself...
 		buffer_.dispatch(cmd, dr);
@@ -2037,6 +2053,21 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr)
 
 	buffer_.undo().endUndoGroup();
 	dr.dispatched(dispatched);
+
+	// NOTE: The code below is copied from Cursor::dispatch. If you
+	// need to modify this, please update the other one too.
+
+	// notify insets we just entered/left
+	if (cursor() != old) {
+		old.beginUndoGroup();
+		old.fixIfBroken();
+		bool badcursor = notifyCursorLeavesOrEnters(old, cursor());
+		if (badcursor) {
+			cursor().fixIfBroken();
+			resetInlineCompletionPos();
+		}
+		old.endUndoGroup();
+	}
 }
 
 
@@ -2128,7 +2159,7 @@ void BufferView::updateHoveredInset() const
 	int const y = d->mouse_position_cache_.y_;
 	Inset const * covering_inset = getCoveringInset(buffer_.text(), x, y);
 
-	d->clickable_inset_ = covering_inset && covering_inset->clickable(x, y);
+	d->clickable_inset_ = covering_inset && covering_inset->clickable(*this, x, y);
 
 	if (covering_inset == d->last_inset_)
 		// Same inset, no need to do anything...
@@ -2140,10 +2171,10 @@ void BufferView::updateHoveredInset() const
 		need_redraw |= d->last_inset_->setMouseHover(this, false);
 		d->last_inset_ = 0;
 	}
-	
+
 	if (covering_inset && covering_inset->setMouseHover(this, true)) {
 		need_redraw = true;
-		// Only the insets that accept the hover state, do 
+		// Only the insets that accept the hover state, do
 		// clear the last_inset_, so only set the last_inset_
 		// member if the hovered setting is accepted.
 		d->last_inset_ = covering_inset;
@@ -2151,9 +2182,9 @@ void BufferView::updateHoveredInset() const
 
 	if (need_redraw) {
 		LYXERR(Debug::PAINTING, "Mouse hover detected at: ("
-				<< d->mouse_position_cache_.x_ << ", " 
+				<< d->mouse_position_cache_.x_ << ", "
 				<< d->mouse_position_cache_.y_ << ")");
-	
+
 		d->update_strategy_ = DecorationUpdate;
 
 		// This event (moving without mouse click) is not passed further.
@@ -2167,7 +2198,7 @@ void BufferView::clearLastInset(Inset * inset) const
 {
 	if (d->last_inset_ != inset) {
 		LYXERR0("Wrong last_inset!");
-		LASSERT(false, /**/);
+		LATTEST(false);
 	}
 	d->last_inset_ = 0;
 }
@@ -2184,7 +2215,7 @@ void BufferView::mouseEventDispatch(FuncRequest const & cmd0)
 	Cursor old = cursor();
 	Cursor cur(*this);
 	cur.push(buffer_.inset());
-	cur.setSelection(d->cursor_.selection());
+	cur.selection(d->cursor_.selection());
 
 	// Either the inset under the cursor or the
 	// surrounding Text will handle this event.
@@ -2202,6 +2233,20 @@ void BufferView::mouseEventDispatch(FuncRequest const & cmd0)
 
 	// Build temporary cursor.
 	Inset * inset = d->text_metrics_[&buffer_.text()].editXY(cur, cmd.x(), cmd.y());
+	if (inset) {
+		// If inset is not editable, cur.pos() might point behind the
+		// inset (depending on cmd.x(), cmd.y()). This is needed for
+		// editing to fix bug 9628, but e.g. the context menu needs a
+		// cursor in front of the inset.
+		if ((inset->hasSettings() || !inset->contextMenuName().empty()
+		     || inset->lyxCode() == SEPARATOR_CODE) &&
+		    cur.nextInset() != inset && cur.prevInset() == inset)
+			cur.posBackward();
+	} else if (cur.inTexted() && cur.pos()
+			&& cur.paragraph().isEnvSeparator(cur.pos() - 1)) {
+		// Always place cursor in front of a separator inset.
+		cur.posBackward();
+	}
 
 	// Put anchor at the same position.
 	cur.resetAnchor();
@@ -2220,8 +2265,6 @@ void BufferView::mouseEventDispatch(FuncRequest const & cmd0)
 	if (!inset || !cur.result().dispatched())
 		cur.dispatch(cmd);
 
-	cur.endUndoGroup();
-
 	// Notify left insets
 	if (cur != old) {
 		bool badcursor = old.fixIfBroken() | cur.fixIfBroken();
@@ -2229,7 +2272,9 @@ void BufferView::mouseEventDispatch(FuncRequest const & cmd0)
 		if (badcursor)
 			cursor().fixIfBroken();
 	}
-	
+
+	cur.endUndoGroup();
+
 	// Do we have a selection?
 	theSelection().haveSelection(cursor().selection());
 
@@ -2308,45 +2353,35 @@ int BufferView::scrollUp(int offset)
 }
 
 
-void BufferView::setCursorFromRow(int row)
+bool BufferView::setCursorFromRow(int row)
 {
-	int tmpid;
-	int tmppos;
-	pit_type newpit = 0;
-	pos_type newpos = 0;
+	TexRow::TextEntry start, end;
+	tie(start,end) = buffer_.texrow().getEntriesFromRow(row);
+	LYXERR(Debug::LATEX,
+	       "setCursorFromRow: for row " << row << ", TexRow has found "
+	       "start (id=" << start.id << ",pos=" << start.pos << "), "
+	       "end (id=" << end.id << ",pos=" << end.pos << ")");
+	return setCursorFromEntries(start, end);
+}
 
-	buffer_.texrow().getIdFromRow(row, tmpid, tmppos);
 
-	bool posvalid = (tmpid != -1);
-	if (posvalid) {
-		// we need to make sure that the row and position
-		// we got back are valid, because the buffer may well
-		// have changed since we last generated the LaTeX.
-		DocIterator const dit = buffer_.getParFromID(tmpid);
-		if (dit == doc_iterator_end(&buffer_))
-			posvalid = false;
-		else {
-			newpit = dit.pit();
-			// now have to check pos.
-			newpos = tmppos;
-			Paragraph const & par = buffer_.text().getPar(newpit);
-			if (newpos > par.size()) {
-				LYXERR0("Requested position no longer valid.");
-				newpos = par.size() - 1;
-			}
-		}
-	}
-	if (!posvalid) {
-		frontend::Alert::error(_("Inverse Search Failed"),
-			_("Invalid position requested by inverse search.\n"
-		    "You need to update the viewed document."));
-		return;
+bool BufferView::setCursorFromEntries(TexRow::TextEntry start,
+                                      TexRow::TextEntry end)
+{
+	DocIterator dit_start, dit_end;
+	tie(dit_start,dit_end) =
+		TexRow::getDocIteratorsFromEntries(start, end, buffer_);
+	if (!dit_start)
+		return false;
+	// Setting selection start
+	d->cursor_.clearSelection();
+	setCursor(dit_start);
+	// Setting selection end
+	if (dit_end) {
+		d->cursor_.resetAnchor();
+		setCursorSelectionTo(dit_end);
 	}
-	d->cursor_.reset();
-	buffer_.text().setCursor(d->cursor_, newpit, newpos);
-	d->cursor_.setSelection(false);
-	d->cursor_.resetAnchor();
-	recenter();
+	return true;
 }
 
 
@@ -2378,9 +2413,9 @@ void BufferView::gotoLabel(docstring const & label)
 		Buffer const * buf = *it;
 
 		// find label
-		Toc & toc = buf->tocBackend().toc("label");
-		TocIterator toc_it = toc.begin();
-		TocIterator end = toc.end();
+		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());
@@ -2399,7 +2434,7 @@ TextMetrics const & BufferView::textMetrics(Text const * t) const
 
 TextMetrics & BufferView::textMetrics(Text const * t)
 {
-	LASSERT(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(
@@ -2430,7 +2465,8 @@ void BufferView::setCursor(DocIterator const & dit)
 		dit[i].inset().edit(d->cursor_, true);
 
 	d->cursor_.setCursor(dit);
-	d->cursor_.setSelection(false);
+	d->cursor_.selection(false);
+	d->cursor_.setCurrentFont();
 	// FIXME
 	// It seems on general grounds as if this is probably needed, but
 	// it is not yet clear.
@@ -2439,6 +2475,18 @@ void BufferView::setCursor(DocIterator const & dit)
 }
 
 
+void BufferView::setCursorSelectionTo(DocIterator const & dit)
+{
+	size_t const n = dit.depth();
+	for (size_t i = 0; i < n; ++i)
+		dit[i].inset().edit(d->cursor_, true);
+
+	d->cursor_.selection(true);
+	d->cursor_.setCursorSelectionTo(dit);
+	d->cursor_.setCurrentFont();
+}
+
+
 bool BufferView::checkDepm(Cursor & cur, Cursor & old)
 {
 	// Would be wrong to delete anything if we have a selection.
@@ -2457,15 +2505,18 @@ bool BufferView::checkDepm(Cursor & cur, Cursor & old)
 
 	d->cursor_ = cur;
 
-	cur.forceBufferUpdate();
-	cur.screenUpdateFlags(Update::Force);
+	// we would rather not do this here, but it needs to be done before
+	// the changed() signal is sent.
+	buffer_.updateBuffer();
+
+	buffer_.changed(true);
 	return true;
 }
 
 
-bool BufferView::mouseSetCursor(Cursor & cur, bool select)
+bool BufferView::mouseSetCursor(Cursor & cur, bool const select)
 {
-	LASSERT(&cur.bv() == this, /**/);
+	LASSERT(&cur.bv() == this, return false);
 
 	if (!select)
 		// this event will clear selection so we save selection for
@@ -2481,27 +2532,23 @@ bool BufferView::mouseSetCursor(Cursor & cur, bool select)
 	if (leftinset)
 		d->cursor_.fixIfBroken();
 
-	// FIXME: shift-mouse selection doesn't work well across insets.
-	bool const do_selection = 
-			select && &d->cursor_.normalAnchor().inset() == &cur.inset();
-
 	// do the dEPM magic if needed
 	// FIXME: (1) move this to InsetText::notifyCursorLeaves?
 	// FIXME: (2) if we had a working InsetText::notifyCursorLeaves,
 	// the leftinset bool would not be necessary (badcursor instead).
 	bool update = leftinset;
-	if (!do_selection && d->cursor_.inTexted())
-		update |= checkDepm(cur, d->cursor_);
 
-	if (!do_selection)
-		d->cursor_.resetAnchor();
-	d->cursor_.setCursor(cur);
-	d->cursor_.boundary(cur.boundary());
-	if (do_selection)
+	if (select) {
 		d->cursor_.setSelection();
-	else
+		d->cursor_.setCursorSelectionTo(cur);
+	} else {
+		if (d->cursor_.inTexted())
+			update |= checkDepm(cur, d->cursor_);
+		d->cursor_.resetAnchor();
+		d->cursor_.setCursor(cur);
 		d->cursor_.clearSelection();
-
+	}
+	d->cursor_.boundary(cur.boundary());
 	d->cursor_.finishUndo();
 	d->cursor_.setCurrentFont();
 	if (update)
@@ -2529,7 +2576,8 @@ void BufferView::putSelectionAt(DocIterator const & cur,
 
 bool BufferView::selectIfEmpty(DocIterator & cur)
 {
-	if (!cur.paragraph().empty())
+	if ((cur.inTexted() && !cur.paragraph().empty())
+	    || (cur.inMathed() && !cur.cell().empty()))
 		return false;
 
 	pit_type const beg_pit = cur.pit();
@@ -2554,7 +2602,7 @@ bool BufferView::selectIfEmpty(DocIterator & cur)
 	d->cursor_.setCursor(cur);
 	d->cursor_.pit() = beg_pit;
 	d->cursor_.pos() = 0;
-	d->cursor_.setSelection(false);
+	d->cursor_.selection(false);
 	d->cursor_.resetAnchor();
 	d->cursor_.pit() = end_pit;
 	d->cursor_.pos() = end_pos;
@@ -2597,7 +2645,7 @@ bool BufferView::singleParUpdate()
 	// (if this paragraph contains insets etc., rebreaking will
 	// recursively descend)
 	tm.redoParagraph(bottom_pit);
-	ParagraphMetrics const & pm = tm.parMetrics(bottom_pit);		
+	ParagraphMetrics const & pm = tm.parMetrics(bottom_pit);
 	if (pm.height() != old_height)
 		// Paragraph height has changed so we cannot proceed to
 		// the singlePar optimisation.
@@ -2634,7 +2682,7 @@ void BufferView::updateMetrics()
 	// make sure inline completion pointer is ok
 	if (d->inlineCompletionPos_.fixIfBroken())
 		d->inlineCompletionPos_ = DocIterator();
-	
+
 	if (d->anchor_pit_ >= npit)
 		// The anchor pit must have been deleted...
 		d->anchor_pit_ = npit - 1;
@@ -2642,19 +2690,19 @@ void BufferView::updateMetrics()
 	// Rebreak anchor paragraph.
 	tm.redoParagraph(d->anchor_pit_);
 	ParagraphMetrics & anchor_pm = tm.par_metrics_[d->anchor_pit_];
-	
+
 	// position anchor
 	if (d->anchor_pit_ == 0) {
 		int scrollRange = d->scrollbarParameters_.max - d->scrollbarParameters_.min;
-		
+
 		// 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.
-	}		
+	}
 	anchor_pm.setPosition(d->anchor_ypos_);
 
 	LYXERR(Debug::PAINTING, "metrics: "
@@ -2706,7 +2754,7 @@ void BufferView::updateMetrics()
 
 void BufferView::insertLyXFile(FileName const & fname)
 {
-	LASSERT(d->cursor_.inTexted(), /**/);
+	LASSERT(d->cursor_.inTexted(), return);
 
 	// Get absolute path of file and add ".lyx"
 	// to the filename if necessary
@@ -2743,19 +2791,19 @@ Point BufferView::coordOffset(DocIterator const & dit) const
 	int lastw = 0;
 
 	// Addup contribution of nested insets, from inside to outside,
- 	// keeping the outer paragraph for a special handling below
+	// keeping the outer paragraph for a special handling below
 	for (size_t i = dit.depth() - 1; i >= 1; --i) {
 		CursorSlice const & sl = dit[i];
 		int xx = 0;
 		int yy = 0;
-		
+
 		// get relative position inside sl.inset()
 		sl.inset().cursorPos(*this, sl, dit.boundary() && (i + 1 == dit.depth()), xx, yy);
-		
+
 		// Make relative position inside of the edited inset relative to sl.inset()
 		x += xx;
 		y += yy;
-		
+
 		// In case of an RTL inset, the edited inset will be positioned to the left
 		// of xx:yy
 		if (sl.text()) {
@@ -2766,21 +2814,8 @@ Point BufferView::coordOffset(DocIterator const & dit) const
 		}
 
 		// remember width for the case that sl.inset() is positioned in an RTL inset
-		if (i && dit[i - 1].text()) {
-			// If this Inset is inside a Text Inset, retrieve the Dimension
-			// from the containing text instead of using Inset::dimension() which
-			// might not be implemented.
-			// FIXME (Abdel 23/09/2007): this is a bit messy because of the
-			// elimination of Inset::dim_ cache. This coordOffset() method needs
-			// to be rewritten in light of the new design.
-			Dimension const & dim = parMetrics(dit[i - 1].text(),
-				dit[i - 1].pit()).insetDimension(&sl.inset());
-			lastw = dim.wid;
-		} else {
-			Dimension const dim = sl.inset().dimension(*this);
-			lastw = dim.wid;
-		}
-		
+		lastw = sl.inset().dimension(*this).wid;
+
 		//lyxerr << "Cursor::getPos, i: "
 		// << i << " x: " << xx << " y: " << y << endl;
 	}
@@ -2789,7 +2824,8 @@ Point BufferView::coordOffset(DocIterator const & dit) const
 	CursorSlice const & sl = dit[0];
 	TextMetrics const & tm = textMetrics(sl.text());
 	ParagraphMetrics const & pm = tm.parMetrics(sl.pit());
-	LASSERT(!pm.rows().empty(), /**/);
+
+	LBUFERR(!pm.rows().empty());
 	y -= pm.rows()[0].ascent();
 #if 1
 	// FIXME: document this mess
@@ -2808,20 +2844,20 @@ Point BufferView::coordOffset(DocIterator const & dit) const
 	for (size_t rit = 0; rit != rend; ++rit)
 		y += pm.rows()[rit].height();
 	y += pm.rows()[rend].ascent();
-	
+
 	TextMetrics const & bottom_tm = textMetrics(dit.bottom().text());
-	
+
 	// Make relative position from the nested inset now bufferview absolute.
 	int xx = bottom_tm.cursorX(dit.bottom(), dit.boundary() && dit.depth() == 1);
 	x += xx;
-	
-	// In the RTL case place the nested inset at the left of the cursor in 
+
+	// In the RTL case place the nested inset at the left of the cursor in
 	// the outer paragraph
 	bool boundary_1 = dit.boundary() && 1 == dit.depth();
 	bool rtl = bottom_tm.isRTL(dit.bottom(), boundary_1);
 	if (rtl)
 		x -= lastw;
-	
+
 	return Point(x, y);
 }
 
@@ -2835,7 +2871,7 @@ Point BufferView::getPos(DocIterator const & dit) const
 	TextMetrics const & tm = textMetrics(bot.text());
 
 	// offset from outer paragraph
-	Point p = coordOffset(dit); 
+	Point p = coordOffset(dit);
 	p.y_ += tm.parMetrics(bot.pit()).position();
 	return p;
 }
@@ -2853,7 +2889,7 @@ bool BufferView::paragraphVisible(DocIterator const & dit) const
 void BufferView::cursorPosAndHeight(Point & p, int & h) const
 {
 	Cursor const & cur = cursor();
-	Font const font = cur.getFont();
+	Font const font = cur.real_current_font;
 	frontend::FontMetrics const & fm = theFontMetrics(font);
 	int const asc = fm.maxAscent();
 	int const des = fm.maxDescent();
@@ -2873,6 +2909,145 @@ bool BufferView::cursorInView(Point const & p, int h) const
 }
 
 
+int BufferView::horizScrollOffset() const
+{
+	return d->horiz_scroll_offset_;
+}
+
+
+int BufferView::horizScrollOffset(Text const * text,
+                                  pit_type pit, pos_type pos) const
+{
+	// Is this a row that is currently scrolled?
+	if (!d->current_row_slice_.empty()
+	    && &text->inset() == d->current_row_slice_.inset().asInsetText()
+	    && pit ==  d->current_row_slice_.pit()
+	    && pos ==  d->current_row_slice_.pos())
+		return d->horiz_scroll_offset_;
+	return 0;
+}
+
+
+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();
+		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();
+
+	// Since we changed row, the scroll offset is not valid anymore
+	d->horiz_scroll_offset_ = 0;
+	d->current_row_slice_ = rowSlice;
+}
+
+
+void BufferView::checkCursorScrollOffset(PainterInfo & pi)
+{
+	CursorSlice rowSlice = d->cursor_.bottom();
+	TextMetrics const & tm = textMetrics(rowSlice.text());
+
+	// Stop if metrics have not been computed yet, since it means
+	// that there is nothing to do.
+	if (!tm.contains(rowSlice.pit()))
+		return;
+	ParagraphMetrics const & pm = tm.parMetrics(rowSlice.pit());
+	Row const & row = pm.getRow(rowSlice.pos(),
+	                            d->cursor_.boundary() && rowSlice == d->cursor_.top());
+	rowSlice.pos() = row.pos();
+
+	// 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_;
+
+	// Horizontal scroll offset of the cursor row in pixels
+	int offset = d->horiz_scroll_offset_;
+	int const MARGIN = 2 * theFontMetrics(d->cursor_.real_current_font).em()
+	                   + row.right_margin;
+	if (row.right_x() <= workWidth() - row.right_margin) {
+		// Row is narrower than the work area, no offset needed.
+		offset = 0;
+	} else {
+		if (cur_x - offset < MARGIN) {
+			// cursor would be too far right
+			offset = cur_x - MARGIN;
+		} else if (cur_x - offset > workWidth() - MARGIN) {
+			// cursor would be too far left
+			offset = cur_x - workWidth() + MARGIN;
+		}
+		// Correct the offset to make sure that we do not scroll too much
+		if (offset < 0)
+			offset = 0;
+		if (row.right_x() - offset < workWidth() - row.right_margin)
+			offset = row.right_x() - workWidth() + row.right_margin;
+	}
+
+	//lyxerr << "cur_x=" << cur_x << ", offset=" << offset << ", row.wid=" << row.width() << ", margin=" << MARGIN << endl;
+
+	if (offset != d->horiz_scroll_offset_)
+		LYXERR(Debug::PAINTING, "Horiz. scroll offset changed from "
+		       << d->horiz_scroll_offset_ << " to " << offset);
+
+	if (d->update_strategy_ == NoScreenUpdate
+	    && (offset != d->horiz_scroll_offset_
+		|| !d->last_row_slice_.empty())) {
+		// FIXME: if one uses SingleParUpdate, then home/end
+		// will not work on long rows. Why?
+		d->update_strategy_ = FullScreenUpdate;
+	}
+
+	d->horiz_scroll_offset_ = offset;
+}
+
+
 void BufferView::draw(frontend::Painter & pain)
 {
 	if (height_ == 0 || width_ == 0)
@@ -2884,22 +3059,28 @@ void BufferView::draw(frontend::Painter & pain)
 	int const y = tm.first().second->position();
 	PainterInfo pi(this, pain);
 
+	// Check whether the row where the cursor lives needs to be scrolled.
+	// Update the drawing strategy if needed.
+	checkCursorScrollOffset(pi);
+
 	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.
+		LYXERR(Debug::PAINTING, "Strategy: NoScreenUpdate");
 		pi.full_repaint = true;
 		pi.pain.setDrawingEnabled(false);
- 		tm.draw(pi, 0, y);
+		tm.draw(pi, 0, y);
 		break;
 
 	case SingleParUpdate:
 		pi.full_repaint = false;
+		LYXERR(Debug::PAINTING, "Strategy: SingleParUpdate");
 		// In general, only the current row of the outermost paragraph
 		// will be redrawn. Particular cases where selection spans
 		// multiple paragraph are correctly detected in TextMetrics.
- 		tm.draw(pi, 0, y);
+		tm.draw(pi, 0, y);
 		break;
 
 	case DecorationUpdate:
@@ -2908,6 +3089,12 @@ void BufferView::draw(frontend::Painter & pain)
 		// because of the single backing pixmap.
 
 	case FullScreenUpdate:
+
+		LYXERR(Debug::PAINTING,
+		       ((d->update_strategy_ == FullScreenUpdate)
+			? "Strategy: FullScreenUpdate"
+			: "Strategy: DecorationUpdate"));
+
 		// The whole screen, including insets, will be refreshed.
 		pi.full_repaint = true;
 
@@ -2921,9 +3108,9 @@ void BufferView::draw(frontend::Painter & pain)
 		// and possibly grey out below
 		pair<pit_type, ParagraphMetrics const *> lastpm = tm.last();
 		int const y2 = lastpm.second->position() + lastpm.second->descent();
-		
+
 		if (y2 < height_) {
-			Color color = buffer().isInternal() 
+			Color color = buffer().isInternal()
 				? Color_background : Color_bottomarea;
 			pain.fillRectangle(0, y2, width_, height_ - y2, color);
 		}
@@ -3077,7 +3264,7 @@ bool samePar(DocIterator const & a, DocIterator const & b)
 }
 
 
-void BufferView::setInlineCompletion(Cursor const & cur, DocIterator const & pos, 
+void BufferView::setInlineCompletion(Cursor const & cur, DocIterator const & pos,
 	docstring const & completion, size_t uniqueChars)
 {
 	uniqueChars = min(completion.size(), uniqueChars);
@@ -3086,9 +3273,9 @@ void BufferView::setInlineCompletion(Cursor const & cur, DocIterator const & pos
 	bool singlePar = true;
 	d->inlineCompletion_ = completion;
 	d->inlineCompletionUniqueChars_ = min(completion.size(), uniqueChars);
-	
+
 	//lyxerr << "setInlineCompletion pos=" << pos << " completion=" << completion << " uniqueChars=" << uniqueChars << std::endl;
-	
+
 	// at new position?
 	DocIterator const & old = d->inlineCompletionPos_;
 	if (old != pos) {
@@ -3101,7 +3288,7 @@ void BufferView::setInlineCompletion(Cursor const & cur, DocIterator const & pos
 		}
 		d->inlineCompletionPos_ = pos;
 	}
-	
+
 	// set update flags
 	if (changed) {
 		if (singlePar && !(cur.result().screenUpdate() & Update::Force))
@@ -3113,8 +3300,8 @@ void BufferView::setInlineCompletion(Cursor const & cur, DocIterator const & pos
 
 
 bool BufferView::clickableInset() const
-{ 
-	return d->clickable_inset_; 
+{
+	return d->clickable_inset_;
 }
 
 } // namespace lyx