X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Fmathed%2FMathData.cpp;h=8fcf7466e34c825cfbe07f7badab5ca09befa1ee;hb=55a3dd7b346d29a52ba305a4558e9e380ef50f47;hp=f44f28709502f91840905b9f6992139fabf97704;hpb=12314897982e07afd8926c997f66d7bb08e7e1fd;p=lyx.git

diff --git a/src/mathed/MathData.cpp b/src/mathed/MathData.cpp
index f44f287095..8fcf7466e3 100644
--- a/src/mathed/MathData.cpp
+++ b/src/mathed/MathData.cpp
@@ -3,7 +3,7 @@
  * This file is part of LyX, the document processor.
  * Licence details can be found in the file COPYING.
  *
- * \author André Pönitz
+ * \author André Pönitz
  * \author Stefan Schimanski
  *
  * Full author contact details are available in file CREDITS.
@@ -12,6 +12,7 @@
 #include <config.h>
 
 #include "MathData.h"
+
 #include "InsetMathBrace.h"
 #include "InsetMathFont.h"
 #include "InsetMathScript.h"
@@ -19,46 +20,47 @@
 #include "MathMacro.h"
 #include "MathStream.h"
 #include "MathSupport.h"
+#include "MetricsInfo.h"
 #include "ReplaceData.h"
 
 #include "Buffer.h"
 #include "BufferView.h"
 #include "CoordCache.h"
 #include "Cursor.h"
-#include "debug.h"
+
+#include "mathed/InsetMathUnknown.h"
+
+#include "support/debug.h"
+#include "support/docstream.h"
 
 #include "frontends/FontMetrics.h"
 #include "frontends/Painter.h"
 
-#include <boost/assert.hpp>
+#include "support/lassert.h"
 #include <boost/next_prior.hpp>
 
+#include <cstdlib>
 
