X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Fmathed%2FInsetMathNest.cpp;h=ecd823063e092fc357c7b9a4075c16623852671f;hb=02e82157ec583c3900e359de86be79fac6512387;hp=484418ea4a5eb5586a4d0c32b28022d9f49b47b6;hpb=ca7b18a5dbef0b7c4fd49bf4f5c3d9a02ac1f46c;p=lyx.git

diff --git a/src/mathed/InsetMathNest.cpp b/src/mathed/InsetMathNest.cpp
index 484418ea4a..ecd823063e 100644
--- a/src/mathed/InsetMathNest.cpp
+++ b/src/mathed/InsetMathNest.cpp
@@ -38,8 +38,8 @@
 #include "MathStream.h"
 #include "MathSupport.h"
 
-#include "Bidi.h"
 #include "Buffer.h"
+#include "BufferParams.h"
 #include "BufferView.h"
 #include "CoordCache.h"
 #include "Cursor.h"
@@ -48,21 +48,25 @@
 #include "Encoding.h"
 #include "FuncRequest.h"
 #include "FuncStatus.h"
-#include "LyXFunc.h"
+#include "LaTeXFeatures.h"
+#include "LyX.h"
 #include "LyXRC.h"
+#include "MetricsInfo.h"
 #include "OutputParams.h"
+#include "TexRow.h"
 #include "Text.h"
 
+#include "frontends/Application.h"
 #include "frontends/Clipboard.h"
 #include "frontends/Painter.h"
 #include "frontends/Selection.h"
 
-#include "support/lassert.h"
 #include "support/debug.h"
+#include "support/docstream.h"
 #include "support/gettext.h"
+#include "support/lassert.h"
 #include "support/lstrings.h"
 #include "support/textutils.h"
-#include "support/docstream.h"
 
 #include <algorithm>
 #include <sstream>
@@ -79,22 +83,33 @@ 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;
 }
