X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Fmathed%2FMathMacroTemplate.cpp;h=d4cf4cfa560bbf830c9b982564ac9fb0aa7c35f8;hb=6c13af3f298a96c5564684b83c52989473b020ce;hp=257c55f639e867657a73fefb49e56a1a2a14ea2d;hpb=ff4460603e3888948b46f0ab5bfa69a862d538ad;p=lyx.git

diff --git a/src/mathed/MathMacroTemplate.cpp b/src/mathed/MathMacroTemplate.cpp
index 257c55f639..d4cf4cfa56 100644
--- a/src/mathed/MathMacroTemplate.cpp
+++ b/src/mathed/MathMacroTemplate.cpp
@@ -13,10 +13,9 @@
 
 #include "MathMacroTemplate.h"
 
-#include "DocIterator.h"
-#include "LaTeXFeatures.h"
 #include "InsetMathBrace.h"
 #include "InsetMathChar.h"
+#include "InsetMathHull.h"
 #include "InsetMathSqrt.h"
 #include "MathMacro.h"
 #include "MathMacroArgument.h"
@@ -30,13 +29,18 @@
 #include "Color.h"
 #include "Cursor.h"
 #include "DispatchResult.h"
+#include "DocIterator.h"
 #include "FuncRequest.h"
 #include "FuncStatus.h"
+#include "LaTeXFeatures.h"
 #include "Lexer.h"
-#include "Undo.h"
+#include "MetricsInfo.h"
+#include "TocBackend.h"
 
 #include "frontends/Painter.h"
 
+#include "insets/RenderPreview.h"
+
 #include "support/lassert.h"
 #include "support/convert.h"
 #include "support/debug.h"
@@ -44,6 +48,7 @@
 #include "support/docstream.h"
 #include "support/lstrings.h"
 
+#include <set>
 #include <sstream>
 
 using namespace std;
@@ -264,14 +269,12 @@ Inset * InsetMathWrapper::clone() const
 void InsetMathWrapper::metrics(MetricsInfo & mi, Dimension & dim) const
 {
 	value_->metrics(mi, dim);
-	//metricsMarkers2(dim);
 }
 
 
 void InsetMathWrapper::draw(PainterInfo & pi, int x, int y) const
 {
 	value_->draw(pi, x, y);
-	//drawMarkers(pi, x, y);
 }
 
 
@@ -364,6 +367,7 @@ Inset * InsetNameWrapper::clone() const
 
 void InsetNameWrapper::metrics(MetricsInfo & mi, Dimension & dim) const
 {
+	Changer dummy = mi.base.changeFontSet("textit");
 	InsetMathWrapper::metrics(mi, dim);
 	dim.wid += mathed_string_width(mi.base.font, from_ascii("\\"));
 }
@@ -371,19 +375,17 @@ void InsetNameWrapper::metrics(MetricsInfo & mi, Dimension & dim) const
 
 void InsetNameWrapper::draw(PainterInfo & pi, int x, int y) const
 {
-	// create fonts
-	PainterInfo namepi = pi;
-	if (parent_.validMacro())
-		namepi.base.font.setColor(Color_latex);
-	else
-		namepi.base.font.setColor(Color_error);
+	ColorCode const color = parent_.validMacro() ? Color_latex : Color_error;
+
+	Changer dummy = pi.base.changeFontSet("textit");
+	Changer dummy2 = pi.base.font.changeColor(color);
 
 	// draw backslash
-	pi.pain.text(x, y, from_ascii("\\"), namepi.base.font);
-	x += mathed_string_width(namepi.base.font, from_ascii("\\"));
+	pi.pain.text(x, y, from_ascii("\\"), pi.base.font);
+	x += mathed_string_width(pi.base.font, from_ascii("\\"));
 
 	// draw name
-	InsetMathWrapper::draw(namepi, x, y);
+	InsetMathWrapper::draw(pi, x, y);
 }
 
 
@@ -392,7 +394,8 @@ void InsetNameWrapper::draw(PainterInfo & pi, int x, int y) const
 
 MathMacroTemplate::MathMacroTemplate(Buffer * buf)
 	: InsetMathNest(buf, 3), numargs_(0), argsInLook_(0), optionals_(0),
