X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Fmathed%2FInsetMathNest.cpp;h=78097f555445236a72d5b1958714b00bf9f9a174;hb=55a3dd7b346d29a52ba305a4558e9e380ef50f47;hp=2d8a7cc61ac85105c4f0b49019e9b0edd91433aa;hpb=97812e871821aab7a290070238d52aceed9dafc2;p=lyx.git

diff --git a/src/mathed/InsetMathNest.cpp b/src/mathed/InsetMathNest.cpp
index 2d8a7cc61a..78097f5554 100644
--- a/src/mathed/InsetMathNest.cpp
+++ b/src/mathed/InsetMathNest.cpp
@@ -3,7 +3,7 @@
  * This file is part of LyX, the document processor.
  * Licence details can be found in the file COPYING.
  *
- * \author André Pönitz
+ * \author André Pönitz
  *
  * Full author contact details are available in file CREDITS.
  */
@@ -13,18 +13,22 @@
 #include "InsetMathNest.h"
 
 #include "InsetMathArray.h"
+#include "InsetMathAMSArray.h"
 #include "InsetMathBig.h"
 #include "InsetMathBox.h"
 #include "InsetMathBrace.h"
+#include "InsetMathChar.h"
 #include "InsetMathColor.h"
 #include "InsetMathComment.h"
 #include "InsetMathDelim.h"
+#include "InsetMathEnsureMath.h"
 #include "InsetMathHull.h"
 #include "InsetMathRef.h"
 #include "InsetMathScript.h"
 #include "InsetMathSpace.h"
 #include "InsetMathSymbol.h"
 #include "InsetMathUnknown.h"
+#include "MathAutoCorrect.h"
 #include "MathCompletionList.h"
 #include "MathData.h"
 #include "MathFactory.h"
@@ -41,9 +45,10 @@
 #include "Cursor.h"
 #include "CutAndPaste.h"
 #include "DispatchResult.h"
+#include "Encoding.h"
 #include "FuncRequest.h"
 #include "FuncStatus.h"
-#include "LyXFunc.h"
+#include "LyX.h"
 #include "LyXRC.h"
 #include "OutputParams.h"
 #include "Text.h"
@@ -74,27 +79,49 @@ using cap::replaceSelection;
 using cap::selClearOrDel;
 
 
-InsetMathNest::InsetMathNest(idx_type nargs)
-	: cells_(nargs), lock_(false), mouse_hover_(false)
-{}
+InsetMathNest::InsetMathNest(Buffer * buf, idx_type nargs)
+	: InsetMath(buf), cells_(nargs), lock_(false)
+{
+	setBuffer(*buf);
+}
 
 
 InsetMathNest::InsetMathNest(InsetMathNest const & inset)
-	: InsetMath(inset), cells_(inset.cells_), lock_(inset.lock_),
-	  mouse_hover_(false)
+	: InsetMath(inset), cells_(inset.cells_), lock_(inset.lock_)
 {}
 
 
+InsetMathNest::~InsetMathNest()
+{
+	map<BufferView const *, bool>::iterator it = mouse_hover_.begin();
+	map<BufferView const *, bool>::iterator end = mouse_hover_.end();
+	for (; it != end; ++it)
+		if (it->second)
+			it->first->clearLastInset(this);
+}
+
+
 InsetMathNest & InsetMathNest::operator=(InsetMathNest const & inset)
 {
 	cells_ = inset.cells_;
 	lock_ = inset.lock_;
-	mouse_hover_ = false;
+	mouse_hover_.clear();
 	InsetMath::operator=(inset);
 	return *this;
 }
 
 
+void InsetMathNest::setBuffer(Buffer & buffer)
+{
+	InsetMath::setBuffer(buffer);
+	for (idx_type i = 0, n = nargs(); i != n; ++i) {
+		MathData & data = cell(i);
+		for (size_t j = 0; j != data.size(); ++j)
+			data[j].nucleus()->setBuffer(buffer);
+	}
+}
+
+
 InsetMath::idx_type InsetMathNest::nargs() const
 {
 	return cells_.size();
@@ -155,6 +182,14 @@ void InsetMathNest::metrics(MetricsInfo const & mi) const
 }
 
 
