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

diff --git a/src/mathed/MathData.cpp b/src/mathed/MathData.cpp
index 805f8b5495..f44f287095 100644
--- a/src/mathed/MathData.cpp
+++ b/src/mathed/MathData.cpp
@@ -1,34 +1,37 @@
 /**
- * \file MathArray.cpp
+ * \file MathData.cpp
  * This file is part of LyX, the document processor.
  * Licence details can be found in the file COPYING.
  *
  * \author André Pönitz
+ * \author Stefan Schimanski
  *
  * Full author contact details are available in file CREDITS.
  */
 
 #include <config.h>
 
-#include "MathArray.h"
+#include "MathData.h"
+#include "InsetMathBrace.h"
 #include "InsetMathFont.h"
 #include "InsetMathScript.h"
+#include "MacroTable.h"
 #include "MathMacro.h"
-#include "MathMacroTable.h"
 #include "MathStream.h"
 #include "MathSupport.h"
 #include "ReplaceData.h"
 
+#include "Buffer.h"
 #include "BufferView.h"
-#include "buffer.h"
-#include "cursor.h"
+#include "CoordCache.h"
+#include "Cursor.h"
 #include "debug.h"
-#include "LColor.h"
 
 #include "frontends/FontMetrics.h"
 #include "frontends/Painter.h"
 
 #include <boost/assert.hpp>
