X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FText3.cpp;h=fa9fa8d69f0c9d22f09682e965a693aa38280c4c;hb=8c6ac457ecc69f57ab54cd8c9b8b7893607c65d6;hp=c02773c77ea0861de52c7d455e34e7015dc705aa;hpb=3a5c55e30d4e2a41a9b82d1699c8db8c2b9fe5de;p=lyx.git

diff --git a/src/Text3.cpp b/src/Text3.cpp
index c02773c77e..fa9fa8d69f 100644
--- a/src/Text3.cpp
+++ b/src/Text3.cpp
@@ -17,6 +17,7 @@
 
 #include "Text.h"
 
+#include "Bidi.h"
 #include "BranchList.h"
 #include "FloatList.h"
 #include "FuncStatus.h"
@@ -24,39 +25,41 @@
 #include "buffer_funcs.h"
 #include "BufferParams.h"
 #include "BufferView.h"
-#include "bufferview_funcs.h"
 #include "Cursor.h"
-#include "CoordCache.h"
 #include "CutAndPaste.h"
-#include "debug.h"
+#include "support/debug.h"
 #include "DispatchResult.h"
 #include "ErrorList.h"
 #include "factory.h"
 #include "FuncRequest.h"
-#include "gettext.h"
+#include "support/gettext.h"
+#include "InsetList.h"
 #include "Intl.h"
 #include "Language.h"
+#include "Layout.h"
 #include "LyXAction.h"
 #include "LyXFunc.h"
 #include "Lexer.h"
 #include "LyXRC.h"
-#include "Row.h"
 #include "Paragraph.h"
 #include "paragraph_funcs.h"
 #include "ParagraphParameters.h"
-#include "Undo.h"
-#include "VSpace.h"
 #include "ParIterator.h"
+#include "TextClass.h"
+#include "TextMetrics.h"
+#include "VSpace.h"
 
 #include "frontends/Clipboard.h"
 #include "frontends/Selection.h"
 
+#include "insets/InsetCollapsable.h"
 #include "insets/InsetCommand.h"
 #include "insets/InsetFloatList.h"
 #include "insets/InsetNewline.h"
 #include "insets/InsetQuotes.h"
 #include "insets/InsetSpecialChar.h"
 #include "insets/InsetText.h"
+#include "insets/InsetInfo.h"
 
 #include "support/lstrings.h"
 #include "support/lyxlib.h"
@@ -66,11 +69,15 @@
 #include "mathed/InsetMathHull.h"
 #include "mathed/MathMacroTemplate.h"
 
-#include <boost/current_function.hpp>
+#include <boost/next_prior.hpp>
 
 #include <clocale>
 #include <sstream>
 
