X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FBufferView.cpp;h=81ebe79977370d21bf2e54341cd2ab5d400dc955;hb=f16b2cab75752e7b0fbec5520e231b068eb29072;hp=84194605a59200d3a6f816f22aa40e02d73e6720;hpb=2a86379ea7c589a75ff84d86755d214f45748550;p=lyx.git

diff --git a/src/BufferView.cpp b/src/BufferView.cpp
index 84194605a5..81ebe79977 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 2.5mm at 100dpi
+	int const default_margin = Length(2.5, Length::MM).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;
 }
@@ -397,7 +416,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 +434,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 +447,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 +465,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 +474,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 +497,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 +518,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()
@@ -656,7 +678,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 +706,10 @@ Change const BufferView::getCurrentChange() const
 		return Change(Change::UNCHANGED);
 
 	DocIterator dit = d->cursor_.selectionBegin();
+	// The selected content might have been changed (see #7685)
+	while (dit.inMathed())
+		// Find enclosing text cursor
+		dit.pop_back();
 	return dit.paragraph().lookupChange(dit.pos());
 }
 
@@ -772,7 +798,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 +809,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 +825,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);
@@ -954,7 +980,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 +993,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.
@@ -1079,11 +1105,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,23 +1119,13 @@ 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:
@@ -1123,16 +1139,6 @@ bool BufferView::getStatus(FuncRequest const & cmd, FuncStatus & flag)
 		flag.setEnabled(true);
 		break;
 
-	case LFUN_BUFFER_TOGGLE_COMPRESSION: {
-		flag.setOnOff(buffer_.params().compressed);
-		break;
-	}
-
-	case LFUN_BUFFER_TOGGLE_OUTPUT_SYNC: {
-		flag.setOnOff(buffer_.params().output_sync);
-		break;
-	}
-
 	case LFUN_SCREEN_UP:
 	case LFUN_SCREEN_DOWN:
 	case LFUN_SCROLL:
@@ -1154,6 +1160,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)
@@ -1213,9 +1223,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;
 
@@ -1228,7 +1239,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);
@@ -1239,7 +1250,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.
@@ -1247,9 +1258,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);
@@ -1260,12 +1274,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);
@@ -1274,9 +1291,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) {
@@ -1294,7 +1311,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);
@@ -1303,12 +1323,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);
@@ -1374,7 +1394,7 @@ 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));
@@ -1382,20 +1402,21 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr)
 		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);
+				cur.pos() = pos;
+				mouseSetCursor(cur);
 				dr.screenUpdate(Update::Force | Update::FitCursor);
 			} else {
 				// Switch to other buffer view and resend cmd
@@ -1420,39 +1441,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:
@@ -1496,6 +1490,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;
 
@@ -1611,7 +1607,7 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr)
 	case LFUN_SCREEN_SHOW_CURSOR:
 		showCursor();
 		break;
-	
+
 	case LFUN_SCREEN_RECENTER:
 		recenter();
 		break;
@@ -1639,7 +1635,7 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr)
 			if (inset->delDatabase(cmd.argument())) {
 				buffer_.invalidateBibfileCache();
 				dr.forceBufferUpdate();
-			}				
+			}
 		}
 		break;
 	}
@@ -1684,15 +1680,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);
@@ -1709,7 +1696,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);
@@ -1717,13 +1703,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;
@@ -1791,6 +1777,42 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr)
 	}
 
 
+	case LFUN_INSET_SELECT_ALL:
+		if (cur.depth() > 1
+		    && cur.selBegin().at_begin()
+		    && cur.selEnd().at_end()) {
+			// All the contents of the inset if selected.
+			// Select the inset from outside.
+			cur.pop();
+			cur.resetAnchor();
+			cur.setSelection(true);
+			cur.posForward();
+		} else if (cur.selBegin().idx() != cur.selEnd().idx()
+			   || (cur.depth() > 1
+				   && cur.selBegin().at_cell_begin()
+			       && cur.selEnd().at_cell_end())) {
+			// At least one complete cell is selected.
+			// Select all cells
+			cur.idx() = 0;
+			cur.pos() = 0;
+			cur.resetAnchor();
+			cur.setSelection(true);
+			cur.idx() = cur.lastidx();
+			cur.pos() = cur.lastpos();
+		} else {
+			// select current cell
+			cur.pit() = 0;
+			cur.pos() = 0;
+			cur.resetAnchor();
+			cur.setSelection(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: {
@@ -1889,7 +1911,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;
 	}
@@ -1968,7 +1990,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();
@@ -1996,6 +2018,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();
+	}
 }
 
 
@@ -2099,10 +2136,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;
@@ -2110,9 +2147,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.
@@ -2161,6 +2198,15 @@ 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() &&
+		    cur.nextInset() != inset && cur.prevInset() == inset)
+			cur.posBackward();
+	}
 
 	// Put anchor at the same position.
 	cur.resetAnchor();
@@ -2188,7 +2234,7 @@ void BufferView::mouseEventDispatch(FuncRequest const & cmd0)
 		if (badcursor)
 			cursor().fixIfBroken();
 	}
