X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FText3.cpp;h=4c1d07bf46720cc8141b32cc79ba8a6034e76647;hb=55a3dd7b346d29a52ba305a4558e9e380ef50f47;hp=704adceac62febde4f794668ebcb5b3a94fd0360;hpb=bb69584112dd31dacb39b387781a9d00af9c7a57;p=lyx.git

diff --git a/src/Text3.cpp b/src/Text3.cpp
index 704adceac6..4c1d07bf46 100644
--- a/src/Text3.cpp
+++ b/src/Text3.cpp
@@ -45,7 +45,6 @@
 #include "SpellChecker.h"
 #include "TextClass.h"
 #include "TextMetrics.h"
-#include "VSpace.h"
 #include "WordLangTuple.h"
 
 #include "frontends/Application.h"
@@ -68,6 +67,7 @@
 #include "support/convert.h"
 #include "support/debug.h"
 #include "support/gettext.h"
+#include "support/lassert.h"
 #include "support/lstrings.h"
 #include "support/lyxtime.h"
 #include "support/os.h"
@@ -93,6 +93,7 @@ using cap::pasteClipboardGraphics;
 using cap::replaceSelection;
 using cap::grabAndEraseSelection;
 using cap::selClearOrDel;
+using cap::pasteSimpleText;
 
 // globals...
 static Font freefont(ignore_font, ignore_language);