-namespace lyx {
+using namespace std;
 
-using std::abs;
-using std::endl;
-using std::min;
-using std::ostringstream;
-using std::string;
-using std::vector;
+namespace lyx {
 
 
-MathData::MathData(const_iterator from, const_iterator to)
-	: base_type(from, to)
+MathData::MathData(Buffer * buf, const_iterator from, const_iterator to)
+	: base_type(from, to), buffer_(buf)
 {}
 
 
 MathAtom & MathData::operator[](pos_type pos)
 {
-	BOOST_ASSERT(pos < size());
+	LASSERT(pos < size(), /**/);
 	return base_type::operator[](pos);
 }
 
 
 MathAtom const & MathData::operator[](pos_type pos) const
 {
-	BOOST_ASSERT(pos < size());
+	LASSERT(pos < size(), /**/);
 	return base_type::operator[](pos);
 }
 
@@ -71,7 +73,7 @@ void MathData::insert(size_type pos, MathAtom const & t)
 
 void MathData::insert(size_type pos, MathData const & ar)
 {
-	BOOST_ASSERT(pos <= size());
+	LASSERT(pos <= size(), /**/);
 	base_type::insert(begin() + pos, ar.begin(), ar.end());
 }
 
@@ -249,19 +251,36 @@ void MathData::metrics(MetricsInfo & mi, Dimension & dim) const
 		return;
 	}
 
-	const_cast<MathData*>(this)->updateMacros(mi);
+	Cursor & cur = mi.base.bv->cursor();
+	const_cast<MathData*>(this)->updateMacros(&cur, mi.macrocontext, InternalUpdate);
+
+	DocIterator const & inlineCompletionPos = mi.base.bv->inlineCompletionPos();
+	MathData const * inlineCompletionData = 0;
+	if (inlineCompletionPos.inMathed())
+		inlineCompletionData = &inlineCompletionPos.cell();
 
 	dim.asc = 0;
 	dim.wid = 0;
 	Dimension d;
-	atom_dims_.clear();
-	for (size_t i = 0, n = size(); i != n; ++i) {
+	CoordCacheBase<Inset> & coords = mi.base.bv->coordCache().insets();
+	for (pos_type i = 0, n = size(); i != n; ++i) {
 		MathAtom const & at = operator[](i);
 		at->metrics(mi, d);
-		atom_dims_.push_back(d);
+		coords.add(at.nucleus(), d);
 		dim += d;
 		if (i == n - 1)
-			kerning_ = at->kerning();
+			kerning_ = at->kerning(mi.base.bv);
+		
+		// HACK to draw completion suggestion inline
+		if (inlineCompletionData != this
+		    || size_t(inlineCompletionPos.pos()) != i + 1)
+			continue;
+		
+		docstring const & completion = mi.base.bv->inlineCompletion();
+		if (completion.length() == 0)
+			continue;
+		
+		dim.wid += mathed_string_width(mi.base.font, completion);
 	}
 	// Cache the dimension.
 	mi.base.bv->coordCache().arrays().add(this, dim);
@@ -288,12 +307,46 @@ void MathData::draw(PainterInfo & pi, int x, int y) const
 		|| x >= bv. workWidth())
 		return;
 
+	DocIterator const & inlineCompletionPos = bv.inlineCompletionPos();
+	MathData const * inlineCompletionData = 0;
+	if (inlineCompletionPos.inMathed())
+		inlineCompletionData = &inlineCompletionPos.cell();
+
+	CoordCacheBase<Inset> & coords = pi.base.bv->coordCache().insets();
 	for (size_t i = 0, n = size(); i != n; ++i) {
 		MathAtom const & at = operator[](i);
-		bv.coordCache().insets().add(at.nucleus(), x, y);
+		coords.add(at.nucleus(), x, y);
 		at->drawSelection(pi, x, y);
 		at->draw(pi, x, y);
-		x += atom_dims_[i].wid;
+		x += coords.dim(at.nucleus()).wid;
+		
+		// Is the inline completion here?
+		if (inlineCompletionData != this
+		    || size_t(inlineCompletionPos.pos()) != i + 1)
+			continue;
+		docstring const & completion = bv.inlineCompletion();
+		if (completion.length() == 0)
+			continue;
+		FontInfo f = pi.base.font;
+		
+		// draw the unique and the non-unique completion part
+		// Note: this is not time-critical as it is
+		// only done once per screen.
+		size_t uniqueTo = bv.inlineCompletionUniqueChars();
+		docstring s1 = completion.substr(0, uniqueTo);
+		docstring s2 = completion.substr(uniqueTo);
+		
+		if (s1.size() > 0) {
+			f.setColor(Color_inlinecompletion);
+			pi.pain.text(x, y, s1, f);
+			x += mathed_string_width(f, s1);
+		}
+		
+		if (s2.size() > 0) {
+			f.setColor(Color_nonunique_inlinecompletion);
+			pi.pain.text(x, y, s2, f);
+			x += mathed_string_width(f, s2);
+		}
 	}
 }
 
@@ -324,20 +377,40 @@ void MathData::drawT(TextPainter & pain, int x, int y) const
 }
 
 
