// define a function for tests
-typedef bool TestItemFunc(MathInset *);
+typedef bool TestItemFunc(MathInset const *);
// define a function for replacing subexpressions
typedef MathInset * ReplaceArgumentFunc(const MathArray & ar);
if (!ar[i]->asCharInset())
continue;
string s = charSequence(ar.begin() + i, ar.end());
- ar[i].reset(new MathStringInset(s));
+ ar[i] = MathAtom(new MathStringInset(s));
ar.erase(i + 1, i + s.size());
}
//lyxerr << "\nStrings to: " << ar << "\n";
}
-MathInset * singleItem(MathArray & ar)
+MathInset const * singleItem(MathArray const & ar)
{
return ar.size() == 1 ? ar.begin()->nucleus() : 0;
}
MathDelimInset * del = (*it)->asDelimInset();
if (!del)
continue;
- MathInset * arr = singleItem(del->cell(0));
+ MathInset const * arr = singleItem(del->cell(0));
if (!arr || !arr->asGridInset())
continue;
*it = MathAtom(new MathMatrixInset(*(arr->asGridInset())));
// convert this inset somehow to a string
-bool extractString(MathInset * p, string & str)
+bool extractString(MathInset const * p, string & str)
{
if (!p)
return false;
}
-bool testString(MathInset * p, const string & str)
+bool testString(MathInset const * p, const string & str)
{
string s;
return extractString(p, s) && str == s;
// replace the original stuff by the new inset
ar.erase(it + 1, jt + 1);
- (*it).reset(p);
+ *it = MathAtom(p);
}
}
continue;
// create a proper exp-inset as replacement
- *it = new MathExFuncInset("exp", sup->cell(1));
+ *it = MathAtom(new MathExFuncInset("exp", sup->cell(1)));
ar.erase(it + 1);
}
//lyxerr << "\nExps to: " << ar << "\n";
continue;
if (!del->isAbs())
continue;
- *it = new MathExFuncInset("det", del->cell(0));
+ *it = MathAtom(new MathExFuncInset("det", del->cell(0)));
}
//lyxerr << "\ndet to: " << ar << "\n";
}
string s = digitSequence(ar.begin() + i, ar.end());
- ar[i].reset(new MathNumberInset(s));
+ ar[i] = MathAtom(new MathNumberInset(s));
ar.erase(i + 1, i + s.size());
}
//lyxerr << "\nNumbers to: " << ar << "\n";
// search deliminiters
//
-bool testOpenParan(MathInset * p)
+bool testOpenParan(MathInset const * p)
{
return testString(p, "(");
}
-bool testCloseParan(MathInset * p)
+bool testCloseParan(MathInset const * p)
{
return testString(p, ")");
}
// is it a function?
if ((*it)->asUnknownInset()) {
// it certainly is if it is well known...
- name = (*it)->asUnknownInset()->name();
+ name = (*it)->name();
} else {
// is this a user defined function?
// it it probably not, if it doesn't have a name.
MathArray::iterator st = extractArgument(p->cell(0), jt, ar.end());
// replace the function name by a real function inset
- (*it).reset(p);
+ *it = MathAtom(p);
// remove the source of the argument from the array
ar.erase(it + 1, st);
// search integrals
//
-bool testSymbol(MathInset * p, string const & name)
+bool testSymbol(MathInset const * p, string const & name)
{
return p->asSymbolInset() && p->asSymbolInset()->name() == name;
}
-bool testIntSymbol(MathInset * p)
+bool testIntSymbol(MathInset const * p)
{
return testSymbol(p, "int");
}
-bool testIntegral(MathInset * p)
+bool testIntegral(MathInset const * p)
{
return
testIntSymbol(p) ||
-bool testIntDiff(MathInset * p)
+bool testIntDiff(MathInset const * p)
{
return testString(p, "d");
}
// handle scripts if available
if (!testIntSymbol(it->nucleus())) {
- p->cell(2) = it->nucleus()->asScriptInset()->down().data();
- p->cell(3) = it->nucleus()->asScriptInset()->up().data();
+ p->cell(2) = it->nucleus()->asScriptInset()->down();
+ p->cell(3) = it->nucleus()->asScriptInset()->up();
}
p->cell(0) = MathArray(it + 1, jt);
// remove used parts
ar.erase(it + 1, tt);
- (*it).reset(p);
+ *it = MathAtom(p);
}
//lyxerr << "\nIntegrals to: " << ar << "\n";
}
}
-bool testSumSymbol(MathInset * p)
+bool testSumSymbol(MathInset const * p)
{
return testSymbol(p, "sum");
}
-bool testSum(MathInset * p)
+bool testSum(MathInset const * p)
{
return
testSumSymbol(p) ||
MathScriptInset * sub = (*it)->asScriptInset();
if (sub && sub->hasDown()) {
// try to figure out the summation index from the subscript
- MathArray & ar = sub->down().data();
+ MathArray & ar = sub->down();
MathArray::iterator xt =
find_if(ar.begin(), ar.end(), &testEqualSign);
if (xt != ar.end()) {
// collect upper bound
if (sub && sub->hasUp())
- p->cell(3) = sub->up().data();
+ p->cell(3) = sub->up();
// use something behind the script as core
MathArray::iterator tt = extractArgument(p->cell(0), it + 1, ar.end());
// cleanup
ar.erase(it + 1, tt);
- (*it).reset(p);
+ *it = MathAtom(p);
}
//lyxerr << "\nSums to: " << ar << "\n";
}
}
-bool testDiffFrac(MathInset * p)
+bool testDiffFrac(MathInset const * p)
{
- MathFracInset * f = p->asFracInset();
+ MathFracInset const * f = p->asFracInset();
return f && testDiffArray(f->cell(0)) && testDiffArray(f->cell(1));
}
if (script && script->hasUp()) {
// things like d.../dx^n
int mult = 1;
- if (extractNumber(script->up().data(), mult)) {
+ if (extractNumber(script->up(), mult)) {
//lyxerr << "mult: " << mult << endl;
for (int i = 0; i < mult; ++i)
diff->addDer(MathArray(dt + 1, st));
// cleanup
ar.erase(it + 1, jt);
- (*it).reset(diff);
+ *it = MathAtom(diff);
}
//lyxerr << "\nDiffs to: " << ar << "\n";
}
continue;
// and it must contain a -> symbol
- MathArray & s = sub->down().data();
+ MathArray & s = sub->down();
MathArray::iterator st = find_if(s.begin(), s.end(), &testRightArrow);
if (st == s.end())
continue;
MathArray f;
MathArray::iterator tt = extractArgument(f, it + 2, ar.end());
- // create a proper inset as replacement
- MathLimInset * p = new MathLimInset(f, x, x0);
-
// cleanup
ar.erase(it + 1, tt);
- (*it).reset(p);
+
+ // create a proper inset as replacement
+ *it = MathAtom(new MathLimInset(f, x, x0));
}
//lyxerr << "\nLimits to: " << ar << "\n";
}
{
MathArray ar = dat;
extractStrings(ar);
- for (MathArray::const_iterator it = ar.begin(); it != ar.end(); ++it)
+ wi.firstitem() = true;
+ for (MathArray::const_iterator it = ar.begin(); it != ar.end(); ++it) {
(*it)->write(wi);
+ wi.firstitem() = false;
+ }
}
projects / lyx.git / blobdiff