Amend 207eaeee9071cb

[lyx.git] / src / Row.cpp

diff --git a/src/Row.cpp b/src/Row.cpp
index a7f00d536d7219cf7d3c0f9783432d2fed3996a1..b85ef3d18b05bfb853efe9ddd911c33ac9dcec89 100644 (file)
--- a/src/Row.cpp
+++ b/src/Row.cpp
@@ -123,7 +123,7 @@ pos_type Row::Element::x2pos(int &x) const
 }
 
 
-bool Row::Element::splitAt(int const width, int next_width, bool force,
+bool Row::Element::splitAt(int const width, int next_width, SplitType split_type,
                            Row::Elements & tail)
 {
        // Not a string or already OK.
@@ -142,13 +142,13 @@ bool Row::Element::splitAt(int const width, int next_width, bool force,
 
        bool const wrap_any = !font.language()->wordWrap();
        FontMetrics::Breaks breaks = fm.breakString(str, width, next_width,
-                                                isRTL(), wrap_any | force);
+                                                isRTL(), wrap_any || split_type == FORCE);
 
        /** if breaking did not really work, give up
-        * case 1: we do not force break and the first element is longer than the limit;
+        * case 1: split type is FIT and the first element is longer than the limit;
         * case 2: the first break occurs at the front of the string
         */
-       if ((!force && breaks.front().nspc_wid > width)
+       if ((split_type == FIT && breaks.front().nspc_wid > width)
            || (breaks.size() > 1 && breaks.front().len == 0)) {
                if (dim.wid == 0)
                        dim.wid = fm.width(str);
@@ -425,6 +425,7 @@ bool Row::sameString(Font const & f, Change const & ch) const
 }
 
 
+// FIXME: remove this and move the changebar update to Row::push_back()
 void Row::finalizeLast()
 {
        if (elements_.empty())
@@ -509,15 +510,14 @@ void Row::addMarginSpace(pos_type const pos, int const width,
 
 void Row::push_back(Row::Element const & e)
 {
-       dim_.wid += e.dim.wid + ((e.type == INSET) ? e.extra : 0);
+       dim_.wid += e.dim.wid;
        elements_.push_back(e);
 }
 
 
 void Row::pop_back()
 {
-       Element const & e = elements_.back();
-       dim_.wid -= e.dim.wid + ((e.type == INSET) ? e.extra : 0);
+       dim_.wid -= elements_.back().dim.wid;
        elements_.pop_back();
 }
 
@@ -548,6 +548,8 @@ Row::Elements Row::shortenIfNeeded(int const max_width, int const next_width)
        Elements::iterator const beg = elements_.begin();
        Elements::iterator const end = elements_.end();
        int wid = left_margin;
+       // the smallest row width we know we can achieve by breaking a string.
+       int min_row_wid = dim_.wid;
 
        // Search for the first element that goes beyond right margin
        Elements::iterator cit = beg;
@@ -572,9 +574,9 @@ Row::Elements Row::shortenIfNeeded(int const max_width, 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 if the row is already short enough after
-                * this element, then cut right after it.
+               /* If the current element allows breaking row after itself,
+                * and if the row is already short enough after this element,
+                * then cut right after it.
                 */
                if (wid_brk <= max_width && brk.row_flags & CanBreakAfter) {
                        end_ = brk.endpos;
@@ -584,9 +586,9 @@ Row::Elements Row::shortenIfNeeded(int const max_width, int const next_width)
                }
                // assume now that the current element is not there
                wid_brk -= brk.dim.wid;
-               /* If the current element is an inset that allows breaking row
-                * before itself, and if the row is already short enough before
-                * this element, then cut right before it.
+               /* If the current element allows breaking row before itself,
+                * and if the row is already short enough before this element,
+                * then cut right before it.
                 */
                if (wid_brk <= max_width && brk.row_flags & CanBreakBefore && cit_brk != beg) {
                        end_ = (cit_brk -1)->endpos;
@@ -600,17 +602,28 @@ Row::Elements Row::shortenIfNeeded(int const max_width, int const next_width)
                 * - shorter than the natural width of the element, in order to enforce
                 *   break-up.
                 */
-               if (brk.splitAt(min(max_width - wid_brk, brk.dim.wid - 2), next_width, false, tail)) {
+               int const split_width =  min(max_width - wid_brk, brk.dim.wid - 2);
+               if (brk.splitAt(split_width, next_width, BEST_EFFORT, tail)) {
                        /* 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.
+                        * next row. Thus breaking here does not help.
                         */
                        if (wid_brk + cit_brk->dim.wid < max_width
-                           && dim_.wid - (wid_brk + brk.dim.wid) >= next_width) {
+                           && min_row_wid - (wid_brk + brk.dim.wid) >= next_width) {
                                tail.clear();
                                break;
                        }
+                       /* if we did not manage to fit a part of the element into
+                        * the split_width limit, at least remember that we can
+                        * shorten the row if needed.
+                        */
+                       if (brk.dim.wid > split_width) {
+                               min_row_wid = wid_brk + brk.dim.wid;
+                               tail.clear();
+                               continue;
+                       }
+                       // We have found a proper place where to break this string element.
                        end_ = brk.endpos;
                        *cit_brk = brk;
                        dim_.wid = wid_brk + brk.dim.wid;
@@ -641,7 +654,7 @@ Row::Elements Row::shortenIfNeeded(int const max_width, int const next_width)
         * shorten the row. Let's try to break it again, but force
         * splitting this time.
         */
-       if (cit->splitAt(max_width - wid, next_width, true, tail)) {
+       if (cit->splitAt(max_width - wid, next_width, FORCE, tail)) {
                end_ = cit->endpos;
                dim_.wid = wid + cit->dim.wid;
                // If there are other elements, they should be removed.