+using std::endl;
+using std::string;
+using std::istringstream;
+using std::ostringstream;
 
 namespace lyx {
 
@@ -79,275 +86,308 @@ using cap::cutSelection;
 using cap::pasteFromStack;
 using cap::pasteClipboard;
 using cap::replaceSelection;
-using cap::saveSelection;
 
 using support::isStrUnsignedInt;
 using support::token;
 
-using std::endl;
-using std::string;
-using std::istringstream;
-using std::ostringstream;
-
-
-extern string current_layout;
-
-
-namespace {
+// globals...
+static Font freefont(ignore_font, ignore_language);
+static bool toggleall = false;
 
-	// globals...
-	Font freefont(Font::ALL_IGNORE);
-	bool toggleall = false;
-
-	void toggleAndShow(Cursor & cur, Text * text,
-		Font const & font, bool toggleall = true)
-	{
-		text->toggleFree(cur, font, toggleall);
-
-		if (font.language() != ignore_language ||
-				font.number() != Font::IGNORE) {
-			Paragraph & par = cur.paragraph();
-			if (cur.boundary() != text->isRTLBoundary(cur.buffer(), par,
-			                        cur.pos(), text->real_current_font))
-				text->setCursor(cur, cur.pit(), cur.pos(),
-				                false, !cur.boundary());
-		}
-	}
-
-
-	void moveCursor(Cursor & cur, bool selecting)
-	{
-		if (selecting || cur.mark())
-			cur.setSelection();
-		saveSelection(cur);
-		cur.bv().switchKeyMap();
-	}
-
-
-	void finishChange(Cursor & cur, bool selecting)
-	{
-		finishUndo();
-		moveCursor(cur, selecting);
-	}
-
-
-	void mathDispatch(Cursor & cur, FuncRequest const & cmd, bool display)
-	{
-		recordUndo(cur);
-		docstring sel = cur.selectionAsString(false);
-
-		// It may happen that sel is empty but there is a selection
-		replaceSelection(cur);
-
-		if (sel.empty()) {
-#ifdef ENABLE_ASSERTIONS
-			const int old_pos = cur.pos();
-#endif
-			cur.insert(new InsetMathHull(hullSimple));
-			BOOST_ASSERT(old_pos == cur.pos());
-			cur.nextInset()->edit(cur, true);
-			// don't do that also for LFUN_MATH_MODE
-			// unless you want end up with always changing
-			// to mathrm when opening an inlined inset --
-			// I really hate "LyXfunc overloading"...
-			if (display)
-				cur.dispatch(FuncRequest(LFUN_MATH_DISPLAY));
-			// Avoid an unnecessary undo step if cmd.argument
-			// is empty
-			if (!cmd.argument().empty())
-				cur.dispatch(FuncRequest(LFUN_MATH_INSERT,
-							 cmd.argument()));
-		} else {
-			// create a macro if we see "\\newcommand"
-			// somewhere, and an ordinary formula
-			// otherwise
-			if (sel.find(from_ascii("\\newcommand")) == string::npos
-			    && sel.find(from_ascii("\\def")) == string::npos)
-			{
-				InsetMathHull * formula = new InsetMathHull;
-				istringstream is(to_utf8(sel));
-				Lexer lex(0, 0);
-				lex.setStream(is);
-				formula->read(cur.buffer(), lex);
-				if (formula->getType() == hullNone)
-					// Don't create pseudo formulas if
-					// delimiters are left out
-					formula->mutate(hullSimple);
-				cur.insert(formula);
-			} else {
-				cur.insert(new MathMacroTemplate(sel));
-			}
-		}
-		cur.message(from_utf8(N_("Math editor mode")));
+static void toggleAndShow(Cursor & cur, Text * text,
+	Font const & font, bool toggleall = true)
+{
+	text->toggleFree(cur, font, toggleall);
+
+	if (font.language() != ignore_language ||
+	    font.fontInfo().number() != FONT_IGNORE) {
+		TextMetrics const & tm = cur.bv().textMetrics(text);
+		if (cur.boundary() != tm.isRTLBoundary(cur.pit(), cur.pos(),
+						       cur.real_current_font))
+			text->setCursor(cur, cur.pit(), cur.pos(),
+					false, !cur.boundary());
 	}
+}
 
-} // namespace anon
-
-
-
-namespace bv_funcs {
 
-string const freefont2string()
+static void moveCursor(Cursor & cur, bool selecting)
 {
-	string data;
-	if (font2string(freefont, toggleall, data))
-		return data;
-	return string();
+	if (selecting || cur.mark())
+		cur.setSelection();
 }
 
-}
 
-void Text::cursorPrevious(Cursor & cur)
+static void finishChange(Cursor & cur, bool selecting)
 {
-	pos_type cpos = cur.pos();
-	pit_type cpar = cur.pit();
-
-	int x = cur.x_target();
-	setCursorFromCoordinates(cur, x, 0);
-	cur.dispatch(FuncRequest(cur.selection()? LFUN_UP_SELECT: LFUN_UP));
-
-	if (cpar == cur.pit() && cpos == cur.pos())
-		// we have a row which is taller than the workarea. The
-		// simplest solution is to move to the previous row instead.
-		cur.dispatch(FuncRequest(cur.selection()? LFUN_UP_SELECT: LFUN_UP));
-
-	finishUndo();
-	cur.updateFlags(Update::Force | Update::FitCursor);
+	cur.finishUndo();
+	moveCursor(cur, selecting);
 }
 
 
-void Text::cursorNext(Cursor & cur)
+static void mathDispatch(Cursor & cur, FuncRequest const & cmd, bool display)
 {
-	pos_type cpos = cur.pos();
-	pit_type cpar = cur.pit();
-
-	int x = cur.x_target();
-	setCursorFromCoordinates(cur, x, cur.bv().workHeight() - 1);
-	cur.dispatch(FuncRequest(cur.selection()? LFUN_DOWN_SELECT: LFUN_DOWN));
+	cur.recordUndo();
+	docstring sel = cur.selectionAsString(false);
 
-	if (cpar == cur.pit() && cpos == cur.pos())
-		// we have a row which is taller than the workarea. The
-		// simplest solution is to move to the next row instead.
-		cur.dispatch(
-			FuncRequest(cur.selection()? LFUN_DOWN_SELECT: LFUN_DOWN));
+	// It may happen that sel is empty but there is a selection
+	replaceSelection(cur);
 
-	finishUndo();
-	cur.updateFlags(Update::Force | Update::FitCursor);
+	if (sel.empty()) {
+#ifdef ENABLE_ASSERTIONS
+		const int old_pos = cur.pos();
+#endif
+		cur.insert(new InsetMathHull(hullSimple));
+		BOOST_ASSERT(old_pos == cur.pos());
+		cur.nextInset()->edit(cur, true);
+		// don't do that also for LFUN_MATH_MODE
+		// unless you want end up with always changing
+		// to mathrm when opening an inlined inset --
+		// I really hate "LyXfunc overloading"...
+		if (display)
+			cur.dispatch(FuncRequest(LFUN_MATH_DISPLAY));
+		// Avoid an unnecessary undo step if cmd.argument
+		// is empty
+		if (!cmd.argument().empty())
+			cur.dispatch(FuncRequest(LFUN_MATH_INSERT,
+						 cmd.argument()));
+	} else {
+		// create a macro if we see "\\newcommand"
+		// somewhere, and an ordinary formula
+		// otherwise
+		if (sel.find(from_ascii("\\newcommand")) == string::npos
+				&& sel.find(from_ascii("\\def")) == string::npos)
+		{
+			InsetMathHull * formula = new InsetMathHull;
+			istringstream is(to_utf8(sel));
+			Lexer lex(0, 0);
+			lex.setStream(is);
+			formula->read(cur.buffer(), lex);
+			if (formula->getType() == hullNone)
+				// Don't create pseudo formulas if
+				// delimiters are left out
+				formula->mutate(hullSimple);
+			cur.insert(formula);
+		} else {
+			cur.insert(new MathMacroTemplate(sel));
+		}
+	}
+	cur.message(from_utf8(N_("Math editor mode")));
 }
 
 
-namespace {
-
-void specialChar(Cursor & cur, InsetSpecialChar::Kind kind)
+static void specialChar(Cursor & cur, InsetSpecialChar::Kind kind)
 {
-	recordUndo(cur);
+	cur.recordUndo();
 	cap::replaceSelection(cur);
 	cur.insert(new InsetSpecialChar(kind));
-	cur.posRight();
+	cur.posForward();
 }
 
 
-bool doInsertInset(Cursor & cur, Text * text,
+static bool doInsertInset(Cursor & cur, Text * text,
 	FuncRequest const & cmd, bool edit, bool pastesel)
 {
-	Inset * inset = createInset(&cur.bv(), cmd);
+	Inset * inset = createInset(cur.bv().buffer(), cmd);
 	if (!inset)
 		return false;
 
-	recordUndo(cur);
-	bool gotsel = false;
-	if (cur.selection()) {
-		lyx::dispatch(FuncRequest(LFUN_CUT));
-		gotsel = true;
-	}
-	text->insertInset(cur, inset);
-
-	if (edit)
-		inset->edit(cur, true);
-
-	if (gotsel && pastesel) {
-		lyx::dispatch(FuncRequest(LFUN_PASTE, "0"));
-		// reset first par to default
-		if (cur.lastpit() != 0 || cur.lastpos() != 0) {
-			Layout_ptr const layout =
-				cur.buffer().params().getTextClass().defaultLayout();
-			cur.text()->paragraphs().begin()->layout(layout);
+	if (InsetCollapsable * ci = inset->asInsetCollapsable())
+		ci->setLayout(cur.bv().buffer().params());
+
+	cur.recordUndo();
+	if (cmd.action == LFUN_INDEX_INSERT) {
+		docstring ds = support::subst(text->getStringToIndex(cur), '\n', ' ');
+		text->insertInset(cur, inset);
+		if (edit)
+			inset->edit(cur, true);
+		// Now put this into inset
+		static_cast<InsetCollapsable *>(inset)->text_.insertStringAsParagraphs(cur, ds);
+	} else {
+		bool gotsel = false;
+		if (cur.selection()) {
+			lyx::dispatch(FuncRequest(LFUN_CUT));
+			gotsel = true;
+		}
+		text->insertInset(cur, inset);
+
+		if (edit)
+			inset->edit(cur, true);
+
+		if (gotsel && pastesel) {
+			lyx::dispatch(FuncRequest(LFUN_PASTE, "0"));
+			InsetText * insetText = dynamic_cast<InsetText *>(inset);
+			if (insetText && !insetText->allowMultiPar() 
+			    || cur.lastpit() == 0) {
+				// reset first par to default
+				LayoutPtr const layout =
+					cur.buffer().params().getTextClass().defaultLayout();
+				cur.text()->paragraphs().begin()->layout(layout);
+				cur.pos() = 0;
+				cur.pit() = 0;
+				// Merge multiple paragraphs -- hack
+				while (cur.lastpit() > 0) {
+					mergeParagraph(cur.buffer().params(),
+						cur.text()->paragraphs(), 0);
+				}
+			} else {
+				// reset surrounding par to default
+				docstring const layoutname = 
+					cur.buffer().params().getTextClass().defaultLayoutName();
+				cur.leaveInset(*inset);
+				text->setLayout(cur, layoutname);
+			}
 		}
 	}
 	return true;
 }
 
 
-} // anon namespace
-
-
-void Text::number(Cursor & cur)
+string const freefont2string()
 {
-	Font font(Font::ALL_IGNORE);
-	font.setNumber(Font::TOGGLE);
-	toggleAndShow(cur, this, font);
+	return freefont.toString(toggleall);
 }
 
 
-bool Text::isRTL(Buffer const & buffer, Paragraph const & par) const
-{
-	return par.isRightToLeftPar(buffer.params());
-}
+/// the type of outline operation
+enum OutlineOp {
+	OutlineUp, // Move this header with text down
+	OutlineDown,   // Move this header with text up
+	OutlineIn, // Make this header deeper
+	OutlineOut // Make this header shallower
+};
 
 
-bool Text::isRTL(Buffer const & buffer, CursorSlice const & sl, bool boundary) const
+static void outline(OutlineOp mode, Cursor & cur)
 {
-	if (!lyxrc.rtl_support && !sl.text())
-		return false;
-
-	int correction = 0;
-	if (boundary && sl.pos() > 0)
-		correction = -1;
-		
-	Paragraph const & par = getPar(sl.pit());
-	return getFont(buffer, par, sl.pos() + correction).isVisibleRightToLeft();
+	Buffer & buf = cur.buffer();
+	pit_type & pit = cur.pit();
+	ParagraphList & pars = buf.text().paragraphs();
+	ParagraphList::iterator bgn = pars.begin();
+	// The first paragraph of the area to be copied:
+	ParagraphList::iterator start = boost::next(bgn, pit);
+	// The final paragraph of area to be copied:
+	ParagraphList::iterator finish = start;
+	ParagraphList::iterator end = pars.end();
+
+	TextClass::const_iterator lit =
+		buf.params().getTextClass().begin();
+	TextClass::const_iterator const lend =
+		buf.params().getTextClass().end();
+
+	int const thistoclevel = start->layout()->toclevel;
+	int toclevel;
+	switch (mode) {
+		case OutlineUp: {
+			// Move out (down) from this section header
+			if (finish != end)
+				++finish;
+			// Seek the one (on same level) below
+			for (; finish != end; ++finish) {
+				toclevel = finish->layout()->toclevel;
+				if (toclevel != Layout::NOT_IN_TOC
+				    && toclevel <= thistoclevel) {
+					break;
+				}
+			}
+			ParagraphList::iterator dest = start;
+			// Move out (up) from this header
+			if (dest == bgn)
+				break;
+			// Search previous same-level header above
+			do {
+				--dest;
+				toclevel = dest->layout()->toclevel;
+			} while(dest != bgn
+				&& (toclevel == Layout::NOT_IN_TOC
+				    || toclevel > thistoclevel));
+			// Not found; do nothing
+			if (toclevel == Layout::NOT_IN_TOC || toclevel > thistoclevel)
+				break;
+			pit_type const newpit = std::distance(bgn, dest);
+			pit_type const len = std::distance(start, finish);
+			pit_type const deletepit = pit + len;
+			buf.undo().recordUndo(cur, ATOMIC_UNDO, newpit, deletepit - 1);
+			pars.insert(dest, start, finish);
+			start = boost::next(pars.begin(), deletepit);
+			pit = newpit;
+			pars.erase(start, finish);
+			break;
+		}
+		case OutlineDown: {
+			// Go down out of current header:
+			if (finish != end)
+				++finish;
+			// Find next same-level header:
+			for (; finish != end; ++finish) {
+				toclevel = finish->layout()->toclevel;
+				if (toclevel != Layout::NOT_IN_TOC && toclevel <= thistoclevel)
+					break;
+			}
+			ParagraphList::iterator dest = finish;
+			// Go one down from *this* header:
+			if (dest != end)
+				++dest;
+			else
+				break;
+			// Go further down to find header to insert in front of:
+			for (; dest != end; ++dest) {
+				toclevel = dest->layout()->toclevel;
+				if (toclevel != Layout::NOT_IN_TOC && toclevel <= thistoclevel)
+					break;
+			}
+			// One such was found:
+			pit_type newpit = std::distance(bgn, dest);
+			pit_type const len = std::distance(start, finish);
+			buf.undo().recordUndo(cur, ATOMIC_UNDO, pit, newpit - 1);
+			pars.insert(dest, start, finish);
+			start = boost::next(bgn, pit);
+			pit = newpit - len;
+			pars.erase(start, finish);
+			break;
+		}
+		case OutlineIn:
+			buf.undo().recordUndo(cur);
+			for (; lit != lend; ++lit) {
+				if ((*lit)->toclevel == thistoclevel + 1 &&
+				    start->layout()->labeltype == (*lit)->labeltype) {
+					start->layout((*lit));
+					break;
+				}
+			}
+			break;
+		case OutlineOut:
+			buf.undo().recordUndo(cur);
+			for (; lit != lend; ++lit) {
+				if ((*lit)->toclevel == thistoclevel - 1 &&
+				    start->layout()->labeltype == (*lit)->labeltype) {
+					start->layout((*lit));
+					break;
+				}
+			}
+			break;
+		default:
+			break;
+	}
 }
 
 
-bool Text::isRTLBoundary(Buffer const & buffer, Paragraph const & par,
-                         pos_type pos) const
+void Text::number(Cursor & cur)
 {
-	if (!lyxrc.rtl_support)
-		return false;
-
-	// no RTL boundary at line start
-	if (pos == 0)
-		return false;
-
-	bool left = getFont(buffer, par, pos - 1).isVisibleRightToLeft();
-	bool right;
-	if (pos == par.size())
-		right = par.isRightToLeftPar(buffer.params());
-	else
-		right = getFont(buffer, par, pos).isVisibleRightToLeft();
-	return left != right;
+	FontInfo font = ignore_font;
+	font.setNumber(FONT_TOGGLE);
+	toggleAndShow(cur, this, Font(font));
 }
 
 
-bool Text::isRTLBoundary(Buffer const & buffer, Paragraph const & par,
-                         pos_type pos, Font const & font) const
+bool Text::isRTL(Buffer const & buffer, Paragraph const & par) const
 {
-	if (!lyxrc.rtl_support)
-		return false;
-
-	bool left = font.isVisibleRightToLeft();
-	bool right;
-	if (pos == par.size())
-		right = par.isRightToLeftPar(buffer.params());
-	else
-		right = getFont(buffer, par, pos).isVisibleRightToLeft();
-	return left != right;
+	return par.isRTL(buffer.params());
 }
 
 
 void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 {
-	LYXERR(Debug::ACTION) << "Text::dispatch: cmd: " << cmd << endl;
+	LYXERR(Debug::ACTION, "Text::dispatch: cmd: " << cmd);
 
 	// FIXME: We use the update flag to indicates wether a singlePar or a
 	// full screen update is needed. We reset it here but shall we restore it
@@ -356,6 +396,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 
 	BOOST_ASSERT(cur.text() == this);
 	BufferView * bv = &cur.bv();
+	TextMetrics & tm = cur.bv().textMetrics(this);
 	CursorSlice oldTopSlice = cur.top();
 	bool oldBoundary = cur.boundary();
 	bool sel = cur.selection();
@@ -376,38 +417,21 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 	case LFUN_PARAGRAPH_MOVE_DOWN: {
 		pit_type const pit = cur.pit();
 		recUndo(cur, pit, pit + 1);
-		finishUndo();
+		cur.finishUndo();
 		std::swap(pars_[pit], pars_[pit + 1]);
-
-		ParIterator begin(cur);
-		// begin.pos() (== cur.pos()) may point beyond the end of the
-		// paragraph referenced by begin. This would cause a crash
-		// in updateLabels()
-		begin.pos() = 0;
-		++cur.pit();
-		ParIterator end = boost::next(ParIterator(cur));
-		updateLabels(cur.buffer(), begin, end);
-
+		updateLabels(cur.buffer());
 		needsUpdate = true;
+		++cur.pit();
 		break;
 	}
 
 	case LFUN_PARAGRAPH_MOVE_UP: {
 		pit_type const pit = cur.pit();
 		recUndo(cur, pit - 1, pit);
-		finishUndo();
+		cur.finishUndo();
 		std::swap(pars_[pit], pars_[pit - 1]);
-
-		ParIterator end = ParIterator(cur);
-		// end.pos() (== cur.pos()) may point beyond the end of the
-		// paragraph referenced by end. This would cause a crash
-		// in boost::next()
-		end.pos() = 0;
-		end = boost::next(end);
+		updateLabels(cur.buffer());
 		--cur.pit();
-		ParIterator begin(cur);
-		updateLabels(cur.buffer(), begin, end);
-
 		needsUpdate = true;
 		break;
 	}
@@ -416,11 +440,10 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 		Paragraph & par = cur.paragraph();
 		bool start = !par.params().startOfAppendix();
 
-#ifdef WITH_WARNINGS
-#warning The code below only makes sense at top level.
+// FIXME: The code below only makes sense at top level.
 // Should LFUN_APPENDIX be restricted to top-level paragraphs?
-#endif
 		// ensure that we have only one start_of_appendix in this document
+		// FIXME: this don't work for multipart document!
 		for (pit_type tmp = 0, end = pars_.size(); tmp != end; ++tmp) {
 			if (pars_[tmp].params().startOfAppendix()) {
 				recUndo(cur, tmp);
@@ -429,7 +452,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 			}
 		}
 
-		recordUndo(cur);
+		cur.recordUndo();
 		par.params().startOfAppendix(start);
 
 		// we can set the refreshing parameters now
@@ -438,20 +461,26 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 	}
 
 	case LFUN_WORD_DELETE_FORWARD:
-		cur.clearSelection();
-		deleteWordForward(cur);
+		if (cur.selection()) {
+			cutSelection(cur, true, false);
+		} else
+			deleteWordForward(cur);
 		finishChange(cur, false);
 		break;
 
 	case LFUN_WORD_DELETE_BACKWARD:
-		cur.clearSelection();
-		deleteWordBackward(cur);
+		if (cur.selection()) {
+			cutSelection(cur, true, false);
+		} else
+			deleteWordBackward(cur);
 		finishChange(cur, false);
 		break;
 
 	case LFUN_LINE_DELETE:
-		cur.clearSelection();
-		deleteLineForward(cur);
+		if (cur.selection()) {
+			cutSelection(cur, true, false);
+		} else
+			tm.deleteLineForward(cur);
 		finishChange(cur, false);
 		break;
 
@@ -477,61 +506,78 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 
 	case LFUN_CHAR_FORWARD:
 	case LFUN_CHAR_FORWARD_SELECT:
-		//lyxerr << BOOST_CURRENT_FUNCTION
-		//       << " LFUN_CHAR_FORWARD[SEL]:\n" << cur << endl;
+		//LYXERR0(" LFUN_CHAR_FORWARD[SEL]:\n" << cur);
 		needsUpdate |= cur.selHandle(cmd.action == LFUN_CHAR_FORWARD_SELECT);
-		if (reverseDirectionNeeded(cur))
-			needsUpdate |= cursorLeft(cur);
-		else
-			needsUpdate |= cursorRight(cur);
+		needsUpdate |= cursorForward(cur);
 
 		if (!needsUpdate && oldTopSlice == cur.top()
 				&& cur.boundary() == oldBoundary) {
 			cur.undispatched();
-			cmd = FuncRequest(LFUN_FINISHED_RIGHT);
-		} else if (cur.selection())
-			saveSelection(cur);
+			cmd = FuncRequest(LFUN_FINISHED_FORWARD);
+		}
 		break;
 
 	case LFUN_CHAR_BACKWARD:
 	case LFUN_CHAR_BACKWARD_SELECT:
 		//lyxerr << "handle LFUN_CHAR_BACKWARD[_SELECT]:\n" << cur << endl;
 		needsUpdate |= cur.selHandle(cmd.action == LFUN_CHAR_BACKWARD_SELECT);
-		if (reverseDirectionNeeded(cur))
-			needsUpdate |= cursorRight(cur);
-		else
-			needsUpdate |= cursorLeft(cur);
+		needsUpdate |= cursorBackward(cur);
 
 		if (!needsUpdate && oldTopSlice == cur.top()
 			&& cur.boundary() == oldBoundary) {
 			cur.undispatched();
-			cmd = FuncRequest(LFUN_FINISHED_LEFT);
+			cmd = FuncRequest(LFUN_FINISHED_BACKWARD);
 		}
-		if (cur.selection())
-			saveSelection(cur);
 		break;
 
-	case LFUN_UP:
-	case LFUN_UP_SELECT: {
-		//lyxerr << "handle LFUN_UP[SEL]:\n" << cur << endl;
-		needsUpdate |= cur.selHandle(cmd.action == LFUN_UP_SELECT);
-		bool const successful = cur.upDownInText(true, needsUpdate);
-		if (!successful)
-			cur.undispatched();
-		if (cur.selection())
-			saveSelection(cur);
-		break;
-	}
+	case LFUN_CHAR_LEFT:
+	case LFUN_CHAR_LEFT_SELECT:
+		//FIXME: for visual cursor, really move left
+		if (reverseDirectionNeeded(cur)) {
+			cmd.action = cmd.action == LFUN_CHAR_LEFT_SELECT ? 
+					LFUN_CHAR_FORWARD_SELECT : LFUN_CHAR_FORWARD;
+		} else {
+			cmd.action = cmd.action == LFUN_CHAR_LEFT_SELECT ? 
+					LFUN_CHAR_BACKWARD_SELECT : LFUN_CHAR_BACKWARD;
+		}
+		dispatch(cur, cmd);
+		return;
+
+	case LFUN_CHAR_RIGHT:
+	case LFUN_CHAR_RIGHT_SELECT:
+		//FIXME: for visual cursor, really move right
+		if (reverseDirectionNeeded(cur)) {
+			cmd.action = cmd.action == LFUN_CHAR_RIGHT_SELECT ? 
+					LFUN_CHAR_BACKWARD_SELECT : LFUN_CHAR_BACKWARD;
+		} else {
+			cmd.action = cmd.action == LFUN_CHAR_RIGHT_SELECT ? 
+					LFUN_CHAR_FORWARD_SELECT : LFUN_CHAR_FORWARD;
+		}
+		dispatch(cur, cmd);
+		return;
 
-	case LFUN_DOWN:
-	case LFUN_DOWN_SELECT: {
-		//lyxerr << "handle LFUN_DOWN[SEL]:\n" << cur << endl;
-		needsUpdate |= cur.selHandle(cmd.action == LFUN_DOWN_SELECT);
-		bool const successful = cur.upDownInText(false, needsUpdate);
-		if (!successful)
+	case LFUN_UP_SELECT:
+	case LFUN_DOWN_SELECT:
+	case LFUN_UP:
+	case LFUN_DOWN: {
+		// stop/start the selection
+		bool select = cmd.action == LFUN_DOWN_SELECT ||
+			cmd.action == LFUN_UP_SELECT;
+		cur.selHandle(select);
+		
+		// move cursor up/down
+		bool up = cmd.action == LFUN_UP_SELECT || cmd.action == LFUN_UP;
+		bool const successful = cur.upDownInText(up, needsUpdate);
+		if (successful) {
+			// notify insets which were left and get their update flags 
+			notifyCursorLeaves(cur.beforeDispatchCursor(), cur);
+			cur.fixIfBroken();
+			
+			// redraw if you leave mathed (for the decorations)
+			needsUpdate |= cur.beforeDispatchCursor().inMathed();
+		} else
 			cur.undispatched();
-		if (cur.selection())
-			saveSelection(cur);
+		
 		break;
 	}
 
@@ -539,77 +585,81 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 	case LFUN_PARAGRAPH_UP_SELECT:
 		needsUpdate |= cur.selHandle(cmd.action == LFUN_PARAGRAPH_UP_SELECT);
 		needsUpdate |= cursorUpParagraph(cur);
-		if (cur.selection())
-			saveSelection(cur);
 		break;
 
 	case LFUN_PARAGRAPH_DOWN:
 	case LFUN_PARAGRAPH_DOWN_SELECT:
 		needsUpdate |= cur.selHandle(cmd.action == LFUN_PARAGRAPH_DOWN_SELECT);
 		needsUpdate |= cursorDownParagraph(cur);
-		if (cur.selection())
-			saveSelection(cur);
 		break;
 
-	case LFUN_SCREEN_UP:
 	case LFUN_SCREEN_UP_SELECT:
-		needsUpdate |= cur.selHandle(cmd.action == LFUN_SCREEN_UP_SELECT);
+		needsUpdate |= cur.selHandle(true);
 		if (cur.pit() == 0 && cur.textRow().pos() == 0)
 			cur.undispatched();
 		else {
-			cursorPrevious(cur);
+			tm.cursorPrevious(cur);
 		}
-		if (cur.selection())
-			saveSelection(cur);
 		break;
 
-	case LFUN_SCREEN_DOWN:
 	case LFUN_SCREEN_DOWN_SELECT:
-		needsUpdate |= cur.selHandle(cmd.action == LFUN_SCREEN_DOWN_SELECT);
+		needsUpdate |= cur.selHandle(true);
 		if (cur.pit() == cur.lastpit()
 			  && cur.textRow().endpos() == cur.lastpos())
 			cur.undispatched();
 		else {
-			cursorNext(cur);
+			tm.cursorNext(cur);
 		}
-		if (cur.selection())
-			saveSelection(cur);
 		break;
 
 	case LFUN_LINE_BEGIN:
 	case LFUN_LINE_BEGIN_SELECT:
 		needsUpdate |= cur.selHandle(cmd.action == LFUN_LINE_BEGIN_SELECT);
-		needsUpdate |= cursorHome(cur);
+		needsUpdate |= tm.cursorHome(cur);
 		break;
 
 	case LFUN_LINE_END:
 	case LFUN_LINE_END_SELECT:
 		needsUpdate |= cur.selHandle(cmd.action == LFUN_LINE_END_SELECT);
-		needsUpdate |= cursorEnd(cur);
-		if (cur.selection())
-			saveSelection(cur);
+		needsUpdate |= tm.cursorEnd(cur);
 		break;
 
+	case LFUN_WORD_RIGHT:
+	case LFUN_WORD_RIGHT_SELECT:
+		//FIXME: for visual cursor mode, really move right
+		if (reverseDirectionNeeded(cur)) {
+			cmd.action = cmd.action == LFUN_WORD_RIGHT_SELECT ?
+					LFUN_WORD_BACKWARD_SELECT : LFUN_WORD_BACKWARD;
+		} else {
+			cmd.action = cmd.action == LFUN_WORD_RIGHT_SELECT ?
+					LFUN_WORD_FORWARD_SELECT : LFUN_WORD_FORWARD;
+		}
+		dispatch(cur, cmd);
+		return;
+
 	case LFUN_WORD_FORWARD:
 	case LFUN_WORD_FORWARD_SELECT:
 		needsUpdate |= cur.selHandle(cmd.action == LFUN_WORD_FORWARD_SELECT);
-		if (reverseDirectionNeeded(cur))
-			needsUpdate |= cursorLeftOneWord(cur);
-		else
-			needsUpdate |= cursorRightOneWord(cur);
-		if (cur.selection())
-			saveSelection(cur);
+		needsUpdate |= cursorForwardOneWord(cur);
 		break;
 
+	case LFUN_WORD_LEFT:
+	case LFUN_WORD_LEFT_SELECT:
+		//FIXME: for visual cursor mode, really move left
+		if (reverseDirectionNeeded(cur)) {
+			cmd.action = cmd.action == LFUN_WORD_LEFT_SELECT ?
+					LFUN_WORD_FORWARD_SELECT : LFUN_WORD_FORWARD;
+		} else {
+			cmd.action = cmd.action == LFUN_WORD_LEFT_SELECT ?
+					LFUN_WORD_BACKWARD_SELECT : LFUN_WORD_BACKWARD;
+		}
+		dispatch(cur, cmd);
+		return;
+
 	case LFUN_WORD_BACKWARD:
 	case LFUN_WORD_BACKWARD_SELECT:
 		needsUpdate |= cur.selHandle(cmd.action == LFUN_WORD_BACKWARD_SELECT);
-		if (reverseDirectionNeeded(cur))
-			needsUpdate |= cursorRightOneWord(cur);
-		else
-			needsUpdate |= cursorLeftOneWord(cur);
-		if (cur.selection())
-			saveSelection(cur);
+		needsUpdate |= cursorBackwardOneWord(cur);
 		break;
 
 	case LFUN_WORD_SELECT: {
@@ -618,16 +668,31 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 		break;
 	}
 
-	case LFUN_BREAK_LINE: {
+	case LFUN_NEW_LINE: {
 		// Not allowed by LaTeX (labels or empty par)
 		if (cur.pos() > cur.paragraph().beginOfBody()) {
 			// this avoids a double undo
 			// FIXME: should not be needed, ideally
 			if (!cur.selection())
-				recordUndo(cur);
+				cur.recordUndo();
 			cap::replaceSelection(cur);
 			cur.insert(new InsetNewline);
-			cur.posRight();
+			cur.posForward();
+			moveCursor(cur, false);
+		}
+		break;
+	}
+	
+	case LFUN_LINE_BREAK: {
+		// Not allowed by LaTeX (labels or empty par)
+		if (cur.pos() > cur.paragraph().beginOfBody()) {
+			// this avoids a double undo
+			// FIXME: should not be needed, ideally
+			if (!cur.selection())
+				cur.recordUndo();
+			cap::replaceSelection(cur);
+			cur.insert(new InsetLinebreak);
+			cur.posForward();
 			moveCursor(cur, false);
 		}
 		break;
@@ -653,8 +718,8 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 		// Reverse the effect of LFUN_BREAK_PARAGRAPH_SKIP.
 		if (!cur.selection()) {
 			if (cur.pos() == cur.lastpos()) {
-				cursorRight(cur);
-				cursorLeft(cur);
+				cursorForward(cur);
+				cursorBackward(cur);
 			}
 			erase(cur);
 			cur.resetAnchor();
@@ -679,15 +744,12 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 			cutSelection(cur, true, false);
 			singleParUpdate = false;
 		}
-		bv->switchKeyMap();
 		break;
 
 	case LFUN_DELETE_BACKWARD_SKIP:
 		// Reverse the effect of LFUN_BREAK_PARAGRAPH_SKIP.
 		if (!cur.selection()) {
-#ifdef WITH_WARNINGS
-#warning look here
-#endif
+			// FIXME: look here
 			//CursorSlice cur = cursor();
 			backspace(cur);
 			//anchor() = cur;
@@ -698,16 +760,8 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 
 	case LFUN_BREAK_PARAGRAPH:
 		cap::replaceSelection(cur);
-		breakParagraph(cur, 0);
-		cur.resetAnchor();
-		bv->switchKeyMap();
-		break;
-
-	case LFUN_BREAK_PARAGRAPH_KEEP_LAYOUT:
-		cap::replaceSelection(cur);
-		breakParagraph(cur, 1);
+		breakParagraph(cur, cmd.argument() == "inverse");
 		cur.resetAnchor();
-		bv->switchKeyMap();
 		break;
 
 	case LFUN_BREAK_PARAGRAPH_SKIP: {
@@ -717,12 +771,15 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 		if (cur.pos() == 0)
 			cur.paragraph().params().labelWidthString(docstring());
 		else
-			breakParagraph(cur, 0);
+			breakParagraph(cur, false);
 		cur.resetAnchor();
-		bv->switchKeyMap();
 		break;
 	}
 
+	// TODO
+	// With the creation of LFUN_PARAGRAPH_PARAMS, this is now redundant,
+	// as its duties can be performed there. Should it be removed??
+	// FIXME For now, it can just dispatch LFUN_PARAGRAPH_PARAMS...
 	case LFUN_PARAGRAPH_SPACING: {
 		Paragraph & par = cur.paragraph();
 		Spacing::Space cur_spacing = par.params().spacing().getSpace();
@@ -763,8 +820,8 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 	}
 
 	case LFUN_INSET_INSERT: {
-		recordUndo(cur);
-		Inset * inset = createInset(bv, cmd);
+		cur.recordUndo();
+		Inset * inset = createInset(bv->buffer(), cmd);
 		if (inset) {
 			// FIXME (Abdel 01/02/2006):
 			// What follows would be a partial fix for bug 2154:
@@ -777,7 +834,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 			// other feature like "automatic labelling".
 			/*
 			Paragraph & par = pars_[cur.pit()];
-			if (inset->lyxCode() == Inset::LABEL_CODE
+			if (inset->lyxCode() == LABEL_CODE
 				&& par.layout()->labeltype == LABEL_COUNTER) {
 				// Go to the end of the paragraph
 				// Warning: Because of Change-Tracking, the last
@@ -788,8 +845,10 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 				dispatch(cur, fr);
 			}
 			*/
+			if (cur.selection())
+				cutSelection(cur, true, false);
 			insertInset(cur, inset);
-			cur.posRight();
+			cur.posForward();
 		}
 		break;
 	}
@@ -807,41 +866,44 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 			insertChar(cur, ' ');
 		else {
 			doInsertInset(cur, this, cmd, false, false);
-			cur.posRight();
+			cur.posForward();
 		}
 		moveCursor(cur, false);
 		break;
 
-	case LFUN_HYPHENATION_POINT_INSERT:
-		specialChar(cur, InsetSpecialChar::HYPHENATION);
-		break;
-
-	case LFUN_LIGATURE_BREAK_INSERT:
-		specialChar(cur, InsetSpecialChar::LIGATURE_BREAK);
-		break;
-
-	case LFUN_DOTS_INSERT:
-		specialChar(cur, InsetSpecialChar::LDOTS);
-		break;
-
-	case LFUN_END_OF_SENTENCE_PERIOD_INSERT:
-		specialChar(cur, InsetSpecialChar::END_OF_SENTENCE);
-		break;
-
-	case LFUN_MENU_SEPARATOR_INSERT:
-		specialChar(cur, InsetSpecialChar::MENU_SEPARATOR);
+	case LFUN_SPECIALCHAR_INSERT: {
+		string const name = to_utf8(cmd.argument());
+		if (name == "hyphenation")
+			specialChar(cur, InsetSpecialChar::HYPHENATION);
+		else if (name == "ligature-break")
+			specialChar(cur, InsetSpecialChar::LIGATURE_BREAK);
+		else if (name == "slash")
+			specialChar(cur, InsetSpecialChar::SLASH);
+		else if (name == "nobreakdash")
+			specialChar(cur, InsetSpecialChar::NOBREAKDASH);
+		else if (name == "dots")
+			specialChar(cur, InsetSpecialChar::LDOTS);
+		else if (name == "end-of-sentence")
+			specialChar(cur, InsetSpecialChar::END_OF_SENTENCE);
+		else if (name == "menu-separator")
+			specialChar(cur, InsetSpecialChar::MENU_SEPARATOR);
+		else if (name.empty())
+			lyxerr << "LyX function 'specialchar-insert' needs an argument." << endl;
+		else
+			lyxerr << "Wrong argument for LyX function 'specialchar-insert'." << endl;
 		break;
+	}
 
 	case LFUN_WORD_UPCASE:
-		changeCase(cur, Text::text_uppercase);
+		changeCase(cur, text_uppercase);
 		break;
 
 	case LFUN_WORD_LOWCASE:
-		changeCase(cur, Text::text_lowercase);
+		changeCase(cur, text_lowercase);
 		break;
 
 	case LFUN_WORD_CAPITALIZE:
-		changeCase(cur, Text::text_capitalization);
+		changeCase(cur, text_capitalization);
 		break;
 
 	case LFUN_CHARS_TRANSPOSE:
@@ -852,18 +914,17 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 		cur.message(_("Paste"));
 		cap::replaceSelection(cur);
 		if (cmd.argument().empty() && !theClipboard().isInternal())
-			pasteClipboard(cur, bv->buffer()->errorList("Paste"));
+			pasteClipboard(cur, bv->buffer().errorList("Paste"));
 		else {
 			string const arg(to_utf8(cmd.argument()));
-			pasteFromStack(cur, bv->buffer()->errorList("Paste"),
+			pasteFromStack(cur, bv->buffer().errorList("Paste"),
 					isStrUnsignedInt(arg) ?
 						convert<unsigned int>(arg) :
 						0);
 		}
-		bv->buffer()->errors("Paste");
+		bv->buffer().errors("Paste");
 		cur.clearSelection(); // bug 393
-		bv->switchKeyMap();
-		finishUndo();
+		cur.finishUndo();
 		break;
 
 	case LFUN_CUT:
@@ -878,8 +939,8 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 
 	case LFUN_SERVER_GET_XY:
 		cur.message(from_utf8(
-			convert<string>(cursorX(cur.bv(), cur.top(), cur.boundary()))
-			+ ' ' + convert<string>(cursorY(cur.bv(), cur.top(), cur.boundary()))));
+			convert<string>(tm.cursorX(cur.top(), cur.boundary()))
+			+ ' ' + convert<string>(tm.cursorY(cur.top(), cur.boundary()))));
 		break;
 
 	case LFUN_SERVER_SET_XY: {
@@ -891,37 +952,39 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 			lyxerr << "SETXY: Could not parse coordinates in '"
 			       << to_utf8(cmd.argument()) << std::endl;
 		else
-			setCursorFromCoordinates(cur, x, y);
+			tm.setCursorFromCoordinates(cur, x, y);
 		break;
 	}
 
 	case LFUN_SERVER_GET_FONT:
-		if (current_font.shape() == Font::ITALIC_SHAPE)
+		if (cur.current_font.fontInfo().shape() == ITALIC_SHAPE)
 			cur.message(from_ascii("E"));
-		else if (current_font.shape() == Font::SMALLCAPS_SHAPE)
+		else if (cur.current_font.fontInfo().shape() == SMALLCAPS_SHAPE)
 			cur.message(from_ascii("N"));
 		else
 			cur.message(from_ascii("0"));
 		break;
 
 	case LFUN_SERVER_GET_LAYOUT:
-		cur.message(from_utf8(cur.paragraph().layout()->name()));
+		cur.message(cur.paragraph().layout()->name());
 		break;
 
 	case LFUN_LAYOUT: {
-		string layout = to_ascii(cmd.argument());
-		LYXERR(Debug::INFO) << "LFUN_LAYOUT: (arg) " << layout << endl;
+		docstring layout = cmd.argument();
+		LYXERR(Debug::INFO, "LFUN_LAYOUT: (arg) " << to_utf8(layout));
+
+		docstring const old_layout = cur.paragraph().layout()->name();
 
 		// Derive layout number from given argument (string)
 		// and current buffer's textclass (number)
-		TextClass const & tclass = bv->buffer()->params().getTextClass();
+		TextClass const & tclass = bv->buffer().params().getTextClass();
 		if (layout.empty())
 			layout = tclass.defaultLayoutName();
 		bool hasLayout = tclass.hasLayout(layout);
 
 		// If the entry is obsolete, use the new one instead.
 		if (hasLayout) {
-			string const & obs = tclass[layout]->obsoleted_by();
+			docstring const & obs = tclass[layout]->obsoleted_by();
 			if (!obs.empty())
 				layout = obs;
 		}
@@ -932,7 +995,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 			break;
 		}
 
-		bool change_layout = (current_layout != layout);
+		bool change_layout = (old_layout != layout);
 
 		if (!change_layout && cur.selection() &&
 			cur.selBegin().pit() != cur.selEnd().pit())
@@ -940,7 +1003,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 			pit_type spit = cur.selBegin().pit();
 			pit_type epit = cur.selEnd().pit() + 1;
 			while (spit != epit) {
-				if (pars_[spit].layout()->name() != current_layout) {
+				if (pars_[spit].layout()->name() != old_layout) {
 					change_layout = true;
 					break;
 				}
@@ -948,21 +1011,17 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 			}
 		}
 
-		if (change_layout) {
-			current_layout = layout;
+		if (change_layout)
 			setLayout(cur, layout);
-			// inform the GUI that the layout has changed.
-			bv->layoutChanged(layout);
-			bv->switchKeyMap();
-		}
+
 		break;
 	}
 
 	case LFUN_CLIPBOARD_PASTE:
 		cur.clearSelection();
-		pasteClipboard(cur, bv->buffer()->errorList("Paste"),
+		pasteClipboard(cur, bv->buffer().errorList("Paste"),
 			       cmd.argument() == "paragraph");
-		bv->buffer()->errors("Paste");
+		bv->buffer().errors("Paste");
 		break;
 
 	case LFUN_PRIMARY_SELECTION_PASTE:
@@ -976,7 +1035,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 		docstring hexstring = cmd.argument();
 		if (lyx::support::isHex(hexstring)) {
 			char_type c = lyx::support::hexToInt(hexstring);
-			if (c > 32 && c < 0x10ffff) {
+			if (c >= 32 && c < 0x10ffff) {
 				lyxerr << "Inserting c: " << c << endl;
 				docstring s = docstring(1, c);
 				lyx::dispatch(FuncRequest(LFUN_SELF_INSERT, s));
@@ -988,14 +1047,14 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 	case LFUN_QUOTE_INSERT: {
 		Paragraph & par = cur.paragraph();
 		pos_type pos = cur.pos();
-		BufferParams const & bufparams = bv->buffer()->params();
-		Layout_ptr const & style = par.layout();
+		BufferParams const & bufparams = bv->buffer().params();
+		LayoutPtr const & style = par.layout();
 		if (!style->pass_thru
 		    && par.getFontSettings(bufparams, pos).language()->lang() != "hebrew") {
 			// this avoids a double undo
 			// FIXME: should not be needed, ideally
 			if (!cur.selection())
-				recordUndo(cur);
+				cur.recordUndo();
 			cap::replaceSelection(cur);
 			pos = cur.pos();
 			char_type c;
@@ -1014,30 +1073,28 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 				cur.insert(new InsetQuotes(c,
 				    bufparams.quotes_language,
 				    InsetQuotes::DoubleQ));
-			cur.posRight();
+			cur.posForward();
 		}
 		else
 			lyx::dispatch(FuncRequest(LFUN_SELF_INSERT, "\""));
 		break;
 	}
 
-	case LFUN_DATE_INSERT:
-		if (cmd.argument().empty())
-			lyx::dispatch(FuncRequest(LFUN_SELF_INSERT,
-				formatted_time(current_time())));
-		else
-			lyx::dispatch(FuncRequest(LFUN_SELF_INSERT,
-				formatted_time(current_time(), to_utf8(cmd.argument()))));
+	case LFUN_DATE_INSERT: {
+		string const format = cmd.argument().empty()
+			? lyxrc.date_insert_format : to_utf8(cmd.argument());
+		string const time = formatted_time(current_time(), format);
+		lyx::dispatch(FuncRequest(LFUN_SELF_INSERT, time));
 		break;
+	}
 
 	case LFUN_MOUSE_TRIPLE:
 		if (cmd.button() == mouse_button::button1) {
-			cursorHome(cur);
+			tm.cursorHome(cur);
 			cur.resetAnchor();
-			cursorEnd(cur);
+			tm.cursorEnd(cur);
 			cur.setSelection();
 			bv->cursor() = cur;
-			saveSelection(cur);
 		}
 		break;
 
@@ -1051,42 +1108,36 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 	// Single-click on work area
 	case LFUN_MOUSE_PRESS: {
 		// Right click on a footnote flag opens float menu
+		// FIXME: Why should we clear the selection in this case?
 		if (cmd.button() == mouse_button::button3)
 			cur.clearSelection();
 
-		// Middle button press pastes if we have a selection
-		// We do this here as if the selection was inside an inset
-		// it could get cleared on the unlocking of the inset so
-		// we have to check this first
-		bool paste_internally = false;
-		if (cmd.button() == mouse_button::button2 && cap::selection()) {
-			// Copy the selection buffer to the clipboard
-			// stack, because we want it to appear in the
-			// "Edit->Paste recent" menu.
-			cap::copySelectionToStack();
-			paste_internally = true;
-		}
+		bool do_selection = cmd.button() == mouse_button::button1
+			&& cmd.argument() == "region-select";
+		// Set the cursor
+		bool update = bv->mouseSetCursor(cur, do_selection);
 
 		// Insert primary selection with middle mouse
 		// if there is a local selection in the current buffer,
 		// insert this
 		if (cmd.button() == mouse_button::button2) {
-			if (paste_internally) {
-				cap::pasteSelection(cur, bv->buffer()->errorList("Paste"));
-				bv->buffer()->errors("Paste");
-				cur.clearSelection(); // bug 393
-				bv->switchKeyMap();
-				bv->buffer()->markDirty();
-				finishUndo();
+			if (cap::selection()) {
+				// Copy the selection buffer to the clipboard
+				// stack, because we want it to appear in the
+				// "Edit->Paste recent" menu.
+				cap::copySelectionToStack();
+
+				cap::pasteSelection(bv->cursor(), 
+						    bv->buffer().errorList("Paste"));
+				bv->buffer().errors("Paste");
+				bv->buffer().markDirty();
+				bv->cursor().finishUndo();
 			} else {
-				bv->mouseSetCursor(cur);
 				lyx::dispatch(FuncRequest(LFUN_PRIMARY_SELECTION_PASTE, "paragraph"));
 			}
 		}
 
-		// we have to update after dePM triggered
-		bool update = bv->mouseSetCursor(cur);
-
+		// we have to update after dEPM triggered
 		if (!update && cmd.button() == mouse_button::button1) {
 			needsUpdate = false;
 			cur.noUpdate();
@@ -1102,37 +1153,40 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 
 		// ignore motions deeper nested than the real anchor
 		Cursor & bvcur = cur.bv().cursor();
-		if (bvcur.anchor_.hasPart(cur)) {
-			CursorSlice old = bvcur.top();
-
-			int const wh = bv->workHeight();
-			int const y = std::max(0, std::min(wh - 1, cmd.y));
-
-			setCursorFromCoordinates(cur, cmd.x, y);
-			cur.setTargetX(cmd.x);
+		if (!bvcur.anchor_.hasPart(cur)) {
+			cur.undispatched();
+			break;
+		}
+		CursorSlice old = bvcur.top();
+
+		int const wh = bv->workHeight();
+		int const y = std::max(0, std::min(wh - 1, cmd.y));
+
+		tm.setCursorFromCoordinates(cur, cmd.x, y);
+		cur.setTargetX(cmd.x);
+		if (cmd.y >= wh)
+			lyx::dispatch(FuncRequest(LFUN_DOWN_SELECT));
+		else if (cmd.y < 0)
+			lyx::dispatch(FuncRequest(LFUN_UP_SELECT));
+		// This is to allow jumping over large insets
+		if (cur.top() == old) {
 			if (cmd.y >= wh)
 				lyx::dispatch(FuncRequest(LFUN_DOWN_SELECT));
 			else if (cmd.y < 0)
 				lyx::dispatch(FuncRequest(LFUN_UP_SELECT));
-			// This is to allow jumping over large insets
-			if (cur.top() == old) {
-				if (cmd.y >= wh)
-					lyx::dispatch(FuncRequest(LFUN_DOWN_SELECT));
-				else if (cmd.y < 0)
-					lyx::dispatch(FuncRequest(LFUN_UP_SELECT));
-			}
-
-			if (cur.top() == old)
-				cur.noUpdate();
-			else {
-				// don't set anchor_
-				bvcur.setCursor(cur);
-				bvcur.selection() = true;
-				//lyxerr << "MOTION: " << bv->cursor() << endl;
-			}
+		}
 
-		} else
-			cur.undispatched();
+		if (cur.top() == old)
+			cur.noUpdate();
+		else {
+			// FIXME: This is brute force! But without it the selected
+			// area is not corrected updated while moving the mouse.
+			cur.updateFlags(Update::Force | Update::FitCursor);
+			// don't set anchor_
+			bvcur.setCursor(cur);
+			bvcur.selection() = true;
+			//lyxerr << "MOTION: " << bv->cursor() << endl;
+		}
 		break;
 	}
 
@@ -1150,13 +1204,11 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 				// but bvcur is current mouse position
 				Cursor & bvcur = cur.bv().cursor();
 				bvcur.selection() = true;
-				saveSelection(bvcur);
 			}
 			needsUpdate = false;
 			cur.noUpdate();
 		}
 
-		bv->switchKeyMap();
 		break;
 	}
 
@@ -1170,40 +1222,43 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 		// "auto_region_delete", which defaults to
 		// true (on).
 
-		if (lyxrc.auto_region_delete)
-			if (cur.selection())
-				cutSelection(cur, false, false);
+		if (lyxrc.auto_region_delete && cur.selection())
+			cutSelection(cur, false, false);
 
 		cur.clearSelection();
-		Font const old_font = real_current_font;
+		Font const old_font = cur.real_current_font;
 
 		docstring::const_iterator cit = cmd.argument().begin();
 		docstring::const_iterator end = cmd.argument().end();
 		for (; cit != end; ++cit)
-			bv->getIntl().getTransManager().
-				translateAndInsert(*cit, this, cur);
+			bv->translateAndInsert(*cit, this, cur);
 
 		cur.resetAnchor();
 		moveCursor(cur, false);
 		break;
 	}
 
-	case LFUN_URL_INSERT: {
-		InsetCommandParams p("url");
-		string const data = InsetCommandMailer::params2string("url", p);
-		bv->showInsetDialog("url", data, 0);
-		break;
-	}
-
-	case LFUN_HTML_INSERT: {
-		InsetCommandParams p("htmlurl");
-		string const data = InsetCommandMailer::params2string("url", p);
-		bv->showInsetDialog("url", data, 0);
+	case LFUN_HYPERLINK_INSERT: {
+		InsetCommandParams p(HYPERLINK_CODE);
+		docstring content;
+		if (cur.selection()) {
+			content = cur.selectionAsString(false);
+			cutSelection(cur, true, false);
+		}
+		p["target"] = (cmd.argument().empty()) ?
+			content : cmd.argument();
+		string const data = InsetCommandMailer::params2string("href", p);
+		if (p["target"].empty()) {
+			bv->showDialog("href", data);
+		} else {
+			FuncRequest fr(LFUN_INSET_INSERT, data);
+			dispatch(cur, fr);
+		}
 		break;
 	}
 
 	case LFUN_LABEL_INSERT: {
-		InsetCommandParams p("label");
+		InsetCommandParams p(LABEL_CODE);
 		// Try to generate a valid label
 		p["name"] = (cmd.argument().empty()) ?
 			cur.getPossibleLabel() :
@@ -1211,7 +1266,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 		string const data = InsetCommandMailer::params2string("label", p);
 
 		if (cmd.argument().empty()) {
-			bv->showInsetDialog("label", data, 0);
+			bv->showDialog("label", data);
 		} else {
 			FuncRequest fr(LFUN_INSET_INSERT, data);
 			dispatch(cur, fr);
@@ -1219,39 +1274,55 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 		break;
 	}
 
-
+	case LFUN_INFO_INSERT: {
+		Inset * inset = createInset(cur.bv().buffer(), cmd);
+		if (!inset)
+			break;
+		// if an empty inset is created (cmd.argument() is empty)
+		// use current selection as parameter.
+		if (cmd.argument().empty() && cur.selection()) {
+			// use selected text as info to avoid a separate UI
+			docstring ds = cur.selectionAsString(false);
+			cutSelection(cur, true, false);
+			static_cast<InsetInfo *>(inset)->setInfo(to_utf8(ds));
+		}
+		insertInset(cur, inset);
+		cur.posForward();
+		break;
+	}
 #if 0
 	case LFUN_LIST_INSERT:
 	case LFUN_THEOREM_INSERT:
 #endif
 	case LFUN_CAPTION_INSERT:
+	case LFUN_FOOTNOTE_INSERT:
 		// Open the inset, and move the current selection
 		// inside it.
 		doInsertInset(cur, this, cmd, true, true);
-		cur.posRight();
-		updateLabels(*bv->buffer());
+		cur.posForward();
+		// These insets are numbered.
+		updateLabels(bv->buffer());
 		break;
 	case LFUN_NOTE_INSERT:
-	case LFUN_CHARSTYLE_INSERT:
+	case LFUN_FLEX_INSERT:
 	case LFUN_BOX_INSERT:
 	case LFUN_BRANCH_INSERT:
 	case LFUN_BIBITEM_INSERT:
 	case LFUN_ERT_INSERT:
 	case LFUN_LISTING_INSERT:
-	case LFUN_FOOTNOTE_INSERT:
 	case LFUN_MARGINALNOTE_INSERT:
 	case LFUN_OPTIONAL_INSERT:
 	case LFUN_ENVIRONMENT_INSERT:
 		// Open the inset, and move the current selection
 		// inside it.
 		doInsertInset(cur, this, cmd, true, true);
-		cur.posRight();
+		cur.posForward();
 		break;
 
 	case LFUN_TABULAR_INSERT:
 		// if there were no arguments, just open the dialog
 		if (doInsertInset(cur, this, cmd, false, true))
-			cur.posRight();
+			cur.posForward();
 		else
 			bv->showDialog("tabularcreate");
 
@@ -1263,10 +1334,10 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 		bool content = cur.selection();  // will some text be moved into the inset?
 
 		doInsertInset(cur, this, cmd, true, true);
-		cur.posRight();
+		cur.posForward();
 		ParagraphList & pars = cur.text()->paragraphs();
 
-		TextClass const & tclass = bv->buffer()->params().getTextClass();
+		TextClass const & tclass = bv->buffer().params().getTextClass();
 
 		// add a separate paragraph for the caption inset
 		pars.push_back(Paragraph());
@@ -1288,7 +1359,12 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 		// reposition the cursor to the caption
 		cur.pit() = cap_pit;
 		cur.pos() = 0;
-		cur.dispatch(FuncRequest(LFUN_CAPTION_INSERT));
+		// FIXME: This Text/Cursor dispatch handling is a mess!
+		// We cannot use Cursor::dispatch here it needs access to up to
+		// date metrics.
+		FuncRequest cmd_caption(LFUN_CAPTION_INSERT);
+		cur.text()->dispatch(cur, cmd_caption);
+		cur.updateFlags(Update::Force);
 		// FIXME: When leaving the Float (or Wrap) inset we should
 		// delete any empty paragraph left above or below the
 		// caption.
@@ -1296,20 +1372,26 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 	}
 
 	case LFUN_INDEX_INSERT:
+		doInsertInset(cur, this, cmd, true, true);
+		cur.posForward();
+		break;
+
 	case LFUN_NOMENCL_INSERT: {
-		Inset * inset = createInset(&cur.bv(), cmd);
+		FuncRequest cmd1 = cmd;
+		if (cmd.argument().empty())
+			cmd1 = FuncRequest(cmd,
+				bv->cursor().innerText()->getStringToIndex(bv->cursor()));
+		Inset * inset = createInset(cur.bv().buffer(), cmd1);
 		if (!inset)
 			break;
-		recordUndo(cur);
+		cur.recordUndo();
 		cur.clearSelection();
 		insertInset(cur, inset);
-		inset->edit(cur, true);
 		// Show the dialog for the nomenclature entry, since the
 		// description entry still needs to be filled in.
 		if (cmd.action == LFUN_NOMENCL_INSERT)
-			InsetCommandMailer("nomenclature",
-				*reinterpret_cast<InsetCommand *>(inset)).showDialog(&cur.bv());
-		cur.posRight();
+			inset->edit(cur, true);
+		cur.posForward();
 		break;
 	}
 
@@ -1318,12 +1400,13 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 	case LFUN_TOC_INSERT:
 	case LFUN_HFILL_INSERT:
 	case LFUN_LINE_INSERT:
+	case LFUN_NEWPAGE_INSERT:
 	case LFUN_PAGEBREAK_INSERT:
 	case LFUN_CLEARPAGE_INSERT:
 	case LFUN_CLEARDOUBLEPAGE_INSERT:
 		// do nothing fancy
 		doInsertInset(cur, this, cmd, false, false);
-		cur.posRight();
+		cur.posForward();
 		break;
 
 	case LFUN_DEPTH_DECREMENT:
@@ -1356,7 +1439,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 			int const nargs = s1.empty() ? 0 : convert<int>(s1);
 			string const s2 = token(s, ' ', 2);
 			string const type = s2.empty() ? "newcommand" : s2;
-			cur.insert(new MathMacroTemplate(from_utf8(token(s, ' ', 0)), nargs, from_utf8(type)));
+			cur.insert(new MathMacroTemplate(from_utf8(token(s, ' ', 0)), nargs, false, from_utf8(type)));
 			//cur.nextInset()->edit(cur, true);
 		}
 		break;
@@ -1373,71 +1456,77 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 	case LFUN_MATH_MATRIX:
 	case LFUN_MATH_DELIM:
 	case LFUN_MATH_BIGDELIM: {
+		if (cur.selection())
+			cur.clearSelection();
+		// FIXME: instead of the above, this one
+		// should be used (but it asserts with Bidi enabled)
+		// cf. http://bugzilla.lyx.org/show_bug.cgi?id=4055
+		// cap::replaceSelection(cur);
 		cur.insert(new InsetMathHull(hullSimple));
-		cur.dispatch(FuncRequest(LFUN_CHAR_FORWARD));
+		checkAndActivateInset(cur, true);
 		BOOST_ASSERT(cur.inMathed());
 		cur.dispatch(cmd);
 		break;
 	}
 
 	case LFUN_FONT_EMPH: {
-		Font font(Font::ALL_IGNORE);
-		font.setEmph(Font::TOGGLE);
+		Font font(ignore_font, ignore_language);
+		font.fontInfo().setEmph(FONT_TOGGLE);
 		toggleAndShow(cur, this, font);
 		break;
 	}
 
 	case LFUN_FONT_BOLD: {
-		Font font(Font::ALL_IGNORE);
-		font.setSeries(Font::BOLD_SERIES);
+		Font font(ignore_font, ignore_language);
+		font.fontInfo().setSeries(BOLD_SERIES);
 		toggleAndShow(cur, this, font);
 		break;
 	}
 
 	case LFUN_FONT_NOUN: {
-		Font font(Font::ALL_IGNORE);
-		font.setNoun(Font::TOGGLE);
+		Font font(ignore_font, ignore_language);
+		font.fontInfo().setNoun(FONT_TOGGLE);
 		toggleAndShow(cur, this, font);
 		break;
 	}
 
-	case LFUN_FONT_CODE: {
-		Font font(Font::ALL_IGNORE);
-		font.setFamily(Font::TYPEWRITER_FAMILY); // no good
+	case LFUN_FONT_TYPEWRITER: {
+		Font font(ignore_font, ignore_language);
+		font.fontInfo().setFamily(TYPEWRITER_FAMILY); // no good
 		toggleAndShow(cur, this, font);
 		break;
 	}
 
 	case LFUN_FONT_SANS: {
-		Font font(Font::ALL_IGNORE);
-		font.setFamily(Font::SANS_FAMILY);
+		Font font(ignore_font, ignore_language);
+		font.fontInfo().setFamily(SANS_FAMILY);
 		toggleAndShow(cur, this, font);
 		break;
 	}
 
 	case LFUN_FONT_ROMAN: {
-		Font font(Font::ALL_IGNORE);
-		font.setFamily(Font::ROMAN_FAMILY);
+		Font font(ignore_font, ignore_language);
+		font.fontInfo().setFamily(ROMAN_FAMILY);
 		toggleAndShow(cur, this, font);
 		break;
 	}
 
 	case LFUN_FONT_DEFAULT: {
-		Font font(Font::ALL_INHERIT, ignore_language);
+		Font font(inherit_font, ignore_language);
 		toggleAndShow(cur, this, font);
 		break;
 	}
 
 	case LFUN_FONT_UNDERLINE: {
-		Font font(Font::ALL_IGNORE);
-		font.setUnderbar(Font::TOGGLE);
+		Font font(ignore_font, ignore_language);
+		font.fontInfo().setUnderbar(FONT_TOGGLE);
 		toggleAndShow(cur, this, font);
 		break;
 	}
 
 	case LFUN_FONT_SIZE: {
-		Font font(Font::ALL_IGNORE);
-		font.setLyXSize(to_utf8(cmd.argument()));
+		Font font(ignore_font, ignore_language);
+		setLyXSize(to_utf8(cmd.argument()), font.fontInfo());
 		toggleAndShow(cur, this, font);
 		break;
 	}
@@ -1446,10 +1535,8 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 		Language const * lang = languages.getLanguage(to_utf8(cmd.argument()));
 		if (!lang)
 			break;
-		Font font(Font::ALL_IGNORE);
-		font.setLanguage(lang);
+		Font font(ignore_font, lang);
 		toggleAndShow(cur, this, font);
-		bv->switchKeyMap();
 		break;
 	}
 
@@ -1463,32 +1550,48 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 	case LFUN_FONT_FREE_UPDATE: {
 		Font font;
 		bool toggle;
-		if (bv_funcs::string2font(to_utf8(cmd.argument()), font, toggle)) {
+		if (font.fromString(to_utf8(cmd.argument()), toggle)) {
 			freefont = font;
 			toggleall = toggle;
 			toggleAndShow(cur, this, freefont, toggleall);
 			cur.message(_("Character set"));
+		} else {
+			lyxerr << "Argument not ok";
 		}
 		break;
 	}
 
 	case LFUN_FINISHED_LEFT:
-		LYXERR(Debug::DEBUG) << "handle LFUN_FINISHED_LEFT:\n" << cur << endl;
-		if (reverseDirectionNeeded(cur))
+		LYXERR(Debug::DEBUG, "handle LFUN_FINISHED_LEFT:\n" << cur);
+		if (reverseDirectionNeeded(cur)) {
 			++cur.pos();
+			cur.setCurrentFont();
+		}
 		break;
 
 	case LFUN_FINISHED_RIGHT:
-		LYXERR(Debug::DEBUG) << "handle LFUN_FINISHED_RIGHT:\n" << cur << endl;
-		if (!reverseDirectionNeeded(cur))
+		LYXERR(Debug::DEBUG, "handle LFUN_FINISHED_RIGHT:\n" << cur);
+		if (!reverseDirectionNeeded(cur)) {
 			++cur.pos();
+			cur.setCurrentFont();
+		}
+		break;
+
+	case LFUN_FINISHED_BACKWARD:
+		LYXERR(Debug::DEBUG, "handle LFUN_FINISHED_BACKWARD:\n" << cur);
+		break;
+
+	case LFUN_FINISHED_FORWARD:
+		LYXERR(Debug::DEBUG, "handle LFUN_FINISHED_FORWARD:\n" << cur);
+		++cur.pos();
+		cur.setCurrentFont();
 		break;
 
 	case LFUN_LAYOUT_PARAGRAPH: {
 		string data;
 		params2string(cur.paragraph(), data);
 		data = "show\n" + data;
-		bv->showDialogWithData("paragraph", data);
+		bv->showDialog("paragraph", data);
 		break;
 	}
 
@@ -1524,27 +1627,27 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 		theLyXFunc().handleKeyFunc(cmd.action);
 		if (!cmd.argument().empty())
 			// FIXME: Are all these characters encoded in one byte in utf8?
-			bv->getIntl().getTransManager()
-				.translateAndInsert(cmd.argument()[0], this, cur);
+			bv->translateAndInsert(cmd.argument()[0], this, cur);
 		break;
 
 	case LFUN_FLOAT_LIST: {
-		TextClass const & tclass = bv->buffer()->params().getTextClass();
+		TextClass const & tclass = bv->buffer().params().getTextClass();
 		if (tclass.floats().typeExist(to_utf8(cmd.argument()))) {
-			// not quite sure if we want this...
-			recordUndo(cur);
-			cur.clearSelection();
+			cur.recordUndo();
+			if (cur.selection())
+				cutSelection(cur, true, false);
 			breakParagraph(cur);
 
 			if (cur.lastpos() != 0) {
-				cursorLeft(cur);
+				cursorBackward(cur);
 				breakParagraph(cur);
 			}
 
 			setLayout(cur, tclass.defaultLayoutName());
-			setParagraph(cur, Spacing(), LYX_ALIGN_LAYOUT, docstring(), 0);
+			ParagraphParameters p;
+			setParagraphs(cur, p);
 			insertInset(cur, new InsetFloatList(to_utf8(cmd.argument())));
-			cur.posRight();
+			cur.posForward();
 		} else {
 			lyxerr << "Non-existent float type: "
 			       << to_utf8(cmd.argument()) << endl;
@@ -1573,24 +1676,28 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 				arg = cur.selectionAsString(false);
 			}
 		}
-		bv->showDialogWithData("thesaurus", to_utf8(arg));
+		bv->showDialog("thesaurus", to_utf8(arg));
 		break;
 	}
 
 	case LFUN_PARAGRAPH_PARAMS_APPLY: {
 		// Given data, an encoding of the ParagraphParameters
 		// generated in the Paragraph dialog, this function sets
-		// the current paragraph appropriately.
-		istringstream is(to_utf8(cmd.argument()));
-		Lexer lex(0, 0);
-		lex.setStream(is);
-		ParagraphParameters params;
-		params.read(lex);
-		setParagraph(cur,
-			     params.spacing(),
-			     params.align(),
-			     params.labelWidthString(),
-			     params.noindent());
+		// the current paragraph, or currently selected paragraphs,
+		// appropriately. 
+		// NOTE: This function overrides all existing settings.
+		setParagraphs(cur, cmd.argument());
+		cur.message(_("Paragraph layout set"));
+		break;
+	}
+	
+	case LFUN_PARAGRAPH_PARAMS: {
+		// Given data, an encoding of the ParagraphParameters as we'd
+		// find them in a LyX file, this function modifies the current paragraph, 
+		// or currently selected paragraphs. 
+		// NOTE: This function only modifies, and does not override, existing
+		// settings.
+		setParagraphs(cur, cmd.argument(), true);
 		cur.message(_("Paragraph layout set"));
 		break;
 	}
@@ -1598,18 +1705,42 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 	case LFUN_ESCAPE:
 		if (cur.selection()) {
 			cur.selection() = false;
-			saveSelection(cur);
 		} else {
 			cur.undispatched();
-			cmd = FuncRequest(LFUN_FINISHED_RIGHT);
+			// This used to be LFUN_FINISHED_RIGHT, I think FORWARD is more
+			// correct, but I'm not 100% sure -- dov, 071019
+			cmd = FuncRequest(LFUN_FINISHED_FORWARD);
 		}
 		break;
 
+	case LFUN_OUTLINE_UP:
+		outline(OutlineUp, cur);
+		setCursor(cur, cur.pit(), 0);
+		updateLabels(cur.buffer());
+		needsUpdate = true;
+		break;
+
+	case LFUN_OUTLINE_DOWN:
+		outline(OutlineDown, cur);
+		setCursor(cur, cur.pit(), 0);
+		updateLabels(cur.buffer());
+		needsUpdate = true;
+		break;
+
+	case LFUN_OUTLINE_IN:
+		outline(OutlineIn, cur);
+		updateLabels(cur.buffer());
+		needsUpdate = true;
+		break;
+
+	case LFUN_OUTLINE_OUT:
+		outline(OutlineOut, cur);
+		updateLabels(cur.buffer());
+		needsUpdate = true;
+		break;
+
 	default:
-		LYXERR(Debug::ACTION)
-			<< BOOST_CURRENT_FUNCTION
-			<< ": Command " << cmd
-			<< " not DISPATCHED by Text" << endl;
+		LYXERR(Debug::ACTION, "Command " << cmd << " not DISPATCHED by Text");
 		cur.undispatched();
 		break;
 	}
@@ -1632,15 +1763,13 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 		// Inserting characters does not change par height
 		ParagraphMetrics const & pms
 			= cur.bv().parMetrics(cur.bottom().text(), cur.bottom().pit());
-		if (pms.dim().height()
-		    == olddim.height()) {
+		if (pms.dim().height() == olddim.height()) {
 			// if so, update _only_ this paragraph
 			cur.updateFlags(Update::SinglePar |
-				Update::FitCursor |
-				Update::MultiParSel);
+				Update::FitCursor);
 			return;
-		} else
-			needsUpdate = true;
+		}
+		needsUpdate = true;
 	}
 
 	if (!needsUpdate
@@ -1668,9 +1797,10 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd,
 {
 	BOOST_ASSERT(cur.text() == this);
 
-	Font const & font = real_current_font;
+	Font const & font = cur.real_current_font;
+	FontInfo const & fontinfo = font.fontInfo();
 	bool enable = true;
-	Inset::Code code = Inset::NO_CODE;
+	InsetCode code = NO_CODE;
 
 	switch (cmd.action) {
 
@@ -1693,145 +1823,149 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd,
 
 	case LFUN_DIALOG_SHOW_NEW_INSET:
 		if (cmd.argument() == "bibitem")
-			code = Inset::BIBITEM_CODE;
+			code = BIBITEM_CODE;
 		else if (cmd.argument() == "bibtex")
-			code = Inset::BIBTEX_CODE;
+			code = BIBTEX_CODE;
 		else if (cmd.argument() == "box")
-			code = Inset::BOX_CODE;
+			code = BOX_CODE;
 		else if (cmd.argument() == "branch")
-			code = Inset::BRANCH_CODE;
+			code = BRANCH_CODE;
 		else if (cmd.argument() == "citation")
-			code = Inset::CITE_CODE;
+			code = CITE_CODE;
 		else if (cmd.argument() == "ert")
-			code = Inset::ERT_CODE;
+			code = ERT_CODE;
 		else if (cmd.argument() == "external")
-			code = Inset::EXTERNAL_CODE;
+			code = EXTERNAL_CODE;
 		else if (cmd.argument() == "float")
-			code = Inset::FLOAT_CODE;
+			code = FLOAT_CODE;
 		else if (cmd.argument() == "graphics")
-			code = Inset::GRAPHICS_CODE;
+			code = GRAPHICS_CODE;
+		else if (cmd.argument() == "href")
+			code = HYPERLINK_CODE;
 		else if (cmd.argument() == "include")
-			code = Inset::INCLUDE_CODE;
+			code = INCLUDE_CODE;
 		else if (cmd.argument() == "index")
-			code = Inset::INDEX_CODE;
+			code = INDEX_CODE;
 		else if (cmd.argument() == "nomenclature")
-			code = Inset::NOMENCL_CODE;
+			code = NOMENCL_CODE;
 		else if (cmd.argument() == "label")
-			code = Inset::LABEL_CODE;
+			code = LABEL_CODE;
 		else if (cmd.argument() == "note")
-			code = Inset::NOTE_CODE;
+			code = NOTE_CODE;
 		else if (cmd.argument() == "ref")
-			code = Inset::REF_CODE;
+			code = REF_CODE;
 		else if (cmd.argument() == "toc")
-			code = Inset::TOC_CODE;
-		else if (cmd.argument() == "url")
-			code = Inset::URL_CODE;
+			code = TOC_CODE;
 		else if (cmd.argument() == "vspace")
-			code = Inset::VSPACE_CODE;
+			code = VSPACE_CODE;
 		else if (cmd.argument() == "wrap")
-			code = Inset::WRAP_CODE;
+			code = WRAP_CODE;
 		else if (cmd.argument() == "listings")
-			code = Inset::LISTINGS_CODE;
+			code = LISTINGS_CODE;
 		break;
 
 	case LFUN_ERT_INSERT:
-		code = Inset::ERT_CODE;
+		code = ERT_CODE;
 		break;
 	case LFUN_LISTING_INSERT:
-	    code = Inset::LISTINGS_CODE;
+	    code = LISTINGS_CODE;
 		break;
 	case LFUN_FOOTNOTE_INSERT:
-		code = Inset::FOOT_CODE;
+		code = FOOT_CODE;
 		break;
 	case LFUN_TABULAR_INSERT:
-		code = Inset::TABULAR_CODE;
+		code = TABULAR_CODE;
 		break;
 	case LFUN_MARGINALNOTE_INSERT:
-		code = Inset::MARGIN_CODE;
+		code = MARGIN_CODE;
 		break;
 	case LFUN_FLOAT_INSERT:
 	case LFUN_FLOAT_WIDE_INSERT:
-		code = Inset::FLOAT_CODE;
+		code = FLOAT_CODE;
 		break;
 	case LFUN_WRAP_INSERT:
-		code = Inset::WRAP_CODE;
+		code = WRAP_CODE;
 		break;
 	case LFUN_FLOAT_LIST:
-		code = Inset::FLOAT_LIST_CODE;
+		code = FLOAT_LIST_CODE;
 		break;
 #if 0
 	case LFUN_LIST_INSERT:
-		code = Inset::LIST_CODE;
+		code = LIST_CODE;
 		break;
 	case LFUN_THEOREM_INSERT:
-		code = Inset::THEOREM_CODE;
+		code = THEOREM_CODE;
 		break;
 #endif
 	case LFUN_CAPTION_INSERT:
-		code = Inset::CAPTION_CODE;
+		code = CAPTION_CODE;
 		break;
 	case LFUN_NOTE_INSERT:
-		code = Inset::NOTE_CODE;
-		break;
-	case LFUN_CHARSTYLE_INSERT:
-		code = Inset::CHARSTYLE_CODE;
-		if (cur.buffer().params().getTextClass().charstyles().empty())
+		code = NOTE_CODE;
+		break;
+	case LFUN_FLEX_INSERT: {
+		code = FLEX_CODE;
+		string s = cmd.getArg(0);
+		InsetLayout il =  cur.buffer().params().getTextClass().insetlayout(from_utf8(s));
+		if (il.lyxtype != "charstyle" &&
+		    il.lyxtype != "custom" &&
+		    il.lyxtype != "element" &&
+		    il.lyxtype != "standard")
 			enable = false;
 		break;
+		}
 	case LFUN_BOX_INSERT:
-		code = Inset::BOX_CODE;
+		code = BOX_CODE;
 		break;
 	case LFUN_BRANCH_INSERT:
-		code = Inset::BRANCH_CODE;
-		if (cur.buffer().getMasterBuffer()->params().branchlist().empty())
+		code = BRANCH_CODE;
+		if (cur.buffer().masterBuffer()->params().branchlist().empty())
 			enable = false;
 		break;
 	case LFUN_LABEL_INSERT:
-		code = Inset::LABEL_CODE;
+		code = LABEL_CODE;
+		break;
+	case LFUN_INFO_INSERT:
+		code = INFO_CODE;
 		break;
 	case LFUN_OPTIONAL_INSERT:
-		code = Inset::OPTARG_CODE;
-		enable = numberOfOptArgs(cur.paragraph())
+		code = OPTARG_CODE;
+		enable = cur.paragraph().insetList().count(OPTARG_CODE)
 			< cur.paragraph().layout()->optionalargs;
 		break;
 	case LFUN_ENVIRONMENT_INSERT:
-		code = Inset::BOX_CODE;
+		code = BOX_CODE;
 		break;
 	case LFUN_INDEX_INSERT:
-		code = Inset::INDEX_CODE;
+		code = INDEX_CODE;
 		break;
 	case LFUN_INDEX_PRINT:
-		code = Inset::INDEX_PRINT_CODE;
+		code = INDEX_PRINT_CODE;
 		break;
 	case LFUN_NOMENCL_INSERT:
-		code = Inset::NOMENCL_CODE;
+		code = NOMENCL_CODE;
 		break;
 	case LFUN_NOMENCL_PRINT:
-		code = Inset::NOMENCL_PRINT_CODE;
+		code = NOMENCL_PRINT_CODE;
 		break;
 	case LFUN_TOC_INSERT:
-		code = Inset::TOC_CODE;
+		code = TOC_CODE;
 		break;
-	case LFUN_HTML_INSERT:
-	case LFUN_URL_INSERT:
-		code = Inset::URL_CODE;
+	case LFUN_HYPERLINK_INSERT:
+		code = HYPERLINK_CODE;
 		break;
 	case LFUN_QUOTE_INSERT:
 		// always allow this, since we will inset a raw quote
 		// if an inset is not allowed.
 		break;
-	case LFUN_HYPHENATION_POINT_INSERT:
-	case LFUN_LIGATURE_BREAK_INSERT:
 	case LFUN_HFILL_INSERT:
-	case LFUN_MENU_SEPARATOR_INSERT:
-	case LFUN_DOTS_INSERT:
-	case LFUN_END_OF_SENTENCE_PERIOD_INSERT:
-		code = Inset::SPECIALCHAR_CODE;
+	case LFUN_SPECIALCHAR_INSERT:
+		code = SPECIALCHAR_CODE;
 		break;
 	case LFUN_SPACE_INSERT:
 		// slight hack: we know this is allowed in math mode
 		if (cur.inTexted())
-			code = Inset::SPACE_CODE;
+			code = SPACE_CODE;
 		break;
 
 	case LFUN_INSET_MODIFY:
@@ -1843,27 +1977,27 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd,
 		break;
 
 	case LFUN_FONT_EMPH:
-		flag.setOnOff(font.emph() == Font::ON);
+		flag.setOnOff(fontinfo.emph() == FONT_ON);
 		return true;
 
 	case LFUN_FONT_NOUN:
-		flag.setOnOff(font.noun() == Font::ON);
+		flag.setOnOff(fontinfo.noun() == FONT_ON);
 		return true;
 
 	case LFUN_FONT_BOLD:
-		flag.setOnOff(font.series() == Font::BOLD_SERIES);
+		flag.setOnOff(fontinfo.series() == BOLD_SERIES);
 		return true;
 
 	case LFUN_FONT_SANS:
-		flag.setOnOff(font.family() == Font::SANS_FAMILY);
+		flag.setOnOff(fontinfo.family() == SANS_FAMILY);
 		return true;
 
 	case LFUN_FONT_ROMAN:
-		flag.setOnOff(font.family() == Font::ROMAN_FAMILY);
+		flag.setOnOff(fontinfo.family() == ROMAN_FAMILY);
 		return true;
 
-	case LFUN_FONT_CODE:
-		flag.setOnOff(font.family() == Font::TYPEWRITER_FAMILY);
+	case LFUN_FONT_TYPEWRITER:
+		flag.setOnOff(fontinfo.family() == TYPEWRITER_FAMILY);
 		return true;
 
 	case LFUN_CUT:
@@ -1905,7 +2039,14 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd,
 		break;
 
 	case LFUN_INSET_DISSOLVE:
-		enable = !isMainText(*cur.bv().buffer()) && cur.inset().nargs() == 1;
+		if (!cmd.argument().empty()) {
+			InsetLayout il = cur.inset().getLayout(cur.buffer().params());
+			enable = cur.inset().lyxCode() == FLEX_CODE
+			         && il.lyxtype == to_utf8(cmd.argument());
+		} else {
+			enable = !isMainText(cur.bv().buffer()) 
+			         && cur.inset().nargs() == 1;
+		}
 		break;
 
 	case LFUN_CHANGE_ACCEPT:
@@ -1919,15 +2060,28 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd,
 		enable = true;
 		break;
 
+	case LFUN_OUTLINE_UP:
+	case LFUN_OUTLINE_DOWN:
+	case LFUN_OUTLINE_IN:
+	case LFUN_OUTLINE_OUT:
+		enable = (cur.paragraph().layout()->toclevel != Layout::NOT_IN_TOC);
+		break;
+
 	case LFUN_WORD_DELETE_FORWARD:
 	case LFUN_WORD_DELETE_BACKWARD:
 	case LFUN_LINE_DELETE:
 	case LFUN_WORD_FORWARD:
 	case LFUN_WORD_BACKWARD:
+	case LFUN_WORD_RIGHT:
+	case LFUN_WORD_LEFT:
 	case LFUN_CHAR_FORWARD:
 	case LFUN_CHAR_FORWARD_SELECT:
 	case LFUN_CHAR_BACKWARD:
 	case LFUN_CHAR_BACKWARD_SELECT:
+	case LFUN_CHAR_LEFT:
+	case LFUN_CHAR_LEFT_SELECT:
+	case LFUN_CHAR_RIGHT:
+	case LFUN_CHAR_RIGHT_SELECT:
 	case LFUN_UP:
 	case LFUN_UP_SELECT:
 	case LFUN_DOWN:
@@ -1940,20 +2094,20 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd,
 	case LFUN_LINE_END_SELECT:
 	case LFUN_WORD_FORWARD_SELECT:
 	case LFUN_WORD_BACKWARD_SELECT:
+	case LFUN_WORD_RIGHT_SELECT:
+	case LFUN_WORD_LEFT_SELECT:
 	case LFUN_WORD_SELECT:
 	case LFUN_PARAGRAPH_UP:
 	case LFUN_PARAGRAPH_DOWN:
-	case LFUN_SCREEN_UP:
-	case LFUN_SCREEN_DOWN:
 	case LFUN_LINE_BEGIN:
+	case LFUN_LINE_BREAK:
 	case LFUN_LINE_END:
-	case LFUN_BREAK_LINE:
+	case LFUN_NEW_LINE:
 	case LFUN_CHAR_DELETE_FORWARD:
 	case LFUN_DELETE_FORWARD_SKIP:
 	case LFUN_CHAR_DELETE_BACKWARD:
 	case LFUN_DELETE_BACKWARD_SKIP:
 	case LFUN_BREAK_PARAGRAPH:
-	case LFUN_BREAK_PARAGRAPH_KEEP_LAYOUT:
 	case LFUN_BREAK_PARAGRAPH_SKIP:
 	case LFUN_PARAGRAPH_SPACING:
 	case LFUN_INSET_INSERT:
@@ -1969,6 +2123,7 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd,
 	case LFUN_DATE_INSERT:
 	case LFUN_SELF_INSERT:
 	case LFUN_LINE_INSERT:
+	case LFUN_NEWPAGE_INSERT:
 	case LFUN_PAGEBREAK_INSERT:
 	case LFUN_CLEARPAGE_INSERT:
 	case LFUN_CLEARDOUBLEPAGE_INSERT:
@@ -1979,6 +2134,7 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd,
 	case LFUN_MATH_MATRIX:
 	case LFUN_MATH_DELIM:
 	case LFUN_MATH_BIGDELIM:
+	case LFUN_MATH_INSERT:
 	case LFUN_MATH_SUBSCRIPT:
 	case LFUN_MATH_SUPERSCRIPT:
 	case LFUN_FONT_DEFAULT:
@@ -2008,6 +2164,7 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd,
 	case LFUN_ACCENT_OGONEK:
 	case LFUN_THESAURUS_ENTRY:
 	case LFUN_PARAGRAPH_PARAMS_APPLY:
+	case LFUN_PARAGRAPH_PARAMS:
 	case LFUN_ESCAPE:
 	case LFUN_BUFFER_END:
 	case LFUN_BUFFER_BEGIN:
@@ -2022,7 +2179,7 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd,
 		return false;
 	}
 
-	if (code != Inset::NO_CODE
+	if (code != NO_CODE
 	    && (cur.empty() || !cur.inset().insetAllowed(code)))
 		enable = false;
 
@@ -2036,7 +2193,7 @@ void Text::pasteString(Cursor & cur, docstring const & clip,
 {
 	cur.clearSelection();
 	if (!clip.empty()) {
-		recordUndo(cur);
+		cur.recordUndo();
 		if (asParagraphs)
 			insertStringAsParagraphs(cur, clip);
 		else