X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Ftext3.C;h=a468a7289665a3590980354f8cc5dc346177fa62;hb=eead5ba43d0ddf06544ad1b40063981d3788c635;hp=12adb07c32ed33b5f41f825b2e303e390eaa1bf3;hpb=0d876bc179f099b5b9ebe427180bce9a996e730f;p=lyx.git

diff --git a/src/text3.C b/src/text3.C
index 12adb07c32..a468a72896 100644
--- a/src/text3.C
+++ b/src/text3.C
@@ -16,16 +16,20 @@
 #include "BufferView.h"
 #include "funcrequest.h"
 #include "lyxrc.h"
+#include "Lsstream.h"
 #include "debug.h"
 #include "bufferparams.h"
 #include "buffer.h"
+#include "bufferview_funcs.h"
 #include "ParagraphParameters.h"
 #include "gettext.h"
 #include "factory.h"
 #include "intl.h"
 #include "box.h"
 #include "language.h"
+#include "support/tostr.h"
 #include "support/lstrings.h"
+#include "support/LAssert.h"
 #include "frontends/LyXView.h"
 #include "frontends/screen.h"
 #include "frontends/Dialogs.h"
@@ -35,13 +39,19 @@
 #include "insets/insetcommand.h"
 #include "insets/insetnewline.h"
 #include "undo_funcs.h"
+#include "text_funcs.h"
+#include "Lsstream.h"
 
 #include <ctime>
 #include <clocale>
 
+using namespace lyx::support;
+using namespace bv_funcs;
+
 using std::endl;
 using std::find;
 using std::vector;
+using lyx::pos_type;
 
 extern string current_layout;
 extern int bibitemMaxWidth(BufferView *, LyXFont const &);
@@ -62,15 +72,12 @@ namespace {
 			if (lt->isInInset())
 				bv->updateInset(lt->inset_owner);
 			else
-				bv->toggleToggle();
+				bv->repaint();
 		}
 		if (!lt->isInInset()) {
 			bv->update(lt, BufferView::SELECT);
-			bv->showCursor();
-		} else if (bv->text->refreshStatus() != LyXText::REFRESH_NONE) {
-			bv->theLockingInset()->hideInsetCursor(bv);
+		} else if (bv->text->needRefresh()) {
 			bv->update(BufferView::SELECT);
-			bv->showCursor();
 		}
 
 		if (!lt->selection.set())