-	
+
 	// Do we have a selection?
 	theSelection().haveSelection(cursor().selection());
 
@@ -2268,23 +2314,36 @@ int BufferView::scrollUp(int offset)
 
 
 void BufferView::setCursorFromRow(int row)
+{
+	setCursorFromRow(row, buffer_.texrow());
+}
+
+
+void BufferView::setCursorFromRow(int row, TexRow const & texrow)
 {
 	int tmpid;
 	int tmppos;
 	pit_type newpit = 0;
 	pos_type newpos = 0;
 
-	buffer_.texrow().getIdFromRow(row, tmpid, tmppos);
+	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);
+		DocIterator dit = buffer_.getParFromID(tmpid);
 		if (dit == doc_iterator_end(&buffer_))
 			posvalid = false;
-		else {
+		else if (dit.depth() > 1) {
+			// We are in an inset.
+			pos_type lastpos = dit.lastpos();
+			dit.pos() = tmppos > lastpos ? lastpos : tmppos;
+			setCursor(dit);
+			recenter();
+			return;
+		} else {
 			newpit = dit.pit();
 			// now have to check pos.
 			newpos = tmppos;
@@ -2337,9 +2396,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");
+		TocIterator toc_it = toc->begin();
+		TocIterator end = toc->end();
 		for (; toc_it != end; ++toc_it) {
 			if (label == toc_it->str()) {
 				lyx::dispatch(toc_it->action());
@@ -2390,6 +2449,7 @@ void BufferView::setCursor(DocIterator const & dit)
 
 	d->cursor_.setCursor(dit);
 	d->cursor_.setSelection(false);
+	d->cursor_.setCurrentFont();
 	// FIXME
 	// It seems on general grounds as if this is probably needed, but
 	// it is not yet clear.
@@ -2415,9 +2475,9 @@ bool BufferView::checkDepm(Cursor & cur, Cursor & old)
 		return false;
 
 	d->cursor_ = cur;
-	
-	// we would rather not do this here, but it needs to be done before 
- 	// the changed() signal is sent.
+
+	// we would rather not do this here, but it needs to be done before
+	// the changed() signal is sent.
 	buffer_.updateBuffer();
 
 	buffer_.changed(true);
@@ -2444,7 +2504,7 @@ bool BufferView::mouseSetCursor(Cursor & cur, bool select)
 		d->cursor_.fixIfBroken();
 
 	// FIXME: shift-mouse selection doesn't work well across insets.
-	bool const do_selection = 
+	bool const do_selection =
 			select && &d->cursor_.normalAnchor().inset() == &cur.inset();
 
 	// do the dEPM magic if needed
@@ -2452,8 +2512,12 @@ bool BufferView::mouseSetCursor(Cursor & cur, bool select)
 	// 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())
+	if (!do_selection && d->cursor_.inTexted()) {
 		update |= checkDepm(cur, d->cursor_);
+		if (cur.inTexted() && cur.pos()
+			&& cur.paragraph().isEnvSeparator(cur.pos() - 1))
+		    cur.posBackward();
+	}
 
 	if (!do_selection)
 		d->cursor_.resetAnchor();
@@ -2491,7 +2555,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();
@@ -2559,7 +2624,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.
@@ -2596,7 +2661,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;
@@ -2604,19 +2669,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: "
@@ -2705,19 +2770,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()) {
@@ -2735,14 +2800,13 @@ Point BufferView::coordOffset(DocIterator const & dit) const
 			// 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());
+			Dimension const & dim = coordCache().getInsets().dim(&sl.inset());
 			lastw = dim.wid;
 		} else {
 			Dimension const dim = sl.inset().dimension(*this);
 			lastw = dim.wid;
 		}
-		
+
 		//lyxerr << "Cursor::getPos, i: "
 		// << i << " x: " << xx << " y: " << y << endl;
 	}
@@ -2771,20 +2835,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);
 }
 
@@ -2798,7 +2862,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;
 }
@@ -2836,6 +2900,135 @@ bool BufferView::cursorInView(Point const & p, int h) const
 }
 
 
+int BufferView::horizScrollOffset() const
+{
+	return d->horiz_scroll_offset_;
+}
+
+
+CursorSlice const & BufferView::currentRowSlice() const
+{
+	return d->current_row_slice_;
+}
+
+
+CursorSlice const & BufferView::lastRowSlice() const
+{
+	return d->last_row_slice_;
+}
+
+
+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(), d->cursor_.bottom().pit(), 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)
@@ -2847,22 +3040,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:
@@ -2871,6 +3070,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;
 
@@ -2884,9 +3089,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);
 		}
@@ -3040,7 +3245,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);
@@ -3049,9 +3254,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) {
@@ -3064,7 +3269,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))
@@ -3076,8 +3281,8 @@ void BufferView::setInlineCompletion(Cursor const & cur, DocIterator const & pos
 
 
 bool BufferView::clickableInset() const
-{ 
-	return d->clickable_inset_; 
+{
+	return d->clickable_inset_;
 }
 
 } // namespace lyx