@@ -128,7 +143,7 @@ void InsetMathNest::cursorPos(BufferView const & bv,
 // to touch all (math)inset's draw() methods. Right now, we'll store
 // absolute value, and make them here relative, only to make them
 // absolute again when actually drawing the cursor. What a mess.
-	LASSERT(&sl.inset() == this, /**/);
+	LASSERT(&sl.inset() == this, return);
 	MathData const & ar = sl.cell();
 	CoordCache const & coord_cache = bv.coordCache();
 	if (!coord_cache.getArrays().has(&ar)) {
@@ -171,9 +186,17 @@ 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, /**/);
+	LASSERT(&cur.inset() == this, return false);
 	if (cur.idx() == cur.lastidx())
 		return false;
 	++cur.idx();
@@ -190,7 +213,7 @@ bool InsetMathNest::idxForward(Cursor & cur) const
 
 bool InsetMathNest::idxPrev(Cursor & cur) const
 {
-	LASSERT(&cur.inset() == this, /**/);
+	LASSERT(&cur.inset() == this, return false);
 	if (cur.idx() == 0)
 		return false;
 	--cur.idx();
@@ -207,7 +230,7 @@ bool InsetMathNest::idxBackward(Cursor & cur) const
 
 bool InsetMathNest::idxFirst(Cursor & cur) const
 {
-	LASSERT(&cur.inset() == this, /**/);
+	LASSERT(&cur.inset() == this, return false);
 	if (nargs() == 0)
 		return false;
 	cur.idx() = 0;
@@ -218,7 +241,7 @@ bool InsetMathNest::idxFirst(Cursor & cur) const
 
 bool InsetMathNest::idxLast(Cursor & cur) const
 {
-	LASSERT(&cur.inset() == this, /**/);
+	LASSERT(&cur.inset() == this, return false);
 	if (nargs() == 0)
 		return false;
 	cur.idx() = cur.lastidx();
@@ -230,7 +253,8 @@ bool InsetMathNest::idxLast(Cursor & cur) const
 void InsetMathNest::dump() const
 {
 	odocstringstream oss;
-	WriteStream os(oss);
+	otexrowstream ots(oss);
+	WriteStream os(ots);
 	os << "---------------------------------------------\n";
 	write(os);
 	os << "\n";
@@ -241,14 +265,13 @@ void InsetMathNest::dump() const
 }
 
 
-void InsetMathNest::draw(PainterInfo & pi, int x, int y) const
+void InsetMathNest::draw(PainterInfo &, int, int) const
 {
 #if 0
 	if (lock_)
 		pi.pain.fillRectangle(x, y - ascent(), width(), height(),
 					Color_mathlockbg);
 #endif
-	setPosCache(pi, x, y);
 }
 
 
@@ -352,11 +375,14 @@ 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;
-	for (size_t i = 0; i < nargs(); ++i)
+	for (size_t i = 0; i < nargs(); ++i) {
+		Changer dummy = os.changeRowEntry(TexRow::mathEntry(id(),i));
 		os << '{' << cell(i) << '}';
+	}
 	if (nargs() == 0)
 		os.pendingSpace(true);
 	if (lock_ && !os.latex()) {
@@ -375,18 +401,37 @@ 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,
+	WriteStream wi(os, runparams.moving_arg, true,
+			runparams.dryrun ? WriteStream::wsDryrun : WriteStream::wsDefault,
 			runparams.encoding);
+	wi.strikeoutMath(runparams.inDeletedInset
+			 && (!LaTeXFeatures::isAvailable("dvipost")
+				|| (runparams.flavor != OutputParams::LATEX
+			            && runparams.flavor != OutputParams::DVILUATEX)));
+	if (runparams.inulemcmd) {
+		wi.ulemCmd(WriteStream::UNDERLINE);
+		if (runparams.local_font) {
+			FontInfo f = runparams.local_font->fontInfo();
+			if (f.strikeout() == FONT_ON)
+				wi.ulemCmd(WriteStream::STRIKEOUT);
+		}
+	}
+	wi.canBreakLine(os.canBreakLine());
+	Changer dummy = wi.changeRowEntry(TexRow::textEntry(runparams.lastid,
+	                                                    runparams.lastpos));
 	write(wi);
-	return wi.line();
+	// Reset parbreak status after a math inset.
+	os.lastChar(0);
+	os.canBreakLine(wi.canBreakLine());
 }
 
 
-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;
 }
 
@@ -439,7 +484,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);
 }
 
 
@@ -519,7 +564,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?
 }
@@ -527,11 +572,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;
@@ -544,15 +590,16 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd)
 		replaceSelection(cur);
 		docstring topaste;
 		if (cmd.argument().empty() && !theClipboard().isInternal())
-			topaste = theClipboard().getAsText();
+			topaste = theClipboard().getAsText(frontend::Clipboard::PlainTextType);
 		else {
 			size_t n = 0;
 			idocstringstream is(cmd.argument());
 			is >> n;
-			topaste = cap::selection(n);
+			topaste = cap::selection(n, buffer().params().documentClassPtr());
 		}
-		cur.niceInsert(topaste, parseflg);
+		cur.niceInsert(topaste, parseflg, false);
 		cur.clearSelection(); // bug 393
+		cur.forceBufferUpdate();
 		cur.finishUndo();
 		break;
 	}
@@ -564,6 +611,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:
@@ -598,16 +646,17 @@ 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);
+		// fall through
 	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):
@@ -619,20 +668,20 @@ 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);
-			if (lyxrc.visual_cursor || !reverseDirectionNeeded(cur))
+			bool right = (act == LFUN_CHAR_RIGHT_SELECT
+						  || act == LFUN_CHAR_RIGHT);
+			if (lyxrc.visual_cursor || !cur.reverseDirectionNeeded())
 				forward = right;
 			else
 				forward = !right;
@@ -658,7 +707,8 @@ 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);
+		// fall through
 	case LFUN_DOWN_SELECT:
 	case LFUN_UP_SELECT: {
 		// close active macro
@@ -668,12 +718,18 @@ 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);
 