-	  type_(MacroTypeNewcommand), lookOutdated_(true)
+	  type_(MacroTypeNewcommand), redefinition_(false), lookOutdated_(true),
+	  premetrics_(false), labelBoxAscent_(0), labelBoxDescent_(0)
 {
 	initMath();
 }
@@ -403,7 +406,8 @@ MathMacroTemplate::MathMacroTemplate(Buffer * buf, docstring const & name, int n
 	MathData const & def, MathData const & display)
 	: InsetMathNest(buf, optionals + 3), numargs_(numargs), argsInLook_(numargs),
 	  optionals_(optionals), optionalValues_(optionalValues),
-	  type_(type), lookOutdated_(true)
+	  type_(type), redefinition_(false), lookOutdated_(true),
+	  premetrics_(false), labelBoxAscent_(0), labelBoxDescent_(0)
 {
 	initMath();
 
@@ -422,26 +426,20 @@ MathMacroTemplate::MathMacroTemplate(Buffer * buf, docstring const & name, int n
 }
 
 
-MathMacroTemplate::MathMacroTemplate(Buffer * buf, docstring const & str)
-	: InsetMathNest(buf, 3), numargs_(0), optionals_(0),
-	type_(MacroTypeNewcommand), lookOutdated_(true)
+bool MathMacroTemplate::fromString(docstring const & str)
 {
-	buffer_ = buf;
-	initMath();
-
-	MathData ar(buf);
+	MathData ar(buffer_);
 	mathed_parse_cell(ar, str, Parse::NORMAL);
 	if (ar.size() != 1 || !ar[0]->asMacroTemplate()) {
 		lyxerr << "Cannot read macro from '" << ar << "'" << endl;
 		asArray(from_ascii("invalidmacro"), cell(0));
-		// FIXME: The macro template does not make sense after this.
-		// The whole parsing should not be in a constructor which
-		// has no chance to report failure.
-		return;
+		// The macro template does not make sense after this.
+		return false;
 	}
 	operator=( *(ar[0]->asMacroTemplate()) );
 
 	updateLook();
+	return true;
 }
 
 
@@ -461,7 +459,7 @@ docstring MathMacroTemplate::name() const
 }
 
 
-void MathMacroTemplate::updateToContext(MacroContext const & mc) const
+void MathMacroTemplate::updateToContext(MacroContext const & mc)
 {
 	redefinition_ = mc.get(name()) != 0;
 }