@@ -198,7 +199,7 @@ static void mathDispatch(Cursor & cur, FuncRequest const & cmd, bool display)
 
 void regexpDispatch(Cursor & cur, FuncRequest const & cmd)
 {
-	LASSERT(cmd.action == LFUN_REGEXP_MODE, return);
+	LASSERT(cmd.action() == LFUN_REGEXP_MODE, return);
 	if (cur.inRegexped()) {
 		cur.message(_("Already in regular expression mode"));
 		return;
@@ -239,14 +240,17 @@ static bool doInsertInset(Cursor & cur, Text * text,
 		ci->setButtonLabel();
 
 	cur.recordUndo();
-	if (cmd.action == LFUN_INDEX_INSERT) {
+	if (cmd.action() == LFUN_INDEX_INSERT) {
 		docstring ds = subst(text->getStringToIndex(cur), '\n', ' ');
 		text->insertInset(cur, inset);
 		if (edit)
 			inset->edit(cur, true);
 		// Now put this into inset
-		cur.text()->insertStringAsLines(cur, ds, cur.current_font);
-		cur.leaveInset(*inset);
+		Font const f(inherit_font, cur.current_font.language());
+		if (!ds.empty()) {
+			cur.text()->insertStringAsLines(cur, ds, f);
+			cur.leaveInset(*inset);
+		}
 		return true;
 	}
 
@@ -268,10 +272,10 @@ static bool doInsertInset(Cursor & cur, Text * text,
 	cur.buffer()->errors("Paste");
 	cur.clearSelection(); // bug 393
 	cur.finishUndo();
-	InsetText * insetText = dynamic_cast<InsetText *>(inset);
-	if (insetText) {
-		insetText->fixParagraphsFont();
-		if (!insetText->allowMultiPar() || cur.lastpit() == 0) {
+	InsetText * inset_text = inset->asInsetText();
+	if (inset_text) {
+		inset_text->fixParagraphsFont();
+		if (!inset_text->allowMultiPar() || cur.lastpit() == 0) {
 			// reset first par to default
 			cur.text()->paragraphs().begin()
 				->setPlainOrDefaultLayout(bparams.documentClass());
@@ -464,29 +468,32 @@ void Text::dispatch(Cursor & cur, FuncRequest & 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
 	// at the end?
-	cur.noUpdate();
+	cur.noScreenUpdate();
 
 	LASSERT(cur.text() == this, /**/);
-	CursorSlice oldTopSlice = cur.top();
-	bool oldBoundary = cur.boundary();
-	bool sel = cur.selection();
+	CursorSlice const oldTopSlice = cur.top();
+	bool const oldBoundary = cur.boundary();
+	bool const oldSelection = cur.selection();
 	// Signals that, even if needsUpdate == false, an update of the
 	// cursor paragraph is required
-	bool singleParUpdate = lyxaction.funcHasFlag(cmd.action,
+	bool singleParUpdate = lyxaction.funcHasFlag(cmd.action(),
 		LyXAction::SingleParUpdate);
 	// Signals that a full-screen update is required
-	bool needsUpdate = !(lyxaction.funcHasFlag(cmd.action,
+	bool needsUpdate = !(lyxaction.funcHasFlag(cmd.action(),
 		LyXAction::NoUpdate) || singleParUpdate);
-
-	switch (cmd.action) {
+	bool const last_misspelled = lyxrc.spellcheck_continuously
+		&& cur.paragraph().isMisspelled(cur.pos(), true);
+	
+	FuncCode const act = cmd.action();
+	switch (act) {
 
 	case LFUN_PARAGRAPH_MOVE_DOWN: {
 		pit_type const pit = cur.pit();
 		recUndo(cur, pit, pit + 1);
 		cur.finishUndo();
 		pars_.swap(pit, pit + 1);
-		cur.buffer()->updateBuffer();
 		needsUpdate = true;
+		cur.forceBufferUpdate();
 		++cur.pit();
 		break;
 	}
@@ -496,9 +503,9 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 		recUndo(cur, pit - 1, pit);
 		cur.finishUndo();
 		pars_.swap(pit, pit - 1);
-		cur.buffer()->updateBuffer();
 		--cur.pit();
 		needsUpdate = true;
+		cur.forceBufferUpdate();
 		break;
 	}
 
@@ -522,7 +529,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 		par.params().startOfAppendix(start);
 
 		// we can set the refreshing parameters now
-		cur.buffer()->updateBuffer();
+		cur.forceBufferUpdate();
 		break;
 	}
 
@@ -552,42 +559,42 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 
 	case LFUN_BUFFER_BEGIN:
 	case LFUN_BUFFER_BEGIN_SELECT:
-		needsUpdate |= cur.selHandle(cmd.action == LFUN_BUFFER_BEGIN_SELECT);
+		needsUpdate |= cur.selHandle(act == LFUN_BUFFER_BEGIN_SELECT);
 		if (cur.depth() == 1)
 			needsUpdate |= cursorTop(cur);
 		else
 			cur.undispatched();
-		cur.updateFlags(Update::FitCursor);
+		cur.screenUpdateFlags(Update::FitCursor);
 		break;
 
 	case LFUN_BUFFER_END:
 	case LFUN_BUFFER_END_SELECT:
-		needsUpdate |= cur.selHandle(cmd.action == LFUN_BUFFER_END_SELECT);
+		needsUpdate |= cur.selHandle(act == LFUN_BUFFER_END_SELECT);
 		if (cur.depth() == 1)
 			needsUpdate |= cursorBottom(cur);
 		else
 			cur.undispatched();
-		cur.updateFlags(Update::FitCursor);
+		cur.screenUpdateFlags(Update::FitCursor);
 		break;
 
 	case LFUN_INSET_BEGIN:
 	case LFUN_INSET_BEGIN_SELECT:
-		needsUpdate |= cur.selHandle(cmd.action == LFUN_INSET_BEGIN_SELECT);
+		needsUpdate |= cur.selHandle(act == LFUN_INSET_BEGIN_SELECT);
 		if (cur.depth() == 1 || !cur.top().at_begin())
 			needsUpdate |= cursorTop(cur);
 		else
 			cur.undispatched();
-		cur.updateFlags(Update::FitCursor);
+		cur.screenUpdateFlags(Update::FitCursor);
 		break;
 
 	case LFUN_INSET_END:
 	case LFUN_INSET_END_SELECT:
-		needsUpdate |= cur.selHandle(cmd.action == LFUN_INSET_END_SELECT);
+		needsUpdate |= cur.selHandle(act == LFUN_INSET_END_SELECT);
 		if (cur.depth() == 1 || !cur.top().at_end())
 			needsUpdate |= cursorBottom(cur);
 		else
 			cur.undispatched();
-		cur.updateFlags(Update::FitCursor);
+		cur.screenUpdateFlags(Update::FitCursor);
 		break;
 
 	case LFUN_INSET_SELECT_ALL:
@@ -599,13 +606,13 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 			needsUpdate |= cursorBottom(cur);
 		} else 
 			cur.undispatched();
-		cur.updateFlags(Update::FitCursor);
+		cur.screenUpdateFlags(Update::FitCursor);
 		break;
 
 	case LFUN_CHAR_FORWARD:
 	case LFUN_CHAR_FORWARD_SELECT:
 		//LYXERR0(" LFUN_CHAR_FORWARD[SEL]:\n" << cur);
-		needsUpdate |= cur.selHandle(cmd.action == LFUN_CHAR_FORWARD_SELECT);
+		needsUpdate |= cur.selHandle(act == LFUN_CHAR_FORWARD_SELECT);
 		needsUpdate |= cursorForward(cur);
 
 		if (!needsUpdate && oldTopSlice == cur.top()
@@ -623,7 +630,12 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 				// provide it with two different cursors.
 				Cursor dummy = cur;
 				dummy.pos() = dummy.pit() = 0;
-				cur.bv().checkDepm(dummy, cur);
+				if (cur.bv().checkDepm(dummy, cur)) {
+					cur.forceBufferUpdate();
+					// DEPM may have requested a screen update
+					cur.screenUpdateFlags(
+						cur.screenUpdate() | dummy.screenUpdate());
+				}
 			}
 		}
 		break;
@@ -631,7 +643,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 	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);
+		needsUpdate |= cur.selHandle(act == LFUN_CHAR_BACKWARD_SELECT);
 		needsUpdate |= cursorBackward(cur);
 
 		if (!needsUpdate && oldTopSlice == cur.top()
@@ -649,7 +661,12 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 				Cursor dummy = cur;
 				dummy.pos() = cur.lastpos();
 				dummy.pit() = cur.lastpit();
-				cur.bv().checkDepm(dummy, cur);
+				if (cur.bv().checkDepm(dummy, cur)) {
+					cur.forceBufferUpdate();
+					// DEPM may have requested a screen update
+					cur.screenUpdateFlags(
+						cur.screenUpdate() | dummy.screenUpdate());
+				}
 			}
 		}
 		break;
@@ -657,7 +674,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 	case LFUN_CHAR_LEFT:
 	case LFUN_CHAR_LEFT_SELECT:
 		if (lyxrc.visual_cursor) {
-			needsUpdate |= cur.selHandle(cmd.action == LFUN_CHAR_LEFT_SELECT);
+			needsUpdate |= cur.selHandle(act == LFUN_CHAR_LEFT_SELECT);
 			needsUpdate |= cursorVisLeft(cur);
 			if (!needsUpdate && oldTopSlice == cur.top()
 					&& cur.boundary() == oldBoundary) {
@@ -666,11 +683,11 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 			}
 		} else {
 			if (reverseDirectionNeeded(cur)) {
-				cmd.action = cmd.action == LFUN_CHAR_LEFT_SELECT ?
-					LFUN_CHAR_FORWARD_SELECT : LFUN_CHAR_FORWARD;
+				cmd.setAction(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;
+				cmd.setAction(cmd.action() == LFUN_CHAR_LEFT_SELECT ?
+					LFUN_CHAR_BACKWARD_SELECT : LFUN_CHAR_BACKWARD);
 			}
 			dispatch(cur, cmd);
 			return;
@@ -680,7 +697,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 	case LFUN_CHAR_RIGHT:
 	case LFUN_CHAR_RIGHT_SELECT:
 		if (lyxrc.visual_cursor) {
-			needsUpdate |= cur.selHandle(cmd.action == LFUN_CHAR_RIGHT_SELECT);
+			needsUpdate |= cur.selHandle(cmd.action() == LFUN_CHAR_RIGHT_SELECT);
 			needsUpdate |= cursorVisRight(cur);
 			if (!needsUpdate && oldTopSlice == cur.top()
 					&& cur.boundary() == oldBoundary) {
@@ -689,11 +706,11 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 			}
 		} else {
 			if (reverseDirectionNeeded(cur)) {
-				cmd.action = cmd.action == LFUN_CHAR_RIGHT_SELECT ?
-					LFUN_CHAR_BACKWARD_SELECT : LFUN_CHAR_BACKWARD;
+				cmd.setAction(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;
+				cmd.setAction(cmd.action() == LFUN_CHAR_RIGHT_SELECT ?
+					LFUN_CHAR_FORWARD_SELECT : LFUN_CHAR_FORWARD);
 			}
 			dispatch(cur, cmd);
 			return;
@@ -706,11 +723,11 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 	case LFUN_UP:
 	case LFUN_DOWN: {
 		// stop/start the selection
-		bool select = cmd.action == LFUN_DOWN_SELECT ||
-			cmd.action == LFUN_UP_SELECT;
+		bool select = cmd.action() == LFUN_DOWN_SELECT ||
+			cmd.action() == LFUN_UP_SELECT;
 
 		// move cursor up/down
-		bool up = cmd.action == LFUN_UP_SELECT || cmd.action == LFUN_UP;
+		bool up = cmd.action() == LFUN_UP_SELECT || cmd.action() == LFUN_UP;
 		bool const atFirstOrLastRow = cur.atFirstOrLastRow(up);
 
 		if (!atFirstOrLastRow) {
@@ -732,25 +749,25 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 
 	case LFUN_PARAGRAPH_UP:
 	case LFUN_PARAGRAPH_UP_SELECT:
-		needsUpdate |= cur.selHandle(cmd.action == LFUN_PARAGRAPH_UP_SELECT);
+		needsUpdate |= cur.selHandle(cmd.action() == LFUN_PARAGRAPH_UP_SELECT);
 		needsUpdate |= cursorUpParagraph(cur);
 		break;
 
 	case LFUN_PARAGRAPH_DOWN:
 	case LFUN_PARAGRAPH_DOWN_SELECT:
-		needsUpdate |= cur.selHandle(cmd.action == LFUN_PARAGRAPH_DOWN_SELECT);
+		needsUpdate |= cur.selHandle(cmd.action() == LFUN_PARAGRAPH_DOWN_SELECT);
 		needsUpdate |= cursorDownParagraph(cur);
 		break;
 
 	case LFUN_LINE_BEGIN:
 	case LFUN_LINE_BEGIN_SELECT:
-		needsUpdate |= cur.selHandle(cmd.action == LFUN_LINE_BEGIN_SELECT);
+		needsUpdate |= cur.selHandle(cmd.action() == LFUN_LINE_BEGIN_SELECT);
 		needsUpdate |= tm->cursorHome(cur);
 		break;
 
 	case LFUN_LINE_END:
 	case LFUN_LINE_END_SELECT:
-		needsUpdate |= cur.selHandle(cmd.action == LFUN_LINE_END_SELECT);
+		needsUpdate |= cur.selHandle(cmd.action() == LFUN_LINE_END_SELECT);
 		needsUpdate |= tm->cursorEnd(cur);
 		break;
 
@@ -792,7 +809,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 	case LFUN_WORD_RIGHT:
 	case LFUN_WORD_RIGHT_SELECT:
 		if (lyxrc.visual_cursor) {
-			needsUpdate |= cur.selHandle(cmd.action == LFUN_WORD_RIGHT_SELECT);
+			needsUpdate |= cur.selHandle(cmd.action() == LFUN_WORD_RIGHT_SELECT);
 			needsUpdate |= cursorVisRightOneWord(cur);
 			if (!needsUpdate && oldTopSlice == cur.top()
 					&& cur.boundary() == oldBoundary) {
@@ -801,11 +818,11 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 			}
 		} else {
 			if (reverseDirectionNeeded(cur)) {
-				cmd.action = cmd.action == LFUN_WORD_RIGHT_SELECT ?
-						LFUN_WORD_BACKWARD_SELECT : LFUN_WORD_BACKWARD;
+				cmd.setAction(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;
+				cmd.setAction(cmd.action() == LFUN_WORD_RIGHT_SELECT ?
+						LFUN_WORD_FORWARD_SELECT : LFUN_WORD_FORWARD);
 			}
 			dispatch(cur, cmd);
 			return;
@@ -814,14 +831,38 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 
 	case LFUN_WORD_FORWARD:
 	case LFUN_WORD_FORWARD_SELECT:
-		needsUpdate |= cur.selHandle(cmd.action == LFUN_WORD_FORWARD_SELECT);
+		needsUpdate |= cur.selHandle(cmd.action() == LFUN_WORD_FORWARD_SELECT);
 		needsUpdate |= cursorForwardOneWord(cur);
+
+		if (!needsUpdate && oldTopSlice == cur.top()
+				&& cur.boundary() == oldBoundary) {
+			cur.undispatched();
+			cmd = FuncRequest(LFUN_FINISHED_FORWARD);
+		
+			// we will probably be moving out the inset, so we should execute
+			// the depm-mechanism, but only when the cursor has a place to 
+			// go outside this inset, i.e. in a slice above.
+			if (cur.depth() > 1 && cur.pos() == cur.lastpos() 
+				  && cur.pit() == cur.lastpit()) {
+				// The cursor hasn't changed yet. To give the 
+				// DEPM the possibility of doing something we must
+				// provide it with two different cursors.
+				Cursor dummy = cur;
+				dummy.pos() = dummy.pit() = 0;
+				if (cur.bv().checkDepm(dummy, cur)) {
+					cur.forceBufferUpdate();
+					// DEPM may have requested a screen update
+					cur.screenUpdateFlags(
+						cur.screenUpdate() | dummy.screenUpdate());
+				}
+			}
+		}
 		break;
 
 	case LFUN_WORD_LEFT:
 	case LFUN_WORD_LEFT_SELECT:
 		if (lyxrc.visual_cursor) {
-			needsUpdate |= cur.selHandle(cmd.action == LFUN_WORD_LEFT_SELECT);
+			needsUpdate |= cur.selHandle(cmd.action() == LFUN_WORD_LEFT_SELECT);
 			needsUpdate |= cursorVisLeftOneWord(cur);
 			if (!needsUpdate && oldTopSlice == cur.top()
 					&& cur.boundary() == oldBoundary) {
@@ -830,11 +871,11 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 			}
 		} else {
 			if (reverseDirectionNeeded(cur)) {
-				cmd.action = cmd.action == LFUN_WORD_LEFT_SELECT ?
-						LFUN_WORD_FORWARD_SELECT : LFUN_WORD_FORWARD;
+				cmd.setAction(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;
+				cmd.setAction(cmd.action() == LFUN_WORD_LEFT_SELECT ?
+						LFUN_WORD_BACKWARD_SELECT : LFUN_WORD_BACKWARD);
 			}
 			dispatch(cur, cmd);
 			return;
@@ -843,8 +884,33 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 
 	case LFUN_WORD_BACKWARD:
 	case LFUN_WORD_BACKWARD_SELECT:
-		needsUpdate |= cur.selHandle(cmd.action == LFUN_WORD_BACKWARD_SELECT);
+		needsUpdate |= cur.selHandle(cmd.action() == LFUN_WORD_BACKWARD_SELECT);
 		needsUpdate |= cursorBackwardOneWord(cur);
+	
+		if (!needsUpdate && oldTopSlice == cur.top()
+				&& cur.boundary() == oldBoundary) {
+			cur.undispatched();
+			cmd = FuncRequest(LFUN_FINISHED_BACKWARD);
+		
+			// we will probably be moving out the inset, so we should execute
+			// the depm-mechanism, but only when the cursor has a place to 
+			// go outside this inset, i.e. in a slice above.
+			if (cur.depth() > 1 && cur.pos() == 0 
+				  && cur.pit() == 0) {
+				// The cursor hasn't changed yet. To give the 
+				// DEPM the possibility of doing something we must
+				// provide it with two different cursors.
+				Cursor dummy = cur;
+				dummy.pos() = cur.lastpos();
+				dummy.pit() = cur.lastpit();
+				if (cur.bv().checkDepm(dummy, cur)) {
+					cur.forceBufferUpdate();
+					// DEPM may have requested a screen update
+					cur.screenUpdateFlags(
+						cur.screenUpdate() | dummy.screenUpdate());
+				}
+			}
+		}
 		break;
 
 	case LFUN_WORD_SELECT: {
@@ -884,8 +950,8 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 						      bv->buffer().params().trackChanges);
 				// Update the selection pos to make sure the selection does not
 				// change as the inserted tab will increase the logical pos.
-				if (cur.anchor_.pit() == pit)
-					cur.anchor_.forwardPos();
+				if (cur.realAnchor().pit() == pit)
+					cur.realAnchor().forwardPos();
 				if (cur.pit() == pit)
 					cur.forwardPos();
 			}
@@ -908,24 +974,22 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 			pit_type const pit_end = cur.selEnd().pit();
 			for (pit_type pit = cur.selBegin().pit(); pit <= pit_end; pit++) {
 				Paragraph & par = paragraphs()[pit];
-				if (par.getChar(0) == '\t') {
-					if (cur.pit() == pit)
-						cur.posBackward();
-					if (cur.anchor_.pit() == pit && cur.anchor_.pos() > 0 )
-						cur.anchor_.backwardPos();
-					
-					par.eraseChar(0, tc);
-				} else 
-					// If no tab was present, try to remove up to four spaces.
-					for (int n_spaces = 0;
-					     par.getChar(0) == ' ' && n_spaces < 4; ++n_spaces) {
+				if (par.empty())
+					continue;
+				char_type const c = par.getChar(0);
+				if (c == '\t' || c == ' ') {
+					// remove either 1 tab or 4 spaces.
+					int const n = (c == ' ' ? 4 : 1);
+					for (int i = 0; i < n 
+						  && !par.empty() && par.getChar(0) == c; ++i) {
 						if (cur.pit() == pit)
 							cur.posBackward();
-						if (cur.anchor_.pit() == pit && cur.anchor_.pos() > 0 )
-							cur.anchor_.backwardPos();
-						
+						if (cur.realAnchor().pit() == pit 
+							  && cur.realAnchor().pos() > 0 )
+							cur.realAnchor().backwardPos();
 						par.eraseChar(0, tc);
 					}
+				}
 			}
 			cur.finishUndo();
 		} else {
@@ -1031,7 +1095,10 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 			if (cur.selection())
 				cutSelection(cur, true, false);
 			cur.insert(inset);
-			cur.posForward();
+			if (inset->editable() && inset->asInsetText())
+				inset->edit(cur, true);
+			else
+				cur.posForward();
 
 			// trigger InstantPreview now
 			if (inset->lyxCode() == EXTERNAL_CODE) {
@@ -1045,8 +1112,10 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 	}
 
 	case LFUN_INSET_DISSOLVE: {
-		if (dissolveInset(cur))
+		if (dissolveInset(cur)) {
 			needsUpdate = true;
+			cur.forceBufferUpdate();
+		}
 		break;
 	}
 
@@ -1268,6 +1337,11 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 		bv->buffer().errors("Paste");
 		break;
 
+	case LFUN_CLIPBOARD_PASTE_SIMPLE:
+		cur.clearSelection();
+		pasteSimpleText(cur, cmd.argument() == "paragraph");
+		break;
+
 	case LFUN_PRIMARY_SELECTION_PASTE:
 		pasteString(cur, theSelection().get(),
 			    cmd.argument() == "paragraph");
@@ -1298,33 +1372,34 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 	}
 
 	case LFUN_QUOTE_INSERT: {
-		Paragraph & par = cur.paragraph();
+		// this avoids a double undo
+		// FIXME: should not be needed, ideally
+		if (!cur.selection())
+			cur.recordUndo();
+		cap::replaceSelection(cur);
+
+		Paragraph const & par = cur.paragraph();
 		pos_type pos = cur.pos();
+
 		BufferParams const & bufparams = bv->buffer().params();
-		Layout const & style = par.layout();
-		InsetLayout const & ilayout = cur.inset().getLayout();
-		if (!style.pass_thru && !ilayout.isPassThru()
-		    && par.getFontSettings(bufparams, pos).language()->lang() != "hebrew") {
-			// this avoids a double undo
-			// FIXME: should not be needed, ideally
-			if (!cur.selection())
-				cur.recordUndo();
-			cap::replaceSelection(cur);
-			pos = cur.pos();
-			char_type c;
-			if (pos == 0)
-				c = ' ';
-			else if (cur.prevInset() && cur.prevInset()->isSpace())
-				c = ' ';
-			else
+		bool const hebrew = 
+			par.getFontSettings(bufparams, pos).language()->lang() == "hebrew";
+		bool const allow_inset_quote = !(par.isPassThru() || hebrew);
+		
+		if (allow_inset_quote) {
+			char_type c = ' ';
+			if (pos > 0 && (!cur.prevInset() || !cur.prevInset()->isSpace()))
 				c = par.getChar(pos - 1);
-			string arg = to_utf8(cmd.argument());
-			cur.insert(new InsetQuotes(cur.buffer(), c, (arg == "single")
-				? InsetQuotes::SingleQuotes : InsetQuotes::DoubleQuotes));
+			string const arg = to_utf8(cmd.argument());
+			InsetQuotes::QuoteTimes const quote_type = (arg == "single")
+				? InsetQuotes::SingleQuotes : InsetQuotes::DoubleQuotes;
+			cur.insert(new InsetQuotes(cur.buffer(), c, quote_type));
 			cur.posForward();
-		}
-		else
+		} else {
+			// The cursor might have been invalidated by the replaceSelection.
+			cur.buffer()->changed(true);
 			lyx::dispatch(FuncRequest(LFUN_SELF_INSERT, "\""));
+		}			
 		break;
 	}
 
@@ -1362,7 +1437,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 		case mouse_button::button1:
 			// Set the cursor
 			if (!bv->mouseSetCursor(cur, cmd.argument() == "region-select"))
-				cur.updateFlags(Update::SinglePar | Update::FitCursor);
+				cur.screenUpdateFlags(Update::SinglePar | Update::FitCursor);
 			if (bvcur.wordSelection())
 				selectWord(bvcur, WHOLE_WORD);
 			break;
@@ -1373,7 +1448,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 			lyx::dispatch(
 				FuncRequest(LFUN_COMMAND_ALTERNATIVES,
 					    "selection-paste ; primary-selection-paste paragraph"));
-			cur.noUpdate();
+			cur.noScreenUpdate();
 			break;
 
 		case mouse_button::button3: {
@@ -1381,11 +1456,11 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 			// selection, a context menu will popup.
 			if (bvcur.selection() && cur >= bvcur.selectionBegin()
 			    && cur < bvcur.selectionEnd()) {
-				cur.noUpdate();
+				cur.noScreenUpdate();
 				return;
 			}
 			if (!bv->mouseSetCursor(cur, false))
-				cur.updateFlags(Update::SinglePar | Update::FitCursor);
+				cur.screenUpdateFlags(Update::SinglePar | Update::FitCursor);
 			break;
 		}
 
@@ -1397,31 +1472,31 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 	case LFUN_MOUSE_MOTION: {
 		// Mouse motion with right or middle mouse do nothing for now.
 		if (cmd.button() != mouse_button::button1) {
-			cur.noUpdate();
+			cur.noScreenUpdate();
 			return;
 		}
 		// ignore motions deeper nested than the real anchor
 		Cursor & bvcur = cur.bv().cursor();
-		if (!bvcur.anchor_.hasPart(cur)) {
+		if (!bvcur.realAnchor().hasPart(cur)) {
 			cur.undispatched();
 			break;
 		}
 		CursorSlice old = bvcur.top();
 
 		int const wh = bv->workHeight();
-		int const y = max(0, 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);
-		if (cmd.y >= wh)
+		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)
+		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)
+			if (cmd.y() >= wh)
 				lyx::dispatch(FuncRequest(LFUN_DOWN_SELECT));
-			else if (cmd.y < 0)
+			else if (cmd.y() < 0)
 				lyx::dispatch(FuncRequest(LFUN_UP_SELECT));
 		}
 		// We continue with our existing selection or start a new one, so don't
@@ -1430,8 +1505,8 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 		bvcur.setSelection(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();
+			cur.screenUpdateFlags(Update::SinglePar | Update::FitCursor);
+			//cur.noScreenUpdate();
 			return;
 		}
 		break;
@@ -1452,23 +1527,23 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 				cur.bv().cursor().setSelection();
 				// We might have removed an empty but drawn selection
 				// (probably a margin)
-				cur.updateFlags(Update::SinglePar | Update::FitCursor);
+				cur.screenUpdateFlags(Update::SinglePar | Update::FitCursor);
 			} else
-				cur.noUpdate();
+				cur.noScreenUpdate();
 			// FIXME: We could try to handle drag and drop of selection here.
 			return;
 
 		case mouse_button::button2:
 			// Middle mouse pasting is handled at mouse press time,
 			// see LFUN_MOUSE_PRESS.
-			cur.noUpdate();
+			cur.noScreenUpdate();
 			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();
+			cur.noScreenUpdate();
 			return;
 
 		case mouse_button::none:
@@ -1501,6 +1576,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 
 		cur.resetAnchor();
 		moveCursor(cur, false);
+		cur.markNewWordPosition();
 		bv->bookmarkEditPosition();
 		break;
 	}
@@ -1514,7 +1590,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 		}
 		p["target"] = (cmd.argument().empty()) ?
 			content : cmd.argument();
-		string const data = InsetCommand::params2string("href", p);
+		string const data = InsetCommand::params2string(p);
 		if (p["target"].empty()) {
 			bv->showDialog("href", data);
 		} else {
@@ -1530,7 +1606,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 		p["name"] = (cmd.argument().empty()) ?
 			cur.getPossibleLabel() :
 			cmd.argument();
-		string const data = InsetCommand::params2string("label", p);
+		string const data = InsetCommand::params2string(p);
 
 		if (cmd.argument().empty()) {
 			bv->showDialog("label", data);
@@ -1569,16 +1645,17 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 	case LFUN_ERT_INSERT:
 	case LFUN_LISTING_INSERT:
 	case LFUN_MARGINALNOTE_INSERT:
-	case LFUN_OPTIONAL_INSERT:
+	case LFUN_ARGUMENT_INSERT:
 	case LFUN_INDEX_INSERT:
 	case LFUN_PREVIEW_INSERT:
+	case LFUN_SCRIPT_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.
-		bv->buffer().updateBuffer();
+		cur.forceBufferUpdate();
 		break;
 
 	case LFUN_TABULAR_INSERT:
@@ -1632,8 +1709,8 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 		// date metrics.
 		FuncRequest cmd_caption(LFUN_CAPTION_INSERT);
 		doInsertInset(cur, cur.text(), cmd_caption, true, false);
-		bv->buffer().updateBuffer();
-		cur.updateFlags(Update::Force);
+		cur.forceBufferUpdate();
+		cur.screenUpdateFlags(Update::Force);
 		// FIXME: When leaving the Float (or Wrap) inset we should
 		// delete any empty paragraph left above or below the
 		// caption.
@@ -1646,7 +1723,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 			p["symbol"] = bv->cursor().innerText()->getStringToIndex(bv->cursor());
 		else
 			p["symbol"] = cmd.argument();
-		string const data = InsetCommand::params2string("nomenclature", p);
+		string const data = InsetCommand::params2string(p);
 		bv->showDialog("nomenclature", data);
 		break;
 	}
@@ -1657,15 +1734,13 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 			p["type"] = from_ascii("idx");
 		else
 			p["type"] = cmd.argument();
-		string const data = InsetCommand::params2string("index_print", p);
+		string const data = InsetCommand::params2string(p);
 		FuncRequest fr(LFUN_INSET_INSERT, data);
 		dispatch(cur, fr);
 		break;
 	}
 	
 	case LFUN_NOMENCL_PRINT:
-	case LFUN_TOC_INSERT:
-	case LFUN_LINE_INSERT:
 	case LFUN_NEWPAGE_INSERT:
 		// do nothing fancy
 		doInsertInset(cur, this, cmd, false, false);
@@ -1691,6 +1766,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 	case LFUN_MATH_MODE:
 		if (cmd.argument() == "on")
 			// don't pass "on" as argument
+			// (it would appear literally in the first cell)
 			mathDispatch(cur, FuncRequest(LFUN_MATH_MODE), false);
 		else
 			mathDispatch(cur, cmd, false);
@@ -1700,6 +1776,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 		if (cmd.argument().empty())
 			cur.errorMessage(from_utf8(N_("Missing argument")));
 		else {
+			cur.recordUndo();
 			string s = to_utf8(cmd.argument());
 			string const s1 = token(s, ' ', 1);
 			int const nargs = s1.empty() ? 0 : convert<int>(s1);
@@ -1838,8 +1915,9 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 		Language const * lang = languages.getLanguage(to_utf8(cmd.argument()));
 		if (!lang)
 			break;
+		selectWordWhenUnderCursor(cur, WHOLE_WORD_STRICT);
 		Font font(ignore_font, lang);
-		toggleAndShow(cur, this, font);
+		toggleAndShow(cur, this, font, false);
 		break;
 	}
 
@@ -1933,10 +2011,11 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 	case LFUN_ACCENT_HUNGARIAN_UMLAUT:
 	case LFUN_ACCENT_CIRCLE:
 	case LFUN_ACCENT_OGONEK:
-		theApp()->handleKeyFunc(cmd.action);
+		theApp()->handleKeyFunc(cmd.action());
 		if (!cmd.argument().empty())
 			// FIXME: Are all these characters encoded in one byte in utf8?
 			bv->translateAndInsert(cmd.argument()[0], this, cur);
+		cur.screenUpdateFlags(Update::FitCursor);
 		break;
 
 	case LFUN_FLOAT_LIST_INSERT: {
@@ -2037,6 +2116,25 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 		break;
 	}
 
+	case LFUN_SPELLING_REMOVE: {
+		docstring word = from_utf8(cmd.getArg(0));
+		Language * lang;
+		if (word.empty()) {
+			word = cur.selectionAsString(false);
+			// FIXME
+			if (word.size() > 100 || word.empty()) {
+				// Get word or selection
+				selectWordWhenUnderCursor(cur, WHOLE_WORD);
+				word = cur.selectionAsString(false);
+			}
+			lang = const_cast<Language *>(cur.getFont().language());
+		} else
+			lang = const_cast<Language *>(languages.getLanguage(cmd.getArg(1)));
+		WordLangTuple wl(word, lang);
+		theSpellChecker()->remove(wl);
+		break;
+	}
+
 	case LFUN_PARAGRAPH_PARAMS_APPLY: {
 		// Given data, an encoding of the ParagraphParameters
 		// generated in the Paragraph dialog, this function sets
@@ -2073,26 +2171,26 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 	case LFUN_OUTLINE_UP:
 		outline(OutlineUp, cur);
 		setCursor(cur, cur.pit(), 0);
-		cur.buffer()->updateBuffer();
+		cur.forceBufferUpdate();
 		needsUpdate = true;
 		break;
 
 	case LFUN_OUTLINE_DOWN:
 		outline(OutlineDown, cur);
 		setCursor(cur, cur.pit(), 0);
-		cur.buffer()->updateBuffer();
+		cur.forceBufferUpdate();
 		needsUpdate = true;
 		break;
 
 	case LFUN_OUTLINE_IN:
 		outline(OutlineIn, cur);
-		cur.buffer()->updateBuffer();
+		cur.forceBufferUpdate();
 		needsUpdate = true;
 		break;
 
 	case LFUN_OUTLINE_OUT:
 		outline(OutlineOut, cur);
-		cur.buffer()->updateBuffer();
+		cur.forceBufferUpdate();
 		needsUpdate = true;
 		break;
 
@@ -2104,12 +2202,27 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 
 	needsUpdate |= (cur.pos() != cur.lastpos()) && cur.selection();
 
+	if (lyxrc.spellcheck_continuously && !needsUpdate) {
+		// Check for misspelled text
+		// The redraw is useful because of the painting of
+		// misspelled markers depends on the cursor position.
+		// Trigger a redraw for cursor moves inside misspelled text.
+		if (!cur.inTexted()) {
+			// move from regular text to math
+			needsUpdate = last_misspelled;
+		} else if (oldTopSlice != cur.top() || oldBoundary != cur.boundary()) {
+			// move inside regular text
+			needsUpdate = last_misspelled
+				|| cur.paragraph().isMisspelled(cur.pos(), true);
+		}
+	}
+
 	// FIXME: The cursor flag is reset two lines below
 	// so we need to check here if some of the LFUN did touch that.
 	// for now only Text::erase() and Text::backspace() do that.
 	// The plan is to verify all the LFUNs and then to remove this
 	// singleParUpdate boolean altogether.
-	if (cur.result().update() & Update::Force) {
+	if (cur.result().screenUpdate() & Update::Force) {
 		singleParUpdate = false;
 		needsUpdate = true;
 	}
@@ -2120,27 +2233,26 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd)
 		// 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);
+		cur.screenUpdateFlags(Update::SinglePar | Update::FitCursor);
 		return;
 	}
-
 	if (!needsUpdate
 	    && &oldTopSlice.inset() == &cur.inset()
 	    && oldTopSlice.idx() == cur.idx()
-	    && !sel // sel is a backup of cur.selection() at the beginning of the function.
+	    && !oldSelection // oldSelection is a backup of cur.selection() at the beginning of the function.
 	    && !cur.selection())
 		// FIXME: it would be better if we could just do this
 		//
 		//if (cur.result().update() != Update::FitCursor)
-		//	cur.noUpdate();
+		//	cur.noScreenUpdate();
 		//
 		// But some LFUNs do not set Update::FitCursor when needed, so we
 		// do it for all. This is not very harmfull as FitCursor will provoke
 		// a full redraw only if needed but still, a proper review of all LFUN
 		// should be done and this needsUpdate boolean can then be removed.
-		cur.updateFlags(Update::FitCursor);
+		cur.screenUpdateFlags(Update::FitCursor);
 	else
-		cur.updateFlags(Update::Force | Update::FitCursor);
+		cur.screenUpdateFlags(Update::Force | Update::FitCursor);
 }
 
 
@@ -2153,7 +2265,7 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd,
 	bool enable = true;
 	InsetCode code = NO_CODE;
 
-	switch (cmd.action) {
+	switch (cmd.action()) {
 
 	case LFUN_DEPTH_DECREMENT:
 		enable = changeDepthAllowed(cur, DEC_DEPTH);
@@ -2203,6 +2315,8 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd,
 			code = NOMENCL_PRINT_CODE;
 		else if (cmd.argument() == "label")
 			code = LABEL_CODE;
+		else if (cmd.argument() == "line")
+			code = LINE_CODE;
 		else if (cmd.argument() == "note")
 			code = NOTE_CODE;
 		else if (cmd.argument() == "phantom")
@@ -2286,8 +2400,8 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd,
 			// make sure we know about such floats
 			if (cit == floats.end() ||
 					// and that we know how to generate a list of them
-			    (!cit->second.needsFloatPkg() && cit->second.listCommand().empty())) {
-				flag.unknown(true);
+			    (!cit->second.usesFloatPkg() && cit->second.listCommand().empty())) {
+				flag.setUnknown(true);
 				// probably not necessary, but...
 				enable = false;
 			}
@@ -2334,17 +2448,16 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd,
 	case LFUN_LABEL_INSERT:
 		code = LABEL_CODE;
 		break;
-	case LFUN_LINE_INSERT:
-		code = LINE_CODE;
-		break;
 	case LFUN_INFO_INSERT:
 		code = INFO_CODE;
 		break;
-	case LFUN_OPTIONAL_INSERT:
-		code = OPTARG_CODE;
-		enable = cur.paragraph().insetList().count(OPTARG_CODE)
-			< cur.paragraph().layout().optionalargs;
+	case LFUN_ARGUMENT_INSERT: {
+		code = ARG_CODE;
+		Layout const & lay = cur.paragraph().layout();
+		int const numargs = lay.reqargs + lay.optargs;
+		enable = cur.paragraph().insetList().count(ARG_CODE) < numargs;
 		break;
+	}
 	case LFUN_INDEX_INSERT:
 		code = INDEX_CODE;
 		break;
@@ -2365,11 +2478,6 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd,
 		// not allowed in description items
 		enable = !inDescriptionItem(cur);
 		break;
-	case LFUN_TOC_INSERT:
-		code = TOC_CODE;
-		// not allowed in description items
-		enable = !inDescriptionItem(cur);
-		break;
 	case LFUN_HYPERLINK_INSERT:
 		if (cur.selIsMultiCell() || cur.selIsMultiLine()) {
 			enable = false;
@@ -2392,6 +2500,9 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd,
 	case LFUN_PREVIEW_INSERT:
 		code = PREVIEW_CODE;
 		break;
+	case LFUN_SCRIPT_INSERT:
+		code = SCRIPT_CODE;
+		break;
 
 	case LFUN_MATH_INSERT:
 	case LFUN_MATH_AMS_MATRIX:
@@ -2421,38 +2532,38 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd,
 
 	case LFUN_FONT_EMPH:
 		flag.setOnOff(fontinfo.emph() == FONT_ON);
-		enable = !cur.inset().getLayout().isPassThru();
+		enable = !cur.paragraph().isPassThru();
 		break;
 
 	case LFUN_FONT_ITAL:
 		flag.setOnOff(fontinfo.shape() == ITALIC_SHAPE);
-		enable = !cur.inset().getLayout().isPassThru();
+		enable = !cur.paragraph().isPassThru();
 		break;
 
 	case LFUN_FONT_NOUN:
 		flag.setOnOff(fontinfo.noun() == FONT_ON);
-		enable = !cur.inset().getLayout().isPassThru();
+		enable = !cur.paragraph().isPassThru();
 		break;
 
 	case LFUN_FONT_BOLD:
 	case LFUN_FONT_BOLDSYMBOL:
 		flag.setOnOff(fontinfo.series() == BOLD_SERIES);
-		enable = !cur.inset().getLayout().isPassThru();
+		enable = !cur.paragraph().isPassThru();
 		break;
 
 	case LFUN_FONT_SANS:
 		flag.setOnOff(fontinfo.family() == SANS_FAMILY);
-		enable = !cur.inset().getLayout().isPassThru();
+		enable = !cur.paragraph().isPassThru();
 		break;
 
 	case LFUN_FONT_ROMAN:
 		flag.setOnOff(fontinfo.family() == ROMAN_FAMILY);
-		enable = !cur.inset().getLayout().isPassThru();
+		enable = !cur.paragraph().isPassThru();
 		break;
 
 	case LFUN_FONT_TYPEWRITER:
 		flag.setOnOff(fontinfo.family() == TYPEWRITER_FAMILY);
-		enable = !cur.inset().getLayout().isPassThru();
+		enable = !cur.paragraph().isPassThru();
 		break;
 
 	case LFUN_CUT:
@@ -2496,6 +2607,7 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd,
 	 }
 
 	case LFUN_CLIPBOARD_PASTE:
+	case LFUN_CLIPBOARD_PASTE_SIMPLE:
 		enable = !theClipboard().empty();
 		break;
 
@@ -2546,7 +2658,7 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd,
 
 	case LFUN_TAB_INSERT:
 	case LFUN_TAB_DELETE:
-		enable = cur.inset().getLayout().isPassThru();
+		enable = cur.paragraph().isPassThru();
 		break;
 
 	case LFUN_SET_GRAPHICS_GROUP: {
@@ -2572,7 +2684,7 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd,
 	}
 
 	case LFUN_LANGUAGE:
-		enable = !cur.inset().getLayout().isPassThru();
+		enable = !cur.paragraph().isPassThru();
 		flag.setOnOff(to_utf8(cmd.argument()) == cur.real_current_font.language()->lang());
 		break;
 
@@ -2582,6 +2694,7 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd,
 	
 	case LFUN_SPELLING_ADD:
 	case LFUN_SPELLING_IGNORE:
+	case LFUN_SPELLING_REMOVE:
 		enable = theSpellChecker();
 		break;
 
@@ -2623,7 +2736,7 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd,
 	case LFUN_FONT_UWAVE:
 	case LFUN_TEXTSTYLE_APPLY:
 	case LFUN_TEXTSTYLE_UPDATE:
-		enable = !cur.inset().getLayout().isPassThru();
+		enable = !cur.paragraph().isPassThru();
 		break;
 
 	case LFUN_WORD_DELETE_FORWARD:
@@ -2670,7 +2783,6 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd,
 	case LFUN_LINE_END:
 	case LFUN_CHAR_DELETE_FORWARD:
 	case LFUN_CHAR_DELETE_BACKWARD:
-	case LFUN_INSET_INSERT:
 	case LFUN_WORD_UPCASE:
 	case LFUN_WORD_LOWCASE:
 	case LFUN_WORD_CAPITALIZE:
@@ -2686,6 +2798,19 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd,
 		enable = true;
 		break;
 
+	case LFUN_INSET_INSERT: {
+		string const type = cmd.getArg(0);
+		if (type == "toc") {
+			code = TOC_CODE;
+			// not allowed in description items
+			//FIXME: couldn't this be merged in Inset::insetAllowed()?
+			enable = !inDescriptionItem(cur);
+		} else {
+			enable = true;
+		}
+		break;
+	}
+
 	default:
 		return false;
 	}