+		// handle autocorrect:
+		if (lyxrc.autocorrection_math && cur.autocorrect()) {
+			cur.autocorrect() = false;
+			cur.message(_("Autocorrect Off ('!' to enter)"));
+		}
+
 		// 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,19 +745,28 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd)
 	}
 
 	case LFUN_MOUSE_DOUBLE:
-	case LFUN_MOUSE_TRIPLE:
 	case LFUN_WORD_SELECT:
 		cur.pos() = 0;
-		cur.idx() = 0;
 		cur.resetAnchor();
-		cur.setSelection(true);
+		cur.selection(true);
 		cur.pos() = cur.lastpos();
+		cur.bv().cursor() = cur;
+		break;
+
+	case LFUN_MOUSE_TRIPLE:
+		cur.idx() = 0;
+		cur.pos() = 0;
+		cur.resetAnchor();
+		cur.selection(true);
 		cur.idx() = cur.lastidx();
+		cur.pos() = cur.lastpos();
+		cur.bv().cursor() = cur;
 		break;
 
 	case LFUN_PARAGRAPH_UP:
 	case LFUN_PARAGRAPH_DOWN:
-		cur.updateFlags(Update::Decoration | Update::FitCursor);
+		cur.screenUpdateFlags(Update::Decoration | Update::FitCursor);
+		// fall through
 	case LFUN_PARAGRAPH_UP_SELECT:
 	case LFUN_PARAGRAPH_DOWN_SELECT:
 		break;
@@ -709,13 +774,14 @@ 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);
+		// fall through
 	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;
@@ -734,13 +800,14 @@ 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);
+		// fall through
 	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()) {
@@ -758,12 +825,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;
 
@@ -772,7 +839,7 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd)
 		if (cur.pos() == 0)
 			// May affect external cell:
 			cur.recordUndoInset();
-		else
+		else if (!cur.inMacroMode())
 			cur.recordUndoSelection();
 		// if the inset can not be removed from within, delete it
 		if (!cur.backspace()) {
@@ -838,7 +905,7 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd)
 		// if relevant. Think typing "\frac<space>".
 		if (cmd.argument()[0] == ' '
 		    && cur.inMacroMode() && cur.macroName() != "\\"
-		    && cur.macroModeClose()) {
+		    && cur.macroModeClose() && cur.pos() > 0) {
 			MathAtom const atom = cur.prevAtom();
 			if (atom->asNestInset() && atom->isActive()) {
 				cur.posBackward();
@@ -951,6 +1018,10 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd)
 	case LFUN_FONT_DEFAULT:
 		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
@@ -961,18 +1032,18 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd)
 		cur.macroModeClose();
 		docstring const save_selection = grabAndEraseSelection(cur);
 		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(createInsetMath("text", buffer_));
 		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");
@@ -983,19 +1054,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;
 	}
 
@@ -1024,8 +1098,8 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd)
 		if (n < 1)
 			n = 1;
 		v_align += 'c';
-		cur.niceInsert(
-			MathAtom(new InsetMathArray(from_ascii("array"), m, n, (char)v_align[0], h_align)));
+		cur.niceInsert(MathAtom(new InsetMathArray(buffer_,
+			from_ascii("array"), m, n, (char)v_align[0], h_align)));
 		break;
 	}
 
@@ -1033,15 +1107,21 @@ void InsetMathNest::doDispatch(Cursor & cur, FuncRequest & cmd)
 		cur.recordUndo();
 		unsigned int m = 1;
 		unsigned int n = 1;
-		docstring name;
+		docstring name = from_ascii("matrix");
 		idocstringstream is(cmd.argument());
 		is >> m >> n >> name;
 		if (m < 1)
 			m = 1;
 		if (n < 1)
 			n = 1;
+		// check if we have a valid decoration
+		if (name != "pmatrix" && name != "bmatrix"
+			&& name != "Bmatrix" && name != "vmatrix"
+			&& name != "Vmatrix" && name != "matrix")
+			name = from_ascii("matrix");
+
 		cur.niceInsert(
-			MathAtom(new InsetMathAMSArray(name, m, n)));
+			MathAtom(new InsetMathAMSArray(buffer_, name, m, n)));
 		break;
 	}
 
