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

diff --git a/src/mathed/InsetMathNest.cpp b/src/mathed/InsetMathNest.cpp
index 413d32efde..78097f5554 100644
--- a/src/mathed/InsetMathNest.cpp
+++ b/src/mathed/InsetMathNest.cpp
@@ -13,6 +13,7 @@
 #include "InsetMathNest.h"
 
 #include "InsetMathArray.h"
+#include "InsetMathAMSArray.h"
 #include "InsetMathBig.h"
 #include "InsetMathBox.h"
 #include "InsetMathBrace.h"
@@ -47,7 +48,7 @@
 #include "Encoding.h"
 #include "FuncRequest.h"
 #include "FuncStatus.h"
-#include "LyXFunc.h"
+#include "LyX.h"
 #include "LyXRC.h"
 #include "OutputParams.h"
 #include "Text.h"
@@ -78,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();
@@ -159,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, /**/);
@@ -340,6 +371,7 @@ MathData InsetMathNest::glue() const
 
 void InsetMathNest::write(WriteStream & os) const
 {
+	MathEnsurer ensurer(os, currentMode() == MATH_MODE);
 	ModeSpecifier specifier(os, currentMode(), lockedMode());
 	docstring const latex_name = name();
 	os << '\\' << latex_name;
@@ -363,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;
 }
 
@@ -427,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);
 }
 
 
@@ -507,7 +550,7 @@ 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?
 }
@@ -515,11 +558,12 @@ void InsetMathNest::handleFont2(Cursor & cur, docstring const & arg)
 
 void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd)
 {
-	//lyxerr << "InsetMathNest: request: " << cmd << endl;
+	//LYXERR0("InsetMathNest: request: " << cmd);
 
 	Parse::flags parseflg = Parse::QUIET | Parse::USETEXT;
 
-	switch (cmd.action) {
+	FuncCode const act = cmd.action();
+	switch (act) {
 
 	case LFUN_CLIPBOARD_PASTE:
 		parseflg |= Parse::VERBATIM;
@@ -539,8 +583,9 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd)
 			is >> n;
 			topaste = cap::selection(n);
 		}
-		cur.niceInsert(topaste, parseflg);
+		cur.niceInsert(topaste, parseflg, false);
 		cur.clearSelection(); // bug 393
+		cur.forceBufferUpdate();
 		cur.finishUndo();
 		break;
 	}
@@ -552,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:
@@ -586,16 +632,16 @@ 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);
+		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):
@@ -607,19 +653,19 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd)
 		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
@@ -646,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
@@ -656,12 +702,12 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd)
 		}
 
 		// 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;
@@ -689,7 +735,7 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd)
 
 	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;
@@ -697,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;
@@ -722,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()) {
@@ -746,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;
 
@@ -808,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,
@@ -817,14 +863,9 @@ 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.
-		if (!cur.inMacroMode()) {
-			MathMacro const * macro = 0;
-			if (cur.pos() > 0 && cmd.argument() != "\\")
-				macro = cur.inset().asInsetMath()->asMacro();
-			
-			if (!macro)
-				cur.recordUndoSelection();
-		}
+		// At the time we hit '\' we are not in macro mode, still.
+		if (!cur.inMacroMode())
+			cur.recordUndoSelection();
 
 		// spacial handling of space. If we insert an inset
 		// via macro mode, we want to put the cursor inside it
@@ -945,6 +986,10 @@ 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
@@ -956,16 +1001,17 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd)
 		selClearOrDel(cur);
 		//cur.plainInsert(MathAtom(new InsetMathMBox(cur.bv())));
 		if (currentMode() <= Inset::TEXT_MODE)
-			cur.plainInsert(MathAtom(new InsetMathEnsureMath));
+			cur.plainInsert(MathAtom(new InsetMathEnsureMath(buffer_)));
 		else
-			cur.plainInsert(MathAtom(new InsetMathBox(from_ascii("mbox"))));
+			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.recordUndoSelection();
-			cur.niceInsert(MathAtom(new InsetMathHull("simple")));
+			cur.niceInsert(MathAtom(new InsetMathHull("simple", cur.buffer())));
 			cur.message(_("create new math text environment ($...$)"));
 		} else {
 			handleFont(cur, cmd.argument(), "textrm");
@@ -976,19 +1022,22 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd)
 	}
 
 	case LFUN_REGEXP_MODE: {
-		InsetMathHull * i = dynamic_cast<InsetMathHull *>(cur.inset().asInsetMath());
-		if (i && i->getType() == hullRegexp) {
-			cur.message(_("Already in regexp mode"));
-			break;
+		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(hullRegexp)));
+		cur.plainInsert(MathAtom(new InsetMathHull(buffer_, hullRegexp)));
 		cur.posBackward();
 		cur.pushBackward(*cur.nextInset());
 		cur.niceInsert(save_selection);
-		cur.message(_("Regexp editor mode"));
+		cur.message(_("Regular expression editor mode"));
 		break;
 	}
 
@@ -1017,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;
 	}
 
@@ -1031,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;
 	}
 
@@ -1055,20 +1120,48 @@ 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));
+		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();
@@ -1102,7 +1195,7 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd)
 	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();
@@ -1139,19 +1232,34 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd)
 				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));
-		} else if (name == "mathspace") {
-			InsetMathSpace tmp;
+			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;
 	}
 