-void MathData::updateMacros(MetricsInfo & mi) 
+void MathData::updateBuffer(ParIterator const & it, UpdateType utype)
 {
-	Cursor & cur = mi.base.bv->cursor();
+	// pass down
+	for (size_t i = 0, n = size(); i != n; ++i) {
+		MathAtom & at = operator[](i);
+		at.nucleus()->updateBuffer(it, utype);
+	}
+}
+
+
+void MathData::updateMacros(Cursor * cur, MacroContext const & mc,
+		UpdateType utype)
+{
+	// If we are editing a macro, we cannot update it immediately,
+	// otherwise wrong undo steps will be recorded (bug 6208).
+	InsetMath const * inmath = cur ? cur->inset().asInsetMath() : 0;
+	MathMacro const * inmacro = inmath ? inmath->asMacro() : 0;
+	docstring const edited_name = inmacro ? inmacro->name() : docstring();
 
 	// go over the array and look for macros
 	for (size_t i = 0; i < size(); ++i) {
 		MathMacro * macroInset = operator[](i).nucleus()->asMacro();
-		if (!macroInset)
+		if (!macroInset || macroInset->name_.empty()
+				|| macroInset->name_[0] == '^'
+				|| macroInset->name_[0] == '_'
+				|| (macroInset->name() == edited_name
+				    && macroInset->displayMode() ==
+						MathMacro::DISPLAY_UNFOLDED))
 			continue;
-		
+
 		// get macro
-		macroInset->updateMacro(mi);
+		macroInset->updateMacro(mc);
 		size_t macroNumArgs = 0;
-		int macroOptionals = 0;
+		size_t macroOptionals = 0;
 		MacroData const * macro = macroInset->macro();
 		if (macro) {
 			macroNumArgs = macro->numargs();
@@ -347,14 +420,18 @@ void MathData::updateMacros(MetricsInfo & mi)
 		// store old and compute new display mode
 		MathMacro::DisplayMode newDisplayMode;
 		MathMacro::DisplayMode oldDisplayMode = macroInset->displayMode();
-		newDisplayMode = macroInset->computeDisplayMode(mi);
+		newDisplayMode = macroInset->computeDisplayMode();
 
 		// arity changed or other reason to detach?
 		if (oldDisplayMode == MathMacro::DISPLAY_NORMAL
-				&& (macroInset->arity() != macroNumArgs
-						|| macroInset->optionals() != macroOptionals
-						|| newDisplayMode == MathMacro::DISPLAY_UNFOLDED)) {
+		    && (macroInset->arity() != macroNumArgs
+			|| macroInset->optionals() != macroOptionals
+			|| newDisplayMode == MathMacro::DISPLAY_UNFOLDED)) {
+
 			detachMacroParameters(cur, i);
+			// FIXME: proper anchor handling, this removes the selection
+			if (cur)
+				cur->clearSelection();
 		}
 
 		// the macro could have been copied while resizing this
@@ -362,73 +439,92 @@ void MathData::updateMacros(MetricsInfo & mi)
 
 		// Cursor in \label?
 		if (newDisplayMode != MathMacro::DISPLAY_UNFOLDED 
-				&& oldDisplayMode == MathMacro::DISPLAY_UNFOLDED) {
+		    && oldDisplayMode == MathMacro::DISPLAY_UNFOLDED) {
 			// put cursor in front of macro
-			int macroSlice = cur.find(macroInset);
-			if (macroSlice != -1)
-				cur.cutOff(macroSlice - 1);
+			if (cur) {
+				int macroSlice = cur->find(macroInset);
+				if (macroSlice != -1)
+					cur->cutOff(macroSlice - 1);
+			}
 		}
 
 		// update the display mode
+		size_t appetite = macroInset->appetite();
 		macroInset->setDisplayMode(newDisplayMode);
 
 		// arity changed?
 		if (newDisplayMode == MathMacro::DISPLAY_NORMAL 
-				&& (macroInset->arity() != macroNumArgs
-						|| macroInset->optionals() != macroOptionals)) {
+		    && (macroInset->arity() != macroNumArgs
+			|| macroInset->optionals() != macroOptionals)) {
 			// is it a virgin macro which was never attached to parameters?
 			bool fromInitToNormalMode
-			= oldDisplayMode == MathMacro::DISPLAY_INIT
-				&& newDisplayMode == MathMacro::DISPLAY_NORMAL;
+			= (oldDisplayMode == MathMacro::DISPLAY_INIT 
+			   || oldDisplayMode == MathMacro::DISPLAY_INTERACTIVE_INIT)
+			  && newDisplayMode == MathMacro::DISPLAY_NORMAL;
+			
+			// if the macro was entered interactively (i.e. not by paste or during
+			// loading), it should not be greedy, but the cursor should
+			// automatically jump into the macro when behind
+			bool interactive = (oldDisplayMode == MathMacro::DISPLAY_INTERACTIVE_INIT);
 			
 			// attach parameters
 			attachMacroParameters(cur, i, macroNumArgs, macroOptionals,
-				fromInitToNormalMode);
+				fromInitToNormalMode, interactive, appetite);
+			
+			if (cur) {
+				// FIXME: proper anchor handling, this removes the selection
+				cur->updateInsets(&cur->bottom().inset());
+				cur->clearSelection();	
+			}
 		}
 
-		// give macro the chance to adapt to new situation
+		// Give macro the chance to adapt to new situation.
+		// The macroInset could be invalid now because it was put into a script 
+		// inset and therefore "deep" copied. So get it again from the MathData.
 		InsetMath * inset = operator[](i).nucleus();
 		if (inset->asScriptInset())
 			inset = inset->asScriptInset()->nuc()[0].nucleus();
-		BOOST_ASSERT(inset->asMacro());
-		inset->asMacro()->updateRepresentation(mi);
+		LASSERT(inset->asMacro(), /**/);
+		inset->asMacro()->updateRepresentation(cur, mc, utype);
 	}
 }
 
 