@@ -1054,7 +1134,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;
 	}
 
@@ -1078,20 +1158,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();
@@ -1125,7 +1233,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();
@@ -1162,19 +1270,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;
 	}
 
@@ -1183,6 +1306,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;
@@ -1242,12 +1366,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();
@@ -1282,11 +1406,11 @@ bool InsetMathNest::getStatus(Cursor & cur, FuncRequest const & cmd,
 	// we just need to be in math mode to enable that
 	case LFUN_MATH_SIZE:
 	case LFUN_MATH_SPACE:
-	case LFUN_MATH_LIMITS:
 	case LFUN_MATH_EXTERN:
 		flag.setEnabled(true);
 		break;
 
+	case LFUN_FONT_UNDERLINE:
 	case LFUN_FONT_FRAK:
 		flag.setEnabled(currentMode() != TEXT_MODE);
 		break;
@@ -1303,6 +1427,12 @@ 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;
@@ -1321,6 +1451,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
@@ -1330,20 +1468,39 @@ 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_CAPTION_INSERT:
+		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;
 
+	case LFUN_PASTE: {
+		docstring const & name = cmd.argument();
+		if (name == "html" || name == "latex")
+			flag.setEnabled(false);
+		break;
+	}
+
 	default:
 		ret = false;
 		break;
@@ -1395,8 +1552,17 @@ 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";
+		&& cmd.modifier() == ShiftModifier;
 	bv.mouseSetCursor(cur, do_selection);
 	if (cmd.button() == mouse_button::button1) {
 		//lyxerr << "## lfunMousePress: setting cursor to: " << cur << endl;
@@ -1408,9 +1574,9 @@ 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());
-	} else if (cmd.button() == mouse_button::button2) {
+		cur.screenUpdateFlags(Update::Decoration | Update::FitCursor
+				| cur.result().screenUpdate());
+	} else if (cmd.button() == mouse_button::button2 && lyxrc.mouse_middlebutton_paste) {
 		if (cap::selection()) {
 			// See comment in Text::dispatch why we do this
 			cap::copySelectionToStack();
@@ -1428,16 +1594,29 @@ void InsetMathNest::lfunMousePress(Cursor & cur, FuncRequest & cmd)
 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)) {
-			//lyxerr << "## lfunMouseMotion: cursor: " << cur << endl;
-			bvcur.setCursor(cur);
-			bvcur.setSelection(true);
-			//lyxerr << "MOTION " << bvcur << endl;
-		} else
-			cur.undispatched();
+	if (cmd.button() != mouse_button::button1)
+		return;
+
+	Cursor & bvcur = cur.bv().cursor();
+
+	// ignore motions deeper nested than the real anchor
+	if (!bvcur.realAnchor().hasPart(cur)) {
+		cur.undispatched();
+		return;
 	}
+
+	CursorSlice old = bvcur.top();
+
+	// We continue with our existing selection or start a new one, so don't
+	// reset the anchor.
+	bvcur.setCursor(cur);
+	// Did we actually move?
+	if (cur.top() == old)
+		// We didn't move one iota, so no need to change selection status
+		// or update the screen.
+		cur.screenUpdateFlags(Update::SinglePar | Update::FitCursor);
+	else
+		bvcur.setSelection();
 }
 
 
@@ -1447,10 +1626,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.setSelection(true);
+			bvcur.selection(true);
 		}
 		return;
 	}
@@ -1467,6 +1646,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()) {
@@ -1482,9 +1662,8 @@ bool InsetMathNest::interpretChar(Cursor & cur, char_type const c)
 		}
 
 		// do not finish macro for known * commands
-		MathWordList const & mwl = mathedWordList();
 		bool star_macro = c == '*'
