Cmake export tests: Handle attic files with now missing references to png graphics

[lyx.git] / src / Row.cpp

diff --git a/src/Row.cpp b/src/Row.cpp
index a61e19f9f13004cbae3a3f986e1b4aefaf7e2d33..bd0945961f415eb44e8768534652dee672038ee2 100644 (file)
--- a/src/Row.cpp
+++ b/src/Row.cpp
@@ -41,7 +41,19 @@ int Row::Element::countSeparators() const
 {
        if (type != STRING)
                return 0;
-       return count(str.begin(), str.end(), ' ');
+       // Consecutive spaces count as only one separator.
+       bool wasspace = false;
+       int nsep = 0;
+       for (size_t i = 0 ; i < str.size() ; ++i) {
+               if (str[i] == ' ') {
+                       if (!wasspace) {
+                               ++nsep;
+                               wasspace = true;
+                       }
+               } else
+                       wasspace = false;
+       }
+       return nsep;
 }
 
 
@@ -52,18 +64,16 @@ double Row::Element::pos2x(pos_type const i) const
        if (i < pos || i > endpos)
                return 0;
 
-       bool const rtl = font.isVisibleRightToLeft();
-
        double w = 0;
        //handle first the two bounds of the element
        if (i == endpos && type != VIRTUAL
                && !(inset && inset->lyxCode() == SEPARATOR_CODE))
-               w = rtl ? 0 : full_width();
+               w = isRTL() ? 0 : full_width();
        else if (i == pos || type != STRING)
-               w = rtl ? full_width() : 0;
+               w = isRTL() ? full_width() : 0;
        else {
                FontMetrics const & fm = theFontMetrics(font);
-               w = fm.pos2x(str, i - pos, font.isVisibleRightToLeft(), extra);
+               w = fm.pos2x(str, i - pos, isRTL(), extra);
        }
 
        return w;
@@ -73,19 +83,18 @@ double Row::Element::pos2x(pos_type const i) const
 pos_type Row::Element::x2pos(int &x) const
 {
        //lyxerr << "x2pos: x=" << x << " w=" << width() << " " << *this;
-       bool const rtl = font.isVisibleRightToLeft();
        size_t i = 0;
 
        switch (type) {
        case STRING: {
                FontMetrics const & fm = theFontMetrics(font);
-               i = fm.x2pos(str, x, rtl, extra);
+               i = fm.x2pos(str, x, isRTL(), extra);
                break;
        }
        case VIRTUAL:
                // those elements are actually empty (but they have a width)
                i = 0;
-               x = rtl ? int(full_width()) : 0;
+               x = isRTL() ? int(full_width()) : 0;
                break;
        case INSET:
        case SPACE:
@@ -93,10 +102,10 @@ pos_type Row::Element::x2pos(int &x) const
                // the closest side.
                if (x > full_width()) {
                        x = int(full_width());
-                       i = !rtl;
+                       i = !isRTL();
                } else {
                        x = 0;
-                       i = rtl;
+                       i = isRTL();
                }
 
        }
@@ -111,10 +120,9 @@ bool Row::Element::breakAt(int w, bool force)
        if (type != STRING || dim.wid <= w)
                return false;
 
-       bool const rtl = font.isVisibleRightToLeft();
        FontMetrics const & fm = theFontMetrics(font);
        int x = w;
-       if(fm.breakAt(str, x, rtl, force)) {
+       if(fm.breakAt(str, x, isRTL(), force)) {
                dim.wid = x;
                endpos = pos + str.length();
                //lyxerr << "breakAt(" << w << ")  Row element Broken at " << x << "(w(str)=" << fm.width(str) << "): e=" << *this << endl;
@@ -126,13 +134,13 @@ bool Row::Element::breakAt(int w, bool force)
 
 pos_type Row::Element::left_pos() const
 {
-       return font.isVisibleRightToLeft() ? endpos : pos;
+       return isRTL() ? endpos : pos;
 }
 
 
 pos_type Row::Element::right_pos() const
 {
-       return font.isVisibleRightToLeft() ? pos : endpos;
+       return isRTL() ? pos : endpos;
 }
 
 
@@ -217,7 +225,7 @@ bool Row::selection() const
 
 ostream & operator<<(ostream & os, Row::Element const & e)
 {
-       if (e.font.isVisibleRightToLeft())
+       if (e.isRTL())
                os << e.endpos << "<<" << e.pos << " ";
        else
                os << e.pos << ">>" << e.endpos << " ";
@@ -263,6 +271,35 @@ ostream & operator<<(ostream & os, Row const & row)
 }
 
 
+int Row::left_x() const
+{
+       double x = left_margin;
+       const_iterator const end = elements_.end();
+       const_iterator cit = elements_.begin();
+       while (cit != end && cit->isVirtual()) {
+               x += cit->full_width();
+               ++cit;
+       }
+       return int(x + 0.5);
+}
+
+
+int Row::right_x() const
+{
+       double x = dim_.wid;
+       const_iterator const begin = elements_.begin();
+       const_iterator cit = elements_.end();
+       while (cit != begin) {
+               --cit;
+               if (cit->isVirtual())
+                       x -= cit->full_width();
+               else
+                       break;
+       }
+       return int(x + 0.5);
+}
+
+
 int Row::countSeparators() const
 {
        int n = 0;
@@ -404,7 +441,8 @@ void Row::shortenIfNeeded(pos_type const keep, int const w)
        ++cit_brk;
        while (cit_brk != beg) {
                --cit_brk;
-               Element & brk = *cit_brk;
+               // make a copy of the element to work on it.
+               Element brk = *cit_brk;
                wid_brk -= brk.dim.wid;
                if (brk.countSeparators() == 0 || brk.pos < keep)
                        continue;
@@ -415,6 +453,15 @@ void Row::shortenIfNeeded(pos_type const keep, int const w)
                 *   break-up.
                 */
                if (brk.breakAt(min(w - wid_brk, brk.dim.wid - 2), false)) {
+                       /* if this element originally did not cause a row overflow
+                        * in itself, and the remainder of the row would still be
+                        * too large after breaking, then we will have issues in
+                        * next row. Thus breaking does not help.
+                        */
+                       if (wid_brk + cit_brk->dim.wid < w
+                           && dim_.wid - (wid_brk + brk.dim.wid) >= w) {
+                               break;
+                       }
                        end_ = brk.endpos;
                        /* after breakAt, there may be spaces at the end of the
                         * string, but they are not counted in the string length
@@ -424,6 +471,7 @@ void Row::shortenIfNeeded(pos_type const keep, int const w)
                         */
                        brk.str = rtrim(brk.str);
                        brk.endpos = brk.pos + brk.str.length();
+                       *cit_brk = brk;
                        dim_.wid = wid_brk + brk.dim.wid;
                        // If there are other elements, they should be removed.
                        elements_.erase(cit_brk + 1, end);
@@ -469,9 +517,9 @@ void Row::reverseRTL(bool const rtl_par)
        pos_type const end = elements_.size();
        while (i < end) {
                // gather a sequence of elements with the same direction
-               bool const rtl = elements_[i].font.isVisibleRightToLeft();
+               bool const rtl = elements_[i].isRTL();
                pos_type j = i;
-               while (j < end && elements_[j].font.isVisibleRightToLeft() == rtl)
+               while (j < end && elements_[j].isRTL() == rtl)
                        ++j;
                // if the direction is not the same as the paragraph
                // direction, the sequence has to be reverted.