namespace lyx {
-using support::rtrim;
using frontend::FontMetrics;
break;
case INSET:
case SPACE:
+ case MARGINSPACE:
// those elements contain only one position. Round to
// the closest side.
if (x > (full_width() + 1) / 2) {
x = 0;
i = isRTL();
}
- break;
- case INVALID:
- LYXERR0("x2pos: INVALID row element !");
}
//lyxerr << "=> p=" << pos + i << " x=" << x << endl;
return pos + i;
}
-Row::Element Row::Element::splitAt(int w, bool force)
+bool Row::Element::splitAt(int const width, int next_width, bool force,
+ Row::Elements & tail)
{
- if (type != STRING || !(row_flags & CanBreakInside))
- return Element();
+ // Not a string or already OK.
+ if (type != STRING || (dim.wid > 0 && dim.wid < width))
+ return false;
FontMetrics const & fm = theFontMetrics(font);
- dim.wid = w;
- int const i = fm.breakAt(str, dim.wid, isRTL(), force);
- if (i != -1) {
- Element ret(STRING, pos + i, font, change);
- ret.str = str.substr(i);
- ret.endpos = ret.pos + ret.str.length();
- ret.row_flags = row_flags & (CanBreakInside | AfterFlags);
- str.erase(i);
- endpos = pos + i;
- //lyxerr << "breakAt(" << w << ") Row element Broken at " << x << "(w(str)=" << fm.width(str) << "): e=" << *this << endl;
- return ret;
+
+ // A a string that is not breakable
+ if (!(row_flags & CanBreakInside)) {
+ // has width been computed yet?
+ if (dim.wid == 0)
+ dim.wid = fm.width(str);
+ return false;
+ }
+
+ bool const wrap_any = !font.language()->wordWrap();
+ FontMetrics::Breaks breaks = fm.breakString(str, width, next_width,
+ isRTL(), wrap_any | force);
+
+ // if breaking did not really work, give up
+ if (!force && breaks.front().wid > width) {
+ if (dim.wid == 0)
+ dim.wid = fm.width(str);
+ return false;
+ }
+
+ Element first_e(STRING, pos, font, change);
+ // should next element eventually replace *this?
+ bool first = true;
+ docstring::size_type i = 0;
+ for (FontMetrics::Break const & brk : breaks) {
+ /* For some reason breakString can decide to break before the
+ * first character (normally we use a 0-width nbsp to prevent
+ * that). Skip leading empty elements, they are never wanted.
+ */
+ if (first && brk.len == 0 && breaks.size() > 1)
+ continue;
+ Element e(STRING, pos + i, font, change);
+ e.str = str.substr(i, brk.len);
+ e.endpos = e.pos + brk.len;
+ e.dim.wid = brk.wid;
+ e.nspc_wid = brk.nspc_wid;
+ e.row_flags = CanBreakInside | BreakAfter;
+ if (first) {
+ // this element eventually goes to *this
+ e.row_flags |= row_flags & ~AfterFlags;
+ first_e = e;
+ first = false;
+ } else
+ tail.push_back(e);
+ i += brk.len;
+ }
+
+ if (!tail.empty()) {
+ // Avoid having a last empty element. This happens when
+ // breaking at the trailing space of string
+ if (tail.back().str.empty())
+ tail.pop_back();
+ else {
+ // Copy the after flags of the original element to the last one.
+ tail.back().row_flags &= ~BreakAfter;
+ tail.back().row_flags |= row_flags & AfterFlags;
+ }
+ // first_e row should be broken after the original element
+ first_e.row_flags |= BreakAfter;
+ } else {
+ // Restore the after flags of the original element.
+ first_e.row_flags &= ~BreakAfter;
+ first_e.row_flags |= row_flags & AfterFlags;
}
- return Element();
+ // update ourselves
+ swap(first_e, *this);
+ return true;
}
-bool Row::Element::breakAt(int w, bool force)
+void Row::Element::rtrim()
{
- return splitAt(w, force).isValid();
+ if (type != STRING)
+ return;
+ /* This is intended for strings that have been created by splitAt.
+ * They may have trailing spaces, but they are not counted in the
+ * string length (QTextLayout feature, actually). We remove them,
+ * and decrease endpos, since spaces at row break are invisible.
+ */
+ str = support::rtrim(str);
+ endpos = pos + str.length();
+ dim.wid = nspc_wid;
}
case Row::SPACE:
os << "SPACE: ";
break;
- case Row::INVALID:
- os << "INVALID: ";
- break;
+ case Row::MARGINSPACE:
+ os << "MARGINSPACE: ";
+ }
+ os << "width=" << e.full_width() << ", row_flags=" << e.row_flags;
+ return os;
+}
+
+
+ostream & operator<<(ostream & os, Row::Elements const & elts)
+{
+ double x = 0;
+ for (Row::Element const & e : elts) {
+ os << "x=" << x << " => " << e << endl;
+ x += e.full_width();
}
- os << "width=" << e.full_width();
return os;
}
<< " descent: " << row.dim_.des
<< " separator: " << row.separator
<< " label_hfill: " << row.label_hfill
- << " row_boundary: " << row.right_boundary() << "\n";
+ << " right_boundary: " << row.right_boundary()
+ << " flushed: " << row.flushed() << "\n";
+ // We cannot use the operator above, unfortunately
double x = row.left_margin;
- Row::Elements::const_iterator it = row.elements_.begin();
- for ( ; it != row.elements_.end() ; ++it) {
- os << "x=" << x << " => " << *it << endl;
- x += it->full_width();
+ for (Row::Element const & e : row.elements_) {
+ os << "x=" << x << " => " << e << endl;
+ x += e.full_width();
}
return os;
}
elt.final = true;
if (elt.change.changed())
changebar_ = true;
-
- if (elt.type == STRING && elt.dim.wid == 0) {
- elt.dim.wid = theFontMetrics(elt.font).width(elt.str);
- dim_.wid += elt.dim.wid;
- }
}
void Row::add(pos_type const pos, char_type const c,
- Font const & f, Change const & ch, bool can_break)
+ Font const & f, Change const & ch)
{
if (!sameString(f, ch)) {
finalizeLast();
Element e(STRING, pos, f, ch);
- e.row_flags = can_break ? CanBreakInside : Inline;
+ e.row_flags = CanBreakInside;
elements_.push_back(e);
}
back().str += c;
}
+void Row::addMarginSpace(pos_type const pos, int const width,
+ Font const & f, Change const & ch)
+{
+ finalizeLast();
+ Element e(MARGINSPACE, pos, f, ch);
+ e.dim.wid = width;
+ e.row_flags = NoBreakBefore;
+ elements_.push_back(e);
+ dim_.wid += e.dim.wid;
+}
+
+
void Row::push_back(Row::Element const & e)
{
dim_.wid += e.dim.wid;
}
-bool Row::shortenIfNeeded(int const w, int const next_width)
+namespace {
+
+// Move stuff after \c it from \c from and the end of \c to.
+void moveElements(Row::Elements & from, Row::Elements::iterator const & it,
+ Row::Elements & to)
{
+ to.insert(to.end(), it, from.end());
+ from.erase(it, from.end());
+ if (!from.empty())
+ from.back().row_flags = (from.back().row_flags & ~AfterFlags) | AlwaysBreakAfter;
+}
+
+}
+
+
+Row::Elements Row::shortenIfNeeded(int const w, int const next_width)
+{
+ // FIXME: performance: if the last element is a string, we would
+ // like to avoid computing its length.
+ finalizeLast();
if (empty() || width() <= w)
- return false;
+ return Elements();
Elements::iterator const beg = elements_.begin();
Elements::iterator const end = elements_.end();
if (cit == end) {
// This should not happen since the row is too long.
- LYXERR0("Something is wrong cannot shorten row: " << *this);
- return false;
+ LYXERR0("Something is wrong, cannot shorten row: " << *this);
+ return Elements();
}
// Iterate backwards over breakable elements and try to break them
Elements::iterator cit_brk = cit;
int wid_brk = wid + cit_brk->dim.wid;
++cit_brk;
+ Elements tail;
while (cit_brk != beg) {
--cit_brk;
// make a copy of the element to work on it.
if (wid_brk <= w && brk.row_flags & CanBreakAfter) {
end_ = brk.endpos;
dim_.wid = wid_brk;
- elements_.erase(cit_brk + 1, end);
- return true;
+ moveElements(elements_, cit_brk + 1, tail);
+ return tail;
}
// assume now that the current element is not there
wid_brk -= brk.dim.wid;
- /*
- * 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();
/* 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
+ * Try to break it cleanly at a length that is both
* - less than the available space on the row
* - 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), !word_wrap)) {
+ if (brk.splitAt(min(w - wid_brk, brk.dim.wid - 2), next_width, false, 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
*/
if (wid_brk + cit_brk->dim.wid < w
&& dim_.wid - (wid_brk + brk.dim.wid) >= next_width) {
+ tail.clear();
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
- * (QTextLayout feature, actually). We remove them, but do
- * not change the end of the row, since spaces at row
- * break are invisible.
- */
- 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);
- return true;
+ moveElements(elements_, cit_brk + 1, tail);
+ return tail;
}
+ LATTEST(tail.empty());
}
- if (cit != beg && cit->type == VIRTUAL) {
- // It is not possible to separate a virtual element from the
- // previous one.
+ if (cit != beg && cit->row_flags & NoBreakBefore) {
+ // It is not possible to separate this element from the
+ // previous one. (e.g. VIRTUAL)
--cit;
wid -= cit->dim.wid;
}
// been added. We can cut right here.
end_ = cit->pos;
dim_.wid = wid;
- elements_.erase(cit, end);
- return true;
+ moveElements(elements_, cit, tail);
+ return tail;
}
/* If we are here, it means that we have not found a separator to
- * shorten the row. Let's try to break it again, but not at word
- * boundary this time.
+ * shorten the row. Let's try to break it again, but force
+ * splitting this time.
*/
- if (cit->breakAt(w - wid, true)) {
+ if (cit->splitAt(w - wid, next_width, true, tail)) {
end_ = cit->endpos;
- // See comment above.
- cit->str = rtrim(cit->str);
- cit->endpos = cit->pos + cit->str.length();
dim_.wid = wid + cit->dim.wid;
// If there are other elements, they should be removed.
- elements_.erase(next(cit, 1), end);
- return true;
+ moveElements(elements_, cit + 1, tail);
+ return tail;
}
- return false;
+
+ // cit == beg; remove all elements after the first one.
+ moveElements(elements_, cit + 1, tail);
+ return tail;
}
-void Row::reverseRTL(bool const rtl_par)
+void Row::reverseRTL()
{
pos_type i = 0;
pos_type const end = elements_.size();
++j;
// if the direction is not the same as the paragraph
// direction, the sequence has to be reverted.
- if (rtl != rtl_par)
+ if (rtl != rtl_)
reverse(elements_.begin() + i, elements_.begin() + j);
i = j;
}
// If the paragraph itself is RTL, reverse everything
- if (rtl_par)
+ if (rtl_)
reverse(elements_.begin(), elements_.end());
- rtl_ = rtl_par;
}
Row::const_iterator const