Change FontMetrics::breakAt to return a position

[lyx.git] / src / Row.cpp

diff --git a/src/Row.cpp b/src/Row.cpp
index 697e526094b7f399801f4d62d24f7b39f5fc503a..2f6db3deaf35b22af36753721a29f00d0b74b215 100644 (file)
--- a/src/Row.cpp
+++ b/src/Row.cpp
@@ -19,14 +19,16 @@
 #include "Row.h"
 
 #include "DocIterator.h"
+#include "Language.h"
 
 #include "frontends/FontMetrics.h"
 
 #include "support/debug.h"
 #include "support/lassert.h"
 #include "support/lstrings.h"
-#include "support/lyxalgo.h"
+#include "support/lyxlib.h"
 
+#include <algorithm>
 #include <ostream>
 
 using namespace std;
@@ -130,19 +132,19 @@ pos_type Row::Element::x2pos(int &x) const
 
 bool Row::Element::breakAt(int w, bool force)
 {
-       if (type != STRING || dim.wid <= w)
+       if (type != STRING)
                return false;
 
        FontMetrics const & fm = theFontMetrics(font);
-       int x = w;
-       if(fm.breakAt(str, x, isRTL(), force)) {
-               dim.wid = x;
-               endpos = pos + str.length();
+       dim.wid = w;
+       int const i = fm.breakAt(str, dim.wid, isRTL(), force);
+       if (i != -1) {
+               str.erase(i);
+               endpos = pos + i;
                //lyxerr << "breakAt(" << w << ")  Row element Broken at " << x << "(w(str)=" << fm.width(str) << "): e=" << *this << endl;
-               return true;
        }
 
-       return false;
+       return i != - 1;
 }
 
 
@@ -296,7 +298,7 @@ int Row::left_x() const
                x += cit->full_width();
                ++cit;
        }
-       return int(x + 0.5);
+       return support::iround(x);
 }
 
 
@@ -312,7 +314,7 @@ int Row::right_x() const
                else
                        break;
        }
-       return int(x + 0.5);
+       return support::iround(x);
 }
 
 
@@ -334,7 +336,7 @@ bool Row::setExtraWidth(int w)
        // amount of expansion: number of expanders time the em value for each
        // string element
        int exp_amount = 0;
-       for (Row::Element const & e : elements_)
+       for (Element const & e : elements_)
                exp_amount += e.expansionAmount();
        if (!exp_amount)
                return false;
@@ -344,8 +346,8 @@ bool Row::setExtraWidth(int w)
                // 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)
+       for (Element & e : elements_)
+               if (e.type == STRING)
                        e.setExtra(extra_per_em);
        // update row dimension
        dim_.wid += w;
@@ -391,6 +393,7 @@ void Row::add(pos_type const pos, Inset const * ins, Dimension const & dim,
        e.dim = dim;
        elements_.push_back(e);
        dim_.wid += dim.wid;
+       changebar_ |= ins->isChanged();
 }
 
 
@@ -478,8 +481,32 @@ bool Row::shortenIfNeeded(pos_type const keep, int const w, int const next_width
                --cit_brk;
                // make a copy of the element to work on it.
                Element brk = *cit_brk;
+               /* If the current element is an inset that allows breaking row
+                * after itself, and it the row is already short enough after
+                * this inset, then cut right after this element.
+                */
+               if (wid_brk <= w && brk.type == INSET
+                   && brk.inset->rowFlags() & Inset::CanBreakAfter) {
+                       end_ = brk.endpos;
+                       dim_.wid = wid_brk;
+                       elements_.erase(cit_brk + 1, end);
+                       return true;
+               }
+               // assume now that the current element is not there
                wid_brk -= brk.dim.wid;
-               if (brk.countSeparators() == 0 || brk.pos < keep)
+               /*
+                * Some Asian languages split lines anywhere (no notion of
+                * word). It seems that QTextLayout is not aware of this fact.
+                * See for reference:
+                *    https://en.wikipedia.org/wiki/Line_breaking_rules_in_East_Asian_languages
+                *
+                * FIXME: Something shall be done about characters which are
+                * not allowed at the beginning or end of line.
+               */
+               bool const word_wrap = brk.font.language()->wordWrap();
+               // When there is text before the body part (think description
+               // environment), do not try to break.
+               if (brk.pos < keep)
                        continue;
                /* We have found a suitable separable element. This is the common case.
                 * Try to break it cleanly (at word boundary) at a length that is both
@@ -487,7 +514,7 @@ bool Row::shortenIfNeeded(pos_type const keep, int const w, int const next_width
                 * - shorter than the natural width of the element, in order to enforce
                 *   break-up.
                 */
-               if (brk.breakAt(min(w - wid_brk, brk.dim.wid - 2), false)) {
+               if (brk.breakAt(min(w - wid_brk, brk.dim.wid - 2), !word_wrap)) {
                        /* 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
@@ -597,17 +624,19 @@ Row::findElement(pos_type const pos, bool const boundary, double & x) const
                        && !begin()->isVirtual()))
                return begin();
 
-       Row::const_iterator cit = begin();
+       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.
+               /** 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, in which case the position
+                * will be before the virtual element.
                 */
-               if (pos + boundary_corr >= cit->pos
-                   && (pos + boundary_corr < cit->endpos || cit->isVirtual())) {
-                               x += cit->pos2x(pos);
-                               break;
+               if (cit->isVirtual() && pos + boundary_corr == cit->pos)
+                       break;
+               else if (pos + boundary_corr >= cit->pos
+                        && pos + boundary_corr < cit->endpos) {
+                       x += cit->pos2x(pos);
+                       break;
                }
                x += cit->full_width();
        }