]> git.lyx.org Git - lyx.git/blobdiff - src/lyxrow_funcs.C
More 'standard conformant blurb' nonsense.
[lyx.git] / src / lyxrow_funcs.C
index 586c1f0320488098243a379587a00b8e1c7175d1..85154f9d1333729f44e6cc6d567442280f765788 100644 (file)
@@ -14,22 +14,19 @@ using std::max;
 using std::min;
 
 
-bool isParEnd(LyXText const & lt,
-       ParagraphList::iterator pit, RowList::iterator rit)
+bool isParEnd(Paragraph const & par, RowList::iterator rit)
 {
-       RowList::iterator next_row = boost::next(rit);
-       return next_row == lt.rows().end() || lt.getPar(next_row) != pit;
+       return boost::next(rit) == par.rows.end();
 }
 
 
-pos_type lastPos(LyXText const & lt,
-       ParagraphList::iterator pit, RowList::iterator rit)
+pos_type lastPos(Paragraph const & par, RowList::iterator rit)
 {
-       if (pit->empty())
+       if (par.empty())
                return 0;
 
-       if (isParEnd(lt, pit, rit))
-               return pit->size() - 1;
+       if (isParEnd(par, rit))
+               return par.size() - 1;
 
        return boost::next(rit)->pos() - 1;
 }
@@ -38,45 +35,43 @@ pos_type lastPos(LyXText const & lt,
 namespace {
 
 bool nextRowIsAllInset(
-       ParagraphList::iterator pit, RowList::iterator rit, pos_type last)
+       Paragraph const & par, pos_type last)
 {
-       if (last + 1 >= pit->size())
+       if (last + 1 >= par.size())
                return false;
 
-       if (!pit->isInset(last + 1))
+       if (!par.isInset(last + 1))
                return false;
 
-       InsetOld const * i = pit->getInset(last + 1);
+       InsetOld const * i = par.getInset(last + 1);
        return i->needFullRow() || i->display();
 }
 
 } // anon namespace
 
 
-pos_type lastPrintablePos(LyXText const & lt,
-       ParagraphList::iterator pit, RowList::iterator rit)
+pos_type lastPrintablePos(Paragraph const & par, RowList::iterator rit)
 {
-       pos_type const last = lastPos(lt, pit, rit);
+       pos_type const last = lastPos(par, rit);
 
        // if this row is an end of par, just act like lastPos()
-       if (isParEnd(lt, pit, rit))
+       if (isParEnd(par, rit))
                return last;
 
-       if (!nextRowIsAllInset(pit, rit, last) && pit->isSeparator(last))
+       if (!nextRowIsAllInset(par, last) && par.isSeparator(last))
                return last - 1;
 
        return last;
 }
 
 
-int numberOfSeparators(LyXText const & lt,
-       ParagraphList::iterator pit, RowList::iterator rit)
+int numberOfSeparators(Paragraph const & par, RowList::iterator rit)
 {
-       pos_type const last = lastPrintablePos(lt, pit, rit);
+       pos_type const last = lastPrintablePos(par, rit);
        int n = 0;
-       pos_type p = max(rit->pos(), pit->beginningOfBody());
+       pos_type p = max(rit->pos(), par.beginningOfBody());
        for ( ; p < last; ++p)
-               if (pit->isSeparator(p))
+               if (par.isSeparator(p))
                        ++n;
        return n;
 }
@@ -84,67 +79,64 @@ int numberOfSeparators(LyXText const & lt,
 
 // This is called _once_ from LyXText and should at least be moved into
 // an anonymous namespace there. (Lgb)
-int numberOfHfills(LyXText const & lt,
-       ParagraphList::iterator pit, RowList::iterator rit)
+int numberOfHfills(Paragraph const & par, RowList::iterator rit)
 {
-       pos_type const last = lastPos(lt, pit, rit);
+       pos_type const last = lastPos(par, rit);
        pos_type first = rit->pos();
 
        // hfill *DO* count at the beginning of paragraphs!
        if (first) {
-               while (first < last && pit->isHfill(first))
+               while (first < last && par.isHfill(first))
                        ++first;
        }
 
-       first = max(first, pit->beginningOfBody());
+       first = max(first, par.beginningOfBody());
 
        int n = 0;
 
        // last, because the end is ignored!
-       for (pos_type p = first; p < last; ++p) {
-               if (pit->isHfill(p))
+       for (pos_type p = first; p < last; ++p)
+               if (par.isHfill(p))
                        ++n;
-       }
+
        return n;
 }
 
 
 // This is called _once_ from LyXText and should at least be moved into
 // an anonymous namespace there. (Lgb)
-int numberOfLabelHfills(LyXText const & lt,
-       ParagraphList::iterator pit, RowList::iterator rit)
+int numberOfLabelHfills(Paragraph const & par, RowList::iterator rit)
 {
-       pos_type last = lastPos(lt, pit, rit);
+       pos_type last = lastPos(par, rit);
        pos_type first = rit->pos();
 
        // hfill *DO* count at the beginning of paragraphs!
        if (first) {
-               while (first < last && pit->isHfill(first))
+               while (first < last && par.isHfill(first))
                        ++first;
        }
 
-       last = min(last, pit->beginningOfBody());
+       last = min(last, par.beginningOfBody());
        int n = 0;
 
        // last, because the end is ignored!
        for (pos_type p = first; p < last; ++p) {
-               if (pit->isHfill(p))
+               if (par.isHfill(p))
                        ++n;
        }
        return n;
 }
 
 
-bool hfillExpansion(LyXText const & lt,
-       ParagraphList::iterator pit, RowList::iterator rit, pos_type pos)
+bool hfillExpansion(Paragraph const & par, RowList::iterator rit, pos_type pos)
 {
-       if (!pit->isHfill(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(lt, pit, rit))
-               for (pos_type i = rit->pos(); i < pos && !pit->isHfill(i); ++i)
+       if (pos >= lastPos(par, rit))
+               for (pos_type i = rit->pos(); i < pos && !par.isHfill(i); ++i)
                        return false;
 
        // at the beginning of a row it does not count, if it is not
@@ -153,15 +145,15 @@ bool hfillExpansion(LyXText const & lt,
                return true;
 
        // in some labels it does not count
-       if (pit->layout()->margintype != MARGIN_MANUAL
-           && pos < pit->beginningOfBody())
+       if (par.layout()->margintype != MARGIN_MANUAL
+           && pos < par.beginningOfBody())
                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();
-       while (i < pos && (pit->isNewline(i) || pit->isHfill(i)))
+       while (i < pos && (par.isNewline(i) || par.isHfill(i)))
                ++i;
 
        return i != pos;