+void InsetMathNest::updateBuffer(ParIterator const & it, UpdateType utype)
+{
+	for (idx_type i = 0, n = nargs(); i != n; ++i)
+		cell(i).updateBuffer(it, utype);
+}
+
+
+
 bool InsetMathNest::idxNext(Cursor & cur) const
 {
 	LASSERT(&cur.inset() == this, /**/);
@@ -336,7 +371,8 @@ MathData InsetMathNest::glue() const
 
 void InsetMathNest::write(WriteStream & os) const
 {
-	ModeSpecifier specifier(os, currentMode());
+	MathEnsurer ensurer(os, currentMode() == MATH_MODE);
+	ModeSpecifier specifier(os, currentMode(), lockedMode());
 	docstring const latex_name = name();
 	os << '\\' << latex_name;
 	for (size_t i = 0; i < nargs(); ++i)
@@ -359,18 +395,29 @@ void InsetMathNest::normalize(NormalStream & os) const
 }
 
 
-int InsetMathNest::latex(odocstream & os, OutputParams const & runparams) const
+void InsetMathNest::latex(otexstream & os, OutputParams const & runparams) const
 {
-	WriteStream wi(os, runparams.moving_arg, true, runparams.dryrun,
-			runparams.encoding);
+	WriteStream wi(os.os(), runparams.moving_arg, true,
+		       runparams.dryrun ? WriteStream::wsDryrun : WriteStream::wsDefault,
+		       runparams.encoding);
+	wi.canBreakLine(os.canBreakLine());
 	write(wi);
-	return wi.line();
+	os.canBreakLine(wi.canBreakLine());
+
+	int lf = wi.line();
+	if (lf > 0 && runparams.lastid != -1) {
+		--lf;
+		os.texrow().newline();
+		os.texrow().start(runparams.lastid, runparams.lastpos);
+	}
+	os.texrow().newlines(lf);
 }
 
 
-bool InsetMathNest::setMouseHover(bool mouse_hover)
+bool InsetMathNest::setMouseHover(BufferView const * bv, bool mouse_hover)
+	const
 {
-	mouse_hover_ = mouse_hover;
+	mouse_hover_[bv] = mouse_hover;
 	return true;
 }
 
@@ -423,7 +470,7 @@ void InsetMathNest::handleFont(Cursor & cur, docstring const & arg,
 	if (cur.inset().asInsetMath()->name() == font)
 		cur.handleFont(to_utf8(font));
 	else
-		handleNest(cur, createInsetMath(font), arg);
+		handleNest(cur, createInsetMath(font, cur.buffer()), arg);
 }
 
 
@@ -446,7 +493,7 @@ void InsetMathNest::handleNest(Cursor & cur, MathAtom const & nest,
 		cur.insert(arg);
 		return;
 	}
-	
+
 	// multiple selected cells in a simple non-grid inset
 	if (i1.asInsetMath()->nrows() == 0 || i1.asInsetMath()->ncols() == 0) {
 		for (idx_type i = i1.idx(); i <= i2.idx(); ++i) {
@@ -456,11 +503,11 @@ void InsetMathNest::handleNest(Cursor & cur, MathAtom const & nest,
 			cur.resetAnchor();
 			cur.pos() = cur.lastpos();
 			cur.setSelection();
-			
+
 			// change font of cell
 			cur.handleNest(nest);
 			cur.insert(arg);
-			
+
 			// cur is in the font inset now. If the loop continues,
 			// we need to get outside again for the next cell
 			if (i + 1 <= i2.idx())
@@ -468,7 +515,7 @@ void InsetMathNest::handleNest(Cursor & cur, MathAtom const & nest,
 		}
 		return;
 	}
-	
+
 	// the complicated case with multiple selected cells in a grid
 	row_type r1, r2;
 	col_type c1, c2;
@@ -481,11 +528,11 @@ void InsetMathNest::handleNest(Cursor & cur, MathAtom const & nest,
 			cur.resetAnchor();
 			cur.pos() = cur.lastpos();
 			cur.setSelection();
-			
-			// 
+
+			//
 			cur.handleNest(nest);
 			cur.insert(arg);
-		
+
 			// cur is in the font inset now. If the loop continues,
 			// we need to get outside again for the next cell
 			if (col + 1 <= c2 || row + 1 <= r2)
@@ -503,19 +550,27 @@ void InsetMathNest::handleFont2(Cursor & cur, docstring const & arg)
 	font.fromString(to_utf8(arg), b);
 	if (font.fontInfo().color() != Color_inherit &&
 	    font.fontInfo().color() != Color_ignore)
-		handleNest(cur, MathAtom(new InsetMathColor(true, font.fontInfo().color())));
-	
+		handleNest(cur, MathAtom(new InsetMathColor(buffer_, true, font.fontInfo().color())));
+
 	// FIXME: support other font changes here as well?
 }
 
 
 void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd)
 {
-	//lyxerr << "InsetMathNest: request: " << cmd << endl;
+	//LYXERR0("InsetMathNest: request: " << cmd);
 
-	switch (cmd.action) {
+	Parse::flags parseflg = Parse::QUIET | Parse::USETEXT;
 
+	FuncCode const act = cmd.action();
+	switch (act) {
+
+	case LFUN_CLIPBOARD_PASTE:
+		parseflg |= Parse::VERBATIM;
+		// fall through
 	case LFUN_PASTE: {
+		if (cur.currentMode() <= TEXT_MODE)
+			parseflg |= Parse::TEXTMODE;
 		cur.recordUndoSelection();
 		cur.message(_("Paste"));
 		replaceSelection(cur);
@@ -528,8 +583,9 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd)
 			is >> n;
 			topaste = cap::selection(n);
 		}
-		cur.niceInsert(topaste);
+		cur.niceInsert(topaste, parseflg, false);
 		cur.clearSelection(); // bug 393
+		cur.forceBufferUpdate();
 		cur.finishUndo();
 		break;
 	}
@@ -541,6 +597,7 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd)
 		// Prevent stale position >= size crash
 		// Probably not necessary anymore, see eraseSelection (gb 2005-10-09)
 		cur.normalize();
+		cur.forceBufferUpdate();
 		break;
 
 	case LFUN_COPY:
@@ -575,43 +632,43 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd)
 	case LFUN_CHAR_LEFT:
 	case LFUN_CHAR_BACKWARD:
 	case LFUN_CHAR_FORWARD:
-		cur.updateFlags(Update::Decoration | Update::FitCursor);
+		cur.screenUpdateFlags(Update::Decoration | Update::FitCursor);
 	case LFUN_CHAR_RIGHT_SELECT:
 	case LFUN_CHAR_LEFT_SELECT:
 	case LFUN_CHAR_BACKWARD_SELECT:
 	case LFUN_CHAR_FORWARD_SELECT: {
 		// are we in a selection?
-		bool select = (cmd.action == LFUN_CHAR_RIGHT_SELECT 
-					   || cmd.action == LFUN_CHAR_LEFT_SELECT
-					   || cmd.action == LFUN_CHAR_BACKWARD_SELECT
-					   || cmd.action == LFUN_CHAR_FORWARD_SELECT);
-		// are we moving forward or backwards? 
+		bool select = (act == LFUN_CHAR_RIGHT_SELECT
+					   || act == LFUN_CHAR_LEFT_SELECT
+					   || act == LFUN_CHAR_BACKWARD_SELECT
+					   || act == LFUN_CHAR_FORWARD_SELECT);
+		// are we moving forward or backwards?
 		// If the command was RIGHT or LEFT, then whether we're moving forward
 		// or backwards depends on the cursor movement mode (logical or visual):
-		//  * in visual mode, since math is always LTR, right -> forward, 
+		//  * in visual mode, since math is always LTR, right -> forward,
 		//    left -> backwards
 		//  * in logical mode, the mapping is determined by the
 		//    reverseDirectionNeeded() function
-		
+
 		bool forward;
 		FuncCode finish_lfun;
 
-		if (cmd.action == LFUN_CHAR_FORWARD 
-				|| cmd.action == LFUN_CHAR_FORWARD_SELECT) {
+		if (act == LFUN_CHAR_FORWARD
+				|| act == LFUN_CHAR_FORWARD_SELECT) {
 			forward = true;
 			finish_lfun = LFUN_FINISHED_FORWARD;
 		}
-		else if (cmd.action == LFUN_CHAR_BACKWARD
-				|| cmd.action == LFUN_CHAR_BACKWARD_SELECT) {
+		else if (act == LFUN_CHAR_BACKWARD
+				|| act == LFUN_CHAR_BACKWARD_SELECT) {
 			forward = false;
 			finish_lfun = LFUN_FINISHED_BACKWARD;
 		}
 		else {
-			bool right = (cmd.action == LFUN_CHAR_RIGHT_SELECT
-						  || cmd.action == LFUN_CHAR_RIGHT);
+			bool right = (act == LFUN_CHAR_RIGHT_SELECT
+						  || act == LFUN_CHAR_RIGHT);
 			if (lyxrc.visual_cursor || !reverseDirectionNeeded(cur))
 				forward = right;
-			else 
+			else
 				forward = !right;
 
 			if (right)
@@ -621,7 +678,6 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd)
 		}
 		// Now that we know exactly what we want to do, let's do it!
 		cur.selHandle(select);
-		cur.autocorrect() = false;
 		cur.clearTargetX();
 		cur.macroModeClose();
 		// try moving forward or backwards as necessary...
@@ -636,7 +692,7 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd)
 
 	case LFUN_DOWN:
 	case LFUN_UP:
-		cur.updateFlags(Update::Decoration | Update::FitCursor);
+		cur.screenUpdateFlags(Update::Decoration | Update::FitCursor);
 	case LFUN_DOWN_SELECT:
 	case LFUN_UP_SELECT: {
 		// close active macro
@@ -644,18 +700,18 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd)
 			cur.macroModeClose();
 			break;
 		}
-		
+
 		// stop/start the selection
-		bool select = cmd.action == LFUN_DOWN_SELECT ||
-			cmd.action == LFUN_UP_SELECT;
+		bool select = act == LFUN_DOWN_SELECT ||
+			act == LFUN_UP_SELECT;
 		cur.selHandle(select);
-		
+
 		// go up/down
-		bool up = cmd.action == LFUN_UP || cmd.action == LFUN_UP_SELECT;
+		bool up = act == LFUN_UP || act == LFUN_UP_SELECT;
 		bool successful = cur.upDownInMath(up);
 		if (successful)
 			break;
-		
+
 		if (cur.fixIfBroken())
 			// FIXME: Something bad happened. We pass the corrected Cursor
 			// instead of letting things go worse.
@@ -672,14 +728,14 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd)
 		cur.pos() = 0;
 		cur.idx() = 0;
 		cur.resetAnchor();
