fix mathed crash

[lyx.git] / src / lyxrow_funcs.C

diff --git a/src/lyxrow_funcs.C b/src/lyxrow_funcs.C
index a9b4cf7cd3970c9bf01fb096c4b3ee5054c8c3af..e4cd8c26ddd1cd767e0b52edb5716cb9ee24f8a9 100644 (file)
--- a/src/lyxrow_funcs.C
+++ b/src/lyxrow_funcs.C
@@ -12,81 +12,38 @@
 #include <config.h>
 
 #include "lyxrow_funcs.h"
-#include "lyxtext.h"
-#include "lyxlayout.h"
 #include "debug.h"
-#include "RowList.h"
-
-#include "support/LAssert.h"
-
-#include <boost/next_prior.hpp>
+#include "lyxlayout.h"
+#include "lyxrow.h"
+#include "paragraph.h"
 
 using lyx::pos_type;
-using lyx::support::Assert;
 
 using std::max;
 using std::min;
 using std::endl;
 
 
-bool isParEnd(Paragraph const & par, RowList::iterator rit)
-{
-#if 0
-       if ((boost::next(rit) == par.rows.end()) != (rit->end() >= par.size())) {
-               lyxerr << endl;
-               lyxerr << "broken row 1: end: " << rit->end() << " next: "
-                       << boost::next(rit)->pos() << endl;
-               lyxerr << endl;
-               Assert(false);
-       }
-#endif
-       return boost::next(rit) == par.rows.end();
-}
-
-#if 1
-pos_type lastPos(Paragraph const & par, RowList::iterator rit)
-{
-       if (par.empty())
-               return 0;
-
-       if (isParEnd(par, rit))
-               return par.size() - 1;
-
-       if (1 && boost::next(rit)->pos() != rit->end()) {
-               lyxerr << endl;
-               lyxerr << "broken row 2: end: " << rit->end() << " next: "
-                       << boost::next(rit)->pos() << endl;
-               lyxerr << endl;
-               Assert(false);
-       }
-       return boost::next(rit)->pos() - 1;
-}
-#else
-pos_type lastPos(Paragraph const &, RowList::iterator rit)
+int numberOfSeparators(Paragraph const & par, Row const & row)
 {
-       return rit->end() - 1;
-}
-#endif
-
-
-int numberOfSeparators(Paragraph const & par, RowList::iterator rit)
-{
-       pos_type const last = lastPos(par, rit);
+       pos_type const first = max(row.pos(), par.beginOfBody());
+       pos_type const last = row.endpos() - 1;
        int n = 0;
-       pos_type p = max(rit->pos(), par.beginningOfBody());
-       for ( ; p < last; ++p)
+       for (pos_type p = first; p < last; ++p) {
                if (par.isSeparator(p))
                        ++n;
+       }
+
        return n;
 }
 
 
 // This is called _once_ from LyXText and should at least be moved into
 // an anonymous namespace there. (Lgb)
-int numberOfHfills(Paragraph const & par, RowList::iterator rit)
+int numberOfHfills(Paragraph const & par, Row const & row)
 {
-       pos_type const last = lastPos(par, rit);
-       pos_type first = rit->pos();
+       pos_type const last = row.endpos() - 1;
+       pos_type first = row.pos();
 
        // hfill *DO* count at the beginning of paragraphs!
        if (first) {
@@ -94,14 +51,15 @@ int numberOfHfills(Paragraph const & par, RowList::iterator rit)
                        ++first;
        }
 
-       first = max(first, par.beginningOfBody());
+       first = max(first, par.beginOfBody());
 
        int n = 0;
 
        // last, because the end is ignored!
-       for (pos_type p = first; p < last; ++p)
+       for (pos_type p = first; p < last; ++p) {
                if (par.isHfill(p))
                        ++n;
+       }
 
        return n;
 }
@@ -109,10 +67,10 @@ int numberOfHfills(Paragraph const & par, RowList::iterator rit)
 
 // This is called _once_ from LyXText and should at least be moved into
 // an anonymous namespace there. (Lgb)
-int numberOfLabelHfills(Paragraph const & par, RowList::iterator rit)
+int numberOfLabelHfills(Paragraph const & par, Row const & row)
 {
-       pos_type last = lastPos(par, rit);
-       pos_type first = rit->pos();
+       pos_type last = row.endpos() - 1;
+       pos_type first = row.pos();
 
        // hfill *DO* count at the beginning of paragraphs!
        if (first) {
@@ -120,43 +78,45 @@ int numberOfLabelHfills(Paragraph const & par, RowList::iterator rit)
                        ++first;
        }
 
-       last = min(last, par.beginningOfBody());
+       last = min(last, par.beginOfBody());
        int n = 0;
 
-       // last, because the end is ignored!
+       // last, because the end is ignored
        for (pos_type p = first; p < last; ++p) {
                if (par.isHfill(p))
                        ++n;
        }
+
        return n;
 }
 
 
-bool hfillExpansion(Paragraph const & par, RowList::iterator rit, pos_type pos)
+bool hfillExpansion(Paragraph const & par, Row const & row, pos_type pos)
 {
        if (!par.isHfill(pos))
                return false;
 
        // at the end of a row it does not count
        // unless another hfill exists on the line
-       if (pos >= lastPos(par, rit))
-               for (pos_type i = rit->pos(); i < pos && !par.isHfill(i); ++i)
+       if (pos >= row.endpos()) {
+               for (pos_type i = row.pos(); i < pos && !par.isHfill(i); ++i)
                        return false;
+       }
 
        // at the beginning of a row it does not count, if it is not
        // the first row of a paragaph
-       if (rit->isParStart())
+       if (row.pos() == 0)
                return true;
 
        // in some labels it does not count
        if (par.layout()->margintype != MARGIN_MANUAL
-           && pos < par.beginningOfBody())
+           && pos < par.beginOfBody())
                return false;
 
        // if there is anything between the first char of the row and
        // the specified position that is not a newline and not a hfill,
        // the hfill will count, otherwise not
-       pos_type i = rit->pos();
+       pos_type i = row.pos();
        while (i < pos && (par.isNewline(i) || par.isHfill(i)))
                ++i;