+#include <boost/next_prior.hpp>
 
 
 namespace lyx {
@@ -41,70 +44,70 @@ using std::string;
 using std::vector;
 
 
-MathArray::MathArray(const_iterator from, const_iterator to)
+MathData::MathData(const_iterator from, const_iterator to)
 	: base_type(from, to)
 {}
 
 
-MathAtom & MathArray::operator[](pos_type pos)
+MathAtom & MathData::operator[](pos_type pos)
 {
 	BOOST_ASSERT(pos < size());
 	return base_type::operator[](pos);
 }
 
 
-MathAtom const & MathArray::operator[](pos_type pos) const
+MathAtom const & MathData::operator[](pos_type pos) const
 {
 	BOOST_ASSERT(pos < size());
 	return base_type::operator[](pos);
 }
 
 
-void MathArray::insert(size_type pos, MathAtom const & t)
+void MathData::insert(size_type pos, MathAtom const & t)
 {
 	base_type::insert(begin() + pos, t);
 }
 
 
-void MathArray::insert(size_type pos, MathArray const & ar)
+void MathData::insert(size_type pos, MathData const & ar)
 {
 	BOOST_ASSERT(pos <= size());
 	base_type::insert(begin() + pos, ar.begin(), ar.end());
 }
 
 
-void MathArray::append(MathArray const & ar)
+void MathData::append(MathData const & ar)
 {
 	insert(size(), ar);
 }
 
 
-void MathArray::erase(size_type pos)
+void MathData::erase(size_type pos)
 {
 	if (pos < size())
 		erase(pos, pos + 1);
 }
 
 
-void MathArray::erase(iterator pos1, iterator pos2)
+void MathData::erase(iterator pos1, iterator pos2)
 {
 	base_type::erase(pos1, pos2);
 }
 
 
-void MathArray::erase(iterator pos)
+void MathData::erase(iterator pos)
 {
 	base_type::erase(pos);
 }
 
 
-void MathArray::erase(size_type pos1, size_type pos2)
+void MathData::erase(size_type pos1, size_type pos2)
 {
 	base_type::erase(begin() + pos1, begin() + pos2);
 }
 
 
-void MathArray::dump2() const
+void MathData::dump2() const
 {
 	odocstringstream os;
 	NormalStream ns(os);
@@ -114,7 +117,7 @@ void MathArray::dump2() const
 }
 
 
-void MathArray::dump() const
+void MathData::dump() const
 {
 	odocstringstream os;
 	NormalStream ns(os);
@@ -124,20 +127,20 @@ void MathArray::dump() const
 }
 
 
-void MathArray::validate(LaTeXFeatures & features) const
+void MathData::validate(LaTeXFeatures & features) const
 {
 	for (const_iterator it = begin(); it != end(); ++it)
 		(*it)->validate(features);
 }
 
 
-bool MathArray::match(MathArray const & ar) const
+bool MathData::match(MathData const & ar) const
 {
 	return size() == ar.size() && matchpart(ar, 0);
 }
 
 
-bool MathArray::matchpart(MathArray const & ar, pos_type pos) const
+bool MathData::matchpart(MathData const & ar, pos_type pos) const
 {
 	if (size() < ar.size() + pos)
 		return false;
@@ -149,7 +152,7 @@ bool MathArray::matchpart(MathArray const & ar, pos_type pos) const
 }
 
 
-void MathArray::replace(ReplaceData & rep)
+void MathData::replace(ReplaceData & rep)
 {
 	for (size_type i = 0; i < size(); ++i) {
 		if (find1(rep.from, i)) {
@@ -160,15 +163,13 @@ void MathArray::replace(ReplaceData & rep)
 		}
 	}
 
-#ifdef WITH_WARNINGS
-#warning temporarily disabled
+	// FIXME: temporarily disabled
 	// for (const_iterator it = begin(); it != end(); ++it)
 	//	it->nucleus()->replace(rep);
-#endif
 }
 
 
-bool MathArray::find1(MathArray const & ar, size_type pos) const
+bool MathData::find1(MathData const & ar, size_type pos) const
 {
 	lyxerr << "finding '" << ar << "' in '" << *this << "'" << endl;
 	for (size_type i = 0, n = ar.size(); i < n; ++i)
@@ -178,7 +179,7 @@ bool MathArray::find1(MathArray const & ar, size_type pos) const
 }
 
 
-MathArray::size_type MathArray::find(MathArray const & ar) const
+MathData::size_type MathData::find(MathData const & ar) const
 {
 	for (int i = 0, last = size() - ar.size(); i < last; ++i)
 		if (find1(ar, i))
@@ -187,7 +188,7 @@ MathArray::size_type MathArray::find(MathArray const & ar) const
 }
 
 
-MathArray::size_type MathArray::find_last(MathArray const & ar) const
+MathData::size_type MathData::find_last(MathData const & ar) const
 {
 	for (int i = size() - ar.size(); i >= 0; --i)
 		if (find1(ar, i))
@@ -196,7 +197,7 @@ MathArray::size_type MathArray::find_last(MathArray const & ar) const
 }
 
 
-bool MathArray::contains(MathArray const & ar) const
+bool MathData::contains(MathData const & ar) const
 {
 	if (find(ar) != size())
 		return true;
@@ -207,25 +208,14 @@ bool MathArray::contains(MathArray const & ar) const
 }
 
 
-void MathArray::touch() const
+void MathData::touch() const
 {
 }
 
 
-bool MathArray::metrics(MetricsInfo & mi, Dimension & dim) const
-{
-	dim = dim_;
-	metrics(mi);
-	if (dim_ == dim)
-		return false;
-	dim = dim_;
-	return true;
-}
-
-
 namespace {
 
-bool isInside(DocIterator const & it, MathArray const & ar,
+bool isInside(DocIterator const & it, MathData const & ar,
 	pos_type p1, pos_type p2)
 {
 	for (size_t i = 0; i != it.depth(); ++i) {
@@ -240,104 +230,75 @@ bool isInside(DocIterator const & it, MathArray const & ar,
 
 
 
-void MathArray::metrics(MetricsInfo & mi) const
+void MathData::metrics(MetricsInfo & mi, Dimension & dim) const
 {
 	frontend::FontMetrics const & fm = theFontMetrics(mi.base.font);
-	dim_ = fm.dimension('I');
+	dim = fm.dimension('I');
 	int xascent = fm.dimension('x').ascent();
-	if (xascent >= dim_.asc)
-		xascent = (2 * dim_.asc) / 3;
+	if (xascent >= dim.asc)
+		xascent = (2 * dim.asc) / 3;
 	minasc_ = xascent;
 	mindes_ = (3 * xascent) / 4;
 	slevel_ = (4 * xascent) / 5;
 	sshift_ = xascent / 4;
 	kerning_ = 0;
 
-	if (empty())
+	if (empty()) {
+		// Cache the dimension.
+		mi.base.bv->coordCache().arrays().add(this, dim);
 		return;
+	}
+
+	const_cast<MathData*>(this)->updateMacros(mi);
 
-	dim_.asc = 0;
-	dim_.wid = 0;
+	dim.asc = 0;
+	dim.wid = 0;
 	Dimension d;
-	//BufferView & bv  = *mi.base.bv;
-	//Buffer const & buf = *bv.buffer();
+	atom_dims_.clear();
 	for (size_t i = 0, n = size(); i != n; ++i) {
 		MathAtom const & at = operator[](i);
-#if 0
-		MathMacro const * mac = at->asMacro();
-		if (mac && buf.hasMacro(mac->name())) {
-			MacroData const & tmpl = buf.getMacro(mac->name());
-			int numargs = tmpl.numargs();
-			if (i + numargs > n)
-				numargs = n - i - 1;
-			lyxerr << "metrics:found macro: " << mac->name()
-				<< " numargs: " << numargs << endl;
-			if (!isInside(bv.cursor(), *this, i + 1, i + numargs + 1)) {
-				MathArray args(begin() + i + 1, begin() + i + numargs + 1);
-				MathArray exp;
-				tmpl.expand(args, exp);
-				mac->setExpansion(exp, args);
-				mac->metricsExpanded(mi, d);
-				dim_.wid += mac->widthExpanded();
-				i += numargs;
-				continue;
-			}
-		}
-#endif
 		at->metrics(mi, d);
-		dim_ += d;
+		atom_dims_.push_back(d);
+		dim += d;
 		if (i == n - 1)
 			kerning_ = at->kerning();
 	}
+	// Cache the dimension.
+	mi.base.bv->coordCache().arrays().add(this, dim);
 }
 
 
-void MathArray::draw(PainterInfo & pi, int x, int y) const
+void MathData::draw(PainterInfo & pi, int x, int y) const
 {
-	//lyxerr << "MathArray::draw: x: " << x << " y: " << y << endl;
+	//lyxerr << "MathData::draw: x: " << x << " y: " << y << endl;
 	BufferView & bv  = *pi.base.bv;
 	setXY(bv, x, y);
 
+	Dimension const & dim = bv.coordCache().getArrays().dim(this);
+
 	if (empty()) {
-		pi.pain.rectangle(x, y - ascent(), width(), height(), LColor::mathline);
+		pi.pain.rectangle(x, y - dim.ascent(), dim.width(), dim.height(), Color_mathline);
 		return;
 	}
 
 	// don't draw outside the workarea
-	if (y + descent() <= 0
-		|| y - ascent() >= bv.workHeight()
-		|| x + width() <= 0
+	if (y + dim.descent() <= 0
+		|| y - dim.ascent() >= bv.workHeight()
+		|| x + dim.width() <= 0
 		|| x >= bv. workWidth())
 		return;
 
 	for (size_t i = 0, n = size(); i != n; ++i) {
 		MathAtom const & at = operator[](i);
-#if 0
-	Buffer const & buf = bv.buffer();
-		// special macro handling
-		MathMacro const * mac = at->asMacro();
-		if (mac && buf.hasMacro(mac->name())) {
-			MacroData const & tmpl = buf.getMacro(mac->name());
-			int numargs = tmpl.numargs();
-			if (i + numargs > n)
-				numargs = n - i - 1;
-			if (!isInside(bv.cursor(), *this, i + 1, i + numargs + 1)) {
-				mac->drawExpanded(pi, x, y);
-				x += mac->widthExpanded();
-				i += numargs;
-				continue;
-			}
-		}
-#endif
 		bv.coordCache().insets().add(at.nucleus(), x, y);
 		at->drawSelection(pi, x, y);
 		at->draw(pi, x, y);
-		x += at->width();
+		x += atom_dims_[i].wid;
 	}
 }
 
 
-void MathArray::metricsT(TextMetricsInfo const & mi, Dimension & dim) const
+void MathData::metricsT(TextMetricsInfo const & mi, Dimension & dim) const
 {
 	dim.clear();
 	Dimension d;
@@ -348,7 +309,7 @@ void MathArray::metricsT(TextMetricsInfo const & mi, Dimension & dim) const
 }
 
 
-void MathArray::drawT(TextPainter & pain, int x, int y) const
+void MathData::drawT(TextPainter & pain, int x, int y) const
 {
 	//lyxerr << "x: " << x << " y: " << y << ' ' << pain.workAreaHeight() << endl;
 
@@ -363,13 +324,362 @@ void MathArray::drawT(TextPainter & pain, int x, int y) const
 }
 
 
-int MathArray::pos2x(size_type pos) const
+void MathData::updateMacros(MetricsInfo & mi) 
+{
+	Cursor & cur = mi.base.bv->cursor();
+
+	// go over the array and look for macros
+	for (size_t i = 0; i < size(); ++i) {
+		MathMacro * macroInset = operator[](i).nucleus()->asMacro();
+		if (!macroInset)
+			continue;
+		
+		// get macro
+		macroInset->updateMacro(mi);
+		size_t macroNumArgs = 0;
+		int macroOptionals = 0;
+		MacroData const * macro = macroInset->macro();
+		if (macro) {
+			macroNumArgs = macro->numargs();
+			macroOptionals = macro->optionals();
+		}
+
+		// store old and compute new display mode
+		MathMacro::DisplayMode newDisplayMode;
+		MathMacro::DisplayMode oldDisplayMode = macroInset->displayMode();
+		newDisplayMode = macroInset->computeDisplayMode(mi);
+
+		// arity changed or other reason to detach?
+		if (oldDisplayMode == MathMacro::DISPLAY_NORMAL
+				&& (macroInset->arity() != macroNumArgs
+						|| macroInset->optionals() != macroOptionals
+						|| newDisplayMode == MathMacro::DISPLAY_UNFOLDED)) {
+			detachMacroParameters(cur, i);
+		}
+
+		// the macro could have been copied while resizing this
+		macroInset = operator[](i).nucleus()->asMacro();
+
+		// Cursor in \label?
+		if (newDisplayMode != 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);
+		}
+
+		// update the display mode
+		macroInset->setDisplayMode(newDisplayMode);
+
+		// arity changed?
+		if (newDisplayMode == MathMacro::DISPLAY_NORMAL 
+				&& (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;
+			
+			// attach parameters
+			attachMacroParameters(cur, i, macroNumArgs, macroOptionals,
+				fromInitToNormalMode);
+		}
+
+		// give macro the chance to adapt to new situation
+		InsetMath * inset = operator[](i).nucleus();
+		if (inset->asScriptInset())
+			inset = inset->asScriptInset()->nuc()[0].nucleus();
+		BOOST_ASSERT(inset->asMacro());
+		inset->asMacro()->updateRepresentation(mi);
+	}
+}
+
+
+void MathData::detachMacroParameters(Cursor & cur, const size_type macroPos)
+{
+	MathMacro * macroInset = operator[](macroPos).nucleus()->asMacro();
+	
+	// detach all arguments
+	std::vector<MathData> detachedArgs;
+	if (macroPos + 1 == size())
+				// strip arguments if we are at the MathData end
+				macroInset->detachArguments(detachedArgs, true);
+	else
+				macroInset->detachArguments(detachedArgs, false);
+	
+	// find cursor slice
+	int curMacroSlice = cur.find(macroInset);
+	int curMacroIdx = -1;
+	int curMacroPos = -1;
+	std::vector<CursorSlice> argSlices;
+	if (curMacroSlice != -1) {
+				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;
+	}
+	
+	// optional arguments to be put back?
+	size_t p = macroPos + 1;
+	size_t j = 0;
+	for (; j < detachedArgs.size() && j < macroInset->optionals(); ++j) {
+		// another non-empty parameter follows?
+		bool canDropEmptyOptional = j >= lastNonEmptyOptional;
+		
+		// then we can drop empty optional parameters
+		if (detachedArgs[j].empty() && canDropEmptyOptional) {
+			if (curMacroIdx == j)
+				cur[curMacroSlice - 1].pos() = macroPos + 1;
+			continue;
+		}
+		
+		// Otherwise we don't drop an empty optional, put it back normally
+		MathData optarg;
+		asArray(from_ascii("[]"), optarg);
+		MathData & arg = detachedArgs[j];
+		
+		// look for "]", i.e. put a brace around?
+		InsetMathBrace * brace = 0;
+		for (size_t q = 0; q < arg.size(); ++q) {
+			if (arg[q]->getChar() == ']') {
+				// put brace
+				brace = new InsetMathBrace();
+				break;
+			}
+		}
+		
+		// put arg between []
+		if (brace) {
+			brace->cell(0) = arg;
+			optarg.insert(1, MathAtom(brace));
+		} else
+			optarg.insert(1, arg);
+		
+		// insert it into the array
+		insert(p, optarg);
+		p += optarg.size();
+		
+		// cursor in optional argument of macro?
+		if (curMacroIdx == j) {
+			if (brace) {
+				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))
+			// cursor right of macro
+			cur[curMacroSlice - 1].pos() += optarg.size();
+	}
+	
+	// put them back into the MathData
+	for (; j < detachedArgs.size(); ++j) {				
+		MathData const & arg = detachedArgs[j];
+		if (arg.size() == 1 && !arg[0]->asScriptInset()) // && arg[0]->asCharInset())
+			insert(p, arg[0]);
+		else
+			insert(p, MathAtom(new InsetMathBrace(arg)));
+		
+		// cursor in j-th argument of macro?
+		if (curMacroIdx == int(j)) {
+			if (operator[](p).nucleus()->asBraceInset()) {
+				cur[curMacroSlice - 1].pos() = p;
+				cur.append(0, curMacroPos);
+				cur.append(argSlices);
+			} else {
+				cur[curMacroSlice - 1].pos() = p; // + macroPos;
+				cur.append(argSlices);
+			}
+		} else if (cur[curMacroSlice - 1].pos() >= int(p))
+			++cur[curMacroSlice - 1].pos();
+		
+		++p;
+	}
+	
+	// FIXME: proper anchor handling, this removes the selection
+	cur.clearSelection();
+	cur.updateInsets(&cur.bottom().inset());
+}
+
+
+void MathData::attachMacroParameters(Cursor & cur, 
+	const size_type macroPos, const size_type macroNumArgs,
+	const int macroOptionals, const bool fromInitToNormalMode)
+{
+	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
+	size_t p = macroPos + 1;
+	size_t j = 0;
+	std::vector<MathData>detachedArgs;
+	MathAtom scriptToPutAround;
+	
+	// find cursor slice again
+	int thisSlice = cur.find(*this);
+	int thisPos = -1;
+	if (thisSlice != -1)
+		thisPos = cur[thisSlice].pos();
+	
+	// insert optional arguments?
+	for (; j < macroOptionals && p < size(); ++j) {
+		// 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;
+		for (; right < size(); ++right) {
+			if (operator[](right)->getChar() == ']')
+				// found right end
+				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 {
+			// 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;
+		}
+	}
+	
+	// insert normal arguments
+	for (; j < macroNumArgs && p < size(); ++j) {
+		MathAtom & cell = operator[](p);
+
+		// fix cursor
+		std::vector<CursorSlice> argSlices;
+		int argPos = 0;
+		if (thisPos == int(p)) {
+			cur.cutOff(thisSlice, argSlices);
+		}
+		
+		InsetMathBrace const * brace = cell->asBraceInset();
+		if (brace) {
+			// found brace, convert into argument
+			detachedArgs.push_back(brace->cell(0));
+			
+			// cursor inside of the brace or just in front of?
+			if (thisPos == int(p) && !argSlices.empty()) {
+				argPos = argSlices[0].pos();
+				argSlices.erase(argSlices.begin());
+			}
+		} else if (cell->asScriptInset() && j + 1 == macroNumArgs) {
+			// 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));
+			else
+				detachedArgs.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)) {
+				argSlices.clear();
+				cur.append(0, 0);
+			}
+		} else {
+			MathData array;
+			array.insert(0, cell);
+			detachedArgs.push_back(array);
+		}
+		
+		// put cursor in argument again
+		if (thisPos == int(p)) {
+			cur.append(j, 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();	
+}
+
+
+int MathData::pos2x(size_type pos) const
 {
 	return pos2x(pos, 0);
 }
 
 
-int MathArray::pos2x(size_type pos, int glue) const
+int MathData::pos2x(size_type pos, int glue) const
 {
 	int x = 0;
 	size_type target = min(pos, size());
@@ -379,19 +689,19 @@ int MathArray::pos2x(size_type pos, int glue) const
 			x += glue;
 		//lyxerr << "char: " << (*it)->getChar()
 		//	<< "width: " << (*it)->width() << std::endl;
-		x += (*it)->width();
+		x += atom_dims_[i].wid;
 	}
 	return x;
 }
 
 
-MathArray::size_type MathArray::x2pos(int targetx) const
+MathData::size_type MathData::x2pos(int targetx) const
 {
 	return x2pos(targetx, 0);
 }
 
 
-MathArray::size_type MathArray::x2pos(int targetx, int glue) const
+MathData::size_type MathData::x2pos(int targetx, int glue) const
 {
 	const_iterator it = begin();
 	int lastx = 0;
@@ -401,7 +711,7 @@ MathArray::size_type MathArray::x2pos(int targetx, int glue) const
 		lastx = currx;
 		if ((*it)->getChar() == ' ')
 			currx += glue;
-		currx += (*it)->width();
+		currx += atom_dims_[it - begin()].wid;
 	}
 
 	/**
@@ -424,48 +734,54 @@ MathArray::size_type MathArray::x2pos(int targetx, int glue) const
 }
 
 
-int MathArray::dist(BufferView const & bv, int x, int y) const
+int MathData::dist(BufferView const & bv, int x, int y) const
+{
+	return bv.coordCache().getArrays().squareDistance(this, x, y);
+}
+
+
+void MathData::setXY(BufferView & bv, int x, int y) const
 {
-	int xx = 0;
-	int yy = 0;
+	//lyxerr << "setting position cache for MathData " << this << std::endl;
+	bv.coordCache().arrays().add(this, x, y);
+}
 
-	const int xo_ = xo(bv);
-	const int yo_ = yo(bv);
 
-	if (x < xo_)
-		xx = xo_ - x;
-	else if (x > xo_ + width())
-		xx = x - xo_ - width();
+Dimension const & MathData::dimension(BufferView const & bv) const
+{
+	return bv.coordCache().getArrays().dim(this);
+}
+
 
-	if (y < yo_ - ascent())
-		yy = yo_ - ascent() - y;
-	else if (y > yo_ + descent())
-		yy = y - yo_ - descent();
+int MathData::xm(BufferView const & bv) const
+{
+	Geometry const & g = bv.coordCache().getArrays().geometry(this);
 
-	return xx + yy;
+	return g.pos.x_ + g.dim.wid / 2;
 }
 
 
-void MathArray::setXY(BufferView & bv, int x, int y) const
+int MathData::ym(BufferView const & bv) const
 {
-	//lyxerr << "setting position cache for MathArray " << this << std::endl;
-	bv.coordCache().arrays().add(this, x, y);
+	Geometry const & g = bv.coordCache().getArrays().geometry(this);
+
+	return g.pos.y_ + (g.dim.des - g.dim.asc) / 2;
 }
 
 
-int MathArray::xo(BufferView const & bv) const
+int MathData::xo(BufferView const & bv) const
 {
 	return bv.coordCache().getArrays().x(this);
 }
 
 
-int MathArray::yo(BufferView const & bv) const
+int MathData::yo(BufferView const & bv) const
 {
 	return bv.coordCache().getArrays().y(this);
 }
 
 
-std::ostream & operator<<(std::ostream & os, MathArray const & ar)
+std::ostream & operator<<(std::ostream & os, MathData const & ar)
 {
 	odocstringstream oss;
 	NormalStream ns(oss);
@@ -474,7 +790,7 @@ std::ostream & operator<<(std::ostream & os, MathArray const & ar)
 }
 
 
-odocstream & operator<<(odocstream & os, MathArray const & ar)
+odocstream & operator<<(odocstream & os, MathData const & ar)
 {
 	NormalStream ns(os);
 	ns << ar;