X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Fmathed%2FInsetMathHull.cpp;h=e21beb236e98730460d693f68c0aab4705482aaa;hb=ad79ac406f9c8fc85880cfeb5416b0299ee9a617;hp=9a5864f314a0b0bc43e3cf01d147b3712afe474e;hpb=f3b70fd2cdbbc282dff8beb1c8fb4ab3f06277fa;p=lyx.git

diff --git a/src/mathed/InsetMathHull.cpp b/src/mathed/InsetMathHull.cpp
index 9a5864f314..e21beb236e 100644
--- a/src/mathed/InsetMathHull.cpp
+++ b/src/mathed/InsetMathHull.cpp
@@ -15,7 +15,6 @@
 #include "InsetMathChar.h"
 #include "InsetMathColor.h"
 #include "InsetMathFrac.h"
-#include "InsetMathGrid.h"
 #include "InsetMathNest.h"
 #include "InsetMathScript.h"
 #include "MathExtern.h"
@@ -38,10 +37,12 @@
 #include "MacroTable.h"
 #include "MathMacro.h"
 #include "MathMacroTemplate.h"
+#include "MetricsInfo.h"
 #include "output_xhtml.h"
 #include "Paragraph.h"
 #include "ParIterator.h"
 #include "sgml.h"
+#include "TexRow.h"
 #include "TextClass.h"
 #include "TextPainter.h"
 #include "TocBackend.h"
@@ -58,11 +59,12 @@
 #include "frontends/Painter.h"
 
 #include "support/convert.h"
-#include "support/lassert.h"
 #include "support/debug.h"
-#include "support/filetools.h"
 #include "support/gettext.h"
+#include "support/filetools.h"
+#include "support/lassert.h"
 #include "support/lstrings.h"
+#include "support/RefChanger.h"
 
 #include <sstream>
 
@@ -79,17 +81,25 @@ namespace {
 	int getCols(HullType type)
 	{
 		switch (type) {
-			case hullEqnArray:
-				return 3;
-			case hullAlign:
-			case hullFlAlign:
-			case hullAlignAt:
-			case hullXAlignAt:
-			case hullXXAlignAt:
-				return 2;
-			default:
-				return 1;
+		case hullEqnArray:
+			return 3;
+		case hullAlign:
+		case hullFlAlign:
+		case hullAlignAt:
+		case hullXAlignAt:
+		case hullXXAlignAt:
+			return 2;
+		case hullUnknown:
+		case hullNone:
+		case hullSimple:
+		case hullEquation:
+		case hullMultline:
+		case hullGather:
+		case hullRegexp:
+			return 1;
 		}
+		// avoid warning
+		return 0;
 	}
 
 
@@ -98,7 +108,7 @@ namespace {
 	size_t firstRelOp(MathData const & ar)
 	{
 		for (MathData::const_iterator it = ar.begin(); it != ar.end(); ++it)
-			if ((*it)->isRelOp())
+			if ((*it)->mathClass() == MC_REL)
 				return it - ar.begin();
 		return ar.size();
 	}
@@ -110,6 +120,37 @@ namespace {
 	}
 
 
+	// writes a preamble for underlined or struck out math display
+	void writeMathdisplayPreamble(WriteStream & os)
+	{
+		if (os.strikeoutMath()) {
+			if (os.ulemCmd() == WriteStream::UNDERLINE)
+				os << "\\raisebox{-\\belowdisplayshortskip}{"
+				      "\\lyxmathsout{\\parbox[b]{\\columnwidth}{";
+			else
+				os << "\\lyxmathsout{\\parbox{\\columnwidth}{";
+		} else if (os.ulemCmd() == WriteStream::UNDERLINE)
+			os << "\\raisebox{-\\belowdisplayshortskip}{"
+			      "\\parbox[b]{\\columnwidth}{";
+		else if (os.ulemCmd() == WriteStream::STRIKEOUT)
+			os << "\\parbox{\\columnwidth}{";
+	}
+
+
+	// writes a postamble for underlined or struck out math display
+	void writeMathdisplayPostamble(WriteStream & os)
+	{
+		if (os.strikeoutMath()) {
+			if (os.ulemCmd() == WriteStream::UNDERLINE)
+				os << "}";
+			os << "}}\\\\\n";
+		} else if (os.ulemCmd() == WriteStream::UNDERLINE)
+			os << "}}\\\\\n";
+		else if (os.ulemCmd() == WriteStream::STRIKEOUT)
+			os << "}\\\\\n";
+	}
+
+
 } // end anon namespace
 
 
@@ -128,29 +169,30 @@ HullType hullType(docstring const & s)
 	if (s == "flalign")   return hullFlAlign;
 	if (s == "regexp")    return hullRegexp;
 	lyxerr << "unknown hull type '" << to_utf8(s) << "'" << endl;
-	return HullType(-1);
+	return hullUnknown;
 }
 
 
 docstring hullName(HullType type)
 {
 	switch (type) {
-		case hullNone:       return from_ascii("none");
-		case hullSimple:     return from_ascii("simple");
-		case hullEquation:   return from_ascii("equation");
-		case hullEqnArray:   return from_ascii("eqnarray");
-		case hullAlign:      return from_ascii("align");
-		case hullAlignAt:    return from_ascii("alignat");
-		case hullXAlignAt:   return from_ascii("xalignat");
-		case hullXXAlignAt:  return from_ascii("xxalignat");
-		case hullMultline:   return from_ascii("multline");
-		case hullGather:     return from_ascii("gather");
-		case hullFlAlign:    return from_ascii("flalign");
-		case hullRegexp:     return from_ascii("regexp");
-		default:
-			lyxerr << "unknown hull type '" << type << "'" << endl;
-			return from_ascii("none");
+	case hullNone:       return from_ascii("none");
+	case hullSimple:     return from_ascii("simple");
+	case hullEquation:   return from_ascii("equation");
+	case hullEqnArray:   return from_ascii("eqnarray");
+	case hullAlign:      return from_ascii("align");
+	case hullAlignAt:    return from_ascii("alignat");
+	case hullXAlignAt:   return from_ascii("xalignat");
+	case hullXXAlignAt:  return from_ascii("xxalignat");
+	case hullMultline:   return from_ascii("multline");
+	case hullGather:     return from_ascii("gather");
+	case hullFlAlign:    return from_ascii("flalign");
+	case hullRegexp:     return from_ascii("regexp");
+	case hullUnknown:
+		lyxerr << "unknown hull type" << endl;
+		break;
 	}
+	return from_ascii("none");
 }
 
 static InsetLabel * dummy_pointer = 0;
