Account for old versions of Pygments

[lyx.git] / src / Row.cpp

diff --git a/src/Row.cpp b/src/Row.cpp
index 58a23805f2ff35491df7fe56d265fcda40e85b52..8d89f64e1c06f17af0e315faecbab718889f4da3 100644 (file)
--- a/src/Row.cpp
+++ b/src/Row.cpp
@@ -37,23 +37,39 @@ using support::rtrim;
 using frontend::FontMetrics;
 
 
+// Maximum length that a space can be stretched when justifying text
+static double const MAX_SPACE_STRETCH = 1.5; //em
+
+
 int Row::Element::countSeparators() const
 {
        if (type != STRING)
                return 0;
-       // 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;
+       return count(str.begin(), str.end(), ' ');
+}
+
+
+int Row::Element::countExpanders() const
+{
+       if (type != STRING)
+               return 0;
+       return theFontMetrics(font).countExpanders(str);
+}
+
+
+int Row::Element::expansionAmount() const
+{
+       if (type != STRING)
+               return 0;
+       return countExpanders() * theFontMetrics(font).em();
+}
+
+
+void Row::Element::setExtra(double extra_per_em)
+{
+       if (type != STRING)
+               return;
+       extra = extra_per_em * theFontMetrics(font).em();
 }
 
 
@@ -99,18 +115,16 @@ pos_type Row::Element::x2pos(int &x) const
        case SPACE:
                // those elements contain only one position. Round to
                // the closest side.
-               if (x > full_width()) {
+               if (x > (full_width() + 1) / 2) {
                        x = int(full_width());
                        i = !isRTL();
                } else {
                        x = 0;
                        i = isRTL();
                }
-
        }
        //lyxerr << "=> p=" << pos + i << " x=" << x << endl;
        return pos + i;
-
 }
 
 
@@ -149,7 +163,8 @@ Row::Row()
          sel_beg(-1), sel_end(-1),
          begin_margin_sel(false), end_margin_sel(false),
          changed_(false), crc_(0),
-         pit_(0), pos_(0), end_(0), right_boundary_(false)
+         pit_(0), pos_(0), end_(0),
+         right_boundary_(false), flushed_(false), rtl_(false)
 {}
 
 
@@ -234,7 +249,7 @@ ostream & operator<<(ostream & os, Row::Element const & e)
        switch (e.type) {
        case Row::STRING:
                os << "STRING: `" << to_utf8(e.str) << "' ("
-                  << e.countSeparators() << " sep.), ";
+                  << e.countExpanders() << " expanders.), ";
                break;
        case Row::VIRTUAL:
                os << "VIRTUAL: `" << to_utf8(e.str) << "', ";
@@ -311,13 +326,30 @@ int Row::countSeparators() const
 }
 
 
-void Row::setSeparatorExtraWidth(double w)
+bool Row::setExtraWidth(int w)
 {
-       separator = w;
-       iterator const end = elements_.end();
-       for (iterator it = elements_.begin() ; it != end ; ++it)
-               if (it->type == Row::STRING)
-                       it->extra = w;
+       if (w < 0)
+               // this is not expected to happen (but it does)
+               return false;
+       // amount of expansion: number of expanders time the em value for each
+       // string element
+       int exp_amount = 0;
+       for (Row::Element const & e : elements_)
+               exp_amount += e.expansionAmount();
+       if (!exp_amount)
+               return false;
+       // extra length per expander per em
+       double extra_per_em = double(w) / exp_amount;
+       if (extra_per_em > MAX_SPACE_STRETCH)
+               // do not stretch more than MAX_SPACE_STRETCH em per expander
+               return false;
+       // add extra length to each element proportionally to its em.
+       for (Row::Element & e : elements_)
+               if (e.type == Row::STRING)
+                       e.setExtra(extra_per_em);
+       // update row dimension
+       dim_.wid += w;
+       return true;
 }
 
 
@@ -413,7 +445,7 @@ void Row::pop_back()
 }
 
 
-bool Row::shortenIfNeeded(pos_type const keep, int const w)
+bool Row::shortenIfNeeded(pos_type const keep, int const w, int const next_width)
 {
        if (empty() || width() <= w)
                return false;
@@ -460,7 +492,7 @@ bool Row::shortenIfNeeded(pos_type const keep, int const w)
                         * next row. Thus breaking does not help.
                         */
                        if (wid_brk + cit_brk->dim.wid < w
-                           && dim_.wid - (wid_brk + brk.dim.wid) >= w) {
+                           && dim_.wid - (wid_brk + brk.dim.wid) >= next_width) {
                                break;
                        }
                        end_ = brk.endpos;
@@ -533,6 +565,56 @@ void Row::reverseRTL(bool const rtl_par)
        // If the paragraph itself is RTL, reverse everything
        if (rtl_par)
                reverse(elements_.begin(), elements_.end());
+       rtl_ = rtl_par;
+}
+
+Row::const_iterator const
+Row::findElement(pos_type const pos, bool const boundary, double & x) const
+{
+       /**
+        * When boundary is true, position i is in the row element (pos, endpos)
+        * if
+        *    pos < i <= endpos
+        * whereas, when boundary is false, the test is
+        *    pos <= i < endpos
+        * The correction below allows to handle both cases.
+       */
+       int const boundary_corr = (boundary && pos) ? -1 : 0;
+
+       x = left_margin;
+
+       /** Early return in trivial cases
+        * 1) the row is empty
+        * 2) the position is the left-most position of the row; there
+        * is a quirk here however: if the first element is virtual
+        * (end-of-par marker for example), then we have to look
+        * closer
+        */
+       if (empty()
+           || (pos == begin()->left_pos() && !boundary
+                       && !begin()->isVirtual()))
+               return begin();
+
+       Row::const_iterator cit = begin();
+       for ( ; cit != end() ; ++cit) {
+               /** Look whether the cursor is inside the element's
+                * span. Note that it is necessary to take the
+                * boundary into account, and to accept virtual
+                * elements, which have pos == endpos.
+                */
+               if (pos + boundary_corr >= cit->pos
+                   && (pos + boundary_corr < cit->endpos || cit->isVirtual())) {
+                               x += cit->pos2x(pos);
+                               break;
+               }
+               x += cit->full_width();
+       }
+
+       if (cit == end())
+               --cit;
+
+       return cit;
 }
 
+
 } // namespace lyx