@@ -542,18 +540,14 @@ void MathMacroTemplate::createLook(int args) const
 
 void MathMacroTemplate::metrics(MetricsInfo & mi, Dimension & dim) const
 {
-	FontSetChanger dummy1(mi.base, from_ascii("mathnormal"));
-	StyleChanger dummy2(mi.base, LM_ST_TEXT);
+	Changer dummy1 = mi.base.changeFontSet("mathnormal");
+	Changer dummy2 = mi.base.font.changeStyle(LM_ST_TEXT);
 
 	// valid macro?
 	MacroData const * macro = 0;
-	if (validName()) {
+	if (validName())
 		macro = mi.macrocontext.get(name());
 
-		// updateToContext() - avoids another lookup
-		redefinition_ = macro != 0;
-	}
-
 	// update look?
 	int argsInDef = maxArgumentInDefinition();
 	if (lookOutdated_ || argsInDef != argsInLook_) {
@@ -581,24 +575,23 @@ void MathMacroTemplate::metrics(MetricsInfo & mi, Dimension & dim) const
 	dim.wid += 6;
 	dim.des += 2;
 	dim.asc += 2;
-
-	setDimCache(mi, dim);
 }
 
 
 void MathMacroTemplate::draw(PainterInfo & pi, int x, int y) const
 {
-	FontSetChanger dummy1(pi.base, from_ascii("mathnormal"));
-	StyleChanger dummy2(pi.base, LM_ST_TEXT);
+	// FIXME: Calling Changer on the same object repeatedly is inefficient.
+	Changer dummy0 = pi.base.font.changeColor(Color_math);
+	Changer dummy1 = pi.base.changeFontSet("mathnormal");
+	Changer dummy2 = pi.base.font.changeStyle(LM_ST_TEXT);
 
-	setPosCache(pi, x, y);
 	Dimension const dim = dimension(*pi.base.bv);
 
 	// draw outer frame
 	int const a = y - dim.asc + 1;
 	int const w = dim.wid - 2;
 	int const h = dim.height() - 2;
-	pi.pain.rectangle(x, a, w, h, Color_mathframe);
+	pi.pain.rectangle(x + 1, a, w, h, Color_mathframe);
 
 	// just to be sure: set some dummy values for coord cache
 	for (idx_type i = 0; i < nargs(); ++i)
@@ -612,29 +605,28 @@ void MathMacroTemplate::draw(PainterInfo & pi, int x, int y) const
 void MathMacroTemplate::edit(Cursor & cur, bool front, EntryDirection entry_from)
 {
 	updateLook();
-	cur.updateFlags(Update::SinglePar);
+	cur.screenUpdateFlags(Update::SinglePar);
 	InsetMathNest::edit(cur, front, entry_from);
 }
 
 
 bool MathMacroTemplate::notifyCursorLeaves(Cursor const & old, Cursor & cur)
 {
-	// find this in cursor old
-	Cursor insetCur = old;
-	int scriptSlice	= insetCur.find(this);
-	LASSERT(scriptSlice != -1, /**/);
-	insetCur.cutOff(scriptSlice);
-	
-	commitEditChanges(insetCur);
+	unsigned int const nargs_before = nargs();
+	commitEditChanges(cur, old);
 	updateLook();
-	cur.updateFlags(Update::Force);
-	return InsetMathNest::notifyCursorLeaves(old, cur);
+	cur.screenUpdateFlags(Update::Force);
+	// If we have removed a cell, we might have invalidated the cursor
+	return InsetMathNest::notifyCursorLeaves(old, cur)
+		|| nargs() < nargs_before;
 }
 
 
-void MathMacroTemplate::removeArguments(Cursor & cur, int from, int to)
+void MathMacroTemplate::removeArguments(Cursor & cur,
+	DocIterator const & /*inset_pos*/, int from, int to)
 {
-	for (DocIterator it = doc_iterator_begin(&buffer(), this); it; it.forwardChar()) {
+	DocIterator it = doc_iterator_begin(&buffer(), this);
+	for (; it; it.forwardChar()) {
 		if (!it.nextInset())
 			continue;
 		if (it.nextInset()->lyxCode() != MATH_MACROARG_CODE)
@@ -673,7 +665,7 @@ void MathMacroTemplate::shiftArguments(size_t from, int by)
 int MathMacroTemplate::maxArgumentInDefinition() const
 {
 	// We don't have a buffer when pasting from the clipboard (bug 6014).
-	Buffer const * macro_buffer = this->isBufferValid() ? &buffer() : 0;
+	Buffer const * macro_buffer = isBufferLoaded() ? &buffer() : 0;
 	int maxArg = 0;
 	DocIterator it = doc_iterator_begin(macro_buffer, this);
 	it.idx() = defIdx();
@@ -716,68 +708,97 @@ void MathMacroTemplate::insertMissingArguments(int maxArg)
 }
 
 
-void MathMacroTemplate::changeArity(Cursor & cur, int newNumArg)
+void MathMacroTemplate::changeArity(Cursor & cur,
+	DocIterator const & inset_pos, int newNumArg)
 {
 	// remove parameter which do not appear anymore in the definition
 	for (int i = numargs_; i > newNumArg; --i)
-		removeParameter(cur, numargs_ - 1, false);
+		removeParameter(cur, inset_pos, numargs_ - 1, true);
 	
 	// add missing parameter
 	for (int i = numargs_; i < newNumArg; ++i)
-		insertParameter(cur, numargs_, false, false);
+		insertParameter(cur, inset_pos, numargs_, true, false);
 }
 
 
-void MathMacroTemplate::commitEditChanges(Cursor & cur)
+///
+class AddRemoveMacroInstanceFix
 {
-	int argsInDef = maxArgumentInDefinition();
-	if (argsInDef != numargs_) {
-		cur.recordUndoFullDocument();
-		changeArity(cur, argsInDef);
+public:
+	///
+	AddRemoveMacroInstanceFix(int n, bool insert) : n_(n), insert_(insert) {}
+	///
+	void operator()(MathMacro * macro)
+	{
+		if (macro->folded()) {
+			if (insert_)
+				macro->insertArgument(n_);
+			else
+				macro->removeArgument(n_);
+		}
 	}
-	insertMissingArguments(argsInDef);
-}
 
+private:
+	///
+	int n_;
+	///
+	bool insert_;
+};
 
-// FIXME: factorize those functions here with a functional style, maybe using Boost's function
-// objects?
 
-void fixMacroInstancesAddRemove(Cursor const & from, docstring const & name, int n, bool insert) {
-	Cursor dit = from;
+///
+class OptionalsMacroInstanceFix
+{
+public:
+	///
+	OptionalsMacroInstanceFix(int optionals) : optionals_(optionals) {}
+	///
+	void operator()(MathMacro * macro)
+	{
+		macro->setOptionals(optionals_);
+	}
 
-	for (; dit; dit.forwardPos()) {
-		// only until a macro is redefined
-		if (dit.inset().lyxCode() == MATHMACRO_CODE) {
-			MathMacroTemplate const & macroTemplate
-			= static_cast<MathMacroTemplate const &>(dit.inset());
-			if (macroTemplate.name() == name)
-				break;
-		}
+private:
+	///
+	int optionals_;
+};
 
-		// in front of macro instance?
-		Inset * inset = dit.nextInset();
-		if (!inset)
-			continue;
-		InsetMath * insetMath = inset->asInsetMath();
-		if (!insetMath)
-			continue;
 
-		MathMacro * macro = insetMath->asMacro();
-		if (macro && macro->name() == name && macro->folded()) {
-			// found macro instance
-			if (insert)
-				macro->insertArgument(n);
-			else
-				macro->removeArgument(n);
-		}
-	}
-}
+///
+class NullMacroInstanceFix
+{
+public:
+	///
+	void operator()(MathMacro * ) {}
+};
 
 
-void fixMacroInstancesOptional(Cursor const & from, docstring const & name, int optionals) {
-	Cursor dit = from;
+template<class F>
+void fixMacroInstances(Cursor & cur, DocIterator const & inset_pos,
+	docstring const & name, F & fix)
+{
+	// goto position behind macro template
+	DocIterator dit = inset_pos;
+	dit.pop_back();
+	dit.top().forwardPos();
+
+	// remember hull to trigger preview reload
+	DocIterator hull(dit.buffer());
+	bool preview_reload_needed = false;
+	set<DocIterator> preview_hulls;
 
+	// iterate over all positions until macro is redefined
 	for (; dit; dit.forwardPos()) {
+		// left the outer hull?
+		if (!hull.empty() && dit.depth() == hull.depth()) {
+			// schedule reload of the preview if necessary 
+			if (preview_reload_needed) {
+				preview_hulls.insert(hull);
+				preview_reload_needed = false;
+			}
+			hull.clear();
+		}
+
 		// only until a macro is redefined
 		if (dit.inset().lyxCode() == MATHMACRO_CODE) {
 			MathMacroTemplate const & macroTemplate
@@ -793,48 +814,61 @@ void fixMacroInstancesOptional(Cursor const & from, docstring const & name, int
 		InsetMath * insetMath = inset->asInsetMath();
 		if (!insetMath)
 			continue;
+
+		// in front of outer hull?
+		InsetMathHull * inset_hull = insetMath->asHullInset();
+		if (inset_hull && hull.empty()) {
+			// remember this for later preview reload
+			hull = dit;
+		}
+
 		MathMacro * macro = insetMath->asMacro();
 		if (macro && macro->name() == name && macro->folded()) {
-			// found macro instance
-			macro->setOptionals(optionals);
+			fix(macro);
+			if (RenderPreview::previewMath())
+				preview_reload_needed = true;
 		}
 	}
-}
 
-
-template<class F>
-void fixMacroInstancesFunctional(Cursor const & from,
-	docstring const & name, F & fix) {
-	Cursor dit = from;
-
-	for (; dit; dit.forwardPos()) {
-		// only until a macro is redefined
-		if (dit.inset().lyxCode() == MATHMACRO_CODE) {
-			MathMacroTemplate const & macroTemplate
-			= static_cast<MathMacroTemplate const &>(dit.inset());
-			if (macroTemplate.name() == name)
-				break;
+	if (!preview_hulls.empty()) {
+		// reload the scheduled previews
+		set<DocIterator>::const_iterator sit = preview_hulls.begin();
+		set<DocIterator>::const_iterator end = preview_hulls.end();
+		for (; sit != end; ++sit) {
+			InsetMathHull * inset_hull =
+				sit->nextInset()->asInsetMath()->asHullInset();
+			LBUFERR(inset_hull);
+			inset_hull->reloadPreview(*sit);
 		}
+		cur.screenUpdateFlags(Update::Force);
+	}
+}
 
-		// in front of macro instance?
-		Inset * inset = dit.nextInset();
-		if (!inset)
-			continue;
-		InsetMath * insetMath = inset->asInsetMath();
-		if (!insetMath)
-			continue;
-		MathMacro * macro = insetMath->asMacro();
-		if (macro && macro->name() == name && macro->folded())
-			F(macro);
+
+void MathMacroTemplate::commitEditChanges(Cursor & cur,
+	DocIterator const & inset_pos)
+{
+	int args_in_def = maxArgumentInDefinition();
+	if (args_in_def != numargs_) {
+		// FIXME: implement precise undo handling (only a few places
+		//   need undo)
+		cur.recordUndoFullBuffer();
+		changeArity(cur, inset_pos, args_in_def);
 	}
+	insertMissingArguments(args_in_def);
+
+	// make sure the preview are up to date
+	NullMacroInstanceFix fix;
+	fixMacroInstances(cur, inset_pos, name(), fix);
 }
 
 
-void MathMacroTemplate::insertParameter(Cursor & cur, int pos, bool greedy, bool addarg)
+void MathMacroTemplate::insertParameter(Cursor & cur,
+	DocIterator const & inset_pos, int pos, bool greedy, bool addarg)
 {
 	if (pos <= numargs_ && pos >= optionals_ && numargs_ < 9) {
 		++numargs_;
-		
+
 		// append example #n
 		if (addarg) {
 			shiftArguments(pos, 1);
@@ -845,13 +879,9 @@ void MathMacroTemplate::insertParameter(Cursor & cur, int pos, bool greedy, bool
 		}
 
 		if (!greedy) {
-			Cursor dit = cur;
-			dit.leaveInset(*this);
-			// TODO: this was dit.forwardPosNoDescend before. Check that this is the same
-			dit.top().forwardPos();
-
 			// fix macro instances
-			fixMacroInstancesAddRemove(dit, name(), pos, true);
+			AddRemoveMacroInstanceFix fix(pos, true);
+			fixMacroInstances(cur, inset_pos, name(), fix);
 		}
 	}
 
@@ -859,11 +889,12 @@ void MathMacroTemplate::insertParameter(Cursor & cur, int pos, bool greedy, bool
 }
 
 
-void MathMacroTemplate::removeParameter(Cursor & cur, int pos, bool greedy)
+void MathMacroTemplate::removeParameter(Cursor & cur,
+	DocIterator const & inset_pos, int pos, bool greedy)
 {
 	if (pos < numargs_ && pos >= 0) {
 		--numargs_;
-		removeArguments(cur, pos, pos);
+		removeArguments(cur, inset_pos, pos, pos);
 		shiftArguments(pos + 1, -1);
 
 		// removed optional parameter?
@@ -886,13 +917,8 @@ void MathMacroTemplate::removeParameter(Cursor & cur, int pos, bool greedy)
 
 		if (!greedy) {
 			// fix macro instances
-			//boost::function<void(MathMacro *)> fix = _1->insertArgument(n);
-			//fixMacroInstancesFunctional(dit, name(), fix);
-			Cursor dit = cur;
-			dit.leaveInset(*this);
-			// TODO: this was dit.forwardPosNoDescend before. Check that this is the same
-			dit.top().forwardPos();
-			fixMacroInstancesAddRemove(dit, name(), pos, false);
+			AddRemoveMacroInstanceFix fix(pos, false);
+			fixMacroInstances(cur, inset_pos, name(), fix);
 		}
 	}
 
@@ -900,7 +926,9 @@ void MathMacroTemplate::removeParameter(Cursor & cur, int pos, bool greedy)
 }
 
 
-void MathMacroTemplate::makeOptional(Cursor & cur) {
+void MathMacroTemplate::makeOptional(Cursor & cur,
+	DocIterator const & inset_pos)
+{
 	if (numargs_ > 0 && optionals_ < numargs_) {
 		++optionals_;
 		cells_.insert(cells_.begin() + optIdx(optionals_ - 1), optionalValues_[optionals_ - 1]);
@@ -910,18 +938,17 @@ void MathMacroTemplate::makeOptional(Cursor & cur) {
 			++cur[macroSlice].idx();
 
 		// fix macro instances
-		Cursor dit = cur;
-		dit.leaveInset(*this);
-		// TODO: this was dit.forwardPosNoDescend before. Check that this is the same
-		dit.top().forwardPos();
-		fixMacroInstancesOptional(dit, name(), optionals_);
+		OptionalsMacroInstanceFix fix(optionals_);
+		fixMacroInstances(cur, inset_pos, name(), fix);
 	}
 
 	updateLook();
 }
 
 
-void MathMacroTemplate::makeNonOptional(Cursor & cur) {
+void MathMacroTemplate::makeNonOptional(Cursor & cur,
+	DocIterator const & inset_pos)
+{
 	if (numargs_ > 0 && optionals_ > 0) {
 		--optionals_;
 
@@ -942,11 +969,8 @@ void MathMacroTemplate::makeNonOptional(Cursor & cur) {
 		}
 
 		// fix macro instances
-		Cursor dit = cur;
-		dit.leaveInset(*this);
-		// TODO: this was dit.forwardPosNoDescend before. Check that this is the same
-		dit.top().forwardPos();
-		fixMacroInstancesOptional(dit, name(), optionals_);
+		OptionalsMacroInstanceFix fix(optionals_);
+		fixMacroInstances(cur, inset_pos, name(), fix);
 	}
 
 	updateLook();
@@ -956,81 +980,99 @@ void MathMacroTemplate::makeNonOptional(Cursor & cur) {
 void MathMacroTemplate::doDispatch(Cursor & cur, FuncRequest & cmd)
 {
 	string const arg = to_utf8(cmd.argument());
-	switch (cmd.action) {
+	switch (cmd.action()) {
 
 	case LFUN_MATH_MACRO_ADD_PARAM:
 		if (numargs_ < 9) {
-			commitEditChanges(cur);
-			cur.recordUndoFullDocument();
+			commitEditChanges(cur, cur);
+			// FIXME: implement precise undo handling (only a few places
+			//   need undo)
+			cur.recordUndoFullBuffer();
 			size_t pos = numargs_;
-			if (arg.size() != 0)
+			if (!arg.empty())
 				pos = (size_t)convert<int>(arg) - 1; // it is checked for >=0 in getStatus
-			insertParameter(cur, pos);
+			insertParameter(cur, cur, pos);
 		}
 		break;
 
 
 	case LFUN_MATH_MACRO_REMOVE_PARAM:
 		if (numargs_ > 0) {
-			commitEditChanges(cur);
-			cur.recordUndoFullDocument();
+			commitEditChanges(cur, cur);
+			// FIXME: implement precise undo handling (only a few places
+			//   need undo)
+			cur.recordUndoFullBuffer();
 			size_t pos = numargs_ - 1;
-			if (arg.size() != 0)
+			if (!arg.empty())
 				pos = (size_t)convert<int>(arg) - 1; // it is checked for >=0 in getStatus
-			removeParameter(cur, pos);
+			removeParameter(cur, cur, pos);
 		}
 		break;
 
 	case LFUN_MATH_MACRO_APPEND_GREEDY_PARAM:
 		if (numargs_ < 9) {
-			commitEditChanges(cur);
-			cur.recordUndoFullDocument();
-			insertParameter(cur, numargs_, true);
+			commitEditChanges(cur, cur);
+			// FIXME: implement precise undo handling (only a few places
+			//   need undo)
+			cur.recordUndoFullBuffer();
+			insertParameter(cur, cur, numargs_, true);
 		}
 		break;
 
 	case LFUN_MATH_MACRO_REMOVE_GREEDY_PARAM:
 		if (numargs_ > 0) {
-			commitEditChanges(cur);
-			cur.recordUndoFullDocument();
-			removeParameter(cur, numargs_ - 1, true);
+			commitEditChanges(cur, cur);
+			// FIXME: implement precise undo handling (only a few places
+			//   need undo)
+			cur.recordUndoFullBuffer();
+			removeParameter(cur, cur, numargs_ - 1, true);
 		}
 		break;
 
 	case LFUN_MATH_MACRO_MAKE_OPTIONAL:
-		commitEditChanges(cur);
-		cur.recordUndoFullDocument();
-		makeOptional(cur);
+		commitEditChanges(cur, cur);
+		// FIXME: implement precise undo handling (only a few places
+		//   need undo)
+		cur.recordUndoFullBuffer();
+		makeOptional(cur, cur);
 		break;
 
 	case LFUN_MATH_MACRO_MAKE_NONOPTIONAL:
-		commitEditChanges(cur);
-		cur.recordUndoFullDocument();
-		makeNonOptional(cur);
+		commitEditChanges(cur, cur);
+		// FIXME: implement precise undo handling (only a few places
+		//   need undo)
+		cur.recordUndoFullBuffer();
+		makeNonOptional(cur, cur);
 		break;
 
 	case LFUN_MATH_MACRO_ADD_OPTIONAL_PARAM:
 		if (numargs_ < 9) {
-			commitEditChanges(cur);
-			cur.recordUndoFullDocument();
-			insertParameter(cur, optionals_);
-			makeOptional(cur);
+			commitEditChanges(cur, cur);
+			// FIXME: implement precise undo handling (only a few places
+			//   need undo)
+			cur.recordUndoFullBuffer();
+			insertParameter(cur, cur, optionals_);
+			makeOptional(cur, cur);
 		}
 		break;
 
 	case LFUN_MATH_MACRO_REMOVE_OPTIONAL_PARAM:
 		if (optionals_ > 0) {
-			commitEditChanges(cur);
-			cur.recordUndoFullDocument();
-			removeParameter(cur, optionals_ - 1);
+			commitEditChanges(cur, cur);
+			// FIXME: implement precise undo handling (only a few places
+			//   need undo)
+			cur.recordUndoFullBuffer();
+			removeParameter(cur, cur, optionals_ - 1);
 		} break;
 
 	case LFUN_MATH_MACRO_ADD_GREEDY_OPTIONAL_PARAM:
 		if (numargs_ == optionals_) {
-			commitEditChanges(cur);
-			cur.recordUndoFullDocument();
-			insertParameter(cur, 0, true);
-			makeOptional(cur);
+			commitEditChanges(cur, cur);
+			// FIXME: implement precise undo handling (only a few places
+			//   need undo)
+			cur.recordUndoFullBuffer();
+			insertParameter(cur, cur, 0, true);
+			makeOptional(cur, cur);
 		}
 		break;
 
@@ -1041,15 +1083,15 @@ void MathMacroTemplate::doDispatch(Cursor & cur, FuncRequest & cmd)
 }
 
 
-bool MathMacroTemplate::getStatus(Cursor & /*cur*/, FuncRequest const & cmd,
+bool MathMacroTemplate::getStatus(Cursor & cur, FuncRequest const & cmd,
 	FuncStatus & flag) const
 {
 	bool ret = true;
 	string const arg = to_utf8(cmd.argument());
-	switch (cmd.action) {
+	switch (cmd.action()) {
 		case LFUN_MATH_MACRO_ADD_PARAM: {
 			int num = numargs_ + 1;
-			if (arg.size() != 0)
+			if (!arg.empty())
 				num = convert<int>(arg);
 			bool on = (num >= optionals_
 				   && numargs_ < 9 && num <= numargs_ + 1);
@@ -1061,9 +1103,10 @@ bool MathMacroTemplate::getStatus(Cursor & /*cur*/, FuncRequest const & cmd,
 			flag.setEnabled(numargs_ < 9);
 			break;
 
+		case LFUN_MATH_MACRO_REMOVE_GREEDY_PARAM:
 		case LFUN_MATH_MACRO_REMOVE_PARAM: {
 			int num = numargs_;
-			if (arg.size() != 0)
+			if (!arg.empty())
 				num = convert<int>(arg);
 			flag.setEnabled(num >= 1 && num <= numargs_);
 			break;
@@ -1098,7 +1141,7 @@ bool MathMacroTemplate::getStatus(Cursor & /*cur*/, FuncRequest const & cmd,
 			break;
 
 		default:
-			ret = false;
+			ret = InsetMathNest::getStatus(cur, cmd, flag);
 			break;
 	}
 	return ret;
@@ -1108,7 +1151,7 @@ bool MathMacroTemplate::getStatus(Cursor & /*cur*/, FuncRequest const & cmd,
 void MathMacroTemplate::read(Lexer & lex)
 {
 	MathData ar(buffer_);
-	mathed_parse_cell(ar, lex.getStream(), Parse::NORMAL);
+	mathed_parse_cell(ar, lex.getStream(), Parse::TRACKMACRO);
 	if (ar.size() != 1 || !ar[0]->asMacroTemplate()) {
 		lyxerr << "Cannot read macro from '" << ar << "'" << endl;
 		lyxerr << "Read: " << to_utf8(asString(ar)) << endl;
@@ -1123,7 +1166,8 @@ void MathMacroTemplate::read(Lexer & lex)
 void MathMacroTemplate::write(ostream & os) const
 {
 	odocstringstream oss;
-	WriteStream wi(oss, false, false, WriteStream::wsDefault);
+	otexrowstream ots(oss);
+	WriteStream wi(ots, false, false, WriteStream::wsDefault);
 	oss << "FormulaMacro\n";
 	write(wi);
 	os << to_utf8(oss.str());
@@ -1136,8 +1180,10 @@ void MathMacroTemplate::write(WriteStream & os) const
 }
 
 
-void MathMacroTemplate::write(WriteStream & os, bool overwriteRedefinition) const
+int MathMacroTemplate::write(WriteStream & os, bool overwriteRedefinition) const
 {
+	int num_lines = 0;
+
 	if (os.latex()) {
 		if (optionals_ > 0) {
 			// macros with optionals use the xargs package, e.g.:
@@ -1200,18 +1246,28 @@ void MathMacroTemplate::write(WriteStream & os, bool overwriteRedefinition) cons
 	if (os.latex()) {
 		// writing .tex. done.
 		os << "\n";
+		++num_lines;
 	} else {
 		// writing .lyx, write special .tex export only if necessary
-		if (!cell(displayIdx()).empty())
+		if (!cell(displayIdx()).empty()) {
 			os << "\n{" << cell(displayIdx()) << '}';
+			++num_lines;
+		}
 	}
+
+	return num_lines;
 }
 
 
-int MathMacroTemplate::plaintext(odocstream & os,
-				 OutputParams const &) const
+docstring MathMacroTemplate::xhtml(XHTMLStream &, OutputParams const &) const
+{
+	return docstring();
+}
+
+int MathMacroTemplate::plaintext(odocstringstream & os,
+				 OutputParams const &, size_t) const
 {
-	static docstring const str = '[' + buffer().B_("math macro") + ']';
+	docstring const str = '[' + buffer().B_("math macro") + ']';
 
 	os << str;
 	return str.size();
@@ -1222,8 +1278,7 @@ bool MathMacroTemplate::validName() const
 {
 	docstring n = name();
 
-	// empty name?
-	if (n.size() == 0)
+	if (n.empty())
 		return false;
 
 	// converting back and force doesn't swallow anything?
@@ -1272,7 +1327,7 @@ bool MathMacroTemplate::fixNameAndCheckIfValid()
 	}
 
 	// now it should be valid if anything in the name survived
-	return data.size() > 0;
+	return !data.empty();
 }
 
 	
@@ -1319,13 +1374,28 @@ size_t MathMacroTemplate::numOptionals() const
 
 void MathMacroTemplate::infoize(odocstream & os) const
 {
-	os << "Math Macro: \\" << name();
+	os << bformat(_("Math Macro: \\%1$s"), name());
 }
 
 
-docstring MathMacroTemplate::contextMenu(BufferView const &, int, int) const
+string MathMacroTemplate::contextMenuName() const
 {
-	return from_ascii("context-math-macro-definition");
+	return "context-math-macro-definition";
 }
 
+
+void MathMacroTemplate::addToToc(DocIterator const & pit, bool output_active,
+								 UpdateType, TocBackend & backend) const
+{
+	docstring str;
+	if (!validMacro())
+		str = bformat(_("Invalid macro! \\%1$s"), name());
+	else
+		str = "\\" + name();
+	TocBuilder & b = backend.builder("math-macro");
+	b.pushItem(pit, str, output_active);
+	b.pop();
+}
+
+
 } // namespace lyx