X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FText3.cpp;h=bcb13e1e3b17cbd8ba3c8ed0111679078b1ced16;hb=53ea0cdd2d96b95c1e964970131f970cd4ed1288;hp=a8e079fdf6a183e3091eb3fc0067ee2bd5a0c1e2;hpb=9383f4c3c6f9cfab2d658701ba66e2b54cd68bea;p=lyx.git

diff --git a/src/Text3.cpp b/src/Text3.cpp
index a8e079fdf6..bcb13e1e3b 100644
--- a/src/Text3.cpp
+++ b/src/Text3.cpp
@@ -27,12 +27,10 @@
 #include "BufferView.h"
 #include "Cursor.h"
 #include "CutAndPaste.h"
-#include "support/debug.h"
 #include "DispatchResult.h"
 #include "ErrorList.h"
 #include "factory.h"
 #include "FuncRequest.h"
-#include "support/gettext.h"
 #include "InsetList.h"
 #include "Intl.h"
 #include "Language.h"
@@ -44,7 +42,6 @@
 #include "Paragraph.h"
 #include "paragraph_funcs.h"
 #include "ParagraphParameters.h"
-#include "ParIterator.h"
 #include "TextClass.h"
 #include "TextMetrics.h"
 #include "VSpace.h"
@@ -60,10 +57,13 @@
 #include "insets/InsetSpecialChar.h"
 #include "insets/InsetText.h"
 #include "insets/InsetInfo.h"
+#include "insets/InsetGraphics.h"
+#include "insets/InsetGraphicsParams.h"
 
-#include "support/lstrings.h"
-#include "support/lyxlib.h"
 #include "support/convert.h"
+#include "support/debug.h"
+#include "support/gettext.h"
+#include "support/lstrings.h"
 #include "support/lyxtime.h"
 
 #include "mathed/InsetMathHull.h"
@@ -75,18 +75,17 @@
 #include <sstream>
 
 using namespace std;
+using namespace lyx::support;
 
 namespace lyx {
 
 using cap::copySelection;
 using cap::cutSelection;
 using cap::pasteFromStack;
-using cap::pasteClipboard;
+using cap::pasteClipboardText;
+using cap::pasteClipboardGraphics;
 using cap::replaceSelection;
 
-using support::isStrUnsignedInt;
-using support::token;
-
 // globals...
 static Font freefont(ignore_font, ignore_language);
 static bool toggleall = false;
@@ -134,7 +133,9 @@ static void mathDispatch(Cursor & cur, FuncRequest const & cmd, bool display)
 		const int old_pos = cur.pos();
 #endif
 		cur.insert(new InsetMathHull(hullSimple));
-		BOOST_ASSERT(old_pos == cur.pos());
+#ifdef ENABLE_ASSERTIONS
+		LASSERT(old_pos == cur.pos(), /**/);
+#endif
 		cur.nextInset()->edit(cur, true);
 		// don't do that also for LFUN_MATH_MODE
 		// unless you want end up with always changing
@@ -152,13 +153,14 @@ static void mathDispatch(Cursor & cur, FuncRequest const & cmd, bool display)
 		// somewhere, and an ordinary formula
 		// otherwise
 		if (sel.find(from_ascii("\\newcommand")) == string::npos
+				&& sel.find(from_ascii("\\newlyxcommand")) == string::npos
 				&& sel.find(from_ascii("\\def")) == string::npos)
 		{
 			InsetMathHull * formula = new InsetMathHull;
 			istringstream is(to_utf8(sel));
-			Lexer lex(0, 0);
+			Lexer lex;
 			lex.setStream(is);
-			formula->read(cur.buffer(), lex);
+			formula->read(lex);
 			if (formula->getType() == hullNone)
 				// Don't create pseudo formulas if
 				// delimiters are left out
@@ -184,57 +186,65 @@ static void specialChar(Cursor & cur, InsetSpecialChar::Kind kind)
 static bool doInsertInset(Cursor & cur, Text * text,
 	FuncRequest const & cmd, bool edit, bool pastesel)
 {
-	Inset * inset = createInset(cur.bv().buffer(), cmd);
+	Buffer & buffer = cur.bv().buffer();
+	BufferParams const & bparams = buffer.params();
+	Inset * inset = createInset(buffer, cmd);
 	if (!inset)
 		return false;
 
 	if (InsetCollapsable * ci = inset->asInsetCollapsable())
-		ci->setLayout(cur.bv().buffer().params());
+		ci->setLayout(bparams);
 
 	cur.recordUndo();
 	if (cmd.action == LFUN_INDEX_INSERT) {
-		docstring ds = support::subst(text->getStringToIndex(cur), '\n', ' ');
+		docstring ds = 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);
+		static_cast<InsetCollapsable *>(inset)->text().insertStringAsParagraphs(cur, ds);
+		return true;
+	}
 
-		if (edit)
-			inset->edit(cur, true);
+	bool gotsel = false;
+	if (cur.selection()) {
+		cutSelection(cur, false, pastesel);
+		cur.clearSelection();
+		gotsel = true;
+	}
+	text->insertInset(cur, inset);
 
-		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);
-			}
-		}
+	if (edit)
+		inset->edit(cur, true);
+
+	if (!gotsel || !pastesel)
+		return true;
+
+	pasteFromStack(cur, cur.buffer().errorList("Paste"), 0);
+	cur.buffer().errors("Paste");
+	cur.clearSelection(); // bug 393
+	cur.finishUndo();
+	InsetText * insetText = dynamic_cast<InsetText *>(inset);
+	if (insetText && (!insetText->allowMultiPar() || cur.lastpit() == 0)) {
+		// reset first par to default
+		cur.text()->paragraphs().begin()
+			->setPlainOrDefaultLayout(bparams.documentClass());
+		cur.pos() = 0;
+		cur.pit() = 0;
+		// Merge multiple paragraphs -- hack
+		while (cur.lastpit() > 0)
+			mergeParagraph(bparams, cur.text()->paragraphs(), 0);
+		cur.leaveInset(*inset);
+	} else {
+		cur.leaveInset(*inset);
+		// reset surrounding par to default
+		DocumentClass const & dc = bparams.documentClass();
+		docstring const layoutname = inset->usePlainLayout()
+			? dc.plainLayoutName()
+			: dc.defaultLayoutName();
+		text->setLayout(cur, layoutname);
 	}
+
 	return true;
 }
 
@@ -266,104 +276,113 @@ static void outline(OutlineOp mode, Cursor & cur)
 	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();
+	DocumentClass const & tc = buf.params().documentClass();
 
-	int const thistoclevel = start->layout()->toclevel;
+	int const thistoclevel = start->layout().toclevel;
 	int toclevel;
+
+	// 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;
+		}
+	}
+
 	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;
-				}
-			}
+			if (start == pars.begin())
+				// Nothing to move.
+				return;
 			ParagraphList::iterator dest = start;
 			// Move out (up) from this header
 			if (dest == bgn)
