write \mathrm{x}\mathrm{y} as \mathrm{xy} again

[features.git] / src / mathed / array.C

diff --git a/src/mathed/array.C b/src/mathed/array.C
index 5b9b7cbbdad6d87718b1052996ed3505f12fb8b0..48deaf73ab7066e3b125c9b91b8cb0d7bb11a3bb 100644 (file)
--- a/src/mathed/array.C
+++ b/src/mathed/array.C
@@ -5,9 +5,11 @@
 #include "math_inset.h"
 #include "math_charinset.h"
 #include "math_scriptinset.h"
+#include "math_stringinset.h"
 #include "debug.h"
 #include "array.h"
 #include "mathed/support.h"
+#include "support/LAssert.h"
 
 using std::ostream;
 using std::endl;
@@ -17,56 +19,58 @@ MathArray::MathArray()
 {}
 
 
-MathArray::MathArray(MathArray const & array, int from, int to)
+MathArray::MathArray(MathArray const & array, size_type from, size_type to)
        : bf_(array.begin() + from, array.begin() + to)
 {}
 
 
-int MathArray::last() const
+void MathArray::substitute(MathMacro const & m)
 {
-       return size() - 1;
+       for (iterator it = begin(); it != end(); ++it)
+               it->nucleus()->substitute(m);
 }
 
 
-void MathArray::substitute(MathMacro const & m)
+MathScriptInset const * MathArray::asScript(const_iterator it) const
 {
-       MathArray tmp;
-       for (iterator it = begin(); it != end(); ++it)
-               it->substitute(tmp, m);
-       swap(tmp);
+       if (it->nucleus()->asScriptInset())
+               return 0;
+       const_iterator jt = it + 1;
+       if (jt == end())
+               return 0;
+       return jt->nucleus()->asScriptInset();
 }
 
 
-MathAtom * MathArray::at(int pos)
+MathAtom & MathArray::at(size_type pos)
 {
-       return (0 <= pos && pos < size()) ? &bf_[pos] : 0;
+       lyx::Assert(pos < size());
+       return bf_[pos];
 }
 
 
-MathAtom const * MathArray::at(int pos) const
+MathAtom const & MathArray::at(size_type pos) const
 {
-       return (0 <= pos && pos < size()) ? &bf_[pos] : 0;
+       lyx::Assert(pos < size());
+       return bf_[pos];
 }
 
 
-void MathArray::insert(int pos, MathInset * p)
+void MathArray::insert(size_type pos, MathAtom const & t)
 {
-       //cerr << "\n  1: "; p->write(cerr, true); cerr << p << "\n";
-       // inserting th
-       bf_.insert(begin() + pos, MathAtom(p));
-       //cerr << "\n  2: "; p->write(cerr, true); cerr << p << "\n";
+       bf_.insert(begin() + pos, t);
 }
 
 
-void MathArray::insert(int pos, MathArray const & array)
+void MathArray::insert(size_type pos, MathArray const & array)
 {
        bf_.insert(begin() + pos, array.begin(), array.end());
 }
 
 
-void MathArray::push_back(MathInset * p)
+void MathArray::push_back(MathAtom const & t)
 {      
-       insert(size(), p);
+       bf_.push_back(t);
 }
 
 
@@ -93,9 +97,9 @@ bool MathArray::empty() const
 {
        return bf_.empty();
 }
-   
 
-int MathArray::size() const
+
+MathArray::size_type MathArray::size() const
 {
        return bf_.size();
 }
@@ -107,14 +111,14 @@ void MathArray::erase()
 }
 
 
-void MathArray::erase(int pos)
+void MathArray::erase(size_type pos)
 {
        if (pos < size())
                erase(pos, pos + 1);
 }
 
 
-void MathArray::erase(int pos1, int pos2)
+void MathArray::erase(size_type pos1, size_type pos2)
 {
        bf_.erase(begin() + pos1, begin() + pos2);
 }
@@ -129,14 +133,14 @@ MathAtom & MathArray::back()
 void MathArray::dump2(ostream & os) const
 {
        for (const_iterator it = begin(); it != end(); ++it)
-               os << *it << ' ';
+               os << it->nucleus() << ' ';
 }
 
 
 void MathArray::dump(ostream & os) const
 {
        for (const_iterator it = begin(); it != end(); ++it)
-               os << "<" << *it << ">";
+               os << "<" << it->nucleus() << ">";
 }
 
 
@@ -157,8 +161,10 @@ string charSequence(MathArray::const_iterator it, MathArray::const_iterator end)
                return s;
 
        for (MathTextCodes c = p->code(); it != end; ++it) {
+               if (!it->nucleus())
+                       break;
                p = it->nucleus()->asCharInset();
-               if (!p || it->up() || it->down() || p->code() != c)
+               if (!p || p->code() != c)
                        break;
                s += p->getChar();
        }
@@ -166,39 +172,67 @@ string charSequence(MathArray::const_iterator it, MathArray::const_iterator end)
 }
 
 
-void MathArray::write(ostream & os, bool fragile) const
+MathArray MathArray::glueChars() const
 {
-       for (const_iterator it = begin(); it != end(); ++it) {
-               MathCharInset const * p = it->nucleus()->asCharInset();
-               if (p && !it->up() && !it->down()) {
-                       // special handling for character sequences with the same code
+       MathArray ar;
+       const_iterator it = begin();
+       while (it != end()) {
+               if (it->nucleus() && it->nucleus()->asCharInset()) {
                        string s = charSequence(it, end());
-                       p->writeHeader(os);
-                       os << s;
-                       p->writeTrailer(os);
-                       it += s.size() - 1;
+                       MathTextCodes c = it->nucleus()->asCharInset()->code();
+                       ar.push_back(MathAtom(new MathStringInset(s, c)));
+                       it += s.size();
                } else {
-                       it->write(os, fragile);
+                       ar.push_back(*it);
+                       ++it;
                }
        }
+       return ar;
 }
 
 
-void MathArray::writeNormal(ostream & os) const
+void MathArray::write(MathWriteInfo & wi) const
 {
-       if (empty()) {
-               os << "[par] ";
-               return;
+       glueChars().write1(wi);
+}
+
+
+void MathArray::write1(MathWriteInfo & wi) const
+{
+       for (const_iterator it = begin(); it != end(); ++it) {  
+               MathInset * p = it->nucleus();
+               if (!p)
+                       continue;
+               if (MathScriptInset const * q = asScript(it)) {
+                       q->write(p, wi);
+                       ++it;
+               } else {
+                       p->write(wi);
+               }
        }
+}
+
 
-       write(os, true);
+void MathArray::writeNormal(ostream & os) const
+{
+       for (const_iterator it = begin(); it != end(); ++it) {  
+               MathInset * p = it->nucleus();
+               if (!p)
+                       continue;
+               if (MathScriptInset const * q = asScript(it)) {
+                       q->writeNormal(p, os);
+                       ++it;
+               } else {
+                       p->writeNormal(os);
+               }
+       }
 }
 
 
 void MathArray::validate(LaTeXFeatures & features) const
 {
        for (const_iterator it = begin(); it != end(); ++it)
-               it->validate(features);
+               it->nucleus()->validate(features);
 }