-		cur.selection() = true;
+		cur.setSelection(true);
 		cur.pos() = cur.lastpos();
 		cur.idx() = cur.lastidx();
 		break;
 
 	case LFUN_PARAGRAPH_UP:
 	case LFUN_PARAGRAPH_DOWN:
-		cur.updateFlags(Update::Decoration | Update::FitCursor);
+		cur.screenUpdateFlags(Update::Decoration | Update::FitCursor);
 	case LFUN_PARAGRAPH_UP_SELECT:
 	case LFUN_PARAGRAPH_DOWN_SELECT:
 		break;
@@ -687,13 +743,13 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd)
 	case LFUN_LINE_BEGIN:
 	case LFUN_WORD_BACKWARD:
 	case LFUN_WORD_LEFT:
-		cur.updateFlags(Update::Decoration | Update::FitCursor);
+		cur.screenUpdateFlags(Update::Decoration | Update::FitCursor);
 	case LFUN_LINE_BEGIN_SELECT:
 	case LFUN_WORD_BACKWARD_SELECT:
 	case LFUN_WORD_LEFT_SELECT:
-		cur.selHandle(cmd.action == LFUN_WORD_BACKWARD_SELECT ||
-				cmd.action == LFUN_WORD_LEFT_SELECT || 
-				cmd.action == LFUN_LINE_BEGIN_SELECT);
+		cur.selHandle(act == LFUN_WORD_BACKWARD_SELECT ||
+				act == LFUN_WORD_LEFT_SELECT ||
+				act == LFUN_LINE_BEGIN_SELECT);
 		cur.macroModeClose();
 		if (cur.pos() != 0) {
 			cur.pos() = 0;
@@ -712,13 +768,13 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd)
 	case LFUN_WORD_FORWARD:
 	case LFUN_WORD_RIGHT:
 	case LFUN_LINE_END:
-		cur.updateFlags(Update::Decoration | Update::FitCursor);
+		cur.screenUpdateFlags(Update::Decoration | Update::FitCursor);
 	case LFUN_WORD_FORWARD_SELECT:
 	case LFUN_WORD_RIGHT_SELECT:
 	case LFUN_LINE_END_SELECT:
-		cur.selHandle(cmd.action == LFUN_WORD_FORWARD_SELECT ||
-				cmd.action == LFUN_WORD_RIGHT_SELECT ||
-				cmd.action == LFUN_LINE_END_SELECT);
+		cur.selHandle(act == LFUN_WORD_FORWARD_SELECT ||
+				act == LFUN_WORD_RIGHT_SELECT ||
+				act == LFUN_LINE_END_SELECT);
 		cur.macroModeClose();
 		cur.clearTargetX();
 		if (cur.pos() != cur.lastpos()) {
@@ -736,12 +792,12 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd)
 		break;
 
 	case LFUN_CELL_FORWARD:
-		cur.updateFlags(Update::Decoration | Update::FitCursor);
+		cur.screenUpdateFlags(Update::Decoration | Update::FitCursor);
 		cur.inset().idxNext(cur);
 		break;
 
 	case LFUN_CELL_BACKWARD:
-		cur.updateFlags(Update::Decoration | Update::FitCursor);
+		cur.screenUpdateFlags(Update::Decoration | Update::FitCursor);
 		cur.inset().idxPrev(cur);
 		break;
 
@@ -798,7 +854,7 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd)
 				cur.insert(arg);
 			break;
 		}
-		// Don't record undo steps if we are in macro mode and
+		// Don't record undo steps if we are in macro mode and thus
 		// cmd.argument is the next character of the macro name.
 		// Otherwise we'll get an invalid cursor if we undo after
 		// the macro was finished and the macro is a known command,
@@ -807,6 +863,7 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd)
 		// InsetMathFrac -> a pos value > 0 is invalid.
 		// A side effect is that an undo before the macro is finished
 		// undoes the complete macro, not only the last character.
+		// At the time we hit '\' we are not in macro mode, still.
 		if (!cur.inMacroMode())
 			cur.recordUndoSelection();
 
@@ -828,7 +885,6 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd)
 		break;
 
 	//case LFUN_SERVER_GET_XY:
-	//	sprintf(dispatch_buffer, "%d %d",);
 	//	break;
 
 	case LFUN_SERVER_SET_XY: {
@@ -875,31 +931,37 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd)
 		break;
 
 	case LFUN_FONT_BOLD:
-		if (currentMode() == TEXT_MODE)
+		if (currentMode() <= TEXT_MODE)
+			handleFont(cur, cmd.argument(), "textbf");
+		else
+			handleFont(cur, cmd.argument(), "mathbf");
+		break;
+	case LFUN_FONT_BOLDSYMBOL:
+		if (currentMode() <= TEXT_MODE)
 			handleFont(cur, cmd.argument(), "textbf");
 		else
 			handleFont(cur, cmd.argument(), "boldsymbol");
 		break;
 	case LFUN_FONT_SANS:
-		if (currentMode() == TEXT_MODE)
+		if (currentMode() <= TEXT_MODE)
 			handleFont(cur, cmd.argument(), "textsf");
 		else
 			handleFont(cur, cmd.argument(), "mathsf");
 		break;
 	case LFUN_FONT_EMPH:
-		if (currentMode() == TEXT_MODE)
+		if (currentMode() <= TEXT_MODE)
 			handleFont(cur, cmd.argument(), "emph");
 		else
 			handleFont(cur, cmd.argument(), "mathcal");
 		break;
 	case LFUN_FONT_ROMAN:
-		if (currentMode() == TEXT_MODE)
+		if (currentMode() <= TEXT_MODE)
 			handleFont(cur, cmd.argument(), "textrm");
 		else
 			handleFont(cur, cmd.argument(), "mathrm");
 		break;
 	case LFUN_FONT_TYPEWRITER:
-		if (currentMode() == TEXT_MODE)
+		if (currentMode() <= TEXT_MODE)
 			handleFont(cur, cmd.argument(), "texttt");
 		else
 			handleFont(cur, cmd.argument(), "mathtt");
@@ -908,13 +970,13 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd)
 		handleFont(cur, cmd.argument(), "mathfrak");
 		break;
 	case LFUN_FONT_ITAL:
-		if (currentMode() == TEXT_MODE)
+		if (currentMode() <= TEXT_MODE)
 			handleFont(cur, cmd.argument(), "textit");
 		else
 			handleFont(cur, cmd.argument(), "mathit");
 		break;
 	case LFUN_FONT_NOUN:
-		if (currentMode() == TEXT_MODE)
+		if (currentMode() <= TEXT_MODE)
 			// FIXME: should be "noun"
 			handleFont(cur, cmd.argument(), "textsc");
 		else
@@ -924,22 +986,32 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd)
 		handleFont(cur, cmd.argument(), "textnormal");
 		break;
 
+	case LFUN_FONT_UNDERLINE:
+		cur.recordUndo();
+		cur.handleNest(createInsetMath("underline", cur.buffer()));
+		break;
 	case LFUN_MATH_MODE: {
 #if 1
 		// ignore math-mode on when already in math mode
 		if (currentMode() == Inset::MATH_MODE && cmd.argument() == "on")
 			break;
+		cur.recordUndoSelection();
 		cur.macroModeClose();
 		docstring const save_selection = grabAndEraseSelection(cur);
 		selClearOrDel(cur);
 		//cur.plainInsert(MathAtom(new InsetMathMBox(cur.bv())));
-		cur.plainInsert(MathAtom(new InsetMathBox(from_ascii("mbox"))));
+		if (currentMode() <= Inset::TEXT_MODE)
+			cur.plainInsert(MathAtom(new InsetMathEnsureMath(buffer_)));
+		else
+			cur.plainInsert(MathAtom(new InsetMathBox(buffer_, from_ascii("mbox"))));
 		cur.posBackward();
 		cur.pushBackward(*cur.nextInset());
 		cur.niceInsert(save_selection);
+		cur.forceBufferUpdate();
 #else
 		if (currentMode() == Inset::TEXT_MODE) {
-			cur.niceInsert(MathAtom(new InsetMathHull("simple")));
+			cur.recordUndoSelection();
+			cur.niceInsert(MathAtom(new InsetMathHull("simple", cur.buffer())));
 			cur.message(_("create new math text environment ($...$)"));
 		} else {
 			handleFont(cur, cmd.argument(), "textrm");
@@ -949,6 +1021,32 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd)
 		break;
 	}
 
+	case LFUN_REGEXP_MODE: {
+		InsetMath * im = cur.inset().asInsetMath();
+		if (im) {
+			InsetMathHull * i = im->asHullInset();		
+			if (i && i->getType() == hullRegexp) {
+				cur.message(_("Already in regular expression mode"));
+				break;
+			}
+		}
+		cur.macroModeClose();
+		docstring const save_selection = grabAndEraseSelection(cur);
+		selClearOrDel(cur);
+		cur.plainInsert(MathAtom(new InsetMathHull(buffer_, hullRegexp)));
+		cur.posBackward();
+		cur.pushBackward(*cur.nextInset());
+		cur.niceInsert(save_selection);
+		cur.message(_("Regular expression editor mode"));
+		break;
+	}
+
+	case LFUN_MATH_FONT_STYLE: {
+		FuncRequest fr = FuncRequest(LFUN_MATH_INSERT, '\\' + cmd.argument());
+		doDispatch(cur, fr);
+		break;
+	}
+
 	case LFUN_MATH_SIZE: {
 		FuncRequest fr = FuncRequest(LFUN_MATH_INSERT, cmd.argument());
 		doDispatch(cur, fr);
@@ -968,8 +1066,24 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd)
 		if (n < 1)
 			n = 1;
 		v_align += 'c';
+		cur.niceInsert(MathAtom(new InsetMathArray(buffer_,
+			from_ascii("array"), m, n, (char)v_align[0], h_align)));
+		break;
+	}
+
+	case LFUN_MATH_AMS_MATRIX: {
+		cur.recordUndo();
+		unsigned int m = 1;
+		unsigned int n = 1;
+		docstring name;
+		idocstringstream is(cmd.argument());
+		is >> m >> n >> name;
+		if (m < 1)
+			m = 1;
+		if (n < 1)
+			n = 1;
 		cur.niceInsert(
-			MathAtom(new InsetMathArray(from_ascii("array"), m, n, (char)v_align[0], h_align)));
+			MathAtom(new InsetMathAMSArray(buffer_, name, m, n)));
 		break;
 	}
 
@@ -982,7 +1096,7 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd)
 		if (rs.empty())
 			rs = ')';
 		cur.recordUndo();
-		cur.handleNest(MathAtom(new InsetMathDelim(ls, rs)));
+		cur.handleNest(MathAtom(new InsetMathDelim(buffer_, ls, rs)));
 		break;
 	}
 
@@ -1006,27 +1120,58 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd)
 			if (have_l)
 				cur.insert(MathAtom(new InsetMathBig(lname,
 								ldelim)));
-			cur.niceInsert(selection);
-			if (have_r)
+			// first insert the right delimiter and then go back
+			// and re-insert the selection (bug 7088)
+			if (have_r) {
 				cur.insert(MathAtom(new InsetMathBig(rname,
 								rdelim)));
+				cur.posBackward();
+			}
+			cur.niceInsert(selection);
 		}
 		// Don't call cur.undispatched() if we did nothing, this would
 		// lead to infinite recursion via Text::dispatch().
 		break;
 	}
 
-	case LFUN_SPACE_INSERT:
+	case LFUN_SPACE_INSERT: {
 		cur.recordUndoSelection();
-		cur.insert(MathAtom(new InsetMathSpace(from_ascii(","))));
+		string const name = cmd.getArg(0);
+		if (name == "normal")
+			cur.insert(MathAtom(new InsetMathSpace(" ", "")));
+		else if (name == "protected")
+			cur.insert(MathAtom(new InsetMathSpace("~", "")));
+		else if (name == "thin" || name == "med" || name == "thick")
+			cur.insert(MathAtom(new InsetMathSpace(name + "space", "")));
+		else if (name == "hfill*")
+			cur.insert(MathAtom(new InsetMathSpace("hspace*{\\fill}", "")));
+		else if (name == "quad" || name == "qquad" ||
+		         name == "enspace" || name == "enskip" ||
+		         name == "negthinspace" || name == "negmedspace" ||
+		         name == "negthickspace" || name == "hfill")
+			cur.insert(MathAtom(new InsetMathSpace(name, "")));
+		else if (name == "hspace" || name == "hspace*") {
+			string const len = cmd.getArg(1);
+			if (len.empty() || !isValidLength(len)) {
+				lyxerr << "LyX function 'space-insert " << name << "' "
+				          "needs a valid length argument." << endl;
+				break;
+			}
+			cur.insert(MathAtom(new InsetMathSpace(name, len)));
+		} else
+			cur.insert(MathAtom(new InsetMathSpace));
 		break;
+	}
 
 	case LFUN_MATH_SPACE:
 		cur.recordUndoSelection();
 		if (cmd.argument().empty())
-			cur.insert(MathAtom(new InsetMathSpace(from_ascii(","))));
-		else
-			cur.insert(MathAtom(new InsetMathSpace(cmd.argument())));
+			cur.insert(MathAtom(new InsetMathSpace));
+		else {
+			string const name = cmd.getArg(0);
+			string const len = cmd.getArg(1);
+			cur.insert(MathAtom(new InsetMathSpace(name, len)));
+		}
 		break;
 
 	case LFUN_ERT_INSERT:
@@ -1046,11 +1191,11 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd)
 		cur.recordUndoSelection();
 		interpretChar(cur, '^');
 		break;
-		
+
 	case LFUN_MATH_MACRO_FOLD:
 	case LFUN_MATH_MACRO_UNFOLD: {
 		Cursor it = cur;
-		bool fold = cmd.action == LFUN_MATH_MACRO_FOLD;
+		bool fold = act == LFUN_MATH_MACRO_FOLD;
 		bool found = findMacroToFoldUnfold(it, fold);
 		if (found) {
 			MathMacro * macro = it.nextInset()->asInsetMath()->asMacro();
@@ -1079,23 +1224,42 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd)
 		else {
 			MathData ar;
 			asArray(cmd.argument(), ar);
-			if (ar.size() == 1 && ar[0]->asNestInset()
-					&& ar[0]->asNestInset()->nargs() > 1)
+			if (cur.selection() && ar.size() == 1
+			    && ar[0]->asNestInset()
+			    && ar[0]->asNestInset()->nargs() > 1)
 				handleNest(cur, ar[0]);
 			else
 				cur.niceInsert(cmd.argument());
 		}
 		break;
+	}
+
+	case LFUN_UNICODE_INSERT: {
+		if (cmd.argument().empty())
+			break;
+		docstring hexstring = cmd.argument();
+		if (isHex(hexstring)) {
+			char_type c = hexToInt(hexstring);
+			if (c >= 32 && c < 0x10ffff) {
+				docstring s = docstring(1, c);
+				FuncCode code = currentMode() == MATH_MODE ?
+					LFUN_MATH_INSERT : LFUN_SELF_INSERT;
+				lyx::dispatch(FuncRequest(code, s));
+			}
 		}
+		break;
+	}
 
 	case LFUN_DIALOG_SHOW_NEW_INSET: {
 		docstring const & name = cmd.argument();
 		string data;
 		if (name == "ref") {
-			InsetMathRef tmp(name);
-			data = tmp.createDialogStr(to_utf8(name));
+			InsetMathRef tmp(buffer_, name);
+			data = tmp.createDialogStr();
+			cur.bv().showDialog(to_utf8(name), data);
+		} else if (name == "mathspace") {
+			cur.bv().showDialog(to_utf8(name));
 		}
-		cur.bv().showDialog(to_utf8(name), data);
 		break;
 	}
 
@@ -1104,6 +1268,7 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd)
 		if (createInsetMath_fromDialogStr(cmd.argument(), ar)) {
 			cur.recordUndoSelection();
 			cur.insert(ar);
+			cur.forceBufferUpdate();			
 		} else
 			cur.undispatched();
 		break;
@@ -1125,7 +1290,7 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd)
 bool InsetMathNest::findMacroToFoldUnfold(Cursor & it, bool fold) const {
 	// look for macro to open/close, but stay in mathed
 	for (; !it.empty(); it.pop_back()) {
-			
+
 		// go backward through the current cell
 		Inset * inset = it.nextInset();
 		while (inset && inset->asInsetMath()) {
@@ -1134,24 +1299,24 @@ bool InsetMathNest::findMacroToFoldUnfold(Cursor & it, bool fold) const {
 				// found the an macro to open/close?
 				if (macro->folded() != fold)
 					return true;
-				
+
 				// Wrong folding state.
 				// If this was the first we see in this slice, look further left,
 				// otherwise go up.
 				if (inset != it.nextInset())
 					break;
 			}
-			
+
 			// go up if this was the left most position
 			if (it.pos() == 0)
 				break;
-			
+
 			// go left
 			it.pos()--;
 			inset = it.nextInset();
 		}
 	}
-	
+
 	return false;
 }
 