@@ -90,34 +97,34 @@ namespace {
 	// check if the given co-ordinates are inside an inset at the
 	// given cursor, if one exists. If so, the inset is returned,
 	// and the co-ordinates are made relative. Otherwise, 0 is returned.
-	Inset * checkInset(BufferView * bv, LyXText & text,
+InsetOld * checkInset(BufferView * /*bv*/, LyXText & text,
 		LyXCursor const & cur, int & x, int & y)
 	{
 		lyx::pos_type const pos = cur.pos();
-		Paragraph /*const*/ & par = *cur.par();
+		ParagraphList::iterator par = cur.par();
 
-		if (pos >= par.size() || !par.isInset(pos))
+		if (pos >= par->size() || !par->isInset(pos))
 			return 0;
 
-		Inset /*const*/ * inset = par.getInset(pos);
+		InsetOld /*const*/ * inset = par->getInset(pos);
 
 		if (!isEditableInset(inset))
 			return 0;
 
 		// get inset dimensions
-		lyx::Assert(par.getInset(pos));
+		Assert(par->getInset(pos));
 
-		LyXFont const & font = text.getFont(bv->buffer(), &par, pos);
+		LyXFont const & font = text.getFont(par, pos);
 
-		int const width = inset->width(bv, font);
+		int const width = inset->width();
 		int const inset_x = font.isVisibleRightToLeft()
 			? (cur.ix() - width) : cur.ix();
 
 		Box b(
 			inset_x + inset->scroll(),
 			inset_x + width,
-			cur.iy() - inset->ascent(bv, font),
-			cur.iy() + inset->descent(bv, font)
+			cur.iy() - inset->ascent(),
+			cur.iy() + inset->descent()
 		);
 
 		if (!b.contained(x, y)) {
@@ -127,7 +134,7 @@ namespace {
 			return 0;
 		}
 
-		text.setCursor(&par, pos, true);
+		text.setCursor(par, pos, true);
 
 		x -= b.x1;
 		// The origin of an inset is on the baseline
@@ -139,14 +146,14 @@ namespace {
 } // anon namespace
 
 
-Inset * LyXText::checkInsetHit(int & x, int & y)
+InsetOld * LyXText::checkInsetHit(int & x, int & y)
 {
 	int y_tmp = y + top_y();
 
 	LyXCursor cur;
 	setCursorFromCoordinates(cur, x, y_tmp);
 
-	Inset * inset = checkInset(bv(), *this, cur, x, y_tmp);
+	InsetOld * inset = checkInset(bv(), *this, cur, x, y_tmp);
 	if (inset) {
 		y = y_tmp;
 		return inset;
@@ -166,56 +173,57 @@ Inset * LyXText::checkInsetHit(int & x, int & y)
 }
 
 
-bool LyXText::gotoNextInset(vector<Inset::Code> const & codes,
+bool LyXText::gotoNextInset(vector<InsetOld::Code> const & codes,
 			    string const & contents)
 {
-	LyXCursor res = cursor;
-	Inset * inset;
+	ParagraphList::iterator end = ownerParagraphs().end();
+	ParagraphList::iterator pit = cursor.par();
+	pos_type pos = cursor.pos();
+
+	InsetOld * inset;
 	do {
-		if (res.pos() < res.par()->size() - 1) {
-			res.pos(res.pos() + 1);
+		if (pos + 1 < pit->size()) {
+			++pos;
 		} else  {
-			res.par(res.par()->next());
-			res.pos(0);
+			++pit;
+			pos = 0;
 		}
 
-	} while (res.par() &&
-		 !(res.par()->isInset(res.pos())
-		   && (inset = res.par()->getInset(res.pos())) != 0
-		   && find(codes.begin(), codes.end(), inset->lyxCode())
-		   != codes.end()
-		   && (contents.empty() ||
-		       static_cast<InsetCommand *>(
-							res.par()->getInset(res.pos()))->getContents()
-		       == contents)));
-
-	if (res.par()) {
-		setCursor(res.par(), res.pos(), false);
+	} while (pit != end &&
+		 !(pit->isInset(pos) &&
+		   (inset = pit->getInset(pos)) != 0 &&
+		   find(codes.begin(), codes.end(), inset->lyxCode()) != codes.end() &&
+		   (contents.empty() ||
+		    static_cast<InsetCommand *>(pit->getInset(pos))->getContents()
+		    == contents)));
+
+	if (pit != end) {
+		setCursor(pit, pos, false);
 		return true;
 	}
 	return false;
 }
 
 
-void LyXText::gotoInset(vector<Inset::Code> const & codes,
-				  bool same_content)
+void LyXText::gotoInset(vector<InsetOld::Code> const & codes,
+			bool same_content)
 {
-	bv()->hideCursor();
 	bv()->beforeChange(this);
 	update();
 
 	string contents;
-	if (same_content && cursor.par()->isInset(cursor.pos())) {
-		Inset const * inset = cursor.par()->getInset(cursor.pos());
+	if (same_content && cursor.pos() < cursor.par()->size()
+	    && cursor.par()->isInset(cursor.pos())) {
+		InsetOld const * inset = cursor.par()->getInset(cursor.pos());
 		if (find(codes.begin(), codes.end(), inset->lyxCode())
 		    != codes.end())
 			contents = static_cast<InsetCommand const *>(inset)->getContents();
 	}
 
 	if (!gotoNextInset(codes, contents)) {
-		if (cursor.pos() || cursor.par() != ownerParagraph()) {
+		if (cursor.pos() || cursor.par() != ownerParagraphs().begin()) {
 			LyXCursor tmp = cursor;
-			cursor.par(ownerParagraph());
+			cursor.par(ownerParagraphs().begin());
 			cursor.pos(0);
 			if (!gotoNextInset(codes, contents)) {
 				cursor = tmp;
@@ -230,9 +238,9 @@ void LyXText::gotoInset(vector<Inset::Code> const & codes,
 }
 
 
-void LyXText::gotoInset(Inset::Code code, bool same_content)
+void LyXText::gotoInset(InsetOld::Code code, bool same_content)
 {
-	gotoInset(vector<Inset::Code>(1, code), same_content);
+	gotoInset(vector<InsetOld::Code>(1, code), same_content);
 }
 
 
@@ -240,49 +248,43 @@ void LyXText::cursorPrevious()
 {
 	int y = top_y();
 
-	if (cursor.row() == rows().begin()) {
-		if (y > 0) {
-			int new_y = bv()->text->top_y() - bv()->workHeight();
-			bv()->screen().draw(bv()->text, bv(), new_y < 0 ? 0 : new_y);
+	if (cursorRow() == rows().begin()) {
+		if (y > 0)
 			bv()->updateScrollbar();
-		}
 		return;
 	}
 
-	RowList::iterator cursorrow = cursor.row();
+	RowList::iterator cursorrow = cursorRow();
 
 	setCursorFromCoordinates(cursor.x_fix(), y);
 	finishUndo();
 
 	int new_y;
-	if (cursorrow == bv()->text->cursor.row()) {
+	if (cursorrow == bv()->text->cursorRow()) {
 		// we have a row which is taller than the workarea. The
 		// simplest solution is to move to the previous row instead.
 		cursorUp(true);
 		return;
 		// This is what we used to do, so we wouldn't skip right past
 		// tall rows, but it's not working right now.
-#if 0
-		new_y = bv->text->top_y() - bv->workHeight();
-#endif
 	} else {
 		if (inset_owner) {
 			new_y = bv()->text->cursor.iy()
 				+ bv()->theLockingInset()->insetInInsetY() + y
-				+ cursor.row()->height()
+				+ cursorRow()->height()
 				- bv()->workHeight() + 1;
 		} else {
 			new_y = cursor.y()
-				- cursor.row()->baseline()
-				+ cursor.row()->height()
+				- cursorRow()->baseline()
+				+ cursorRow()->height()
 				- bv()->workHeight() + 1;
 		}
 	}
-	bv()->screen().draw(bv()->text, bv(), new_y < 0 ? 0 : new_y);
-	if (cursor.row() != rows().begin()) {
+	//bv()->screen().draw(bv()->text, bv(), new_y < 0 ? 0 : new_y);
+	if (cursorRow() != rows().begin()) {
 		LyXCursor cur;
-		setCursor(cur, boost::prior(cursor.row())->par(),
-			  boost::prior(cursor.row())->pos(), false);
+		setCursor(cur, boost::prior(cursorRow())->par(),
+			  boost::prior(cursorRow())->pos(), false);
 		if (cur.y() > top_y()) {
 			cursorUp(true);
 		}
@@ -295,11 +297,11 @@ void LyXText::cursorNext()
 {
 	int topy = top_y();
 
-	if (boost::next(cursor.row()) == rows().end()) {
-		int y = cursor.y() - cursor.row()->baseline() +
-			cursor.row()->height();
+	if (boost::next(cursorRow()) == rows().end()) {
+		int y = cursor.y() - cursorRow()->baseline() +
+			cursorRow()->height();
 		if (y > topy + bv()->workHeight()) {
-			bv()->screen().draw(bv()->text, bv(), bv()->text->top_y() + bv()->workHeight());
+			//bv()->screen().draw(bv()->text, bv(), bv()->text->top_y() + bv()->workHeight());
 			bv()->updateScrollbar();
 		}
 		return;
@@ -314,13 +316,13 @@ void LyXText::cursorNext()
 
 	getRowNearY(y);
 
-	RowList::iterator cursorrow = cursor.row();
+	RowList::iterator cursorrow = cursorRow();
 	setCursorFromCoordinates(cursor.x_fix(), y);
 	// + bv->workHeight());
 	finishUndo();
 
 	int new_y;
-	if (cursorrow == bv()->text->cursor.row()) {
+	if (cursorrow == bv()->text->cursorRow()) {
 		// we have a row which is taller than the workarea. The
 		// simplest solution is to move to the next row instead.
 		cursorDown(true);
@@ -334,16 +336,17 @@ void LyXText::cursorNext()
 		if (inset_owner) {
 			new_y = bv()->text->cursor.iy()
 				+ bv()->theLockingInset()->insetInInsetY()
-				+ y - cursor.row()->baseline();
+				+ y - cursorRow()->baseline();
 		} else {
-			new_y =  cursor.y() - cursor.row()->baseline();
+			new_y =  cursor.y() - cursorRow()->baseline();
 		}
 	}
-	bv()->screen().draw(bv()->text, bv(), new_y);
-	if (boost::next(cursor.row()) != rows().end()) {
+	//bv()->screen().draw(bv()->text, bv(), new_y);
+
+	RowList::iterator next_row = boost::next(cursorRow());
+	if (next_row != rows().end()) {
 		LyXCursor cur;
-		setCursor(cur, boost::next(cursor.row())->par(),
-			  boost::next(cursor.row())->pos(), false);
+		setCursor(cur, next_row->par(), next_row->pos(), false);
 		if (cur.y() < top_y() + bv()->workHeight()) {
 			cursorDown(true);
 		}
@@ -361,9 +364,9 @@ namespace {
 
 void specialChar(LyXText * lt, BufferView * bv, InsetSpecialChar::Kind kind)
 {
-	bv->hideCursor();
 	lt->update();
 	InsetSpecialChar * new_inset = new InsetSpecialChar(kind);
+	replaceSelection(lt);
 	if (!bv->insertInset(new_inset))
 		delete new_inset;
 	else
@@ -374,20 +377,22 @@ void specialChar(LyXText * lt, BufferView * bv, InsetSpecialChar::Kind kind)
 void doInsertInset(LyXText * lt, FuncRequest const & cmd,
 		   bool edit, bool pastesel)
 {
-	Inset * inset = createInset(cmd);
+	InsetOld * inset = createInset(cmd);
 	BufferView * bv = cmd.view();
 
 	if (inset) {
 		bool gotsel = false;
 		if (lt->selection.set()) {
-			lt->cutSelection(true, false);
+			bv->owner()->dispatch(FuncRequest(LFUN_CUT));
 			gotsel = true;
 		}
 		if (bv->insertInset(inset)) {
-			if (edit)
-				inset->edit(bv);
+			if (edit) {
+				FuncRequest cmd(bv, LFUN_INSET_EDIT, "left");
+				inset->localDispatch(cmd);
+			}
 			if (gotsel && pastesel)
-				bv->owner()->dispatch(FuncRequest(LFUN_PASTESELECTION));
+				bv->owner()->dispatch(FuncRequest(LFUN_PASTE));
 		}
 		else
 			delete inset;
@@ -396,7 +401,7 @@ void doInsertInset(LyXText * lt, FuncRequest const & cmd,
 
 }
 
-Inset::RESULT LyXText::dispatch(FuncRequest const & cmd)
+InsetOld::RESULT LyXText::dispatch(FuncRequest const & cmd)
 {
 	lyxerr[Debug::ACTION] << "LyXFunc::dispatch: action[" << cmd.action
 			      <<"] arg[" << cmd.argument << ']' << endl;
@@ -406,14 +411,16 @@ Inset::RESULT LyXText::dispatch(FuncRequest const & cmd)
 	switch (cmd.action) {
 
 	case LFUN_APPENDIX: {
-		Paragraph * par = cursor.par();
-		bool start = !par->params().startOfAppendix();
+		ParagraphList::iterator pit = cursor.par();
+		bool start = !pit->params().startOfAppendix();
 
 		// ensure that we have only one start_of_appendix in this document
-		Paragraph * tmp = ownerParagraph();
-		for (; tmp; tmp = tmp->next()) {
+		ParagraphList::iterator tmp = ownerParagraphs().begin();
+		ParagraphList::iterator end = ownerParagraphs().end();
+
+		for (; tmp != end; ++tmp) {
 			if (tmp->params().startOfAppendix()) {
-				setUndo(bv, Undo::EDIT, tmp, tmp->next());
+				recordUndo(bv, Undo::ATOMIC, tmp);
 				tmp->params().startOfAppendix(false);
 				int tmpy;
 				setHeightOfRow(getRow(tmp, 0, tmpy));
@@ -421,13 +428,13 @@ Inset::RESULT LyXText::dispatch(FuncRequest const & cmd)
 			}
 		}
 
-		setUndo(bv, Undo::EDIT, par, par->next());
-		par->params().startOfAppendix(start);
+		recordUndo(bv, Undo::ATOMIC, pit);
+		pit->params().startOfAppendix(start);
 
 		// we can set the refreshing parameters now
 		updateCounters();
 		redoHeightOfParagraph();
-		postPaint(0);
+		postPaint();
 		setCursor(cursor.par(), cursor.pos());
 		update();
 		break;
@@ -457,15 +464,6 @@ Inset::RESULT LyXText::dispatch(FuncRequest const & cmd)
 		finishChange(bv);
 		break;
 
-	case LFUN_SHIFT_TAB:
-	case LFUN_TAB:
-		if (!selection.mark())
-			bv->beforeChange(this);
-		update();
-		cursorTab();
-		finishChange(bv);
-		break;
-
 	case LFUN_WORDRIGHT:
 		if (!selection.mark())
 			bv->beforeChange(this);
@@ -590,9 +588,9 @@ Inset::RESULT LyXText::dispatch(FuncRequest const & cmd)
 
 	case LFUN_WORDSEL: {
 		update();
-		LyXCursor cur1;
+		LyXCursor cur1 = cursor;
 		LyXCursor cur2;
-		getWord(cur1, cur2, WHOLE_WORD);
+		::getWord(cur1, cur2, lyx::WHOLE_WORD, ownerParagraphs());
 		setCursor(cur1.par(), cur1.pos());
 		bv->beforeChange(this);
 		setCursor(cur2.par(), cur2.pos());
@@ -610,9 +608,10 @@ Inset::RESULT LyXText::dispatch(FuncRequest const & cmd)
 		if (cursor.pos() < cursor.par()->size()
 		    && cursor.par()->isInset(cursor.pos())
 		    && isHighlyEditableInset(cursor.par()->getInset(cursor.pos()))) {
-			Inset * tmpinset = cursor.par()->getInset(cursor.pos());
+			InsetOld * tmpinset = cursor.par()->getInset(cursor.pos());
 			cmd.message(tmpinset->editMessage());
-			tmpinset->edit(bv, !is_rtl);
+			FuncRequest cmd1(bv, LFUN_INSET_EDIT, is_rtl ? "right" : "left");
+			tmpinset->localDispatch(cmd1);
 			break;
 		}
 		if (!is_rtl)
@@ -635,9 +634,10 @@ Inset::RESULT LyXText::dispatch(FuncRequest const & cmd)
 		    cursor.pos() < cursor.par()->size() &&
 		    cursor.par()->isInset(cursor.pos()) &&
 		    isHighlyEditableInset(cursor.par()->getInset(cursor.pos()))) {
-			Inset * tmpinset = cursor.par()->getInset(cursor.pos());
+			InsetOld * tmpinset = cursor.par()->getInset(cursor.pos());
 			cmd.message(tmpinset->editMessage());
-			tmpinset->edit(bv, is_rtl);
+			FuncRequest cmd1(bv, LFUN_INSET_EDIT, is_rtl ? "left" : "right");
+			tmpinset->localDispatch(cmd1);
 			break;
 		}
 		if (is_rtl)
@@ -650,7 +650,7 @@ Inset::RESULT LyXText::dispatch(FuncRequest const & cmd)
 		if (!selection.mark())
 			bv->beforeChange(this);
 		bv->update(this, BufferView::UPDATE);
-		cursorUp(bv);
+		cursorUp(false);
 		finishChange(bv);
 		break;
 
@@ -658,7 +658,7 @@ Inset::RESULT LyXText::dispatch(FuncRequest const & cmd)
 		if (!selection.mark())
 			bv->beforeChange(this);
 		bv->update(this, BufferView::UPDATE);
-		cursorDown(bv);
+		cursorDown(false);
 		finishChange(bv);
 		break;
 
@@ -684,10 +684,6 @@ Inset::RESULT LyXText::dispatch(FuncRequest const & cmd)
 		bv->update(this, BufferView::UPDATE);
 		cursorPrevious();
 		finishChange(bv, false);
-		// was:
-		// finishUndo();
-		// moveCursorUpdate(bv, false, false);
-		// owner_->view_state_changed();
 		break;
 
 	case LFUN_NEXT:
@@ -721,7 +717,7 @@ Inset::RESULT LyXText::dispatch(FuncRequest const & cmd)
 		if (cursor.pos() <= body)
 			break;
 
-		bv->beforeChange(this);
+		replaceSelection(bv->getLyXText());
 		insertInset(new InsetNewline);
 		update();
 		setCursor(cursor.par(), cursor.pos());
@@ -736,10 +732,9 @@ Inset::RESULT LyXText::dispatch(FuncRequest const & cmd)
 			update();
 			// It is possible to make it a lot faster still
 			// just comment out the line below...
-			bv->showCursor();
 		} else {
 			update();
-			cutSelection(bv, true);
+			cutSelection(true, false);
 			update();
 		}
 		moveCursorUpdate(bv, false);
@@ -780,7 +775,7 @@ Inset::RESULT LyXText::dispatch(FuncRequest const & cmd)
 			}
 		} else {
 			update();
-			cutSelection(bv, true);
+			cutSelection(true, false);
 		}
 		update();
 		break;
@@ -794,11 +789,10 @@ Inset::RESULT LyXText::dispatch(FuncRequest const & cmd)
 				update();
 				// It is possible to make it a lot faster still
 				// just comment out the line below...
-				bv->showCursor();
 			}
 		} else {
 			update();
-			cutSelection(bv, true);
+			cutSelection(true, false);
 			update();
 		}
 		bv->owner()->view_state_changed();
@@ -827,13 +821,13 @@ Inset::RESULT LyXText::dispatch(FuncRequest const & cmd)
 			}
 		} else {
 			update();
-			cutSelection(bv, true);
+			cutSelection(true, false);
 		}
 		update();
 		break;
 
 	case LFUN_BREAKPARAGRAPH:
-		bv->beforeChange(this);
+		replaceSelection(bv->getLyXText());
 		breakParagraph(bv->buffer()->paragraphs, 0);
 		update();
 		selection.cursor = cursor;
@@ -842,7 +836,7 @@ Inset::RESULT LyXText::dispatch(FuncRequest const & cmd)
 		break;
 
 	case LFUN_BREAKPARAGRAPHKEEPLAYOUT:
-		bv->beforeChange(this);
+		replaceSelection(bv->getLyXText());
 		breakParagraph(bv->buffer()->paragraphs, 1);
 		update();
 		selection.cursor = cursor;
@@ -855,7 +849,7 @@ Inset::RESULT LyXText::dispatch(FuncRequest const & cmd)
 		// indentation and add a "defskip" at the top.
 		// Otherwise, do the same as LFUN_BREAKPARAGRAPH.
 		LyXCursor cur = cursor;
-		bv->beforeChange(this);
+		replaceSelection(bv->getLyXText());
 		if (cur.pos() == 0) {
 			if (cur.par()->params().spaceTop() == VSpace(VSpace::NONE)) {
 				setParagraph(
@@ -880,13 +874,13 @@ Inset::RESULT LyXText::dispatch(FuncRequest const & cmd)
 	}
 
 	case LFUN_PARAGRAPH_SPACING: {
-		Paragraph * par = cursor.par();
-		Spacing::Space cur_spacing = par->params().spacing().getSpace();
+		ParagraphList::iterator pit = cursor.par();
+		Spacing::Space cur_spacing = pit->params().spacing().getSpace();
 		float cur_value = 1.0;
 		if (cur_spacing == Spacing::Other)
-			cur_value = par->params().spacing().getValue();
+			cur_value = pit->params().spacing().getValue();
 
-		istringstream is(cmd.argument.c_str());
+		istringstream is(STRCONV(cmd.argument));
 		string tmp;
 		is >> tmp;
 		Spacing::Space new_spacing = cur_spacing;
@@ -914,15 +908,19 @@ Inset::RESULT LyXText::dispatch(FuncRequest const & cmd)
 			       << cmd.argument << endl;
 		}
 		if (cur_spacing != new_spacing || cur_value != new_value) {
-			par->params().spacing(Spacing(new_spacing, new_value));
+			pit->params().spacing(Spacing(new_spacing, new_value));
 			redoParagraph();
 			update();
 		}
 		break;
 	}
 
+	case LFUN_INSET_SETTINGS:
+		Assert(bv->theLockingInset());
+		bv->theLockingInset()->getLockingInset()->showInsetDialog(bv);
+		break;
+
 	case LFUN_INSET_TOGGLE:
-		bv->hideCursor();
 		bv->beforeChange(this);
 		update();
 		toggleInset();
@@ -930,12 +928,12 @@ Inset::RESULT LyXText::dispatch(FuncRequest const & cmd)
 		bv->switchKeyMap();
 		break;
 
-	case LFUN_PROTECTEDSPACE:
+	case LFUN_SPACE_INSERT:
 		if (cursor.par()->layout()->free_spacing) {
 			insertChar(' ');
 			update();
 		} else {
-			specialChar(this, bv, InsetSpecialChar::PROTECTED_SEPARATOR);
+			doInsertInset(this, cmd, false, false);
 		}
 		moveCursorUpdate(bv, false);
 		break;
@@ -1014,29 +1012,34 @@ Inset::RESULT LyXText::dispatch(FuncRequest const & cmd)
 
 	case LFUN_TRANSPOSE_CHARS:
 		update();
-		transposeChars();
+		recordUndo(bv, Undo::ATOMIC, cursor.par());
+		if (transposeChars(cursor))
+			checkParagraph(cursor.par(), cursor.pos());
 		if (inset_owner)
 			bv->updateInset(inset_owner);
 		update();
 		break;
 
-	case LFUN_PASTE:
+	case LFUN_PASTE: {
 		cmd.message(_("Paste"));
-		bv->hideCursor();
-		// clear the selection
-		bv->toggleSelection();
-		clearSelection();
-		update();
-		pasteSelection();
+		replaceSelection(bv->getLyXText());
+		size_t sel_index = 0;
+		string const & arg = cmd.argument;
+		if (isStrUnsignedInt(arg)) {
+			size_t const paste_arg = strToUnsignedInt(arg);
+#warning FIXME Check if the arg is in the domain of available selections.
+			sel_index = paste_arg;
+		}
+		pasteSelection(sel_index);
 		clearSelection(); // bug 393
 		update();
 		bv->switchKeyMap();
 		break;
+	}
 
 	case LFUN_CUT:
-		bv->hideCursor();
 		update();
-		cutSelection(bv, true);
+		cutSelection(true, true);
 		update();
 		cmd.message(_("Cut"));
 		break;
@@ -1069,7 +1072,7 @@ Inset::RESULT LyXText::dispatch(FuncRequest const & cmd)
 	case LFUN_SETXY: {
 		int x = 0;
 		int y = 0;
-		istringstream is(cmd.argument.c_str());
+		istringstream is(STRCONV(cmd.argument));
 		is >> x >> y;
 		if (!is)
 			lyxerr << "SETXY: Could not parse coordinates in '"
@@ -1126,21 +1129,22 @@ Inset::RESULT LyXText::dispatch(FuncRequest const & cmd)
 		}
 
 		bool change_layout = (current_layout != layout);
+
 		if (!change_layout && selection.set() &&
 			selection.start.par() != selection.end.par())
 		{
-			Paragraph * spar = selection.start.par();
-			Paragraph * epar = selection.end.par()->next();
-			while (spar != epar) {
-				if (spar->layout()->name() != current_layout) {
+			ParagraphList::iterator spit = selection.start.par();
+			ParagraphList::iterator epit = boost::next(selection.end.par());
+			while (spit != epit) {
+				if (spit->layout()->name() != current_layout) {
 					change_layout = true;
 					break;
 				}
-				spar = spar->next();
+				++spit;
 			}
 		}
+
 		if (change_layout) {
-			bv->hideCursor();
 			current_layout = layout;
 			update();
 			setLayout(layout);
@@ -1154,7 +1158,6 @@ Inset::RESULT LyXText::dispatch(FuncRequest const & cmd)
 	case LFUN_PASTESELECTION: {
 		if (!bv->buffer())
 			break;
-		bv->hideCursor();
 		// this was originally a beforeChange(bv->text), i.e
 		// the outermost LyXText!
 		bv->beforeChange(this);
@@ -1171,38 +1174,38 @@ Inset::RESULT LyXText::dispatch(FuncRequest const & cmd)
 	}
 
 	case LFUN_GOTOERROR:
-		gotoInset(Inset::ERROR_CODE, false);
+		gotoInset(InsetOld::ERROR_CODE, false);
 		break;
 
 	case LFUN_GOTONOTE:
-		gotoInset(Inset::NOTE_CODE, false);
+		gotoInset(InsetOld::NOTE_CODE, false);
 		break;
 
 	case LFUN_REFERENCE_GOTO:
 	{
-		vector<Inset::Code> tmp;
-		tmp.push_back(Inset::LABEL_CODE);
-		tmp.push_back(Inset::REF_CODE);
+		vector<InsetOld::Code> tmp;
+		tmp.push_back(InsetOld::LABEL_CODE);
+		tmp.push_back(InsetOld::REF_CODE);
 		gotoInset(tmp, true);
 		break;
 	}
 
 	case LFUN_QUOTE: {
-		Paragraph const * par = cursor.par();
+		replaceSelection(bv->getLyXText());
+		ParagraphList::iterator pit = cursor.par();
 		lyx::pos_type pos = cursor.pos();
 		char c;
 		if (!pos)
 			c = ' ';
-		else if (par->isInset(pos - 1) && par->getInset(pos - 1)->isSpace())
+		else if (pit->isInset(pos - 1) && pit->getInset(pos - 1)->isSpace())
 			c = ' ';
 		else
-			c = par->getChar(pos - 1);
+			c = pit->getChar(pos - 1);
 
-		bv->hideCursor();
-		LyXLayout_ptr const & style = par->layout();
+		LyXLayout_ptr const & style = pit->layout();
 
 		if (style->pass_thru ||
-				par->getFontSettings(bv->buffer()->params,
+				pit->getFontSettings(bv->buffer()->params,
 					 pos).language()->lang() == "hebrew" ||
 			(!bv->insertInset(new InsetQuotes(c, bv->buffer()->params))))
 			bv->owner()->dispatch(FuncRequest(LFUN_SELFINSERT, "\""));
@@ -1210,6 +1213,7 @@ Inset::RESULT LyXText::dispatch(FuncRequest const & cmd)
 	}
 
 	case LFUN_DATE_INSERT: {
+		replaceSelection(bv->getLyXText());
 		time_t now_time_t = time(NULL);
 		struct tm * now_tm = localtime(&now_time_t);
 		setlocale(LC_TIME, "");
@@ -1238,7 +1242,6 @@ Inset::RESULT LyXText::dispatch(FuncRequest const & cmd)
 			break;
 		if (cmd.button() == mouse_button::button1) {
 			if (!isInInset()) {
-				bv->screen().hideCursor();
 				bv->screen().toggleSelection(this, bv);
 			}
 			cursorHome();
@@ -1259,12 +1262,11 @@ Inset::RESULT LyXText::dispatch(FuncRequest const & cmd)
 			break;
 		if (cmd.button() == mouse_button::button1) {
 			if (!isInInset()) {
-				bv->screen().hideCursor();
 				bv->screen().toggleSelection(this, bv);
-				selectWord(LyXText::WHOLE_WORD_STRICT);
+				selectWord(lyx::WHOLE_WORD_STRICT);
 				bv->screen().toggleSelection(this, bv, false);
 			} else {
-				selectWord(LyXText::WHOLE_WORD_STRICT);
+				selectWord(lyx::WHOLE_WORD_STRICT);
 			}
 			update();
 			bv->haveSelection(selection.set());
@@ -1282,11 +1284,10 @@ Inset::RESULT LyXText::dispatch(FuncRequest const & cmd)
 
 		// Check for inset locking
 		if (bv->theLockingInset()) {
-			Inset * tli = bv->theLockingInset();
+			InsetOld * tli = bv->theLockingInset();
 			LyXCursor cursor = bv->text->cursor;
-			LyXFont font = bv->text->getFont(bv->buffer(),
-								cursor.par(), cursor.pos());
-			int width = tli->width(bv, font);
+			LyXFont font = bv->text->getFont(cursor.par(), cursor.pos());
+			int width = tli->width();
 			int inset_x = font.isVisibleRightToLeft()
 				? cursor.ix() - width : cursor.ix();
 			int start_x = inset_x + tli->scroll();
@@ -1306,9 +1307,7 @@ Inset::RESULT LyXText::dispatch(FuncRequest const & cmd)
 			break;
 		}
 
-		bv->screen().hideCursor();
-
-		RowList::iterator cursorrow = bv->text->cursor.row();
+		RowList::iterator cursorrow = bv->text->cursorRow();
 		bv->text->setCursorFromCoordinates(cmd.x, cmd.y + bv->text->top_y());
 	#if 0
 		// sorry for this but I have a strange error that the y value jumps at
@@ -1320,7 +1319,7 @@ Inset::RESULT LyXText::dispatch(FuncRequest const & cmd)
 			       << bv->text->cursor.y() << endl;
 	#endif
 		// This is to allow jumping over large insets
-		if (cursorrow == bv->text->cursor.row()) {
+		if (cursorrow == bv->text->cursorRow()) {
 			if (cmd.y >= bv->workHeight())
 				bv->text->cursorDown(false);
 			else if (cmd.y < 0)
@@ -1331,9 +1330,8 @@ Inset::RESULT LyXText::dispatch(FuncRequest const & cmd)
 		if (!bv->text->selection.set())
 			bv->update(BufferView::UPDATE);
 		bv->text->setSelection();
-		bv->screen().toggleToggle(bv->text, bv);
+		bv->repaint();
 		bv->fitCursor();
-		bv->showCursor();
 		break;
 	}
 
@@ -1358,7 +1356,7 @@ Inset::RESULT LyXText::dispatch(FuncRequest const & cmd)
 
 		int x = cmd.x;
 		int y = cmd.y;
-		Inset * inset_hit = bv->text->checkInsetHit(x, y);
+		InsetOld * inset_hit = bv->text->checkInsetHit(x, y);
 
 		// Middle button press pastes if we have a selection
 		// We do this here as if the selection was inside an inset
@@ -1387,12 +1385,11 @@ Inset::RESULT LyXText::dispatch(FuncRequest const & cmd)
 
 		if (!inset_hit)
 			selection_possible = true;
-		bv->screen().hideCursor();
 
 		// Clear the selection
 		bv->screen().toggleSelection(bv->text, bv);
 		bv->text->clearSelection();
-		bv->text->fullRebreak();
+		bv->text->partialRebreak();
 		bv->update();
 		bv->updateScrollbar();
 
@@ -1402,9 +1399,7 @@ Inset::RESULT LyXText::dispatch(FuncRequest const & cmd)
 			UpdatableInset * inset = static_cast<UpdatableInset *>(inset_hit);
 			selection_possible = false;
 			bv->owner()->message(inset->editMessage());
-			//inset->edit(bv, x, y, cmd.button());
 			// We just have to lock the inset before calling a PressEvent on it!
-			// we don't need the edit() call here! (Jug20020329)
 			if (!bv->lockInset(inset))
 				lyxerr[Debug::INSETS] << "Cannot lock inset" << endl;
 			FuncRequest cmd1(bv, LFUN_MOUSE_PRESS, x, y, cmd.button());
@@ -1456,7 +1451,7 @@ Inset::RESULT LyXText::dispatch(FuncRequest const & cmd)
 		// inset, inset_hit is 0, and inset_x == x, inset_y == y.
 		int x = cmd.x;
 		int y = cmd.y;
-		Inset * inset_hit = bv->text->checkInsetHit(x, y);
+		InsetOld * inset_hit = bv->text->checkInsetHit(x, y);
 
 		if (bv->theLockingInset()) {
 			// We are in inset locking mode.
@@ -1516,8 +1511,8 @@ Inset::RESULT LyXText::dispatch(FuncRequest const & cmd)
 			// (Joacim)
 			// ...or maybe the SetCursorParUndo()
 			// below isn't necessary at all anylonger?
-			if (inset_hit->lyxCode() == Inset::REF_CODE)
-				setCursorParUndo(bv);
+			if (inset_hit->lyxCode() == InsetOld::REF_CODE)
+				recordUndo(bv, Undo::ATOMIC);
 
 			bv->owner()->message(inset_hit->editMessage());
 
@@ -1609,7 +1604,6 @@ Inset::RESULT LyXText::dispatch(FuncRequest const & cmd)
 		break;
 
 	case LFUN_INDEX_PRINT:
-	case LFUN_PARENTINSERT:
 	case LFUN_TOC_INSERT:
 	case LFUN_HFILL:
 		// do nothing fancy