-void MathData::detachMacroParameters(Cursor & cur, const size_type macroPos)
+void MathData::detachMacroParameters(DocIterator * cur, const size_type macroPos)
 {
 	MathMacro * macroInset = operator[](macroPos).nucleus()->asMacro();
 	
 	// detach all arguments
-	std::vector<MathData> detachedArgs;
+	vector<MathData> detachedArgs;
 	if (macroPos + 1 == size())
-				// strip arguments if we are at the MathData end
-				macroInset->detachArguments(detachedArgs, true);
+		// strip arguments if we are at the MathData end
+		macroInset->detachArguments(detachedArgs, true);
 	else
-				macroInset->detachArguments(detachedArgs, false);
+		macroInset->detachArguments(detachedArgs, false);
 	
 	// find cursor slice
-	int curMacroSlice = cur.find(macroInset);
-	int curMacroIdx = -1;
-	int curMacroPos = -1;
-	std::vector<CursorSlice> argSlices;
+	int curMacroSlice = -1;
+	if (cur)
+		curMacroSlice = cur->find(macroInset);
+	idx_type curMacroIdx = -1;
+	pos_type curMacroPos = -1;
+	vector<CursorSlice> argSlices;
 	if (curMacroSlice != -1) {
-				curMacroPos = cur[curMacroSlice].pos();
-				curMacroIdx = cur[curMacroSlice].idx();
-				cur.cutOff(curMacroSlice, argSlices);
-				cur.pop_back();
+		curMacroPos = (*cur)[curMacroSlice].pos();
+		curMacroIdx = (*cur)[curMacroSlice].idx();
+		cur->cutOff(curMacroSlice, argSlices);
+		cur->pop_back();
 	}
 	
 	// only [] after the last non-empty argument can be dropped later 
 	size_t lastNonEmptyOptional = 0;
 	for (size_t l = 0; l < detachedArgs.size() && l < macroInset->optionals(); ++l) {
-				if (!detachedArgs[l].empty())
-					lastNonEmptyOptional = l;
+		if (!detachedArgs[l].empty())
+			lastNonEmptyOptional = l;
 	}
 	
 	// optional arguments to be put back?
-	size_t p = macroPos + 1;
+	pos_type p = macroPos + 1;
 	size_t j = 0;
 	for (; j < detachedArgs.size() && j < macroInset->optionals(); ++j) {
 		// another non-empty parameter follows?
@@ -437,7 +533,7 @@ void MathData::detachMacroParameters(Cursor & cur, const size_type macroPos)
 		// then we can drop empty optional parameters
 		if (detachedArgs[j].empty() && canDropEmptyOptional) {
 			if (curMacroIdx == j)
-				cur[curMacroSlice - 1].pos() = macroPos + 1;
+				(*cur)[curMacroSlice - 1].pos() = macroPos + 1;
 			continue;
 		}
 		
@@ -451,7 +547,7 @@ void MathData::detachMacroParameters(Cursor & cur, const size_type macroPos)
 		for (size_t q = 0; q < arg.size(); ++q) {
 			if (arg[q]->getChar() == ']') {
 				// put brace
-				brace = new InsetMathBrace();
+				brace = new InsetMathBrace(buffer_);
 				break;
 			}
 		}
@@ -467,251 +563,325 @@ void MathData::detachMacroParameters(Cursor & cur, const size_type macroPos)
 		insert(p, optarg);
 		p += optarg.size();
 		
+		// cursor in macro?
+		if (curMacroSlice == -1)
+			continue;
+		
 		// cursor in optional argument of macro?
 		if (curMacroIdx == j) {
 			if (brace) {
-				cur.append(0, curMacroPos);
-				cur[curMacroSlice - 1].pos() = macroPos + 2;
+				cur->append(0, curMacroPos);
+				(*cur)[curMacroSlice - 1].pos() = macroPos + 2;
 			} else
-				cur[curMacroSlice - 1].pos() = macroPos + 2 + curMacroPos;
-			cur.append(argSlices);
-		} else if (cur[curMacroSlice - 1].pos() >= int(p))
+				(*cur)[curMacroSlice - 1].pos() = macroPos + 2 + curMacroPos;
+			cur->append(argSlices);
+		} else if ((*cur)[curMacroSlice - 1].pos() >= int(p))
 			// cursor right of macro
-			cur[curMacroSlice - 1].pos() += optarg.size();
+			(*cur)[curMacroSlice - 1].pos() += optarg.size();
 	}
 	
 	// put them back into the MathData