-			&& (mwl.find(name.substr(1) + "*") != mwl.end()
+			&& (in_word_set(name.substr(1) + '*')
 			    || cur.buffer()->getMacro(name.substr(1) + "*", cur, true));
 		if (isAlphaASCII(c) || star_macro) {
 			cur.activeMacro()->setName(name + docstring(1, c));
@@ -1497,24 +1676,29 @@ 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"));
-			} else if (c == '{') {
-				cur.backspace();
-				cur.niceInsert(MathAtom(new InsetMathBrace));
-			} else if (c == '%') {
+				cur.niceInsert(createInsetMath("mathcircumflex", buf));
+			} else if (c == '{' || c == '%') {
+				//using the saved selection as argument
+				InsetMathUnknown * p = cur.activeMacro();
+				p->finalize();
+				MathData sel(cur.buffer());
+				asArray(p->selection(), sel);
 				cur.backspace();
-				cur.niceInsert(MathAtom(new InsetMathComment));
+				if (c == '{')
+					cur.niceInsert(MathAtom(new InsetMathBrace(sel)));
+				else
+					cur.niceInsert(MathAtom(new InsetMathComment(sel)));
 			} else if (c == '#') {
-				LASSERT(cur.activeMacro(), /**/);
+				LASSERT(cur.activeMacro(), return false);
 				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;
 		}
@@ -1547,6 +1731,13 @@ bool InsetMathNest::interpretChar(Cursor & cur, char_type const c)
 					new InsetMathBig(name.substr(1), delim)));
 				return true;
 			}
+		} else if (name == "\\smash" && c == '[') {
+			// We can't use cur.macroModeClose() because
+			// it would create an InsetMathPhantom
+			InsetMathUnknown * p = cur.activeMacro();
+			p->finalize();
+			interpretChar(cur, c);
+			return true;
 		}
 
 		// leave macro mode and try again if necessary
@@ -1558,7 +1749,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;
@@ -1570,7 +1761,7 @@ bool InsetMathNest::interpretChar(Cursor & cur, char_type const c)
 		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)"));
@@ -1579,7 +1770,7 @@ bool InsetMathNest::interpretChar(Cursor & cur, char_type const c)
 
 	// just clear selection on pressing the space bar
 	if (cur.selection() && c == ' ') {
-		cur.setSelection(false);
+		cur.selection(false);
 		return true;
 	}
 
@@ -1587,8 +1778,12 @@ bool InsetMathNest::interpretChar(Cursor & cur, char_type const c)
 		//lyxerr << "starting with macro" << endl;
 		bool reduced = cap::reduceSelectionToOneCell(cur);
 		if (reduced || !cur.selection()) {
+			cur.recordUndoInset();
 			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;
 	}
@@ -1607,13 +1802,13 @@ bool InsetMathNest::interpretChar(Cursor & cur, char_type const c)
 			// 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...
-			if (!cur.pos() != 0 || cur.prevAtom()->getChar() != ' ') {
+			if (cur.pos() == 0 || cur.prevAtom()->getChar() != ' ') {
 				cur.insert(c);
 				// FIXME: we have to enable full redraw here because of the
 				// 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;
 		}
@@ -1623,7 +1818,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;
 		}
 
@@ -1632,7 +1827,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;
 		}
 
@@ -1641,7 +1836,26 @@ 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("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;
@@ -1651,11 +1865,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");
+		if (currentMode() == InsetMath::MATH_MODE && Encodings::isUnicodeTextOnly(c)) {
+			MathAtom at = createInsetMath("text", buf);
 			at.nucleus()->cell(0).push_back(MathAtom(new InsetMathChar(c)));
 			cur.niceInsert(at);
 			cur.posForward();
@@ -1663,18 +1877,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;
 	}
 
@@ -1732,7 +1946,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;
@@ -1758,10 +1972,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();
@@ -1863,8 +2077,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_;
 }
@@ -1921,12 +2134,12 @@ MathCompletionList::MathCompletionList(Cursor const & cur)
 	}
 	sort(locals.begin(), locals.end());
 
-	if (globals.size() > 0)
+	if (!globals.empty())
 		return;
 
 	// fill in global macros
 	macros.clear();
