#include "BufferView.h"
#include "CoordCache.h"
#include "Cursor.h"
-#include "debug.h"
+#include "support/debug.h"
#include "support/docstream.h"
#include <boost/assert.hpp>
#include <boost/next_prior.hpp>
+using namespace std;
namespace lyx {
-using std::abs;
-using std::endl;
-using std::min;
-using std::ostringstream;
-using std::string;
-using std::vector;
-
MathData::MathData(const_iterator from, const_iterator to)
: base_type(from, to)
return;
}
- const_cast<MathData*>(this)->updateMacros(mi);
+ Cursor & cur = mi.base.bv->cursor();
+ const_cast<MathData*>(this)->updateMacros(&cur, mi.macrocontext);
dim.asc = 0;
dim.wid = 0;
}
-void MathData::updateMacros(MetricsInfo & mi)
+void MathData::updateMacros(Cursor * cur, MacroContext const & mc)
{
- 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();
continue;
// get macro
- macroInset->updateMacro(mi);
+ macroInset->updateMacro(mc);
size_t macroNumArgs = 0;
size_t macroOptionals = 0;
MacroData const * macro = macroInset->macro();
// 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)) {
+
detachMacroParameters(cur, i);
}
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);
+ if (cur) {
+ int macroSlice = cur->find(macroInset);
+ if (macroSlice != -1)
+ cur->cutOff(macroSlice - 1);
+ }
}
// update the display mode
// is it a virgin macro which was never attached to parameters?
bool fromInitToNormalMode
= (oldDisplayMode == MathMacro::DISPLAY_INIT
- || oldDisplayMode == MathMacro::DISPLAY_NONGREEDY_INIT)
+ || oldDisplayMode == MathMacro::DISPLAY_INTERACTIVE_INIT)
&& newDisplayMode == MathMacro::DISPLAY_NORMAL;
- bool greedy = (oldDisplayMode != MathMacro::DISPLAY_NONGREEDY_INIT);
+
+ // 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, greedy);
+ fromInitToNormalMode, interactive);
- // FIXME: proper anchor handling, this removes the selection
- cur.updateInsets(&cur.bottom().inset());
- cur.clearSelection();
+ 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);
+ inset->asMacro()->updateRepresentation(cur);
}
}
-void MathData::detachMacroParameters(Cursor & cur, const size_type macroPos)
+void MathData::detachMacroParameters(Cursor * 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 curMacroSlice = -1;
+ if (cur)
+ curMacroSlice = cur->find(macroInset);
idx_type curMacroIdx = -1;
pos_type curMacroPos = -1;
- std::vector<CursorSlice> argSlices;
+ 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?
// 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;
}
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 == 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) {
+ // FIXME: proper anchor handling, this removes the selection
+ cur->clearSelection();
+ 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 bool greedy)
+ const bool interactiveInit)
{
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;
- 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 (greedy) {
+ if (!interactiveInit) {
collectOptionalParameters(cur, macroOptionals, detachedArgs, p,
macroPos, thisPos, thisSlice);
collectParameters(cur, macroNumArgs, detachedArgs, p,
- scriptToPutAround,
- macroPos, thisPos, thisSlice);
+ scriptToPutAround, macroPos, thisPos, thisSlice);
}
// attach arguments back to macro inset
scriptToPutAround.nucleus()->asScriptInset()->nuc()[0]
= operator[](macroPos);
operator[](macroPos) = scriptToPutAround;
+
+ // go into the script inset nucleus
+ if (cur && thisPos == int(macroPos))
+ cur->append(0, 0);
- if (thisPos == int(macroPos))
- cur.append(0, 0);
+ // get pointer to "deep" copied macro inset
+ InsetMathScript * 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);
+ (*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())) {
+ // 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);
+ (*cur)[thisSlice].pos() = macroPos;
+ cur->push_back(CursorSlice(*macroInset));
+ macroInset->idxFirst(*cur);
}
}
-void MathData::collectOptionalParameters(Cursor & cur,
- const size_type numOptionalParams, std::vector<MathData> & params,
+void MathData::collectOptionalParameters(Cursor * cur,
+ const size_type numOptionalParams, vector<MathData> & params,
size_t & pos, const pos_type macroPos, const int thisPos, const int thisSlice)
{
// insert optional arguments?
// is a [] block following which could be an optional parameter?
if (operator[](pos)->getChar() != '[')
break;
-
+
// found possible optional argument, look for "]"
size_t right = pos + 1;
for (; right < size(); ++right) {
params.push_back(optarg);
// place cursor in optional argument of macro
- if (thisPos >= int(pos) && thisPos <= int(right)) {
- int paramPos = std::max(0, thisPos - int(pos) - 1);
- std::vector<CursorSlice> x;
- cur.cutOff(thisSlice, x);
- cur[thisSlice].pos() = macroPos;
+ 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);
+ cur->append(0, paramPos);
+ cur->append(x);
}
pos = right + 1;
}
// fill up empty optional parameters
- while (params.size() < numOptionalParams) {
- params.push_back(MathData());
- }
+ while (params.size() < numOptionalParams)
+ params.push_back(MathData());
}
-void MathData::collectParameters(Cursor & cur,
- const size_type numParams, std::vector<MathData> & params,
+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)
{
MathAtom & cell = operator[](pos);
// fix cursor
- std::vector<CursorSlice> argSlices;
+ vector<CursorSlice> argSlices;
int argPos = 0;
- if (thisPos == int(pos)) {
- 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();
// this should only happen after loading, so make cursor handling simple
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
}
// put cursor in argument again
- if (thisPos == int(pos)) {
- cur.append(params.size() - 1, 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;
}
++pos;
if ((*it)->getChar() == ' ')
x += glue;
//lyxerr << "char: " << (*it)->getChar()
- // << "width: " << (*it)->width() << std::endl;
+ // << "width: " << (*it)->width() << endl;
x += atom_dims_[i].wid;
}
return x;
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);
}
}
-std::ostream & operator<<(std::ostream & os, MathData const & ar)
+ostream & operator<<(ostream & os, MathData const & ar)
{
odocstringstream oss;
NormalStream ns(oss);
projects / features.git / blobdiff