-	for (; j < detachedArgs.size(); ++j) {				
+	for (; j < detachedArgs.size(); ++j, ++p) {
 		MathData const & arg = detachedArgs[j];
-		if (arg.size() == 1 && !arg[0]->asScriptInset()) // && arg[0]->asCharInset())
+		if (arg.size() == 1 
+		    && !arg[0]->asScriptInset()
+		    && !(arg[0]->asMacro() && arg[0]->asMacro()->arity() > 0))
 			insert(p, arg[0]);
 		else
 			insert(p, MathAtom(new InsetMathBrace(arg)));
 		
+		// cursor in macro?
+		if (curMacroSlice == -1)
+			continue;
+		
 		// cursor in j-th argument of macro?
-		if (curMacroIdx == int(j)) {
+		if (curMacroIdx == j) {
 			if (operator[](p).nucleus()->asBraceInset()) {
-				cur[curMacroSlice - 1].pos() = p;
-				cur.append(0, curMacroPos);
-				cur.append(argSlices);
+				(*cur)[curMacroSlice - 1].pos() = p;
+				cur->append(0, curMacroPos);
+				cur->append(argSlices);
 			} else {
-				cur[curMacroSlice - 1].pos() = p; // + macroPos;
-				cur.append(argSlices);
+				(*cur)[curMacroSlice - 1].pos() = p; // + macroPos;
+				cur->append(argSlices);
 			}
-		} else if (cur[curMacroSlice - 1].pos() >= int(p))
-			++cur[curMacroSlice - 1].pos();
-		
-		++p;
+		} else if ((*cur)[curMacroSlice - 1].pos() >= int(p))
+			++(*cur)[curMacroSlice - 1].pos();
 	}
 	
-	// FIXME: proper anchor handling, this removes the selection
-	cur.clearSelection();
-	cur.updateInsets(&cur.bottom().inset());
+	if (cur)
+		cur->updateInsets(&cur->bottom().inset());
 }
 
 