-				break;
+				return;
 			// Search previous same-level header above
 			do {
 				--dest;
-				toclevel = dest->layout()->toclevel;
+				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);
+				return;
+			pit_type const newpit = distance(bgn, dest);
+			pit_type const len = 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;
+			return;
 		}
 		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;
+			if (finish == end)
+				// Nothing to move.
+				return;
 			// Go one down from *this* header:
-			if (dest != end)
-				++dest;
-			else
-				break;
+			ParagraphList::iterator dest = boost::next(finish, 1);
 			// 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)
+				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);
+			pit_type newpit = distance(bgn, dest);
+			pit_type const len = 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;
+			return;
 		}
-		case OutlineIn:
-			buf.undo().recordUndo(cur);
-			for (; lit != lend; ++lit) {
-				if ((*lit)->toclevel == thistoclevel + 1 &&
-				    start->layout()->labeltype == (*lit)->labeltype) {
-					start->layout((*lit));
-					break;
+		case OutlineIn: {
+			pit_type const len = distance(start, finish);
+			buf.undo().recordUndo(cur, ATOMIC_UNDO, pit, pit + len - 1);
+			for (; start != finish; ++start) {
+				toclevel = start->layout().toclevel;
+				if (toclevel == Layout::NOT_IN_TOC)
+					continue;
+				DocumentClass::const_iterator lit = tc.begin();
+				DocumentClass::const_iterator len = tc.end();
+				for (; lit != len; ++lit) {
+					if (lit->toclevel == toclevel + 1 &&
+					    start->layout().labeltype == lit->labeltype) {
+						start->setLayout(*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;
+			return;
+		}
+		case OutlineOut: {
+			pit_type const len = distance(start, finish);
+			buf.undo().recordUndo(cur, ATOMIC_UNDO, pit, pit + len - 1);
+			for (; start != finish; ++start) {
+				toclevel = start->layout().toclevel;
+				if (toclevel == Layout::NOT_IN_TOC)
+					continue;
+				DocumentClass::const_iterator lit = tc.begin();
+				DocumentClass::const_iterator len = tc.end();
+				for (; lit != len; ++lit) {
+					if (lit->toclevel == toclevel - 1 &&
+						start->layout().labeltype == lit->labeltype) {
+							start->setLayout(*lit);
+							break;
+					}
 				}
 			}
-			break;
-		default:
-			break;
+			return;
+		}
 	}
 }
 
@@ -372,7 +391,7 @@ void Text::number(Cursor & cur)
 {
 	FontInfo font = ignore_font;
 	font.setNumber(FONT_TOGGLE);
-	toggleAndShow(cur, this, Font(font));
+	toggleAndShow(cur, this, Font(font, ignore_language));
 }
 
 
@@ -386,14 +405,17 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 {
 	LYXERR(Debug::ACTION, "Text::dispatch: cmd: " << cmd);
 
+	BufferView * bv = &cur.bv();
+	TextMetrics & tm = bv->textMetrics(this);
+	if (!tm.contains(cur.pit()))
+		lyx::dispatch(FuncRequest(LFUN_SCREEN_RECENTER));
+
 	// 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
 	// at the end?
 	cur.noUpdate();
 
-	BOOST_ASSERT(cur.text() == this);
-	BufferView * bv = &cur.bv();
-	TextMetrics & tm = cur.bv().textMetrics(this);
+	LASSERT(cur.text() == this, /**/);
 	CursorSlice oldTopSlice = cur.top();
 	bool oldBoundary = cur.boundary();
 	bool sel = cur.selection();
@@ -404,10 +426,6 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 	// Signals that a full-screen update is required
 	bool needsUpdate = !(lyxaction.funcHasFlag(cmd.action,
 		LyXAction::NoUpdate) || singleParUpdate);
-	// Remember the old paragraph metric (_outer_ paragraph!)
-	ParagraphMetrics const & pm = cur.bv().parMetrics(
-		cur.bottom().text(), cur.bottom().pit());
-	Dimension olddim = pm.dim();
 
 	switch (cmd.action) {
 
@@ -415,7 +433,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 		pit_type const pit = cur.pit();
 		recUndo(cur, pit, pit + 1);
 		cur.finishUndo();
-		std::swap(pars_[pit], pars_[pit + 1]);
+		swap(pars_[pit], pars_[pit + 1]);
 		updateLabels(cur.buffer());
 		needsUpdate = true;
 		++cur.pit();
@@ -426,7 +444,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 		pit_type const pit = cur.pit();
 		recUndo(cur, pit - 1, pit);
 		cur.finishUndo();
-		std::swap(pars_[pit], pars_[pit - 1]);
+		swap(pars_[pit], pars_[pit - 1]);
 		updateLabels(cur.buffer());
 		--cur.pit();
 		needsUpdate = true;
@@ -489,6 +507,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 		} else {
 			cur.undispatched();
 		}
+		cur.updateFlags(Update::FitCursor);
 		break;
 
 	case LFUN_BUFFER_END:
@@ -499,6 +518,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 		} else {
 			cur.undispatched();
 		}
+		cur.updateFlags(Update::FitCursor);
 		break;
 
 	case LFUN_CHAR_FORWARD:
@@ -529,29 +549,50 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 
 	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;
+		if (lyxrc.visual_cursor) {
+			needsUpdate |= cur.selHandle(cmd.action == LFUN_CHAR_LEFT_SELECT);
+			needsUpdate |= cursorVisLeft(cur);
+			if (!needsUpdate && oldTopSlice == cur.top()
+					&& cur.boundary() == oldBoundary) {
+				cur.undispatched();
+				cmd = FuncRequest(LFUN_FINISHED_LEFT);
+			}
 		} else {
-			cmd.action = cmd.action == LFUN_CHAR_LEFT_SELECT ? 
+			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;
 		}
-		dispatch(cur, cmd);
-		return;
+		break;
 
 	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;
+		if (lyxrc.visual_cursor) {
+			needsUpdate |= cur.selHandle(cmd.action == LFUN_CHAR_RIGHT_SELECT);
+			needsUpdate |= cursorVisRight(cur);
+			if (!needsUpdate && oldTopSlice == cur.top()
+					&& cur.boundary() == oldBoundary) {
+				cur.undispatched();
+				cmd = FuncRequest(LFUN_FINISHED_RIGHT);
+			}
 		} else {
-			cmd.action = cmd.action == LFUN_CHAR_RIGHT_SELECT ? 
+			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;
 		}
-		dispatch(cur, cmd);
-		return;
+		break;
+		
 
 	case LFUN_UP_SELECT:
 	case LFUN_DOWN_SELECT:
@@ -566,10 +607,6 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 		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
@@ -590,25 +627,6 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 		needsUpdate |= cursorDownParagraph(cur);
 		break;
 
-	case LFUN_SCREEN_UP_SELECT:
-		needsUpdate |= cur.selHandle(true);
-		if (cur.pit() == 0 && cur.textRow().pos() == 0)
-			cur.undispatched();
-		else {
-			tm.cursorPrevious(cur);
-		}
-		break;
-
-	case LFUN_SCREEN_DOWN_SELECT:
-		needsUpdate |= cur.selHandle(true);
-		if (cur.pit() == cur.lastpit()
-			  && cur.textRow().endpos() == cur.lastpos())
-			cur.undispatched();
-		else {
-			tm.cursorNext(cur);
-		}
-		break;
-
 	case LFUN_LINE_BEGIN:
 	case LFUN_LINE_BEGIN_SELECT:
 		needsUpdate |= cur.selHandle(cmd.action == LFUN_LINE_BEGIN_SELECT);
@@ -623,16 +641,26 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 
 	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;
+		if (lyxrc.visual_cursor) {
+			needsUpdate |= cur.selHandle(cmd.action == LFUN_WORD_RIGHT_SELECT);
+			needsUpdate |= cursorVisRightOneWord(cur);
+			if (!needsUpdate && oldTopSlice == cur.top()
+					&& cur.boundary() == oldBoundary) {
+				cur.undispatched();
+				cmd = FuncRequest(LFUN_FINISHED_RIGHT);
+			}
 		} else {
-			cmd.action = cmd.action == LFUN_WORD_RIGHT_SELECT ?
-					LFUN_WORD_FORWARD_SELECT : LFUN_WORD_FORWARD;
+			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;
 		}
-		dispatch(cur, cmd);
-		return;
+		break;
 
 	case LFUN_WORD_FORWARD:
 	case LFUN_WORD_FORWARD_SELECT:
@@ -642,16 +670,26 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 
 	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;
+		if (lyxrc.visual_cursor) {
+			needsUpdate |= cur.selHandle(cmd.action == LFUN_WORD_LEFT_SELECT);
+			needsUpdate |= cursorVisLeftOneWord(cur);
+			if (!needsUpdate && oldTopSlice == cur.top()
+					&& cur.boundary() == oldBoundary) {
+				cur.undispatched();
+				cmd = FuncRequest(LFUN_FINISHED_LEFT);
+			}
 		} else {
-			cmd.action = cmd.action == LFUN_WORD_LEFT_SELECT ?
-					LFUN_WORD_BACKWARD_SELECT : LFUN_WORD_BACKWARD;
+			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;
 		}
-		dispatch(cur, cmd);
-		return;
+		break;
 
 	case LFUN_WORD_BACKWARD:
 	case LFUN_WORD_BACKWARD_SELECT:
@@ -665,36 +703,24 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 		break;
 	}
 
-	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())
-				cur.recordUndo();
-			cap::replaceSelection(cur);
-			cur.insert(new InsetNewline);
-			cur.posForward();
-			moveCursor(cur, false);
-		}
+	case LFUN_NEWLINE_INSERT: {
+		InsetNewlineParams inp;
+		docstring arg = cmd.argument();
+		// this avoids a double undo
+		// FIXME: should not be needed, ideally
+		if (!cur.selection())
+			cur.recordUndo();
+		cap::replaceSelection(cur);
+		if (arg == "linebreak")
+			inp.kind = InsetNewlineParams::LINEBREAK;
+		else
+			inp.kind = InsetNewlineParams::NEWLINE;
+		cur.insert(new InsetNewline(inp));
+		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;
-	}
-
 	case LFUN_CHAR_DELETE_FORWARD:
 		if (!cur.selection()) {
 			if (cur.pos() == cur.paragraph().size())
@@ -711,21 +737,6 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 		moveCursor(cur, false);
 		break;
 
-	case LFUN_DELETE_FORWARD_SKIP:
-		// Reverse the effect of LFUN_BREAK_PARAGRAPH_SKIP.
-		if (!cur.selection()) {
-			if (cur.pos() == cur.lastpos()) {
-				cursorForward(cur);
-				cursorBackward(cur);
-			}
-			erase(cur);
-			cur.resetAnchor();
-		} else {
-			cutSelection(cur, true, false);
-		}
-		break;
-
-
 	case LFUN_CHAR_DELETE_BACKWARD:
 		if (!cur.selection()) {
 			if (bv->getIntl().getTransManager().backspace()) {
@@ -743,36 +754,12 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 		}
 		break;
 
-	case LFUN_DELETE_BACKWARD_SKIP:
-		// Reverse the effect of LFUN_BREAK_PARAGRAPH_SKIP.
-		if (!cur.selection()) {
-			// FIXME: look here
-			//CursorSlice cur = cursor();
-			backspace(cur);
-			//anchor() = cur;
-		} else {
-			cutSelection(cur, true, false);
-		}
-		break;
-
 	case LFUN_BREAK_PARAGRAPH:
 		cap::replaceSelection(cur);
 		breakParagraph(cur, cmd.argument() == "inverse");
 		cur.resetAnchor();
 		break;
 
-	case LFUN_BREAK_PARAGRAPH_SKIP: {
-		// When at the beginning of a paragraph, remove
-		// indentation.  Otherwise, do the same as LFUN_BREAK_PARAGRAPH.
-		cap::replaceSelection(cur);
-		if (cur.pos() == 0)
-			cur.paragraph().params().labelWidthString(docstring());
-		else
-			breakParagraph(cur, false);
-		cur.resetAnchor();
-		break;
-	}
-
 	// TODO
 	// With the creation of LFUN_PARAGRAPH_PARAMS, this is now redundant,
 	// as its duties can be performed there. Should it be removed??
@@ -832,7 +819,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 			/*
 			Paragraph & par = pars_[cur.pit()];
 			if (inset->lyxCode() == LABEL_CODE
-				&& par.layout()->labeltype == LABEL_COUNTER) {
+				&& par.layout().labeltype == LABEL_COUNTER) {
 				// Go to the end of the paragraph
 				// Warning: Because of Change-Tracking, the last
 				// position is 'size()' and not 'size()-1':
@@ -844,7 +831,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 			*/
 			if (cur.selection())
 				cutSelection(cur, true, false);
-			insertInset(cur, inset);
+			cur.insert(inset);
 			cur.posForward();
 		}
 		break;
@@ -854,12 +841,48 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 		needsUpdate |= dissolveInset(cur);
 		break;
 
-	case LFUN_INSET_SETTINGS:
-		cur.inset().showInsetDialog(bv);
+	case LFUN_INSET_SETTINGS: {
+		Inset & inset = cur.inset();
+		if (cmd.getArg(0) == insetName(inset.lyxCode())) {
+			// This inset dialog has been explicitely requested.
+			inset.showInsetDialog(bv);
+			break;
+		}
+		// else, if there is an inset at the cursor, access this
+		Inset * next_inset = cur.nextInset();
+		if (next_inset) {
+			next_inset->showInsetDialog(bv);
+			break;
+		}
+		// if not then access the underlying inset.
+		inset.showInsetDialog(bv);
 		break;
+	}
+
+	case LFUN_SET_GRAPHICS_GROUP: {
+		InsetGraphics * ins = graphics::getCurrentGraphicsInset(cur);
+		if (!ins)
+			break;
+
+		cur.recordUndoFullDocument();
+
+		string id = to_utf8(cmd.argument());
+		string grp = graphics::getGroupParams(bv->buffer(), id);
+		InsetGraphicsParams tmp, inspar = ins->getParams();
+
+		if (id.empty())
+			inspar.groupId = to_utf8(cmd.argument());
+		else {
+			InsetGraphics::string2params(grp, bv->buffer(), tmp);
+			tmp.filename = inspar.filename;
+			inspar = tmp;
+		}
+
+		ins->setParams(inspar);
+	}
 
 	case LFUN_SPACE_INSERT:
-		if (cur.paragraph().layout()->free_spacing)
+		if (cur.paragraph().layout().free_spacing)
 			insertChar(cur, ' ');
 		else {
 			doInsertInset(cur, this, cmd, false, false);
@@ -907,22 +930,45 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 		charsTranspose(cur);
 		break;
 
-	case LFUN_PASTE:
+	case LFUN_PASTE: {
 		cur.message(_("Paste"));
+		LASSERT(cur.selBegin().idx() == cur.selEnd().idx(), /**/);
 		cap::replaceSelection(cur);
-		if (cmd.argument().empty() && !theClipboard().isInternal())
-			pasteClipboard(cur, bv->buffer().errorList("Paste"));
-		else {
-			string const arg(to_utf8(cmd.argument()));
+
+		// without argument?
+		string const arg = to_utf8(cmd.argument());
+		if (arg.empty()) {
+			if (theClipboard().isInternal())
+				pasteFromStack(cur, bv->buffer().errorList("Paste"), 0);
+			else if (theClipboard().hasGraphicsContents())
+				pasteClipboardGraphics(cur, bv->buffer().errorList("Paste"));
+			else
+				pasteClipboardText(cur, bv->buffer().errorList("Paste"));
+		} else if (isStrUnsignedInt(arg)) {
+			// we have a numerical argument
 			pasteFromStack(cur, bv->buffer().errorList("Paste"),
-					isStrUnsignedInt(arg) ?
-						convert<unsigned int>(arg) :
-						0);
+				       convert<unsigned int>(arg));
+		} else {
+			Clipboard::GraphicsType type = Clipboard::AnyGraphicsType;
+			if (arg == "pdf")
+				type = Clipboard::PdfGraphicsType;
+			else if (arg == "png")
+				type = Clipboard::PngGraphicsType;
+			else if (arg == "jpeg")
+				type = Clipboard::JpegGraphicsType;
+			else if (arg == "linkback")
+				type = Clipboard::LinkBackGraphicsType;
+			else
+				LASSERT(false, /**/);
+
+			pasteClipboardGraphics(cur, bv->buffer().errorList("Paste"), type);
 		}
+
 		bv->buffer().errors("Paste");
 		cur.clearSelection(); // bug 393
 		cur.finishUndo();
 		break;
+	}
 
 	case LFUN_CUT:
 		cutSelection(cur, true, true);
@@ -947,41 +993,45 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 		is >> x >> y;
 		if (!is)
 			lyxerr << "SETXY: Could not parse coordinates in '"
-			       << to_utf8(cmd.argument()) << std::endl;
+			       << to_utf8(cmd.argument()) << endl;
 		else
 			tm.setCursorFromCoordinates(cur, x, y);
 		break;
 	}
 
-	case LFUN_SERVER_GET_FONT:
-		if (cur.current_font.fontInfo().shape() == ITALIC_SHAPE)
-			cur.message(from_ascii("E"));
-		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(cur.paragraph().layout()->name());
+		cur.message(cur.paragraph().layout().name());
 		break;
 
 	case LFUN_LAYOUT: {
 		docstring layout = cmd.argument();
 		LYXERR(Debug::INFO, "LFUN_LAYOUT: (arg) " << to_utf8(layout));
 
-		docstring const old_layout = cur.paragraph().layout()->name();
+		Paragraph const & para = cur.paragraph();
+		docstring const old_layout = para.layout().name();
+		DocumentClass const & tclass = bv->buffer().params().documentClass();
 
-		// Derive layout number from given argument (string)
-		// and current buffer's textclass (number)
-		TextClass const & tclass = bv->buffer().params().getTextClass();
 		if (layout.empty())
 			layout = tclass.defaultLayoutName();
+
+		if (para.forcePlainLayout()) 
+			// in this case only the empty layout is allowed
+			layout = tclass.plainLayoutName();
+		else if (para.usePlainLayout()) {
+			// in this case, default layout maps to empty layout 
+			if (layout == tclass.defaultLayoutName())
+				layout = tclass.plainLayoutName();
+		} else { 
+			// otherwise, the empty layout maps to the default
+			if (layout == tclass.plainLayoutName())
+				layout = tclass.defaultLayoutName();
+		}
+
 		bool hasLayout = tclass.hasLayout(layout);
 
 		// If the entry is obsolete, use the new one instead.
 		if (hasLayout) {
-			docstring const & obs = tclass[layout]->obsoleted_by();
+			docstring const & obs = tclass[layout].obsoleted_by();
 			if (!obs.empty())
 				layout = obs;
 		}
@@ -1000,7 +1050,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() != old_layout) {
+				if (pars_[spit].layout().name() != old_layout) {
 					change_layout = true;
 					break;
 				}
@@ -1016,7 +1066,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 
 	case LFUN_CLIPBOARD_PASTE:
 		cur.clearSelection();
-		pasteClipboard(cur, bv->buffer().errorList("Paste"),
+		pasteClipboardText(cur, bv->buffer().errorList("Paste"),
 			       cmd.argument() == "paragraph");
 		bv->buffer().errors("Paste");
 		break;
@@ -1030,8 +1080,8 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 		if (cmd.argument().empty())
 			break;
 		docstring hexstring = cmd.argument();
-		if (lyx::support::isHex(hexstring)) {
-			char_type c = lyx::support::hexToInt(hexstring);
+		if (isHex(hexstring)) {
+			char_type c = hexToInt(hexstring);
 			if (c >= 32 && c < 0x10ffff) {
 				lyxerr << "Inserting c: " << c << endl;
 				docstring s = docstring(1, c);
@@ -1045,8 +1095,8 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 		Paragraph & par = cur.paragraph();
 		pos_type pos = cur.pos();
 		BufferParams const & bufparams = bv->buffer().params();
-		LayoutPtr const & style = par.layout();
-		if (!style->pass_thru
+		Layout 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
@@ -1062,14 +1112,9 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 			else
 				c = par.getChar(pos - 1);
 			string arg = to_utf8(cmd.argument());
-			if (arg == "single")
-				cur.insert(new InsetQuotes(c,
-				    bufparams.quotes_language,
-				    InsetQuotes::SingleQ));
-			else
-				cur.insert(new InsetQuotes(c,
-				    bufparams.quotes_language,
-				    InsetQuotes::DoubleQ));
+			cur.insert(new InsetQuotes(c, bufparams.quotes_language,
+				(arg == "single") ? InsetQuotes::SingleQuotes
+					: InsetQuotes::DoubleQuotes));
 			cur.posForward();
 		}
 		else
@@ -1103,51 +1148,63 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 		break;
 
 	// 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();
-
-		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 (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 {
-				lyx::dispatch(FuncRequest(LFUN_PRIMARY_SELECTION_PASTE, "paragraph"));
+	case LFUN_MOUSE_PRESS:
+		// We are not marking a selection with the keyboard in any case.
+		cur.bv().cursor().mark() = false;
+		switch (cmd.button()) {
+		case mouse_button::button1:
+			// Set the cursor
+			if (!bv->mouseSetCursor(cur, cmd.argument() == "region-select"))
+				cur.updateFlags(Update::SinglePar | Update::FitCursor);
+			break;			
+
+		case mouse_button::button2:
+			// Middle mouse pasting.
+			bv->mouseSetCursor(cur);
+			if (!cap::selection()) {			
+				// There is no local selection in the current buffer, so try to
+				// paste primary selection instead.
+				lyx::dispatch(FuncRequest(LFUN_PRIMARY_SELECTION_PASTE,
+					"paragraph"));
+				// Nothing else to do.
+				cur.noUpdate();
+				return;
 			}
-		}
+			// 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"));
+			cur.updateFlags(Update::Force | Update::FitCursor);
+			bv->buffer().errors("Paste");
+			bv->buffer().markDirty();
+			bv->cursor().finishUndo();
+			break;
 
-		// we have to update after dEPM triggered
-		if (!update && cmd.button() == mouse_button::button1) {
-			needsUpdate = false;
-			cur.noUpdate();
+		case mouse_button::button3: {
+			Cursor const & bvcur = cur.bv().cursor();
+			// Don't do anything if we right-click a
+			// selection, a context menu will popup.
+			if (bvcur.selection() && cur >= bvcur.selectionBegin()
+			    && cur < bvcur.selectionEnd()) {
+				cur.noUpdate();
+				return;
+			}
+			if (!bv->mouseSetCursor(cur, false))
+				cur.updateFlags(Update::SinglePar | Update::FitCursor);
+			break;			
 		}
 
+		default:
+			break;
+		} // switch (cmd.button())
 		break;
-	}
 
 	case LFUN_MOUSE_MOTION: {
-		// Only use motion with button 1
-		//if (cmd.button() != mouse_button::button1)
-		//	return false;
-
+		// Mouse motion with right or middle mouse do nothing for now.
+		if (cmd.button() != mouse_button::button1) {
+			cur.noUpdate();
+			return;
+		}
 		// ignore motions deeper nested than the real anchor
 		Cursor & bvcur = cur.bv().cursor();
 		if (!bvcur.anchor_.hasPart(cur)) {
@@ -1157,7 +1214,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 		CursorSlice old = bvcur.top();
 
 		int const wh = bv->workHeight();
-		int const y = std::max(0, std::min(wh - 1, cmd.y));
+		int const y = max(0, min(wh - 1, cmd.y));
 
 		tm.setCursorFromCoordinates(cur, cmd.x, y);
 		cur.setTargetX(cmd.x);
@@ -1172,42 +1229,57 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 			else if (cmd.y < 0)
 				lyx::dispatch(FuncRequest(LFUN_UP_SELECT));
 		}
-
-		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;
+		// We continue with our existing selection or start a new one, so don't
+		// reset the anchor.
+		bvcur.setCursor(cur);
+		bvcur.selection() = true;
+		if (cur.top() == old) {
+			// We didn't move one iota, so no need to update the screen.
+			cur.updateFlags(Update::SinglePar | Update::FitCursor);
+			//cur.noUpdate();
+			return;
 		}
 		break;
 	}
 
-	case LFUN_MOUSE_RELEASE: {
-		if (cmd.button() == mouse_button::button2)
-			break;
-
-		if (cmd.button() == mouse_button::button1) {
-			// if there is new selection, update persistent
-			// selection, otherwise, single click does not
-			// clear persistent selection buffer
+	case LFUN_MOUSE_RELEASE:
+		switch (cmd.button()) {
+		case mouse_button::button1:
+			// Cursor was set at LFUN_MOUSE_PRESS or LFUN_MOUSE_MOTION time.
+			// If there is a new selection, update persistent selection;
+			// otherwise, single click does not clear persistent selection
+			// buffer.
 			if (cur.selection()) {
-				// finish selection
-				// if double click, cur is moved to the end of word by selectWord
-				// but bvcur is current mouse position
-				Cursor & bvcur = cur.bv().cursor();
-				bvcur.selection() = true;
+				// Finish selection. If double click,
+				// cur is moved to the end of word by
+				// selectWord but bvcur is current
+				// mouse position.
+				cur.bv().cursor().setSelection();
 			}
-			needsUpdate = false;
+			// FIXME: We could try to handle drag and drop of selection here.
 			cur.noUpdate();
-		}
+			return;
+
+		case mouse_button::button2:
+			// Middle mouse pasting is handled at mouse press time,
+			// see LFUN_MOUSE_PRESS.
+			cur.noUpdate();
+			return;
+
+		case mouse_button::button3:
+			// Cursor was set at LFUN_MOUSE_PRESS time.
+			// FIXME: If there is a selection we could try to handle a special
+			// drag & drop context menu.
+			cur.noUpdate();
+			return;
+
+		case mouse_button::none:
+		case mouse_button::button4:
+		case mouse_button::button5:
+			break;
+		} // switch (cmd.button())
 
 		break;
-	}
 
 	case LFUN_SELF_INSERT: {
 		if (cmd.argument().empty())
@@ -1244,7 +1316,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 		}
 		p["target"] = (cmd.argument().empty()) ?
 			content : cmd.argument();
-		string const data = InsetCommandMailer::params2string("href", p);
+		string const data = InsetCommand::params2string("href", p);
 		if (p["target"].empty()) {
 			bv->showDialog("href", data);
 		} else {
@@ -1260,7 +1332,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 		p["name"] = (cmd.argument().empty()) ?
 			cur.getPossibleLabel() :
 			cmd.argument();
-		string const data = InsetCommandMailer::params2string("label", p);
+		string const data = InsetCommand::params2string("label", p);
 
 		if (cmd.argument().empty()) {
 			bv->showDialog("label", data);
@@ -1272,48 +1344,40 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 	}
 
 	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.
+		Inset * inset;
 		if (cmd.argument().empty() && cur.selection()) {
-			// use selected text as info to avoid a separate UI
+			// if command argument is empty use current selection as parameter.
 			docstring ds = cur.selectionAsString(false);
 			cutSelection(cur, true, false);
-			static_cast<InsetInfo *>(inset)->setInfo(to_utf8(ds));
+			FuncRequest cmd0(cmd, ds);
+			inset = createInset(cur.bv().buffer(), cmd0);
+		} else {
+			inset = createInset(cur.bv().buffer(), cmd);
 		}
+		if (!inset)
+			break;
 		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.posForward();
-		// These insets are numbered.
-		updateLabels(bv->buffer());
-		break;
 	case LFUN_NOTE_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_MARGINALNOTE_INSERT:
 	case LFUN_OPTIONAL_INSERT:
-	case LFUN_ENVIRONMENT_INSERT:
+	case LFUN_INDEX_INSERT:
 		// Open the inset, and move the current selection
 		// inside it.
 		doInsertInset(cur, this, cmd, true, true);
 		cur.posForward();
+		// Some insets are numbered, others are shown in the outline pane so
+		// let's update the labels and the toc backend.
+		updateLabels(bv->buffer());
 		break;
 
 	case LFUN_TABULAR_INSERT:
@@ -1334,13 +1398,12 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 		cur.posForward();
 		ParagraphList & pars = cur.text()->paragraphs();
 
-		TextClass const & tclass = bv->buffer().params().getTextClass();
+		DocumentClass const & tclass = bv->buffer().params().documentClass();
 
 		// add a separate paragraph for the caption inset
 		pars.push_back(Paragraph());
 		pars.back().setInsetOwner(pars[0].inInset());
-		pars.back().layout(tclass.defaultLayout());
-
+		pars.back().setPlainOrDefaultLayout(tclass);
 		int cap_pit = pars.size() - 1;
 
 		// if an empty inset was created, we create an additional empty
@@ -1349,8 +1412,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 		if (!content) {
 			pars.push_back(Paragraph());
 			pars.back().setInsetOwner(pars[0].inInset());
-			pars.back().layout(tclass.defaultLayout());
-
+			pars.back().setPlainOrDefaultLayout(tclass);
 		}
 
 		// reposition the cursor to the caption
@@ -1368,39 +1430,22 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 		break;
 	}
 
-	case LFUN_INDEX_INSERT:
-		doInsertInset(cur, this, cmd, true, true);
-		cur.posForward();
-		break;
-
 	case LFUN_NOMENCL_INSERT: {
-		FuncRequest cmd1 = cmd;
+		InsetCommandParams p(NOMENCL_CODE);
 		if (cmd.argument().empty())
-			cmd1 = FuncRequest(cmd,
-				bv->cursor().innerText()->getStringToIndex(bv->cursor()));
-		Inset * inset = createInset(cur.bv().buffer(), cmd1);
-		if (!inset)
-			break;
-		cur.recordUndo();
-		cur.clearSelection();
-		insertInset(cur, inset);
-		// Show the dialog for the nomenclature entry, since the
-		// description entry still needs to be filled in.
-		if (cmd.action == LFUN_NOMENCL_INSERT)
-			inset->edit(cur, true);
-		cur.posForward();
+			p["symbol"] = bv->cursor().innerText()->getStringToIndex(bv->cursor());
+		else
+			p["symbol"] = cmd.argument();
+		string const data = InsetCommand::params2string("nomenclature", p);
+		bv->showDialog("nomenclature", data);	
 		break;
 	}
 
 	case LFUN_INDEX_PRINT:
 	case LFUN_NOMENCL_PRINT:
 	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.posForward();
@@ -1418,7 +1463,6 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 		mathDispatch(cur, cmd, true);
 		break;
 
-	case LFUN_MATH_IMPORT_SELECTION:
 	case LFUN_MATH_MODE:
 		if (cmd.argument() == "on")
 			// don't pass "on" as argument
@@ -1435,8 +1479,10 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 			string const s1 = token(s, ' ', 1);
 			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, false, from_utf8(type)));
+			MacroType type = MacroTypeNewcommand;
+			if (s2 == "def")
+				type = MacroTypeDef;
+			cur.insert(new MathMacroTemplate(from_utf8(token(s, ' ', 0)), nargs, false, type));
 			//cur.nextInset()->edit(cur, true);
 		}
 		break;
@@ -1453,15 +1499,11 @@ 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.recordUndo();
+		cap::replaceSelection(cur);
 		cur.insert(new InsetMathHull(hullSimple));
 		checkAndActivateInset(cur, true);
-		BOOST_ASSERT(cur.inMathed());
+		LASSERT(cur.inMathed(), /**/);
 		cur.dispatch(cmd);
 		break;
 	}
@@ -1537,14 +1579,14 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 		break;
 	}
 
-	case LFUN_FONT_FREE_APPLY:
+	case LFUN_TEXTSTYLE_APPLY:
 		toggleAndShow(cur, this, freefont, toggleall);
 		cur.message(_("Character set"));
 		break;
 
 	// Set the freefont using the contents of \param data dispatched from
 	// the frontends and apply it at the current cursor location.
-	case LFUN_FONT_FREE_UPDATE: {
+	case LFUN_TEXTSTYLE_UPDATE: {
 		Font font;
 		bool toggle;
 		if (font.fromString(to_utf8(cmd.argument()), toggle)) {
@@ -1560,18 +1602,24 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 
 	case LFUN_FINISHED_LEFT:
 		LYXERR(Debug::DEBUG, "handle LFUN_FINISHED_LEFT:\n" << cur);
-		if (reverseDirectionNeeded(cur)) {
-			++cur.pos();
-			cur.setCurrentFont();
-		}
+		// We're leaving an inset, going left. If the inset is LTR, we're 
+		// leaving from the front, so we should not move (remain at --- but
+		// not in --- the inset). If the inset is RTL, move left, without 
+		// entering the inset itself; i.e., move to after the inset.
+		if (cur.paragraph().getFontSettings(
+				cur.bv().buffer().params(), cur.pos()).isRightToLeft())
+			cursorVisLeft(cur, true);
 		break;
 
 	case LFUN_FINISHED_RIGHT:
 		LYXERR(Debug::DEBUG, "handle LFUN_FINISHED_RIGHT:\n" << cur);
-		if (!reverseDirectionNeeded(cur)) {
-			++cur.pos();
-			cur.setCurrentFont();
-		}
+		// We're leaving an inset, going right. If the inset is RTL, we're 
+		// leaving from the front, so we should not move (remain at --- but
+		// not in --- the inset). If the inset is LTR, move right, without 
+		// entering the inset itself; i.e., move to after the inset.
+		if (!cur.paragraph().getFontSettings(
+				cur.bv().buffer().params(), cur.pos()).isRightToLeft())
+			cursorVisRight(cur, true);
 		break;
 
 	case LFUN_FINISHED_BACKWARD:
@@ -1597,7 +1645,8 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 		params2string(cur.paragraph(), data);
 
 		// Will the paragraph accept changes from the dialog?
-		bool const accept = !cur.inset().forceDefaultParagraphs(cur.idx());
+		bool const accept = 
+			cur.inset().allowParagraphCustomization(cur.idx());
 
 		data = "update " + convert<string>(accept) + '\n' + data;
 		bv->updateDialog("paragraph", data);
@@ -1615,7 +1664,6 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 	case LFUN_ACCENT_UNDERDOT:
 	case LFUN_ACCENT_UNDERBAR:
 	case LFUN_ACCENT_CARON:
-	case LFUN_ACCENT_SPECIAL_CARON:
 	case LFUN_ACCENT_BREVE:
 	case LFUN_ACCENT_TIE:
 	case LFUN_ACCENT_HUNGARIAN_UMLAUT:
@@ -1627,8 +1675,8 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 			bv->translateAndInsert(cmd.argument()[0], this, cur);
 		break;
 
-	case LFUN_FLOAT_LIST: {
-		TextClass const & tclass = bv->buffer().params().getTextClass();
+	case LFUN_FLOAT_LIST_INSERT: {
+		DocumentClass const & tclass = bv->buffer().params().documentClass();
 		if (tclass.floats().typeExist(to_utf8(cmd.argument()))) {
 			cur.recordUndo();
 			if (cur.selection())
@@ -1640,10 +1688,19 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 				breakParagraph(cur);
 			}
 
-			setLayout(cur, tclass.defaultLayoutName());
+			docstring const laystr = cur.inset().usePlainLayout() ?
+				tclass.plainLayoutName() :
+				tclass.defaultLayoutName();
+			setLayout(cur, laystr);
 			ParagraphParameters p;
+			// FIXME If this call were replaced with one to clearParagraphParams(),
+			// then we could get rid of this method altogether.
 			setParagraphs(cur, p);
-			insertInset(cur, new InsetFloatList(to_utf8(cmd.argument())));
+			// FIXME This should be simplified when InsetFloatList takes a 
+			// Buffer in its constructor.
+			InsetFloatList * ifl = new InsetFloatList(to_utf8(cmd.argument()));
+			ifl->setBuffer(bv->buffer());
+			insertInset(cur, ifl);
 			cur.posForward();
 		} else {
 			lyxerr << "Non-existent float type: "
@@ -1757,16 +1814,11 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 	// FIXME: the following code should go in favor of fine grained
 	// update flag treatment.
 	if (singleParUpdate) {
-		// 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 so, update _only_ this paragraph
-			cur.updateFlags(Update::SinglePar |
-				Update::FitCursor);
-			return;
-		}
-		needsUpdate = true;
+		// Inserting characters does not change par height in general. So, try
+		// to update _only_ this paragraph. BufferView will detect if a full
+		// metrics update is needed anyway.
+		cur.updateFlags(Update::SinglePar | Update::FitCursor);
+		return;
 	}
 
 	if (!needsUpdate
@@ -1792,7 +1844,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 bool Text::getStatus(Cursor & cur, FuncRequest const & cmd,
 			FuncStatus & flag) const
 {
-	BOOST_ASSERT(cur.text() == this);
+	LASSERT(cur.text() == this, /**/);
 
 	Font const & font = cur.real_current_font;
 	FontInfo const & fontinfo = font.fontInfo();
@@ -1811,11 +1863,6 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd,
 
 	case LFUN_APPENDIX:
 		flag.setOnOff(cur.paragraph().params().startOfAppendix());
-		return true;
-
-	case LFUN_BIBITEM_INSERT:
-		enable = (cur.paragraph().layout()->labeltype == LABEL_BIBLIO
-			  && cur.pos() == 0);
 		break;
 
 	case LFUN_DIALOG_SHOW_NEW_INSET:
@@ -1851,6 +1898,8 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd,
 			code = NOTE_CODE;
 		else if (cmd.argument() == "ref")
 			code = REF_CODE;
+		else if (cmd.argument() == "space")
+			code = SPACE_CODE;
 		else if (cmd.argument() == "toc")
 			code = TOC_CODE;
 		else if (cmd.argument() == "vspace")
@@ -1865,7 +1914,7 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd,
 		code = ERT_CODE;
 		break;
 	case LFUN_LISTING_INSERT:
-	    code = LISTINGS_CODE;
+		code = LISTINGS_CODE;
 		break;
 	case LFUN_FOOTNOTE_INSERT:
 		code = FOOT_CODE;
@@ -1883,31 +1932,27 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd,
 	case LFUN_WRAP_INSERT:
 		code = WRAP_CODE;
 		break;
-	case LFUN_FLOAT_LIST:
+	case LFUN_FLOAT_LIST_INSERT:
 		code = FLOAT_LIST_CODE;
 		break;
-#if 0
-	case LFUN_LIST_INSERT:
-		code = LIST_CODE;
-		break;
-	case LFUN_THEOREM_INSERT:
-		code = THEOREM_CODE;
-		break;
-#endif
 	case LFUN_CAPTION_INSERT:
 		code = CAPTION_CODE;
 		break;
 	case LFUN_NOTE_INSERT:
 		code = NOTE_CODE;
+		// in commands (sections etc., only Notes are allowed)
+		enable = (cmd.argument().empty() || cmd.getArg(0) == "Note" ||
+			  !cur.paragraph().layout().isCommand());
 		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")
+		InsetLayout il = 
+			cur.buffer().params().documentClass().insetLayout(from_utf8(s));
+		if (il.lyxtype() != "charstyle" &&
+		    il.lyxtype() != "custom" &&
+		    il.lyxtype() != "element" &&
+		    il.lyxtype ()!= "standard")
 			enable = false;
 		break;
 		}
@@ -1928,10 +1973,7 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd,
 	case LFUN_OPTIONAL_INSERT:
 		code = OPTARG_CODE;
 		enable = cur.paragraph().insetList().count(OPTARG_CODE)
-			< cur.paragraph().layout()->optionalargs;
-		break;
-	case LFUN_ENVIRONMENT_INSERT:
-		code = BOX_CODE;
+			< cur.paragraph().layout().optionalargs;
 		break;
 	case LFUN_INDEX_INSERT:
 		code = INDEX_CODE;
@@ -1940,6 +1982,10 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd,
 		code = INDEX_PRINT_CODE;
 		break;
 	case LFUN_NOMENCL_INSERT:
+		if (cur.selIsMultiCell() || cur.selIsMultiLine()) {
+			enable = false;
+			break;
+		}
 		code = NOMENCL_CODE;
 		break;
 	case LFUN_NOMENCL_PRINT:
@@ -1949,13 +1995,16 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd,
 		code = TOC_CODE;
 		break;
 	case LFUN_HYPERLINK_INSERT:
+		if (cur.selIsMultiCell() || cur.selIsMultiLine()) {
+			enable = false;
+			break;
+		}
 		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_HFILL_INSERT:
 	case LFUN_SPECIALCHAR_INSERT:
 		code = SPECIALCHAR_CODE;
 		break;
@@ -1975,49 +2024,64 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd,
 
 	case LFUN_FONT_EMPH:
 		flag.setOnOff(fontinfo.emph() == FONT_ON);
-		return true;
+		break;
 
 	case LFUN_FONT_NOUN:
 		flag.setOnOff(fontinfo.noun() == FONT_ON);
-		return true;
+		break;
 
 	case LFUN_FONT_BOLD:
 		flag.setOnOff(fontinfo.series() == BOLD_SERIES);
-		return true;
+		break;
 
 	case LFUN_FONT_SANS:
 		flag.setOnOff(fontinfo.family() == SANS_FAMILY);
-		return true;
+		break;
 
 	case LFUN_FONT_ROMAN:
 		flag.setOnOff(fontinfo.family() == ROMAN_FAMILY);
-		return true;
+		break;
 
 	case LFUN_FONT_TYPEWRITER:
 		flag.setOnOff(fontinfo.family() == TYPEWRITER_FAMILY);
-		return true;
+		break;
 
 	case LFUN_CUT:
 	case LFUN_COPY:
 		enable = cur.selection();
 		break;
 
-	case LFUN_PASTE:
+	case LFUN_PASTE: {
 		if (cmd.argument().empty()) {
 			if (theClipboard().isInternal())
 				enable = cap::numberOfSelections() > 0;
 			else
 				enable = !theClipboard().empty();
-		} else {
-			string const arg = to_utf8(cmd.argument());
-			if (isStrUnsignedInt(arg)) {
-				unsigned int n = convert<unsigned int>(arg);
-				enable = cap::numberOfSelections() > n;
-			} else
-				// unknown argument
-				enable = false;
+			break;
+		}
+		
+		// we have an argument
+		string const arg = to_utf8(cmd.argument());
+		if (isStrUnsignedInt(arg)) {
+			// it's a number and therefore means the internal stack
+			unsigned int n = convert<unsigned int>(arg);
+			enable = cap::numberOfSelections() > n;
+			break;
+		}
+		
+		// explicit graphics type?
+		if ((arg == "pdf" && theClipboard().hasGraphicsContents(Clipboard::PdfGraphicsType))
+		    || (arg == "png" && theClipboard().hasGraphicsContents(Clipboard::PngGraphicsType))
+		    || (arg == "jpeg" && theClipboard().hasGraphicsContents(Clipboard::JpegGraphicsType))
+		    || (arg == "linkback" && theClipboard().hasGraphicsContents(Clipboard::LinkBackGraphicsType))) {
+			enable = true;
+			break;
 		}
+		
+		// unknown argument
+		enable = false;
 		break;
+	 }
 
 	case LFUN_CLIPBOARD_PASTE:
 		enable = !theClipboard().empty();
@@ -2039,7 +2103,7 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd,
 		if (!cmd.argument().empty()) {
 			InsetLayout il = cur.inset().getLayout(cur.buffer().params());
 			enable = cur.inset().lyxCode() == FLEX_CODE
-			         && il.lyxtype == to_utf8(cmd.argument());
+			         && il.lyxtype() == to_utf8(cmd.argument());
 		} else {
 			enable = !isMainText(cur.bv().buffer()) 
 			         && cur.inset().nargs() == 1;
@@ -2061,9 +2125,25 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd,
 	case LFUN_OUTLINE_DOWN:
 	case LFUN_OUTLINE_IN:
 	case LFUN_OUTLINE_OUT:
-		enable = (cur.paragraph().layout()->toclevel != Layout::NOT_IN_TOC);
+		// FIXME: LyX is not ready for outlining within inset.
+		enable = isMainText(cur.bv().buffer())
+			&& cur.paragraph().layout().toclevel != Layout::NOT_IN_TOC;
 		break;
 
+	case LFUN_NEWLINE_INSERT:
+		// LaTeX restrictions (labels or empty par)
+		enable = (cur.pos() > cur.paragraph().beginOfBody());
+		break;
+
+	case LFUN_SET_GRAPHICS_GROUP: {
+		InsetGraphics * ins = graphics::getCurrentGraphicsInset(cur);
+		if (!ins) 
+			enable = false;
+		else
+			flag.setOnOff(to_utf8(cmd.argument()) == ins->getParams().groupId);
+		break;
+	}
+
 	case LFUN_WORD_DELETE_FORWARD:
 	case LFUN_WORD_DELETE_BACKWARD:
 	case LFUN_LINE_DELETE:
@@ -2085,8 +2165,6 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd,
 	case LFUN_DOWN_SELECT:
 	case LFUN_PARAGRAPH_UP_SELECT:
 	case LFUN_PARAGRAPH_DOWN_SELECT:
-	case LFUN_SCREEN_UP_SELECT:
-	case LFUN_SCREEN_DOWN_SELECT:
 	case LFUN_LINE_BEGIN_SELECT:
 	case LFUN_LINE_END_SELECT:
 	case LFUN_WORD_FORWARD_SELECT:
@@ -2097,15 +2175,10 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd,
 	case LFUN_PARAGRAPH_UP:
 	case LFUN_PARAGRAPH_DOWN:
 	case LFUN_LINE_BEGIN:
-	case LFUN_LINE_BREAK:
 	case LFUN_LINE_END:
-	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_SKIP:
 	case LFUN_PARAGRAPH_SPACING:
 	case LFUN_INSET_INSERT:
 	case LFUN_WORD_UPCASE:
@@ -2114,18 +2187,13 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd,
 	case LFUN_CHARS_TRANSPOSE:
 	case LFUN_SERVER_GET_XY:
 	case LFUN_SERVER_SET_XY:
-	case LFUN_SERVER_GET_FONT:
 	case LFUN_SERVER_GET_LAYOUT:
 	case LFUN_LAYOUT:
 	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:
 	case LFUN_MATH_DISPLAY:
-	case LFUN_MATH_IMPORT_SELECTION:
 	case LFUN_MATH_MODE:
 	case LFUN_MATH_MACRO:
 	case LFUN_MATH_MATRIX:
@@ -2138,8 +2206,8 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd,
 	case LFUN_FONT_UNDERLINE:
 	case LFUN_FONT_SIZE:
 	case LFUN_LANGUAGE:
-	case LFUN_FONT_FREE_APPLY:
-	case LFUN_FONT_FREE_UPDATE:
+	case LFUN_TEXTSTYLE_APPLY:
+	case LFUN_TEXTSTYLE_UPDATE:
 	case LFUN_LAYOUT_PARAGRAPH:
 	case LFUN_PARAGRAPH_UPDATE:
 	case LFUN_ACCENT_UMLAUT:
@@ -2153,7 +2221,6 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd,
 	case LFUN_ACCENT_UNDERDOT:
 	case LFUN_ACCENT_UNDERBAR:
 	case LFUN_ACCENT_CARON:
-	case LFUN_ACCENT_SPECIAL_CARON:
 	case LFUN_ACCENT_BREVE:
 	case LFUN_ACCENT_TIE:
 	case LFUN_ACCENT_HUNGARIAN_UMLAUT:
@@ -2180,7 +2247,7 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd,
 	    && (cur.empty() || !cur.inset().insetAllowed(code)))
 		enable = false;
 
-	flag.enabled(enable);
+	flag.setEnabled(enable);
 	return true;
 }