@@ -293,7 +335,7 @@ void InsetMathHull::updateBuffer(ParIterator const & it, UpdateType utype)
 
 
 void InsetMathHull::addToToc(DocIterator const & pit, bool output_active,
-							 UpdateType utype) const
+							 UpdateType utype, TocBackend & backend) const
 {
 	if (!buffer_) {
 		//FIXME: buffer_ should be set at creation for this inset! Problem is
@@ -302,15 +344,42 @@ void InsetMathHull::addToToc(DocIterator const & pit, bool output_active,
 		return;
 	}
 
-	shared_ptr<Toc> toc = buffer().tocBackend().toc("equation");
-
+	TocBuilder & b = backend.builder("equation");
+	// compute first and last item
+	row_type first = nrows();
+	for (row_type row = 0; row != nrows(); ++row)
+		if (numbered(row)) {
+			first = row;
+			break;
+		}
+	if (first == nrows())
+		// no equation
+		return;
+	row_type last = nrows() - 1;
+	for (; last != 0; --last)
+		if (numbered(last))
+			break;
+	// add equation numbers
+	b.pushItem(pit, docstring(), output_active);
+	if (first != last)
+		b.argumentItem(bformat(from_ascii("(%1$s-%2$s)"),
+		                       numbers_[first], numbers_[last]));
 	for (row_type row = 0; row != nrows(); ++row) {
 		if (!numbered(row))
 			continue;
 		if (label_[row])
-			label_[row]->addToToc(pit, output_active, utype);
-		toc->push_back(TocItem(pit, 0, nicelabel(row), output_active));
+			label_[row]->addToToc(pit, output_active, utype, backend);
+		docstring label = nicelabel(row);
+		if (first == last)
+			// this is the only equation
+			b.argumentItem(label);
+		else {
+			// insert as sub-items
+			b.pushItem(pit, label, output_active);
+			b.pop();
+		}
 	}
+	b.pop();
 }
 
 
@@ -326,9 +395,26 @@ Inset * InsetMathHull::editXY(Cursor & cur, int x, int y)
 
 InsetMath::mode_type InsetMathHull::currentMode() const
 {
-	if (type_ == hullNone)
+	switch (type_) {
+	case hullNone:
 		return UNDECIDED_MODE;
+
 	// definitely math mode ...
+	case hullUnknown:
+	case hullSimple:
+	case hullEquation:
+	case hullMultline:
+	case hullGather:
+	case hullEqnArray:
+	case hullAlign:
+	case hullFlAlign:
+	case hullAlignAt:
+	case hullXAlignAt:
+	case hullXXAlignAt:
+	case hullRegexp:
+		return MATH_MODE;
+	}
+	// avoid warning
 	return MATH_MODE;
 }
 
@@ -351,9 +437,9 @@ bool InsetMathHull::idxLast(Cursor & cur) const
 
 // FIXME: InsetMathGrid should be changed to let the real column alignment be
 // given by a virtual method like displayColAlign, because the values produced
-// by defaultColAlign can be invalidated by lfuns such as add-column. I suspect
-// that for the moment the values produced by defaultColAlign are not used,
-// notably because alignment is not implemented in the LyXHTML output.
+// by defaultColAlign can be invalidated by lfuns such as add-column. For the
+// moment the values produced by defaultColAlign are not used, notably because
+// alignment is not implemented in the LyXHTML output.
 char InsetMathHull::defaultColAlign(col_type col)
 {
 	return colAlign(type_, col);
@@ -386,47 +472,42 @@ char InsetMathHull::displayColAlign(idx_type idx) const
 }
 
 
+int InsetMathHull::displayColSpace(col_type col) const
+{
+	return colSpace(type_, col);
+}
+
+
+// FIXME: same comment as for defaultColAlign applies.
 int InsetMathHull::defaultColSpace(col_type col)
 {
-	if (type_ == hullAlign || type_ == hullAlignAt)
-		return 0;
-	if (type_ == hullXAlignAt)
-		return (col & 1) ? 20 : 0;
-	if (type_ == hullXXAlignAt || type_ == hullFlAlign)
-		return (col & 1) ? 40 : 0;
-	return 0;
+	return colSpace(type_, col);
 }
 
 
-docstring InsetMathHull::standardFont() const
+string InsetMathHull::standardFont() const
 {
-	docstring font_name;
 	switch (type_) {
 	case hullRegexp:
-		font_name = from_ascii("texttt");
-		break;
+		return "texttt";
 	case hullNone:
-		font_name = from_ascii("lyxnochange");
-		break;
+		return "lyxnochange";
 	default:
-		font_name = from_ascii("mathnormal");
+		return "mathnormal";
 	}
-	return font_name;
 }
 
 
 ColorCode InsetMathHull::standardColor() const
 {
-	ColorCode color;
 	switch (type_) {
 	case hullRegexp:
 	case hullNone:
-		color = Color_foreground;
-		break;
+		return Color_foreground;
+
 	default:
-		color = Color_math;
+		return Color_math;
 	}
-	return color;
 }
 
 
@@ -461,13 +542,12 @@ void InsetMathHull::metrics(MetricsInfo & mi, Dimension & dim) const
 			if (display())
 				dim.des += displayMargin();
 		}