-void MathData::attachMacroParameters(Cursor & cur, 
+void MathData::attachMacroParameters(Cursor * cur, 
 	const size_type macroPos, const size_type macroNumArgs,
-	const int macroOptionals, const bool fromInitToNormalMode)
+	const int macroOptionals, const bool fromInitToNormalMode,
+	const bool interactiveInit, const size_t appetite)
 {
 	MathMacro * macroInset = operator[](macroPos).nucleus()->asMacro();
 
-	// start at atom behind the macro again, maybe with some new arguments from above
-	// to add them back into the macro inset
+	// start at atom behind the macro again, maybe with some new arguments 
+	// from the detach phase above, to add them back into the macro inset
 	size_t p = macroPos + 1;
-	size_t j = 0;
-	std::vector<MathData>detachedArgs;
+	vector<MathData> detachedArgs;
 	MathAtom scriptToPutAround;
-	
-	// find cursor slice again
-	int thisSlice = cur.find(*this);
+
+	// find cursor slice again of this MathData
+	int thisSlice = -1;
+	if (cur)
+		thisSlice = cur->find(*this);
 	int thisPos = -1;
 	if (thisSlice != -1)
-		thisPos = cur[thisSlice].pos();
-	
+		thisPos = (*cur)[thisSlice].pos();
+
+	// find arguments behind the macro
+	if (!interactiveInit) {
+		collectOptionalParameters(cur, macroOptionals, detachedArgs, p,
+			scriptToPutAround, macroPos, thisPos, thisSlice);
+	}
+	collectParameters(cur, macroNumArgs, detachedArgs, p,
+		scriptToPutAround, macroPos, thisPos, thisSlice, appetite);
+
+	// attach arguments back to macro inset
+	macroInset->attachArguments(detachedArgs, macroNumArgs, macroOptionals);
+
+	// found tail script? E.g. \foo{a}b^x
+	if (scriptToPutAround.nucleus()) {
+		InsetMathScript * scriptInset =
+			scriptToPutAround.nucleus()->asScriptInset();
+		// In the math parser we remove empty braces in the base
+		// of a script inset, but we have to restore them here.
+		if (scriptInset->nuc().empty()) {
+			MathData ar;
+			scriptInset->nuc().push_back(
+					MathAtom(new InsetMathBrace(ar)));
+		}
+		// put macro into a script inset
+		scriptInset->nuc()[0] = operator[](macroPos);
+		operator[](macroPos) = scriptToPutAround;
+
+		// go into the script inset nucleus
+		if (cur && thisPos == int(macroPos))
+			cur->append(0, 0);
+
+		// get pointer to "deep" copied macro inset
+		scriptInset = operator[](macroPos).nucleus()->asScriptInset();
+		macroInset = scriptInset->nuc()[0].nucleus()->asMacro();	
+	}
+
+	// remove them from the MathData
+	erase(begin() + macroPos + 1, begin() + p);
+
+	// cursor outside this MathData?
+	if (thisSlice == -1)
+		return;
+
+	// fix cursor if right of p
+	if (thisPos >= int(p))
+		(*cur)[thisSlice].pos() -= p - (macroPos + 1);
+
+	// was the macro inset just inserted interactively and was now folded
+	// and the cursor is just behind?
+	if ((*cur)[thisSlice].pos() == int(macroPos + 1)
+	    && interactiveInit
+	    && fromInitToNormalMode
+	    && macroInset->arity() > 0
+	    && thisSlice + 1 == int(cur->depth())) {
+		// then enter it if the cursor was just behind
+		(*cur)[thisSlice].pos() = macroPos;
+		cur->push_back(CursorSlice(*macroInset));
+		macroInset->idxFirst(*cur);
+	}
+}
+
+
+void MathData::collectOptionalParameters(Cursor * cur, 
+	const size_type numOptionalParams, vector<MathData> & params, 
+	size_t & pos, MathAtom & scriptToPutAround,
+	const pos_type macroPos, const int thisPos, const int thisSlice)
+{
+	Buffer * buf = cur ? cur->buffer() : 0;
 	// insert optional arguments?
-	for (; j < macroOptionals && p < size(); ++j) {
+	while (params.size() < numOptionalParams 
+	       && pos < size()
+	       && !scriptToPutAround.nucleus()) {
 		// is a [] block following which could be an optional parameter?
-		if (operator[](p)->getChar() != '[') {
-			detachedArgs.push_back(MathData());
-			continue;
-		}
-				
-		// found optional argument, look for "]"
-		size_t right = p + 1;
+		if (operator[](pos)->getChar() != '[')
+			break;
+		
+		// found possible optional argument, look for "]"
+		size_t right = pos + 1;
 		for (; right < size(); ++right) {
-			if (operator[](right)->getChar() == ']')
+			MathAtom & cell = operator[](right);
+
+			if (cell->getChar() == ']')
 				// found right end
 				break;
+			
+			// maybe "]" with a script around?
+			InsetMathScript * script = cell.nucleus()->asScriptInset();
+			if (!script)
+				continue;
+			if (script->nuc().size() != 1)
+				continue;
+			if (script->nuc()[0]->getChar() == ']') {
+				// script will be put around the macro later
+				scriptToPutAround = cell;
+				break;
+			}
 		}
 		
 		// found?
-		if (right < size()) {
-			// add everything between [ and ] as optional argument
-			MathData optarg(begin() + p + 1, begin() + right);
-			// a brace?
-			bool brace = false;
-			if (optarg.size() == 1 && optarg[0]->asBraceInset()) {
-				brace = true;
-				detachedArgs.push_back(optarg[0]->asBraceInset()->cell(0));
-			} else
-				detachedArgs.push_back(optarg);
-			// place cursor in optional argument of macro
-			if (thisPos >= int(p) && thisPos <= int(right)) {
-				int pos = std::max(0, thisPos - int(p) - 1);
-				std::vector<CursorSlice> x;
-				cur.cutOff(thisSlice, x);
-				cur[thisSlice].pos() = macroPos;
-				if (brace) {
-					pos = x[0].pos();
-					x.erase(x.begin());
-				}
-				cur.append(0, pos);
-				cur.append(x);
-			}
-			p = right + 1;
-		} else {
+		if (right >= size()) {
 			// no ] found, so it's not an optional argument
-			// Note: This was "macroPos = p" before, which probably
-			//       does not make sense. We want to stop with optional
-			//       argument handling instead, so go back to the beginning.
-			j = 0; 
 			break;
 		}
+		
+		// add everything between [ and ] as optional argument
+		MathData optarg(buf, begin() + pos + 1, begin() + right);
+		
+		// a brace?
+		bool brace = false;
+		if (optarg.size() == 1 && optarg[0]->asBraceInset()) {
+			brace = true;
+			params.push_back(optarg[0]->asBraceInset()->cell(0));
+		} else
+			params.push_back(optarg);
+		
+		// place cursor in optional argument of macro
+		if (thisSlice != -1
+		    && thisPos >= int(pos) && thisPos <= int(right)) {
+			int paramPos = max(0, thisPos - int(pos) - 1);
+			vector<CursorSlice> x;
+			cur->cutOff(thisSlice, x);
+			(*cur)[thisSlice].pos() = macroPos;
+			if (brace) {
+				paramPos = x[0].pos();
+				x.erase(x.begin());
+			}
+			cur->append(0, paramPos);
+			cur->append(x);
+		}
+		pos = right + 1;
 	}
+
+	// fill up empty optional parameters
+	while (params.size() < numOptionalParams)
+		params.push_back(MathData());	
+}
+
+
+void MathData::collectParameters(Cursor * cur, 
+	const size_type numParams, vector<MathData> & params, 
+	size_t & pos, MathAtom & scriptToPutAround,
+	const pos_type macroPos, const int thisPos, const int thisSlice,
+	const size_t appetite) 
+{
+	size_t startSize = params.size();
 	
 	// insert normal arguments
-	for (; j < macroNumArgs && p < size(); ++j) {
-		MathAtom & cell = operator[](p);
-
+	while (params.size() < numParams
+	       && params.size() - startSize < appetite
+	       && pos < size()
+	       && !scriptToPutAround.nucleus()) {
+		MathAtom & cell = operator[](pos);
+		
 		// fix cursor
-		std::vector<CursorSlice> argSlices;
+		vector<CursorSlice> argSlices;
 		int argPos = 0;
-		if (thisPos == int(p)) {
-			cur.cutOff(thisSlice, argSlices);
-		}
+		if (thisSlice != -1 && thisPos == int(pos))
+			cur->cutOff(thisSlice, argSlices);		
 		
+		// which kind of parameter is it? In {}? With index x^n?
 		InsetMathBrace const * brace = cell->asBraceInset();
 		if (brace) {
 			// found brace, convert into argument
-			detachedArgs.push_back(brace->cell(0));
+			params.push_back(brace->cell(0));
 			
 			// cursor inside of the brace or just in front of?
-			if (thisPos == int(p) && !argSlices.empty()) {
+			if (thisPos == int(pos) && !argSlices.empty()) {
 				argPos = argSlices[0].pos();
 				argSlices.erase(argSlices.begin());
 			}
-		} else if (cell->asScriptInset() && j + 1 == macroNumArgs) {
+		} else if (cell->asScriptInset() && params.size() + 1 == numParams) {
 			// last inset with scripts without braces
 			// -> they belong to the macro, not the argument
 			InsetMathScript * script = cell.nucleus()->asScriptInset();
 			if (script->nuc().size() == 1 && script->nuc()[0]->asBraceInset())
 				// nucleus in brace? Unpack!
-				detachedArgs.push_back(script->nuc()[0]->asBraceInset()->cell(0));
+				params.push_back(script->nuc()[0]->asBraceInset()->cell(0));
 			else
-				detachedArgs.push_back(script->nuc());
+				params.push_back(script->nuc());
 			
 			// script will be put around below
 			scriptToPutAround = cell;
 			
 			// this should only happen after loading, so make cursor handling simple
-			if (thisPos >= int(macroPos) && thisPos <= int(macroPos + macroNumArgs)) {
+			if (thisPos >= int(macroPos) && thisPos <= int(macroPos + numParams)) {
 				argSlices.clear();
-				cur.append(0, 0);
+				if (cur)
+					cur->append(0, 0);
 			}
 		} else {
+			// the simplest case: plain inset
 			MathData array;
 			array.insert(0, cell);
-			detachedArgs.push_back(array);
+			params.push_back(array);
 		}
 		
 		// put cursor in argument again
-		if (thisPos == int(p)) {
-			cur.append(j, argPos);
-			cur.append(argSlices);
-			cur[thisSlice].pos() = macroPos;
+		if (thisSlice != - 1 && thisPos == int(pos)) {
+			cur->append(params.size() - 1, argPos);
+			cur->append(argSlices);
+			(*cur)[thisSlice].pos() = macroPos;
 		}
 		
-		++p;
-	}
-	
-	// attach arguments back to macro inset
-	macroInset->attachArguments(detachedArgs, macroNumArgs, macroOptionals);
-	
-	// found tail script? E.g. \foo{a}b^x
-	if (scriptToPutAround.nucleus()) {
-		// put macro into a script inset
-		scriptToPutAround.nucleus()->asScriptInset()->nuc()[0] 
-		= operator[](macroPos);
-		operator[](macroPos) = scriptToPutAround;
-		
-		if (thisPos == int(macroPos))
-			cur.append(0, 0);
-	}
-	
-	// remove them from the MathData
-	erase(begin() + macroPos + 1, begin() + p);
-	
-	// fix cursor if right of p
-	if (thisPos >= int(p))
-		cur[thisSlice].pos() -= p - (macroPos + 1);
-	
-	// was the macro inset just inserted and was now folded?
-	if (cur[thisSlice].pos() == int(macroPos + 1)
-			&& fromInitToNormalMode
-			&& macroInset->arity() > 0
-			&& thisSlice + 1 == int(cur.depth())) {
-		// then enter it if the cursor was just behind
-		cur[thisSlice].pos() = macroPos;
-		cur.push_back(CursorSlice(*macroInset));
-		macroInset->idxFirst(cur);
-	}
-	
-	// FIXME: proper anchor handling, this removes the selection
-	cur.updateInsets(&cur.bottom().inset());
-	cur.clearSelection();	
+		++pos;
+	}	
 }
 
 
-int MathData::pos2x(size_type pos) const
+int MathData::pos2x(BufferView const * bv, size_type pos) const
 {
-	return pos2x(pos, 0);
+	return pos2x(bv, pos, 0);
 }
 
 
-int MathData::pos2x(size_type pos, int glue) const
+int MathData::pos2x(BufferView const * bv, size_type pos, int glue) const
 {
 	int x = 0;
 	size_type target = min(pos, size());
+	CoordCacheBase<Inset> const & coords = bv->coordCache().getInsets();
 	for (size_type i = 0; i < target; ++i) {
 		const_iterator it = begin() + i;
 		if ((*it)->getChar() == ' ')
 			x += glue;
 		//lyxerr << "char: " << (*it)->getChar()
-		//	<< "width: " << (*it)->width() << std::endl;
-		x += atom_dims_[i].wid;
+		//	<< "width: " << (*it)->width() << endl;
+		x += coords.dim((*it).nucleus()).wid;
 	}
 	return x;
 }
 
 
-MathData::size_type MathData::x2pos(int targetx) const
+MathData::size_type MathData::x2pos(BufferView const * bv, int targetx) const
 {
-	return x2pos(targetx, 0);
+	return x2pos(bv, targetx, 0);
 }
 
 
-MathData::size_type MathData::x2pos(int targetx, int glue) const
+MathData::size_type MathData::x2pos(BufferView const * bv, int targetx, int glue) const
 {
 	const_iterator it = begin();
 	int lastx = 0;
 	int currx = 0;
+	CoordCacheBase<Inset> const & coords = bv->coordCache().getInsets();
 	// find first position after targetx
 	for (; currx < targetx && it < end(); ++it) {
 		lastx = currx;
 		if ((*it)->getChar() == ' ')
 			currx += glue;
-		currx += atom_dims_[it - begin()].wid;
+		currx += coords.dim((*it).nucleus()).wid;
 	}
 
 	/**
@@ -742,7 +912,7 @@ int MathData::dist(BufferView const & bv, int x, int y) const
 
 void MathData::setXY(BufferView & bv, int x, int y) const
 {
-	//lyxerr << "setting position cache for MathData " << this << std::endl;
+	//lyxerr << "setting position cache for MathData " << this << endl;
 	bv.coordCache().arrays().add(this, x, y);
 }
 
@@ -781,7 +951,7 @@ int MathData::yo(BufferView const & bv) const
 }
 
 
-std::ostream & operator<<(std::ostream & os, MathData const & ar)
+ostream & operator<<(ostream & os, MathData const & ar)
 {
 	odocstringstream oss;
 	NormalStream ns(oss);