-	MacroTable::globalMacros().getMacroNames(macros);
+	MacroTable::globalMacros().getMacroNames(macros, false);
 	//lyxerr << "Globals completion macros: ";
 	for (it = macros.begin(); it != macros.end(); ++it) {
 		//lyxerr << "\\" + *it << " ";
@@ -1940,8 +2153,21 @@ MathCompletionList::MathCompletionList(Cursor const & cur)
 	globals.push_back(from_ascii("\\framebox"));
 	globals.push_back(from_ascii("\\makebox"));
 	globals.push_back(from_ascii("\\kern"));
+	globals.push_back(from_ascii("\\xhookrightarrow"));
+	globals.push_back(from_ascii("\\xhookleftarrow"));
 	globals.push_back(from_ascii("\\xrightarrow"));
+	globals.push_back(from_ascii("\\xRightarrow"));
+	globals.push_back(from_ascii("\\xrightharpoondown"));
+	globals.push_back(from_ascii("\\xrightharpoonup"));
+	globals.push_back(from_ascii("\\xrightleftharpoons"));
 	globals.push_back(from_ascii("\\xleftarrow"));
+	globals.push_back(from_ascii("\\xLeftarrow"));
+	globals.push_back(from_ascii("\\xleftharpoondown"));
+	globals.push_back(from_ascii("\\xleftharpoonup"));
+	globals.push_back(from_ascii("\\xleftrightarrow"));
+	globals.push_back(from_ascii("\\xLeftrightarrow"));
+	globals.push_back(from_ascii("\\xleftrightharpoons"));
+	globals.push_back(from_ascii("\\xmapsto"));
 	globals.push_back(from_ascii("\\split"));
 	globals.push_back(from_ascii("\\gathered"));
 	globals.push_back(from_ascii("\\aligned"));
@@ -1949,12 +2175,15 @@ 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"));
 	globals.push_back(from_ascii("\\root"));
 	globals.push_back(from_ascii("\\tabular"));
+	globals.push_back(from_ascii("\\sideset"));
 	globals.push_back(from_ascii("\\stackrel"));
+	globals.push_back(from_ascii("\\stackrelthree"));
 	globals.push_back(from_ascii("\\binom"));
 	globals.push_back(from_ascii("\\choose"));
 	globals.push_back(from_ascii("\\brace"));
@@ -1984,12 +2213,24 @@ MathCompletionList::MathCompletionList(Cursor const & cur)
 	globals.push_back(from_ascii("\\hphantom"));
 	globals.push_back(from_ascii("\\phantom"));
 	globals.push_back(from_ascii("\\vphantom"));
+	globals.push_back(from_ascii("\\cancel"));
+	globals.push_back(from_ascii("\\bcancel"));
+	globals.push_back(from_ascii("\\xcancel"));
+	globals.push_back(from_ascii("\\cancelto"));
+	globals.push_back(from_ascii("\\smash"));
+	globals.push_back(from_ascii("\\mathclap"));
+	globals.push_back(from_ascii("\\mathllap"));
+	globals.push_back(from_ascii("\\mathrlap"));
+	globals.push_back(from_ascii("\\ensuremath"));
 	MathWordList const & words = mathedWordList();
 	MathWordList::const_iterator it2;
 	//lyxerr << "Globals completion commands: ";
 	for (it2 = words.begin(); it2 != words.end(); ++it2) {
-		globals.push_back("\\" + (*it2).first);
-		//lyxerr << "\\" + (*it2).first << " ";
+		if (it2->second.inset != "macro" && !it2->second.hidden) {
+			// macros are already read from MacroTable::globalMacros()
+			globals.push_back('\\' + it2->first);
+			//lyxerr << '\\' + it2->first << ' ';
+		}
 	}
 	//lyxerr << std::endl;
 	sort(globals.begin(), globals.end());
@@ -2028,7 +2269,10 @@ std::string MathCompletionList::icon(size_t idx) const
 		cmd = locals[idx];
 
 	// get the icon resource name by stripping the backslash
-	return "images/math/" + to_utf8(cmd.substr(1)) + ".png";
+	docstring icon_name = frontend::Application::mathIcon(cmd.substr(1));
+	if (icon_name.empty())
+		return std::string();
+	return "images/math/" + to_utf8(icon_name);
 }
 
 std::vector<docstring> MathCompletionList::globals;