-		// Cache the inset dimension.
-		setDimCache(mi, dim);
 		return;
 	}
 
-	FontSetChanger dummy1(mi.base, standardFont());
-	StyleChanger dummy2(mi.base, display() ? LM_ST_DISPLAY : LM_ST_TEXT);
+	Changer dummy1 = mi.base.changeFontSet(standardFont());
+	Changer dummy2 = mi.base.font.changeStyle(display() ? LM_ST_DISPLAY
+	                                                    : LM_ST_TEXT);
 
 	// let the cells adjust themselves
 	InsetMathGrid::metrics(mi, dim);
@@ -478,7 +558,7 @@ void InsetMathHull::metrics(MetricsInfo & mi, Dimension & dim) const
 	}
 
 	if (numberedType()) {
-		FontSetChanger dummy(mi.base, from_ascii("mathbf"));
+		Changer dummy = mi.base.changeFontSet("mathbf");
 		int l = 0;
 		for (row_type row = 0; row < nrows(); ++row)
 			l = max(l, mathed_string_width(mi.base.font, nicelabel(row)));
@@ -487,17 +567,15 @@ void InsetMathHull::metrics(MetricsInfo & mi, Dimension & dim) const
 			dim.wid += 30 + l;
 	}
 
-	if (type_ == hullRegexp)
-		dim.wid += 2;
+	// reserve some space for marker.
+	dim.wid += 2;
+
 	// make it at least as high as the current font
 	int asc = 0;
 	int des = 0;
 	math_font_max_dim(mi.base.font, asc, des);
 	dim.asc = max(dim.asc, asc);
 	dim.des = max(dim.des, des);
-	// Cache the inset dimension.
-	// FIXME: This will overwrite InsetMathGrid dimension, is that OK?
-	setDimCache(mi, dim);
 }
 
 
