math_support.h \
math_symbolinset.C \
math_symbolinset.h \
+ math_unknowninset.C \
+ math_unknowninset.h \
math_xdata.C \
math_xdata.h
{}
+MathArray::MathArray(iterator from, iterator to)
+ : bf_(from, to)
+{}
+
+
void MathArray::substitute(MathMacro const & m)
{
for (iterator it = begin(); it != end(); ++it)
void MathArray::erase()
{
- erase(0, size());
+ bf_.erase(begin(), end());
}
}
+void MathArray::erase(iterator pos1, iterator pos2)
+{
+ bf_.erase(pos1, pos2);
+}
+
+
+void MathArray::erase(iterator pos)
+{
+ bf_.erase(pos);
+}
+
+
void MathArray::erase(size_type pos1, size_type pos2)
{
bf_.erase(begin() + pos1, begin() + pos2);
MathArray();
///
MathArray(MathArray const &, size_type from, size_type to);
+ ///
+ MathArray(iterator from, iterator to);
///
size_type size() const;
///
void insert(size_type pos, MathArray const &);
+ ///
+ void erase(iterator pos1, iterator pos2);
+ ///
+ void erase(iterator pos);
///
void erase(size_type pos1, size_type pos2);
///
}
+bool MathDelimInset::isParanthesis() const
+{
+ return left_ == "(" && right_ == ")";
+}
+
+
+bool MathDelimInset::isBrackets() const
+{
+ return left_ == "[" && right_ == "]";
+}
+
+
+bool MathDelimInset::isAbs() const
+{
+ return left_ == "|" && right_ == "|";
+}
+
+
void MathDelimInset::maplize(MapleStream & os) const
{
- if (left_ == "|" && right_ == "|") {
+ if (isAbs()) {
bool mat =
cell(0).size() == 1 && cell(0).begin()->nucleus()
&& cell(0).begin()->nucleus()->asMatrixInset();
void MathDelimInset::octavize(OctaveStream & os) const
{
- if (left_ == "|" && right_ == "|")
+ if (isAbs())
os << "det(" << cell(0) << ")";
else
os << left_.c_str() << cell(0) << right_.c_str();
MathDelimInset * asDelimInset() { return this; }
///
MathDelimInset const * asDelimInset() const { return this; }
+ /// is it (...)?
+ bool isParanthesis() const;
+ /// is it [...]?
+ bool isBrackets() const;
+ /// is it |...|?
+ bool isAbs() const;
///
void metrics(MathMetricsInfo const & st) const;
///
using std::ostream;
-MathExFuncInset::MathExFuncInset(string const & name)
+MathExFuncInset::MathExFuncInset(string const & name, MathArray const & arg)
: MathNestInset(1), name_(name)
-{}
+{
+ cell(0) = arg;
+}
MathInset * MathExFuncInset::clone() const
class MathExFuncInset : public MathNestInset {
public:
///
- explicit MathExFuncInset(string const & name);
+ MathExFuncInset(string const & name, MathArray const & arg);
///
MathInset * clone() const;
///
--- /dev/null
+
+// This file contains most of the magic that extracts "context
+// information" from the unstructered layout-oriented stuff in an
+// MathArray.
+
+
+#include "math_charinset.h"
+#include "math_deliminset.h"
+#include "math_exfuncinset.h"
+#include "math_funcinset.h"
+#include "math_matrixinset.h"
+#include "math_mathmlstream.h"
+#include "math_scriptinset.h"
+#include "math_stringinset.h"
+#include "debug.h"
+
+
+std::ostream & operator<<(ostream & os, MathArray const & ar)
+{
+ NormalStream ws(os);
+ ws << ar;
+ return os;
+}
+
+
+MathScriptInset const * asScript(MathArray::const_iterator it)
+{
+ if (it->nucleus()->asScriptInset())
+ return 0;
+ ++it;
+ if (!it->nucleus())
+ return 0;
+ return it->nucleus()->asScriptInset();
+}
+
+
+
+// returns sequence of char with same code starting at it up to end
+// it might be less, though...
+string charSequence(MathArray::const_iterator it, MathArray::const_iterator end)
+{
+ string s;
+ MathCharInset const * p = it->nucleus()->asCharInset();
+ if (p) {
+ for (MathTextCodes c = p->code(); it != end; ++it) {
+ if (!it->nucleus())
+ break;
+ p = it->nucleus()->asCharInset();
+ if (!p || p->code() != c)
+ break;
+ s += p->getChar();
+ }
+ }
+ return s;
+}
+
+
+void glueChars(MathArray & dat)
+{
+ MathArray ar;
+ MathArray::const_iterator it = dat.begin();
+ while (it != dat.end()) {
+ if (it->nucleus() && it->nucleus()->asCharInset()) {
+ string s = charSequence(it, dat.end());
+ MathTextCodes c = it->nucleus()->asCharInset()->code();
+ ar.push_back(MathAtom(new MathStringInset(s, c)));
+ it += s.size();
+ } else {
+ ar.push_back(*it);
+ ++it;
+ }
+ }
+ ar.swap(dat);
+}
+
+
+bool needAsterisk(MathAtom const &, MathAtom const &)
+{
+ return false;
+}
+
+
+void guessAsterisks(MathArray & dat)
+{
+ if (dat.size() <= 1)
+ return;
+ MathArray ar;
+ ar.push_back(*dat.begin());
+ MathArray::const_iterator it = dat.begin();
+ MathArray::const_iterator jt = it + 1;
+ for (; jt != dat.end(); ++it, ++jt) {
+ if (needAsterisk(*it, *jt))
+ ar.push_back(MathAtom(new MathCharInset('*')));
+ ar.push_back(*it);
+ }
+ ar.push_back(*dat.end());
+ ar.swap(dat);
+}
+
+
+MathInset * singleItem(MathArray & ar)
+{
+ lyxerr << "ar.size: " << ar.size() << "\n";
+ //lyxerr << "ar.begin: " << ar.begin() << "\n";
+ //lyxerr << "ar.nuc: " << ar.begin()->nucleus() << "\n";
+ lyxerr << "ar.nuc: " << *ar.begin()->nucleus() << "\n";
+ return ar.size() == 1 ? ar.begin()->nucleus() : 0;
+}
+
+
+void extractMatrices(MathArray & ar)
+{
+ for (MathArray::iterator it = ar.begin(); it != ar.end(); ++it) {
+ if (!it->nucleus())
+ continue;
+ MathDelimInset * del = it->nucleus()->asDelimInset();
+ if (!del)
+ continue;
+ MathInset * arr = singleItem(del->cell(0));
+ if (!arr || !arr->asArrayInset())
+ continue;
+ *it = MathAtom(new MathMatrixInset(*(arr->asArrayInset())));
+ }
+}
+
+
+void extractDelims(MathArray & ar) {
+ // use indices rather than iterators for the loop because we are going
+ // to modify the array.
+ for (MathArray::size_type i = 0; i < ar.size(); ++i) {
+ MathArray::iterator it = ar.begin() + i;
+ if (!it->nucleus())
+ continue;
+ if ((*it)->getChar() != '(')
+ continue;
+
+ // search last closing paranthesis
+ MathArray::iterator et = ar.end();
+ for (MathArray::iterator jt = it + 1; jt != ar.end(); ++jt)
+ if ((*jt)->getChar() == ')')
+ et = jt;
+ if (et == ar.end())
+ continue;
+
+ // create a proper deliminset
+ MathAtom at(new MathDelimInset("(", ")"));
+ at->cell(0) = MathArray(it + 1, et);
+
+ // replace the original stuff by the new inset
+ ar.erase(it + 1, et + 1);
+ *it = at;
+ }
+}
+
+
+// assume 'extractDelims' ran before
+void extractFunctions(MathArray & ar)
+{
+ // we need at least two items...
+ if (ar.size() <= 1)
+ return;
+
+ for (MathArray::size_type i = 0; i < ar.size() - 1; ++i) {
+ MathArray::iterator it = ar.begin() + i;
+
+ // is this a function name?
+ if (!it->nucleus())
+ continue;
+ MathFuncInset * func = (*it)->asFuncInset();
+ if (!func)
+ continue;
+
+ // do we have an exponent?
+ // simply skippping the postion does the right thing:
+ // 'sin' '^2' 'x' -> 'sin(x)' '^2'
+ MathArray::iterator jt = it + 1;
+ if (MathScriptInset * script = (*jt)->asScriptInset()) {
+ // allow superscripts only
+ if (script->hasDown())
+ continue;
+ ++jt;
+ if (jt == ar.end())
+ continue;
+ }
+
+ // jt points now to the "argument". Since we had run "extractDelims"
+ // before, this could be a single argument only. Get hold of this.
+ MathArray arg;
+ MathDelimInset * del = (*jt)->asDelimInset();
+ if (del && del->isParanthesis())
+ arg = del->cell(0);
+ else
+ arg.push_back(*jt);
+
+ // replace the function name by a real function inset
+ (*it).reset(new MathExFuncInset(func->name(), arg));
+
+ // remove the source of the argument from the array
+ ar.erase(jt);
+ }
+}
+
+
+void extractStructure(MathArray & ar)
+{
+ glueChars(ar);
+ extractMatrices(ar);
+ extractDelims(ar);
+ extractFunctions(ar);
+}
+
+
+void write(MathArray const & dat, WriteStream & wi)
+{
+ MathArray ar = dat;
+ glueChars(ar);
+ for (MathArray::const_iterator it = ar.begin(); it != ar.end(); ++it) {
+ MathInset const * p = it->nucleus();
+ if (it + 1 != ar.end()) {
+ if (MathScriptInset const * q = asScript(it)) {
+ q->write(p, wi);
+ ++it;
+ continue;
+ }
+ }
+ p->write(wi);
+ }
+}
+
+
+void normalize(MathArray const & dat, NormalStream & os)
+{
+ MathArray ar = dat;
+ glueChars(ar);
+ for (MathArray::const_iterator it = ar.begin(); it != ar.end(); ++it) {
+ MathInset const * p = it->nucleus();
+ if (it + 1 != ar.end()) {
+ if (MathScriptInset const * q = asScript(it)) {
+ q->normalize(p, os);
+ ++it;
+ continue;
+ }
+ }
+ p->normalize(os);
+ }
+}
+
+
+void octavize(MathArray const & dat, OctaveStream & os)
+{
+ MathArray ar = dat;
+ extractStructure(ar);
+ for (MathArray::const_iterator it = ar.begin(); it != ar.end(); ++it) {
+ MathInset const * p = it->nucleus();
+ if (it + 1 != ar.end()) {
+ if (MathScriptInset const * q = asScript(it)) {
+ q->octavize(p, os);
+ ++it;
+ continue;
+ }
+ }
+ p->octavize(os);
+ }
+}
+
+
+void maplize(MathArray const & dat, MapleStream & os)
+{
+ MathArray ar = dat;
+ extractStructure(ar);
+ for (MathArray::const_iterator it = ar.begin(); it != ar.end(); ++it) {
+ MathInset const * p = it->nucleus();
+ if (it + 1 != ar.end()) {
+ if (MathScriptInset const * q = asScript(it)) {
+ q->maplize(p, os);
+ ++it;
+ continue;
+ }
+ }
+ p->maplize(os);
+ }
+}
+
+
+void mathmlize(MathArray const & dat, MathMLStream & os)
+{
+ MathArray ar = dat;
+ extractStructure(ar);
+ if (ar.size() == 0)
+ os << "<mrow/>";
+ else if (ar.size() == 1)
+ os << ar.begin()->nucleus();
+ else {
+ os << MTag("mrow");
+ for (MathArray::const_iterator it = ar.begin(); it != ar.end(); ++it) {
+ MathInset const * p = it->nucleus();
+ if (it + 1 != ar.end()) {
+ if (MathScriptInset const * q = asScript(it)) {
+ q->mathmlize(p, os);
+ ++it;
+ continue;
+ }
+ }
+ p->mathmlize(os);
+ }
+ os << ETag("mrow");
+ }
+}
+
--- /dev/null
+#ifndef MATH_EXTERN_H
+#define MATH_EXTERN_H
+
+class NormalStream;
+class MapleStream;
+class MathMLStream;
+class OctaveStream;
+class WriteStream;
+class MathArray;
+
+void write(MathArray const &, WriteStream &);
+void normalize(MathArray const &, NormalStream &);
+void maplize(MathArray const &, MapleStream &);
+void mathmlize(MathArray const &, MathMLStream &);
+void octavize(MathArray const &, OctaveStream &);
+
+#endif
#include "math_spaceinset.h"
#include "math_specialcharinset.h"
#include "math_sqrtinset.h"
-#include "math_symbolinset.h"
#include "math_stackrelinset.h"
+#include "math_symbolinset.h"
+#include "math_unknowninset.h"
MathAtom createMathInset(latexkeys const * l)
return MathAtom(new MathDotsInset(l->name));
case LM_TK_BOX:
return MathAtom(new MathBoxInset(l->name));
+ case LM_TK_FUNC:
+ return MathAtom(new MathFuncInset(l->name));
}
- return MathAtom(new MathFuncInset(l->name));
+ return MathAtom(new MathUnknownInset(l->name));
}
return MathAtom(new MathMacro(s));
//cerr << "creating inset 2 with name: '" << s << "'\n";
- return MathAtom(new MathFuncInset(s));
+ return MathAtom(new MathUnknownInset(s));
}
///
void draw(Painter &, int x, int y) const;
///
- void write(WriteStream &) const;
- ///
- void normalize(NormalStream &) const;
- ///
string const & name() const;
+ /// identifies FuncInsets
+ MathFuncInset * asFuncInset() { return this; }
///
void setName(string const &);
+
+ ///
+ void normalize(NormalStream &) const;
///
void maplize(MapleStream &) const;
///
void mathmlize(MathMLStream &) const;
///
void octavize(OctaveStream &) const;
+ ///
+ void write(WriteStream &) const;
private:
///
string name_;
// split it "nicely" on the firest relop
pos_type pos = firstRelOp(cell(0));
- cell(1) = cell(0);
+ cell(1) = MathArray(cell(0), pos, cell(0).size());
cell(0).erase(pos, cell(0).size());
- cell(1).erase(0, pos);
if (cell(1).size()) {
- cell(2) = cell(1);
+ cell(2) = MathArray(cell(1), 1, cell(1).size());
cell(1).erase(1, cell(1).size());
- cell(2).erase(0);
}
setType(LM_OT_EQNARRAY);
class MathBoxInset;
class MathCharInset;
class MathDelimInset;
+class MathFuncInset;
class MathGridInset;
class MathHullInset;
class MathMatrixInset;
virtual bool covers(int x, int y) const;
/// identifies NestInsets
- virtual MathNestInset * asNestInset() { return 0; }
+ virtual MathNestInset * asNestInset() { return 0; }
/// identifies CharInsets
- virtual MathCharInset const * asCharInset() const { return 0; }
+ virtual MathCharInset const * asCharInset() const { return 0; }
/// identifies ScriptInsets
+ virtual MathScriptInset * asScriptInset() { return 0; }
virtual MathScriptInset const * asScriptInset() const { return 0; }
- /// identifies ScriptInsets
- virtual MathScriptInset * asScriptInset() { return 0; }
- /// identifies HullInsets
- virtual MathHullInset const * asHullInset() const { return 0; }
/// identifies HullInsets
- virtual MathHullInset * asHullInset() { return 0; }
+ virtual MathHullInset * asHullInset() { return 0; }
+ virtual MathHullInset const * asHullInset() const { return 0; }
/// identifies SpaceInset
- virtual MathSpaceInset * asSpaceInset() { return 0; }
+ virtual MathSpaceInset * asSpaceInset() { return 0; }
/// identifies GridInset
- virtual MathGridInset * asGridInset() { return 0; }
+ virtual MathGridInset * asGridInset() { return 0; }
/// identifies ArrayInsets
- virtual MathArrayInset * asArrayInset() { return 0; }
+ virtual MathArrayInset * asArrayInset() { return 0; }
/// identifies MatrixInsets
virtual MathMatrixInset const * asMatrixInset() const { return 0; }
/// identifies BoxInsets
- virtual MathBoxInset * asBoxInset() { return 0; }
+ virtual MathBoxInset * asBoxInset() { return 0; }
/// identifies DelimInsets
- virtual MathDelimInset * asDelimInset() { return 0; }
- /// identifies DelimInsets
- virtual MathDelimInset const * asDelimInset() const { return 0; }
+ virtual MathDelimInset * asDelimInset() { return 0; }
+ virtual MathDelimInset const * asDelimInset() const { return 0; }
+ /// identifies FuncInsets
+ virtual MathFuncInset * asFuncInset() { return 0; }
/// identifies macro templates
- virtual MathMacroTemplate * asMacroTemplate() { return 0; }
+ virtual MathMacroTemplate * asMacroTemplate() { return 0; }
/// identifies hyperactive insets
- virtual UpdatableInset * asHyperActiveInset() const { return 0; }
+ virtual UpdatableInset * asHyperActiveInset() const { return 0; }
/// identifies things that can get scripts
virtual bool isScriptable() const { return false; }
- ///
+ /// thing that can be moved into
virtual bool isActive() const { return nargs() > 0; }
/// identifies insets from the outer world
virtual bool isHyperActive() const { return 0; }
--- /dev/null
+#ifdef __GNUG__
+#pragma implementation
+#endif
+
+#include "math_unknowninset.h"
+#include "font.h"
+#include "Painter.h"
+#include "math_support.h"
+#include "math_mathmlstream.h"
+
+
+
+extern LyXFont WhichFont(short type, int size);
+
+
+MathUnknownInset::MathUnknownInset(string const & nm)
+ : name_(nm)
+{}
+
+
+MathInset * MathUnknownInset::clone() const
+{
+ return new MathUnknownInset(*this);
+}
+
+
+string const & MathUnknownInset::name() const
+{
+ return name_;
+}
+
+
+void MathUnknownInset::setName(string const & n)
+{
+ name_ = n;
+}
+
+
+void MathUnknownInset::write(WriteStream & os) const
+{
+ os << "\\" << name_.c_str() << ' ';
+}
+
+
+void MathUnknownInset::normalize(NormalStream & os) const
+{
+ os << "[func " << name_.c_str() << ']';
+}
+
+
+void MathUnknownInset::metrics(MathMetricsInfo const & mi) const
+{
+ mi_ = mi;
+ mathed_string_dim(LM_TC_TEX, mi_, name_, ascent_, descent_, width_);
+}
+
+
+void MathUnknownInset::draw(Painter & pain, int x, int y) const
+{
+ drawStr(pain, LM_TC_TEX, mi_, x, y, name_);
+}
+
+
+void MathUnknownInset::maplize(MapleStream & os) const
+{
+ os << name_.c_str();
+}
+
+
+void MathUnknownInset::mathmlize(MathMLStream & os) const
+{
+ os << MTag("mi") << name_.c_str() << ETag("mi");
+}
+
+
+void MathUnknownInset::octavize(OctaveStream & os) const
+{
+ os << name_.c_str();
+}
--- /dev/null
+// -*- C++ -*-
+#ifndef MATH_UNKNOWNINSET_H
+#define MATH_UNKNOWNINSET_H
+
+#include "math_diminset.h"
+#include "math_defs.h"
+
+#ifdef __GNUG__
+#pragma interface
+#endif
+
+/**
+ Unknowntions or LaTeX names for objects that we really don't know
+ */
+class MathUnknownInset : public MathDimInset {
+public:
+ ///
+ explicit MathUnknownInset(string const & nm);
+ ///
+ MathInset * clone() const;
+ ///
+ void metrics(MathMetricsInfo const & st) const;
+ ///
+ void draw(Painter &, int x, int y) const;
+ ///
+ string const & name() const;
+ /// identifies UnknownInsets
+ MathUnknownInset const * asUnknownInset() const { return this; }
+ ///
+ void setName(string const &);
+
+ ///
+ void normalize(NormalStream &) const;
+ ///
+ void maplize(MapleStream &) const;
+ ///
+ void mathmlize(MathMLStream &) const;
+ ///
+ void octavize(OctaveStream &) const;
+ ///
+ void write(WriteStream &) const;
+private:
+ ///
+ string name_;
+ ///
+ mutable MathMetricsInfo mi_;
+};
+#endif
projects / features.git / commitdiff