This is LyX 2.2.0alpha1

[lyx.git] / src / Row.cpp

diff --git a/src/Row.cpp b/src/Row.cpp
index 7108c3c2adbef72248d28803f93b8a0397c4ab08..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;
@@ -480,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.