@@ -536,15 +614,17 @@ void InsetMathHull::drawBackground(PainterInfo & pi, int x, int y) const
 void InsetMathHull::draw(PainterInfo & pi, int x, int y) const
 {
 	BufferView const * const bv = pi.base.bv;
+	Dimension const dim = dimension(*bv);
 
-	if (type_ == hullRegexp) {
-		Dimension const dim = dimension(*bv);
-		pi.pain.rectangle(x + 1, y - dim.ascent() + 1,
-			dim.width() - 2, dim.height() - 2, Color_regexpframe);
-	}
+	if (type_ == hullRegexp)
+		pi.pain.rectangle(x + 2, y - dim.ascent() + 1,
+		                  dim.width() - 3, dim.height() - 2, Color_regexpframe);
 
 	if (previewState(bv)) {
-		Dimension const dim = dimension(*bv);
+		// Do not draw change tracking cue if taken care of by RowPainter
+		// already.
+		Changer dummy = !canPaintChange(*bv) ? make_change(pi.change_, Change())
+			: Changer();
 		if (previewTooSmall(dim)) {
 			// we have an extra frame
 			preview_->draw(pi, x + ERROR_FRAME_WIDTH, y);
@@ -552,29 +632,34 @@ void InsetMathHull::draw(PainterInfo & pi, int x, int y) const
 			// one pixel gap in front
 			preview_->draw(pi, x + 1, y);
 		}
-		setPosCache(pi, x, y);
 		return;
 	}
 
 	ColorCode color = pi.selected && lyxrc.use_system_colors
 				? Color_selectiontext : standardColor();
 	bool const really_change_color = pi.base.font.color() == Color_none;
-	ColorChanger dummy0(pi.base.font, color, really_change_color);
-	FontSetChanger dummy1(pi.base, standardFont());
-	StyleChanger dummy2(pi.base, display() ? LM_ST_DISPLAY : LM_ST_TEXT);
+	Changer dummy0 = really_change_color ? pi.base.font.changeColor(color)
+		: Changer();
+	Changer dummy1 = pi.base.changeFontSet(standardFont());
+	Changer dummy2 = pi.base.font.changeStyle(display() ? LM_ST_DISPLAY
+	                                                    : LM_ST_TEXT);
 
 	InsetMathGrid::draw(pi, x + 1, y);
+	drawMarkers2(pi, x, y);
 
 	if (numberedType()) {
 		int const xx = x + colinfo_.back().offset_ + colinfo_.back().width_ + 20;
 		for (row_type row = 0; row < nrows(); ++row) {
 			int const yy = y + rowinfo_[row].offset_;
-			FontSetChanger dummy(pi.base, from_ascii("mathrm"));
+			Changer dummy = pi.base.changeFontSet("mathrm");
 			docstring const nl = nicelabel(row);
 			pi.draw(xx, yy, nl);
 		}
 	}
-	setPosCache(pi, x, y);
+	// drawing change line
+	if (canPaintChange(*bv))
+		pi.change_.paintCue(pi, x + 1, y + 1 - dim.asc,
+		                    x + dim.wid, y + dim.des);
 }
 
 