@@ -1160,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;
@@ -1219,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();
@@ -1264,6 +1373,7 @@ 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;
@@ -1280,10 +1390,17 @@ bool InsetMathNest::getStatus(Cursor & cur, FuncRequest const & cmd,
 		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;
@@ -1297,6 +1414,14 @@ bool InsetMathNest::getStatus(Cursor & cur, FuncRequest const & cmd,
 		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
@@ -1306,16 +1431,24 @@ bool InsetMathNest::getStatus(Cursor & cur, FuncRequest const & cmd,
 	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;
@@ -1371,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);
@@ -1384,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
@@ -1406,7 +1548,7 @@ 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.setSelection(true);
@@ -1423,7 +1565,7 @@ 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.setSelection(true);
@@ -1443,6 +1585,7 @@ bool InsetMathNest::interpretChar(Cursor & cur, char_type const c)
 		save_selection = grabAndEraseSelection(cur);
 
 	cur.clearTargetX();
+	Buffer * buf = cur.buffer();
 
 	// handle macroMode
 	if (cur.inMacroMode()) {
@@ -1473,24 +1616,24 @@ bool InsetMathNest::interpretChar(Cursor & cur, char_type const c)
 			if (c == '\\') {
 				cur.backspace();
 				if (currentMode() <= InsetMath::TEXT_MODE)
-					cur.niceInsert(createInsetMath("textbackslash"));
+					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"));
+				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;
 		}
@@ -1534,7 +1677,7 @@ bool InsetMathNest::interpretChar(Cursor & cur, char_type const c)
 			}
 		}
 		if (c == '{')
-			cur.niceInsert(MathAtom(new InsetMathBrace));
+			cur.niceInsert(MathAtom(new InsetMathBrace(buf)));
 		else if (c != ' ')
 			interpretChar(cur, c);
 		return true;
@@ -1564,24 +1707,16 @@ bool InsetMathNest::interpretChar(Cursor & cur, char_type const 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;
 	}
 
 	selClearOrDel(cur);
 
-	MathMacro const * macro = cur.inset().asInsetMath()->asMacro();
-	if (macro && macro->displayMode() == MathMacro::DISPLAY_UNFOLDED) {
-		// resume macro_mode
-		docstring const & s = macro->name();
-		cur.leaveInset(*macro);
-		cur.plainErase();
-		docstring safe = grabAndEraseSelection(cur);
-		cur.insert(MathAtom(new InsetMathUnknown("\\" + s + c, safe, false)));
-		return true;	
-	}
-
 	if (c == '\n') {
 		if (currentMode() <= InsetMath::TEXT_MODE)
 			cur.insert(c);
@@ -1600,7 +1735,7 @@ bool InsetMathNest::interpretChar(Cursor & cur, char_type const 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;
 		}
@@ -1610,7 +1745,7 @@ bool InsetMathNest::interpretChar(Cursor & cur, char_type const 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;
 		}
 
@@ -1619,7 +1754,7 @@ bool InsetMathNest::interpretChar(Cursor & cur, char_type const 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;
 		}
 
@@ -1628,7 +1763,29 @@ bool InsetMathNest::interpretChar(Cursor & cur, char_type const c)
 	}
 
 	// These should be treated differently when not in text mode:
-	if (currentMode() != InsetMath::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;
@@ -1638,11 +1795,11 @@ bool InsetMathNest::interpretChar(Cursor & cur, char_type const 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");
+			MathAtom at = createInsetMath("text", buf);
 			at.nucleus()->cell(0).push_back(MathAtom(new InsetMathChar(c)));
 			cur.niceInsert(at);
 			cur.posForward();
@@ -1650,18 +1807,18 @@ bool InsetMathNest::interpretChar(Cursor & cur, char_type const c)
 		}
 	} else {
 		if (c == '^') {
-			cur.niceInsert(createInsetMath("textasciicircum"));
+			cur.niceInsert(createInsetMath("textasciicircum", buf));
 			return true;
 		}
 		if (c == '~') {
-			cur.niceInsert(createInsetMath("textasciitilde"));
+			cur.niceInsert(createInsetMath("textasciitilde", buf));
 			return true;
 		}
 	}
 
 	if (c == '{' || c == '}' || c == '&' || c == '$' || c == '#' ||
 	    c == '%' || c == '_') {
-		cur.niceInsert(createInsetMath(docstring(1, c)));
+		cur.niceInsert(createInsetMath(docstring(1, c), buf));
 		return true;
 	}
 
@@ -1719,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;
@@ -1745,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();
@@ -1850,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_;
 }
@@ -1862,10 +2018,6 @@ bool InsetMathNest::cursorMathForward(Cursor & cur)
 	if (cur.pos() != cur.lastpos() && cur.openable(cur.nextAtom())) {
 		cur.pushBackward(*cur.nextAtom().nucleus());
 		cur.inset().idxFirst(cur);
-		MathMacro const * macro = cur.inset().asInsetMath()->asMacro();
-		if (macro && macro->displayMode() == MathMacro::DISPLAY_UNFOLDED)
-			// editing macros is only possible at lastpos
-			cur.pos() = cur.lastpos();
 		return true;
 	}
 	if (cur.posForward() || idxForward(cur))
@@ -1887,17 +2039,11 @@ bool InsetMathNest::cursorMathBackward(Cursor & cur)
 		cur.inset().idxLast(cur);
 		return true;
 	}
-	MathMacro const * macro = cur.inset().asInsetMath()->asMacro();
-	int s = cur.depth() - 2;
-	if (macro && macro->displayMode() == MathMacro::DISPLAY_UNFOLDED
-		  && s >= 0 && cur[s].inset().asInsetMath())
-		// editing macros is only possible at lastpos
-		return cur.popBackward();
-
 	if (cur.posBackward() || idxBackward(cur))
 		return true;
 	// 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())
 		return cur.popBackward();
 	return false;
@@ -1946,6 +2092,7 @@ MathCompletionList::MathCompletionList(Cursor const & cur)
 	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"));