@@ -1163,12 +1328,12 @@ bool InsetMathNest::getStatus(Cursor & cur, FuncRequest const & cmd,
 	//string tc = "mathnormal";
 	bool ret = true;
 	string const arg = to_utf8(cmd.argument());
-	switch (cmd.action) {
-	case LFUN_TABULAR_FEATURE:
+	switch (cmd.action()) {
+	case LFUN_INSET_MODIFY:
 		flag.setEnabled(false);
 		break;
 #if 0
-	case LFUN_TABULAR_FEATURE:
+	case LFUN_INSET_MODIFY:
 		// FIXME: check temporarily disabled
 		// valign code
 		char align = mathcursor::valign();
@@ -1190,6 +1355,7 @@ bool InsetMathNest::getStatus(Cursor & cur, FuncRequest const & cmd,
 	/// We have to handle them since 1.4 blocks all unhandled actions
 	case LFUN_FONT_ITAL:
 	case LFUN_FONT_BOLD:
+	case LFUN_FONT_BOLDSYMBOL:
 	case LFUN_FONT_SANS:
 	case LFUN_FONT_EMPH:
 	case LFUN_FONT_TYPEWRITER:
@@ -1198,10 +1364,6 @@ bool InsetMathNest::getStatus(Cursor & cur, FuncRequest const & cmd,
 	case LFUN_FONT_DEFAULT:
 		flag.setEnabled(true);
 		break;
-	case LFUN_MATH_MUTATE:
-		//flag.setOnOff(mathcursor::formula()->hullType() == to_utf8(cmd.argument()));
-		flag.setOnOff(false);
-		break;
 
 	// we just need to be in math mode to enable that
 	case LFUN_MATH_SIZE:
@@ -1211,22 +1373,34 @@ bool InsetMathNest::getStatus(Cursor & cur, FuncRequest const & cmd,
 		flag.setEnabled(true);
 		break;
 
+	case LFUN_FONT_UNDERLINE:
 	case LFUN_FONT_FRAK:
 		flag.setEnabled(currentMode() != TEXT_MODE);
 		break;
 
-	case LFUN_MATH_INSERT: {
+	case LFUN_MATH_FONT_STYLE: {
 		bool const textarg =
-			arg == "\\textbf"   || arg == "\\textsf" ||
-			arg == "\\textrm"   || arg == "\\textmd" ||
-			arg == "\\textit"   || arg == "\\textsc" ||
-			arg == "\\textsl"   || arg == "\\textup" ||
-			arg == "\\texttt"   || arg == "\\textbb" ||
-			arg == "\\textnormal";
+			arg == "textbf"   || arg == "textsf" ||
+			arg == "textrm"   || arg == "textmd" ||
+			arg == "textit"   || arg == "textsc" ||
+			arg == "textsl"   || arg == "textup" ||
+			arg == "texttt"   || arg == "textbb" ||
+			arg == "textnormal";
 		flag.setEnabled(currentMode() != TEXT_MODE || textarg);
 		break;
 	}
 
+	case LFUN_MATH_MODE:
+		// forbid "math-mode on" in math mode to prevent irritating
+		// behaviour of menu entries (bug 6709)
+		flag.setEnabled(currentMode() == TEXT_MODE || arg != "on");
+		break;
+
+	case LFUN_MATH_INSERT:
+		flag.setEnabled(currentMode() != TEXT_MODE);
+		break;
+
+	case LFUN_MATH_AMS_MATRIX:
 	case LFUN_MATH_MATRIX:
 		flag.setEnabled(currentMode() == MATH_MODE);
 		break;
@@ -1236,29 +1410,45 @@ bool InsetMathNest::getStatus(Cursor & cur, FuncRequest const & cmd,
 		// getStatus is not called with a valid reference and the
 		// dialog would not be applyable.
 		string const name = cmd.getArg(0);
-		flag.setEnabled(name == "ref");
+		flag.setEnabled(name == "ref" || name == "mathspace");
+		break;
+	}
+
+	case LFUN_DIALOG_SHOW_NEW_INSET: {
+		docstring const & name = cmd.argument();
+		if (name == "space")
+			flag.setEnabled(false);
 		break;
 	}
 
+
 	case LFUN_MATH_DELIM:
 	case LFUN_MATH_BIGDELIM:
 		// Don't do this with multi-cell selections
 		flag.setEnabled(cur.selBegin().idx() == cur.selEnd().idx());
 		break;
-		
+
 	case LFUN_MATH_MACRO_FOLD:
 	case LFUN_MATH_MACRO_UNFOLD: {
 		Cursor it = cur;
-		bool found = findMacroToFoldUnfold(it, cmd.action == LFUN_MATH_MACRO_FOLD);
+		bool found = findMacroToFoldUnfold(it, cmd.action() == LFUN_MATH_MACRO_FOLD);
 		flag.setEnabled(found);
 		break;
 	}
-		
+
 	case LFUN_SPECIALCHAR_INSERT:
+	case LFUN_SCRIPT_INSERT:
 		// FIXME: These would probably make sense in math-text mode
 		flag.setEnabled(false);
 		break;
 
+	case LFUN_SPACE_INSERT: {
+		docstring const & name = cmd.argument();
+		if (name == "visible")
+			flag.setEnabled(false);
+		break;
+	}
+
 	case LFUN_INSET_DISSOLVE:
 		flag.setEnabled(!asHullInset());
 		break;
@@ -1274,7 +1464,7 @@ bool InsetMathNest::getStatus(Cursor & cur, FuncRequest const & cmd,
 void InsetMathNest::edit(Cursor & cur, bool front, EntryDirection entry_from)
 {
 	cur.push(*this);
-	bool enter_front = (entry_from == Inset::ENTRY_DIRECTION_RIGHT || 
+	bool enter_front = (entry_from == Inset::ENTRY_DIRECTION_RIGHT ||
 		(entry_from == Inset::ENTRY_DIRECTION_IGNORE && front));
 	cur.idx() = enter_front ? 0 : cur.lastidx();
 	cur.pos() = enter_front ? 0 : cur.lastpos();
@@ -1314,6 +1504,15 @@ void InsetMathNest::lfunMousePress(Cursor & cur, FuncRequest & cmd)
 {
 	//lyxerr << "## lfunMousePress: buttons: " << cmd.button() << endl;
 	BufferView & bv = cur.bv();
+	if (cmd.button() == mouse_button::button3) {
+		// Don't do anything if we right-click a
+		// selection, a context menu will popup.
+		if (bv.cursor().selection() && cur >= bv.cursor().selectionBegin()
+		      && cur < bv.cursor().selectionEnd()) {
+	 		cur.noScreenUpdate();
+			return;
+		}
+	}
 	bool do_selection = cmd.button() == mouse_button::button1
 		&& cmd.argument() == "region-select";
 	bv.mouseSetCursor(cur, do_selection);
@@ -1327,8 +1526,8 @@ void InsetMathNest::lfunMousePress(Cursor & cur, FuncRequest & cmd)
 		// Update::FitCursor: adjust the screen to the cursor
 		//                    position if needed
 		// cur.result().update(): don't overwrite previously set flags.
-		cur.updateFlags(Update::Decoration | Update::FitCursor 
-				| cur.result().update());
+		cur.screenUpdateFlags(Update::Decoration | Update::FitCursor
+				| cur.result().screenUpdate());
 	} else if (cmd.button() == mouse_button::button2) {
 		if (cap::selection()) {
 			// See comment in Text::dispatch why we do this
@@ -1349,10 +1548,10 @@ void InsetMathNest::lfunMouseMotion(Cursor & cur, FuncRequest & cmd)
 	// only select with button 1
 	if (cmd.button() == mouse_button::button1) {
 		Cursor & bvcur = cur.bv().cursor();
-		if (bvcur.anchor_.hasPart(cur)) {
+		if (bvcur.realAnchor().hasPart(cur)) {
 			//lyxerr << "## lfunMouseMotion: cursor: " << cur << endl;
 			bvcur.setCursor(cur);
-			bvcur.selection() = true;
+			bvcur.setSelection(true);
 			//lyxerr << "MOTION " << bvcur << endl;
 		} else
 			cur.undispatched();
@@ -1366,10 +1565,10 @@ void InsetMathNest::lfunMouseRelease(Cursor & cur, FuncRequest & cmd)
 
 	if (cmd.button() == mouse_button::button1) {
 		if (!cur.selection())
-			cur.noUpdate();
+			cur.noScreenUpdate();
 		else {
 			Cursor & bvcur = cur.bv().cursor();
-			bvcur.selection() = true;
+			bvcur.setSelection(true);
 		}
 		return;
 	}
@@ -1378,7 +1577,7 @@ void InsetMathNest::lfunMouseRelease(Cursor & cur, FuncRequest & cmd)
 }
 
 
-bool InsetMathNest::interpretChar(Cursor & cur, char_type c)
+bool InsetMathNest::interpretChar(Cursor & cur, char_type const c)
 {
 	//lyxerr << "interpret 2: '" << c << "'" << endl;
 	docstring save_selection;
@@ -1386,6 +1585,7 @@ bool InsetMathNest::interpretChar(Cursor & cur, char_type c)
 		save_selection = grabAndEraseSelection(cur);
 
 	cur.clearTargetX();
+	Buffer * buf = cur.buffer();
 
 	// handle macroMode
 	if (cur.inMacroMode()) {
@@ -1404,7 +1604,7 @@ bool InsetMathNest::interpretChar(Cursor & cur, char_type c)
 		MathWordList const & mwl = mathedWordList();
 		bool star_macro = c == '*'
 			&& (mwl.find(name.substr(1) + "*") != mwl.end()
-			    || cur.buffer().getMacro(name.substr(1) + "*", cur, true));
+			    || cur.buffer()->getMacro(name.substr(1) + "*", cur, true));
 		if (isAlphaASCII(c) || star_macro) {
 			cur.activeMacro()->setName(name + docstring(1, c));
 			return true;
@@ -1415,22 +1615,25 @@ bool InsetMathNest::interpretChar(Cursor & cur, char_type c)
 			// remove the '\\'
 			if (c == '\\') {
 				cur.backspace();
-				if (currentMode() == InsetMath::TEXT_MODE)
-					cur.niceInsert(createInsetMath("textbackslash"));
+				if (currentMode() <= InsetMath::TEXT_MODE)
+					cur.niceInsert(createInsetMath("textbackslash", buf));
 				else
-					cur.niceInsert(createInsetMath("backslash"));
+					cur.niceInsert(createInsetMath("backslash", buf));
+			} else if (c == '^' && currentMode() == InsetMath::MATH_MODE) {
+				cur.backspace();
+				cur.niceInsert(createInsetMath("mathcircumflex", buf));
 			} else if (c == '{') {
 				cur.backspace();
-				cur.niceInsert(MathAtom(new InsetMathBrace));
+				cur.niceInsert(MathAtom(new InsetMathBrace(buf)));
 			} else if (c == '%') {
 				cur.backspace();
-				cur.niceInsert(MathAtom(new InsetMathComment));
+				cur.niceInsert(MathAtom(new InsetMathComment(buf)));
 			} else if (c == '#') {
 				LASSERT(cur.activeMacro(), /**/);
 				cur.activeMacro()->setName(name + docstring(1, c));
 			} else {
 				cur.backspace();
-				cur.niceInsert(createInsetMath(docstring(1, c)));
+				cur.niceInsert(createInsetMath(docstring(1, c), buf));
 			}
 			return true;
 		}
@@ -1466,28 +1669,36 @@ bool InsetMathNest::interpretChar(Cursor & cur, char_type c)
 		}
 
 		// leave macro mode and try again if necessary
-		cur.macroModeClose();
+		if (cur.macroModeClose()) {
+			MathAtom const atom = cur.prevAtom();
+			if (atom->asNestInset() && atom->isActive()) {
+				cur.posBackward();
+				cur.pushBackward(*cur.nextInset());
+			}
+		}
 		if (c == '{')
-			cur.niceInsert(MathAtom(new InsetMathBrace));
+			cur.niceInsert(MathAtom(new InsetMathBrace(buf)));
 		else if (c != ' ')
 			interpretChar(cur, c);
 		return true;
 	}
 
-	// This is annoying as one has to press <space> far too often.
-	// Disable it.
 
-#if 0
-		// leave autocorrect mode if necessary
-		if (autocorrect() && c == ' ') {
-			autocorrect() = false;
-			return true;
-		}
-#endif
+	// leave autocorrect mode if necessary
+	if (lyxrc.autocorrection_math && c == ' ' && cur.autocorrect()) {
+		cur.autocorrect() = false;
+		cur.message(_("Autocorrect Off ('!' to enter)"));
+		return true;
+	} 
+	if (lyxrc.autocorrection_math && c == '!' && !cur.autocorrect()) {
+		cur.autocorrect() = true;
+		cur.message(_("Autocorrect On (<space> to exit)"));
+		return true;
+	}
 
 	// just clear selection on pressing the space bar
 	if (cur.selection() && c == ' ') {
-		cur.selection() = false;
+		cur.setSelection(false);
 		return true;
 	}
 
@@ -1496,7 +1707,10 @@ bool InsetMathNest::interpretChar(Cursor & cur, char_type c)
 		bool reduced = cap::reduceSelectionToOneCell(cur);
 		if (reduced || !cur.selection()) {
 			docstring const safe = cap::grabAndEraseSelection(cur);
-			cur.insert(MathAtom(new InsetMathUnknown(from_ascii("\\"), safe, false)));
+			if (!cur.inRegexped())
+				cur.insert(MathAtom(new InsetMathUnknown(from_ascii("\\"), safe, false)));
+			else
+				cur.niceInsert(createInsetMath("backslash", buf));
 		}
 		return true;
 	}
@@ -1504,14 +1718,14 @@ bool InsetMathNest::interpretChar(Cursor & cur, char_type c)
 	selClearOrDel(cur);
 
 	if (c == '\n') {
-		if (currentMode() == InsetMath::TEXT_MODE)
+		if (currentMode() <= InsetMath::TEXT_MODE)
 			cur.insert(c);
 		return true;
 	}
 
 	if (c == ' ') {
-		if (currentMode() == InsetMath::TEXT_MODE) {
-			// insert spaces in text mode,
+		if (currentMode() <= InsetMath::TEXT_MODE) {
+			// insert spaces in text or undecided mode,
 			// but suppress direct insertion of two spaces in a row
 			// the still allows typing  '<space>a<space>' and deleting the 'a', but
 			// it is better than nothing...
@@ -1521,7 +1735,7 @@ bool InsetMathNest::interpretChar(Cursor & cur, char_type c)
 				// visual box corners that define the inset. If we know for
 				// sure that we stay within the same cell we can optimize for
 				// that using:
-				//cur.updateFlags(Update::SinglePar | Update::FitCursor);
+				//cur.screenUpdateFlags(Update::SinglePar | Update::FitCursor);
 			}
 			return true;
 		}
@@ -1531,7 +1745,7 @@ bool InsetMathNest::interpretChar(Cursor & cur, char_type c)
 			// visual box corners that define the inset. If we know for
 			// sure that we stay within the same cell we can optimize for
 			// that using:
-			//cur.updateFlags(Update::SinglePar | Update::FitCursor);
+			//cur.screenUpdateFlags(Update::SinglePar | Update::FitCursor);
 			return true;
 		}
 
@@ -1540,7 +1754,7 @@ bool InsetMathNest::interpretChar(Cursor & cur, char_type c)
 			// visual box corners that define the inset. If we know for
 			// sure that we stay within the same cell we can optimize for
 			// that using:
-			//cur.updateFlags(Update::FitCursor);
+			//cur.screenUpdateFlags(Update::FitCursor);
 			return true;
 		}
 
@@ -1548,8 +1762,30 @@ bool InsetMathNest::interpretChar(Cursor & cur, char_type c)
 		return cur.pos() != cur.lastpos();
 	}
 
-	// These shouldn't work in text mode:
-	if (currentMode() != InsetMath::TEXT_MODE) {
+	// These should be treated differently when not in text mode:
+	if (cur.inRegexped()) {
+		switch (c) {
+		case '\\':
+			cur.niceInsert(createInsetMath("backslash", buf));
+			break;
+		case '^':
+			cur.niceInsert(createInsetMath("mathcircumflex", buf));
+			break;
+		case '{':
+		case '}':
+		case '#':
+		case '%':
+		case '_':
+			cur.niceInsert(createInsetMath(docstring(1, c), buf));
+			break;
+		case '~':
+			cur.niceInsert(createInsetMath("sim", buf));
+			break;
+		default:
+			cur.insert(c);
+		}
+		return true;
+	} else if (currentMode() != InsetMath::TEXT_MODE) {
 		if (c == '_') {
 			script(cur, false, save_selection);
 			return true;
@@ -1559,25 +1795,47 @@ bool InsetMathNest::interpretChar(Cursor & cur, char_type c)
 			return true;
 		}
 		if (c == '~') {
-			cur.niceInsert(createInsetMath("sim"));
+			cur.niceInsert(createInsetMath("sim", buf));
+			return true;
+		}
+		if (currentMode() == InsetMath::MATH_MODE && !isAsciiOrMathAlpha(c)) {
+			MathAtom at = createInsetMath("text", buf);
+			at.nucleus()->cell(0).push_back(MathAtom(new InsetMathChar(c)));
+			cur.niceInsert(at);
+			cur.posForward();
+			return true;
+		}
+	} else {
+		if (c == '^') {
+			cur.niceInsert(createInsetMath("textasciicircum", buf));
+			return true;
+		}
+		if (c == '~') {
+			cur.niceInsert(createInsetMath("textasciitilde", buf));
 			return true;
 		}
 	}
 
 	if (c == '{' || c == '}' || c == '&' || c == '$' || c == '#' ||
-	    c == '%' || c == '_' || c == '^') {
-		cur.niceInsert(createInsetMath(docstring(1, c)));
+	    c == '%' || c == '_') {
+		cur.niceInsert(createInsetMath(docstring(1, c), buf));
 		return true;
 	}
 
 
 	// try auto-correction
-	//if (autocorrect() && hasPrevAtom() && math_autocorrect(prevAtom(), c))
-	//	return true;
+	if (lyxrc.autocorrection_math && cur.autocorrect() && cur.pos() != 0
+		  && math_autocorrect(cur.prevAtom(), c))
+		return true;
 
 	// no special circumstances, so insert the character without any fuss
 	cur.insert(c);
-	cur.autocorrect() = true;
+	if (lyxrc.autocorrection_math) {
+		if (!cur.autocorrect())
+			cur.message(_("Autocorrect Off ('!' to enter)"));
+		else
+			cur.message(_("Autocorrect On (<space> to exit)"));
+	}
 	return true;
 }
 
@@ -1618,7 +1876,7 @@ bool InsetMathNest::script(Cursor & cur, bool up,
 	//lyxerr << "handling script: up: " << up << endl;
 	if (cur.inMacroMode() && cur.macroName() == "\\") {
 		if (up)
-			cur.niceInsert(createInsetMath("mathcircumflex"));
+			cur.niceInsert(createInsetMath("mathcircumflex", cur.buffer()));
 		else
 			interpretChar(cur, '_');
 		return true;
@@ -1644,10 +1902,10 @@ bool InsetMathNest::script(Cursor & cur, bool up,
 		// one if in the very first position of the array
 		if (cur.pos() == 0) {
 			//lyxerr << "new scriptinset" << endl;
-			cur.insert(new InsetMathScript(up));
+			cur.insert(new InsetMathScript(buffer_, up));
 		} else {
 			//lyxerr << "converting prev atom " << endl;
-			cur.prevAtom() = MathAtom(new InsetMathScript(cur.prevAtom(), up));
+			cur.prevAtom() = MathAtom(new InsetMathScript(buffer_, cur.prevAtom(), up));
 		}
 		--cur.pos();
 		InsetMathScript * inset = cur.nextAtom().nucleus()->asScriptInset();
@@ -1694,7 +1952,7 @@ InsetMathNest::createCompletionList(Cursor const & cur) const
 {
 	if (!cur.inMacroMode())
 		return 0;
-	
+
 	return new MathCompletionList(cur);
 }
 
@@ -1703,7 +1961,7 @@ docstring InsetMathNest::completionPrefix(Cursor const & cur) const
 {
 	if (!cur.inMacroMode())
 		return docstring();
-	
+
 	return cur.activeMacro()->name();
 }
 
@@ -1734,7 +1992,7 @@ bool InsetMathNest::insertCompletion(Cursor & cur, docstring const & s,
 }
 
 
-void InsetMathNest::completionPosAndDim(Cursor const & cur, int & x, int & y, 
+void InsetMathNest::completionPosAndDim(Cursor const & cur, int & x, int & y,
 					Dimension & dim) const
 {
 	Inset const * inset = cur.activeMacro();
@@ -1749,8 +2007,7 @@ void InsetMathNest::completionPosAndDim(Cursor const & cur, int & x, int & y,
 	dim.asc += 3;
 
 	// and position
-	Point xy
-	= cur.bv().coordCache().insets().xy(inset);
+	Point xy = cur.bv().coordCache().insets().xy(inset);
 	x = xy.x_;
 	y = xy.y_;
 }
@@ -1762,7 +2019,7 @@ bool InsetMathNest::cursorMathForward(Cursor & cur)
 		cur.pushBackward(*cur.nextAtom().nucleus());
 		cur.inset().idxFirst(cur);
 		return true;
-	} 
+	}
 	if (cur.posForward() || idxForward(cur))
 		return true;
 	// try to pop forwards --- but don't pop out of math! leave that to
@@ -1781,10 +2038,10 @@ bool InsetMathNest::cursorMathBackward(Cursor & cur)
 		cur.push(*cur.nextAtom().nucleus());
 		cur.inset().idxLast(cur);
 		return true;
-	} 
+	}
 	if (cur.posBackward() || idxBackward(cur))
 		return true;
-	// try to pop backwards --- but don't pop out of math! leave that to 
+	// try to pop backwards --- but don't pop out of math! leave that to
 	// the FINISH lfuns
 	int s = cur.depth() - 2;
 	if (s >= 0 && cur[s].inset().asInsetMath())
@@ -1799,10 +2056,10 @@ MathCompletionList::MathCompletionList(Cursor const & cur)
 {
 	// fill it with macros from the buffer
 	MacroNameSet macros;
-	cur.buffer().listMacroNames(macros);
+	cur.buffer()->listMacroNames(macros);
 	MacroNameSet::const_iterator it;
 	for (it = macros.begin(); it != macros.end(); ++it) {
-		if (cur.buffer().getMacro(*it, cur, false))
+		if (cur.buffer()->getMacro(*it, cur, false))
 			locals.push_back("\\" + *it);
 	}
 	sort(locals.begin(), locals.end());
@@ -1834,6 +2091,8 @@ MathCompletionList::MathCompletionList(Cursor const & cur)
 	globals.push_back(from_ascii("\\alignedat"));
 	globals.push_back(from_ascii("\\cases"));
 	globals.push_back(from_ascii("\\substack"));
+	globals.push_back(from_ascii("\\xymatrix"));
+	globals.push_back(from_ascii("\\Diagram"));
 	globals.push_back(from_ascii("\\subarray"));
 	globals.push_back(from_ascii("\\array"));
 	globals.push_back(from_ascii("\\sqrt"));
@@ -1859,6 +2118,9 @@ MathCompletionList::MathCompletionList(Cursor const & cur)
 	globals.push_back(from_ascii("\\color"));
 	globals.push_back(from_ascii("\\normalcolor"));
 	globals.push_back(from_ascii("\\textcolor"));
+	globals.push_back(from_ascii("\\cfrac"));
+	globals.push_back(from_ascii("\\cfracleft"));
+	globals.push_back(from_ascii("\\cfracright"));
 	globals.push_back(from_ascii("\\dfrac"));
 	globals.push_back(from_ascii("\\tfrac"));
 	globals.push_back(from_ascii("\\dbinom"));
@@ -1899,7 +2161,7 @@ docstring const & MathCompletionList::data(size_t idx) const
 }
 
 
-std::string MathCompletionList::icon(size_t idx) const 
+std::string MathCompletionList::icon(size_t idx) const
 {
 	// get the latex command
 	docstring cmd;
@@ -1908,7 +2170,7 @@ std::string MathCompletionList::icon(size_t idx) const
 		cmd = globals[idx - lsize];
 	else
 		cmd = locals[idx];
-	
+
 	// get the icon resource name by stripping the backslash
 	return "images/math/" + to_utf8(cmd.substr(1)) + ".png";
 }