@@ -584,8 +669,7 @@ void InsetMathHull::metricsT(TextMetricsInfo const & mi, Dimension & dim) const
 		InsetMathGrid::metricsT(mi, dim);
 	} else {
 		odocstringstream os;
-		TexRow texrow(false);
-		otexrowstream ots(os,texrow);
+		otexrowstream ots(os);
 		WriteStream wi(ots, false, true, WriteStream::wsDefault);
 		write(wi);
 		dim.wid = os.str().size();
@@ -601,8 +685,7 @@ void InsetMathHull::drawT(TextPainter & pain, int x, int y) const
 		InsetMathGrid::drawT(pain, x, y);
 	} else {
 		odocstringstream os;
-		TexRow texrow(false);
-		otexrowstream ots(os,texrow);
+		otexrowstream ots(os);
 		WriteStream wi(ots, false, true, WriteStream::wsDefault);
 		write(wi);
 		pain.draw(x, y, os.str().c_str());
@@ -621,8 +704,7 @@ static docstring latexString(InsetMathHull const & inset)
 	static Encoding const * encoding = 0;
 	if (inset.isBufferValid())
 		encoding = &(inset.buffer().params().encoding());
-	TexRow texrow(false);
-	otexrowstream ots(ls,texrow);
+	otexrowstream ots(ls);
 	WriteStream wi(ots, false, true, WriteStream::wsPreview, encoding);
 	inset.write(wi);
 	return ls.str();
@@ -729,9 +811,7 @@ void InsetMathHull::preparePreview(DocIterator const & pos,
 		macro_preamble.append(*it);
 
 	// set the font series and size for this snippet
-	DocIterator dit = pos;
-	while (dit.inMathed())
-		dit.pop_back();
+	DocIterator dit = pos.getInnerText();
 	Paragraph const & par = dit.paragraph();
 	Font font = par.getFontSettings(buffer->params(), dit.pos());
 	font.fontInfo().realize(par.layout().font);
@@ -849,20 +929,22 @@ bool InsetMathHull::numbered(row_type row) const
 bool InsetMathHull::ams() const
 {
 	switch (type_) {
-		case hullAlign:
-		case hullFlAlign:
-		case hullMultline:
-		case hullGather:
-		case hullAlignAt:
-		case hullXAlignAt:
-		case hullXXAlignAt:
-			return true;
-		case hullNone:
-		case hullSimple:
-		case hullEquation:
-		case hullEqnArray:
-		case hullRegexp:
-			break;
+	case hullAlign:
+	case hullFlAlign:
+	case hullMultline:
+	case hullGather:
+	case hullAlignAt:
+	case hullXAlignAt:
+	case hullXXAlignAt:
+		return true;
+	case hullUnknown:
+	case hullRegexp:
+		return false;
+	case hullNone:
+	case hullSimple:
+	case hullEquation:
+	case hullEqnArray:
+		break;
 	}
 	for (size_t row = 0; row < numbered_.size(); ++row)
 		if (numbered_[row] == NOTAG)
@@ -871,23 +953,71 @@ bool InsetMathHull::ams() const
 }
 
 
+bool InsetMathHull::outerDisplay() const
+{
+	switch (type_) {
+	case hullEquation:
+	case hullEqnArray:
+	case hullAlign:
+	case hullFlAlign:
+	case hullGather:
+	case hullMultline:
+		return true;
+	case hullNone:
+	case hullSimple:
+	case hullAlignAt:
+	case hullXAlignAt:
+	case hullXXAlignAt:
+	case hullUnknown:
+	case hullRegexp:
+		break;
+	}
+	return false;
+}
+
+
 Inset::DisplayType InsetMathHull::display() const
 {
-	if (type_ == hullSimple || type_ == hullNone || type_ == hullRegexp)
+	switch (type_) {
+	case hullUnknown:
+	case hullSimple:
+	case hullNone:
+	case hullRegexp:
 		return Inline;
+	case hullEqnArray:
+	case hullAlign:
+	case hullFlAlign:
+	case hullAlignAt:
+	case hullXAlignAt:
+	case hullXXAlignAt:
+	case hullEquation:
+	case hullMultline:
+	case hullGather:
+		return AlignCenter;
+	}
+	// avoid warning
 	return AlignCenter;
 }
 
 bool InsetMathHull::numberedType() const
 {
-	if (type_ == hullNone)
-		return false;
-	if (type_ == hullSimple)
-		return false;
-	if (type_ == hullXXAlignAt)
-		return false;
-	if (type_ == hullRegexp)
+	switch (type_) {
+	case hullUnknown:
+	case hullNone:
+	case hullSimple:
+	case hullXXAlignAt:
+	case hullRegexp:
 		return false;
+	case hullEqnArray:
+	case hullAlign:
+	case hullFlAlign:
+	case hullAlignAt:
+	case hullXAlignAt:
+	case hullEquation:
+	case hullMultline:
+	case hullGather:
+		break;
+	}
 	for (row_type row = 0; row < nrows(); ++row)
 		if (numbered(row))
 			return true;
@@ -903,14 +1033,17 @@ void InsetMathHull::validate(LaTeXFeatures & features) const
 
 		if (type_ == hullRegexp) {
 			features.require("color");
-			string frcol = lcolor.getLaTeXName(Color_regexpframe);
-			string bgcol = "white";
+			docstring frcol = from_utf8(lcolor.getLaTeXName(Color_regexpframe));
+			docstring bgcol = from_ascii("white");
 			features.addPreambleSnippet(
-				string("\\newcommand{\\regexp}[1]{\\fcolorbox{")
-				+ frcol + string("}{")
-				+ bgcol + string("}{\\ensuremath{\\mathtt{#1}}}}"));
+				"\\newcommand{\\regexp}[1]{\\fcolorbox{"
+				+ frcol + "}{"
+				+ bgcol + "}{\\ensuremath{\\mathtt{#1}}}}");
 			features.addPreambleSnippet(
-				string("\\newcommand{\\endregexp}{}"));
+				from_ascii("\\newcommand{\\endregexp}{}"));
+		} else if (outerDisplay() && features.inDeletedInset()
+			   && !features.mustProvide("ct-dvipost")) {
+				features.require("ct-tikz-math-sout");
 		}
 
 		// Validation is necessary only if not using AMS math.
@@ -942,6 +1075,8 @@ void InsetMathHull::header_write(WriteStream & os) const
 		break;
 
 	case hullSimple:
+		if (os.ulemCmd())
+			os << "\\mbox{";
 		os << '$';
 		os.startOuterRow();
 		if (cell(0).empty())
@@ -949,6 +1084,7 @@ void InsetMathHull::header_write(WriteStream & os) const
 		break;
 
 	case hullEquation:
+		writeMathdisplayPreamble(os);
 		os << "\n";
 		os.startOuterRow();
 		if (n)
@@ -962,6 +1098,7 @@ void InsetMathHull::header_write(WriteStream & os) const
 	case hullFlAlign:
 	case hullGather:
 	case hullMultline:
+		writeMathdisplayPreamble(os);
 		os << "\n";
 		os.startOuterRow();
 		os << "\\begin{" << hullName(type_) << star(n) << "}\n";
@@ -986,7 +1123,7 @@ void InsetMathHull::header_write(WriteStream & os) const
 		os << "\\regexp{";
 		break;
 
-	default:
+	case hullUnknown:
 		os << "\n";
 		os.startOuterRow();
 		os << "\\begin{unknown" << star(n) << "}\n";
@@ -1006,6 +1143,8 @@ void InsetMathHull::footer_write(WriteStream & os) const
 
 	case hullSimple:
 		os << '$';
+		if (os.ulemCmd())
+			os << "}";
 		break;
 
 	case hullEquation:
@@ -1015,15 +1154,22 @@ void InsetMathHull::footer_write(WriteStream & os) const
 			os << "\\end{equation" << star(n) << "}\n";
 		else
 			os << "\\]\n";
+		writeMathdisplayPostamble(os);
 		break;
 
 	case hullEqnArray:
 	case hullAlign:
 	case hullFlAlign:
-	case hullAlignAt:
-	case hullXAlignAt:
 	case hullGather:
 	case hullMultline:
+		os << "\n";
+		os.startOuterRow();
+		os << "\\end{" << hullName(type_) << star(n) << "}\n";
+		writeMathdisplayPostamble(os);
+		break;
+
+	case hullAlignAt:
+	case hullXAlignAt:
 		os << "\n";
 		os.startOuterRow();
 		os << "\\end{" << hullName(type_) << star(n) << "}\n";
@@ -1040,7 +1186,7 @@ void InsetMathHull::footer_write(WriteStream & os) const
 		os << "\\endregexp{}}";
 		break;
 
-	default:
+	case hullUnknown:
 		os << "\n";
 		os.startOuterRow();
 		os << "\\end{unknown" << star(n) << "}\n";
@@ -1049,7 +1195,7 @@ void InsetMathHull::footer_write(WriteStream & os) const
 }
 
 
-bool InsetMathHull::isTable() const
+bool InsetMathHull::allowsTabularFeatures() const
 {
 	switch (type_) {
 	case hullEqnArray:
@@ -1065,6 +1211,7 @@ bool InsetMathHull::isTable() const
 	case hullSimple:
 	case hullEquation:
 	case hullRegexp:
+	case hullUnknown:
 		break;
 	}
 	return false;
@@ -1272,10 +1419,46 @@ void InsetMathHull::setType(HullType type)
 }
 
 
+bool InsetMathHull::isMutable(HullType type)
+{
+	switch (type) {
+	case hullNone:
+	case hullSimple:
+	case hullEquation:
+	case hullEqnArray:
+	case hullAlign:
+	case hullFlAlign:
+	case hullAlignAt:
+	case hullXAlignAt:
+	case hullXXAlignAt:
+	case hullMultline:
+	case hullGather:
+		return true;
+	case hullUnknown:
+	case hullRegexp:
+		return false;
+	}
+	// avoid warning
+	return false;
+}
+
+
 void InsetMathHull::mutate(HullType newtype)
 {
 	//lyxerr << "mutating from '" << type_ << "' to '" << newtype << "'" << endl;
 
+  	if (newtype == type_)
+		return;
+
+	// This guards the algorithm below it, which is designed with certain types
+	// in mind.
+	if (!isMutable(newtype) || !isMutable(type_)) {
+		lyxerr << "mutation from '" << to_utf8(hullName(type_))
+		       << "' to '" << to_utf8(hullName(newtype))
+		       << "' not implemented" << endl;
+		return;
+	}
+
 	// we try to move along the chain
 	// none <-> simple <-> equation <-> eqnarray -> *align* -> multline, gather -+
 	//                                     ^                                     |
@@ -1284,22 +1467,14 @@ void InsetMathHull::mutate(HullType newtype)
 	// directly supported because it handles labels and numbering for
 	// "down mutation".
 
-	if (newtype == type_) {
-		// done
-	}
-
-	else if (newtype < hullNone) {
-		// unknown type
-		dump();
-	}
-
-	else if (type_ == hullNone) {
+	switch (type_) {
+	case hullNone:
 		setType(hullSimple);
 		numbered(0, false);
 		mutate(newtype);
-	}
+		break;
 
-	else if (type_ == hullSimple) {
+	case hullSimple:
 		if (newtype == hullNone) {
 			setType(hullNone);
 			numbered(0, false);
@@ -1308,95 +1483,138 @@ void InsetMathHull::mutate(HullType newtype)
 			numbered(0, label_[0] ? true : false);
 			mutate(newtype);
 		}
-	}
+		break;
 
-	else if (type_ == hullEquation) {
-		if (newtype < type_) {
+	case hullEquation:
+		switch (newtype) {
+		case hullNone:
+		case hullSimple:
 			setType(hullSimple);
 			numbered(0, false);
 			mutate(newtype);
-		} else if (newtype == hullEqnArray) {
+			break;
+		case hullEqnArray:
 			// split it "nicely" on the first relop
 			splitTo3Cols();
 			setType(hullEqnArray);
-		} else if (newtype == hullMultline || newtype == hullGather) {
+			break;
+		case hullMultline:
+		case hullGather:
 			setType(newtype);
-		} else {
+			break;
+		default:
+			// *align*
 			// split it "nicely"
 			splitTo2Cols();
 			setType(hullAlign);
 			mutate(newtype);
+			break;
 		}
-	}
+		break;
 
-	else if (type_ == hullEqnArray) {
-		if (newtype < type_) {
+	case hullEqnArray:
+		switch (newtype) {
+		case hullNone:
+		case hullSimple:
+		case hullEquation:
 			glueall(newtype);
 			mutate(newtype);
-		} else { // align & Co.
+			break;
+		default:
+			// align & Co.
 			changeCols(2);
 			setType(hullAlign);
 			mutate(newtype);
+			break;
 		}
-	}
+		break;
 
-	else if (type_ ==  hullAlign || type_ == hullAlignAt ||
-		 type_ == hullXAlignAt || type_ == hullFlAlign) {
-		if (newtype < hullAlign) {
+	case hullAlign:
+	case hullAlignAt:
+	case hullXAlignAt:
+	case hullFlAlign:
+		switch (newtype) {
+		case hullNone:
+		case hullSimple:
+		case hullEquation:
+		case hullEqnArray:
 			changeCols(3);
 			setType(hullEqnArray);
 			mutate(newtype);
-		} else if (newtype == hullGather || newtype == hullMultline) {
+			break;
+		case hullGather:
+		case hullMultline:
 			changeCols(1);
 			setType(newtype);
-		} else if (newtype ==   hullXXAlignAt) {
+			break;
+		case hullXXAlignAt:
 			for (row_type row = 0; row < nrows(); ++row)
 				numbered(row, false);
 			setType(newtype);
-		} else {
+			break;
+		default:
 			setType(newtype);
+			break;
 		}
-	}
+		break;
 
-	else if (type_ == hullXXAlignAt) {
+	case hullXXAlignAt:
 		for (row_type row = 0; row < nrows(); ++row)
 			numbered(row, false);
-		if (newtype < hullAlign) {
+		switch (newtype) {
+		case hullNone:
+		case hullSimple:
+		case hullEquation:
+		case hullEqnArray:
 			changeCols(3);
 			setType(hullEqnArray);
 			mutate(newtype);
-		} else if (newtype == hullGather || newtype == hullMultline) {
+			break;
+		case hullGather:
+		case hullMultline:
 			changeCols(1);
 			setType(newtype);
-		} else {
+			break;
+		default:
 			setType(newtype);
+			break;
 		}
-	}
+		break;
 
-	else if (type_ == hullMultline || type_ == hullGather) {
-		if (newtype == hullGather || newtype == hullMultline)
+	case hullMultline:
+	case hullGather:
+		switch (newtype) {
+		case hullGather:
+		case hullMultline:
 			setType(newtype);
-		else if (newtype == hullAlign || newtype == hullFlAlign  ||
-			 newtype == hullAlignAt || newtype == hullXAlignAt) {
+			break;
+		case hullAlign:
+		case hullFlAlign:
+		case hullAlignAt:
+		case hullXAlignAt:
 			splitTo2Cols();
 			setType(newtype);
-		} else if (newtype ==   hullXXAlignAt) {
+			break;
+		case hullXXAlignAt:
 			splitTo2Cols();
 			for (row_type row = 0; row < nrows(); ++row)
 				numbered(row, false);
 			setType(newtype);
-		} else {
+			break;
+		default:
+			// first we mutate to EqnArray
 			splitTo3Cols();
 			setType(hullEqnArray);
 			mutate(newtype);
+			break;
 		}
-	}
+		break;
 
-	else {
-		lyxerr << "mutation from '" << to_utf8(hullName(type_))
-		       << "' to '" << to_utf8(hullName(newtype))
-		       << "' not implemented" << endl;
-	}
+	default:
+		// we passed the guard so we should not be here
+		LASSERT("Mutation not implemented, but should have been.", return);
+		break;
+	}// switch
 }
 
 
@@ -1474,7 +1692,12 @@ void InsetMathHull::doExtern(Cursor & cur, FuncRequest & func)
 	}
 
 	// only inline, display or eqnarray math is allowed
-	if (getType() > hullEqnArray) {
+	switch (getType()) {
+	case hullSimple:
+	case hullEquation:
+	case hullEqnArray:
+		break;
+	default:
 		frontend::Alert::warning(_("Bad math environment"),
 				_("Computation cannot be performed for AMS "
 				  "math environments.\nChange the math "
@@ -1734,7 +1957,7 @@ void InsetMathHull::doDispatch(Cursor & cur, FuncRequest & cmd)
 	}
 
 	case LFUN_TABULAR_FEATURE:
-		if (!isTable())
+		if (!allowsTabularFeatures())
 			cur.undispatched();
 		else
 			InsetMathGrid::doDispatch(cur, cmd);
@@ -1747,6 +1970,21 @@ void InsetMathHull::doDispatch(Cursor & cur, FuncRequest & cmd)
 }
 
 
+namespace {
+
+bool allowDisplayMath(Cursor const & cur)
+{
+	LATTEST(cur.depth() > 1);
+	Cursor tmpcur = cur;
+	tmpcur.pop();
+	FuncStatus status;
+	FuncRequest cmd(LFUN_MATH_DISPLAY);
+	return tmpcur.getStatus(cmd, status) && status.enabled();
+}
+
+}
+
+
 bool InsetMathHull::getStatus(Cursor & cur, FuncRequest const & cmd,
 		FuncStatus & status) const
 {
@@ -1771,32 +2009,14 @@ bool InsetMathHull::getStatus(Cursor & cur, FuncRequest const & cmd,
 	case LFUN_MATH_MUTATE: {
 		HullType const ht = hullType(cmd.argument());
 		status.setOnOff(type_ == ht);
-		status.setEnabled(true);
+		status.setEnabled(isMutable(ht) && isMutable(type_));
 
-		if (ht != hullSimple) {
-			Cursor tmpcur = cur;
-			while (!tmpcur.empty()) {
-				InsetCode code = tmpcur.inset().lyxCode();
-				if (code == BOX_CODE) {
-					return true;
-				} else if (code == TABULAR_CODE) {
-					FuncRequest tmpcmd(LFUN_MATH_DISPLAY);
-					if (tmpcur.getStatus(tmpcmd, status) && !status.enabled())
-						return true;
-				}
-				tmpcur.pop_back();
-			}
-		}
+		if (ht != hullSimple && status.enabled())
+			status.setEnabled(allowDisplayMath(cur));
 		return true;
 	}
 	case LFUN_MATH_DISPLAY: {
-		bool enable = true;
-		if (cur.depth() > 1) {
-			Inset const & in = cur[cur.depth()-2].inset();
-			if (in.lyxCode() == SCRIPT_CODE)
-				enable = display() != Inline;
-		}
-		status.setEnabled(enable);
+		status.setEnabled(display() != Inline || allowDisplayMath(cur));
 		status.setOnOff(display() != Inline);
 		return true;
 	}
@@ -1855,7 +2075,7 @@ bool InsetMathHull::getStatus(Cursor & cur, FuncRequest const & cmd,
 		return InsetMathGrid::getStatus(cur, cmd, status);
 
 	case LFUN_TABULAR_FEATURE: {
-		if (!isTable())
+		if (!allowsTabularFeatures())
 			return false;
 		string s = cmd.getArg(0);
 		if (!rowChangeOK()
@@ -2053,8 +2273,7 @@ bool InsetMathHull::searchForward(BufferView * bv, string const & str,
 void InsetMathHull::write(ostream & os) const
 {
 	odocstringstream oss;
-	TexRow texrow(false);
-	otexrowstream ots(oss,texrow);
+	otexrowstream ots(oss);
 	WriteStream wi(ots, false, false, WriteStream::wsDefault);
 	oss << "Formula ";
 	write(wi);
@@ -2097,8 +2316,7 @@ int InsetMathHull::plaintext(odocstringstream & os,
 	}
 
 	odocstringstream oss;
-	TexRow texrow(false);
-	otexrowstream ots(oss,texrow);
+	otexrowstream ots(oss);
 	Encoding const * const enc = encodings.fromLyXName("utf8");
 	WriteStream wi(ots, false, true, WriteStream::wsDefault, enc);
 
@@ -2140,8 +2358,7 @@ int InsetMathHull::docbook(odocstream & os, OutputParams const & runparams) cons
 	++ms.tab(); ms.cr(); ms.os() << '<' << bname << '>';
 
 	odocstringstream ls;
-	TexRow texrow;
-	otexstream ols(ls, texrow);
+	otexstream ols(ls);
 	if (runparams.flavor == OutputParams::XML) {
 		ms << MTag("alt role='tex' ");
 		// Workaround for db2latex: db2latex always includes equations with
@@ -2159,7 +2376,7 @@ int InsetMathHull::docbook(odocstream & os, OutputParams const & runparams) cons
 	} else {
 		ms << MTag("alt role='tex'");
 		latex(ols, runparams);
-		res = texrow.rows();
+		res = ols.texrow().rows();
 		ms << from_utf8(subst(subst(to_utf8(ls.str()), "&", "&amp;"), "<", "&lt;"));
 		ms << ETag("alt");
 	}
@@ -2364,7 +2581,9 @@ docstring InsetMathHull::xhtml(XHTMLStream & xs, OutputParams const & op) const
 	//    )
 	// but what follows is equivalent, since we'll enter only if either (a) we
 	// tried and failed with MathML or HTML or (b) didn't try yet at all but
-	// aren't doing LaTeX, in which case we are doing Images.
+	// aren't doing LaTeX.
+	//
+	// so this is for Images.
 	if (!success && mathtype != BufferParams::LaTeX) {
 		graphics::PreviewImage const * pimage = 0;
 		if (!op.dryrun) {
@@ -2391,7 +2610,7 @@ docstring InsetMathHull::xhtml(XHTMLStream & xs, OutputParams const & op) const
 
 			string const tag = (getType() == hullSimple) ? "span" : "div";
 			xs << html::CR()
-			   << html::StartTag(tag)
+			   << html::StartTag(tag, "style = \"text-align: center;\"")
 				 << html::CompTag("img", "src=\"" + filename + "\" alt=\"Mathematical Equation\"")
 				 << html::EndTag(tag)
 				 << html::CR();
@@ -2406,8 +2625,7 @@ docstring InsetMathHull::xhtml(XHTMLStream & xs, OutputParams const & op) const
 		// Unfortunately, we cannot use latexString() because we do not want
 		// $...$ or whatever.
 		odocstringstream ls;
-		TexRow texrow(false);
-		otexrowstream ots(ls,texrow);
+		otexrowstream ots(ls);
 		WriteStream wi(ots, false, true, WriteStream::wsPreview);
 		ModeSpecifier specifier(wi, MATH_MODE);
 		mathAsLatex(wi);
@@ -2458,4 +2676,12 @@ void InsetMathHull::recordLocation(DocIterator const & di)
 	docit_ = di;
 }
 
+
+bool InsetMathHull::canPaintChange(BufferView const &) const
+{
+	// We let RowPainter do it seamlessly for inline insets
+	return display() != Inline;
+}
+
+
 } // namespace lyx