#include "support/lassert.h"
#include "support/lstrings.h"
#include "support/lyxlib.h"
+#include "support/textutils.h"
#include <algorithm>
#include <ostream>
static double const MAX_SPACE_STRETCH = 1.5; //em
-int Row::Element::countSeparators() const
-{
- if (type != STRING)
- return 0;
- return count(str.begin(), str.end(), ' ');
-}
-
-
int Row::Element::countExpanders() const
{
if (type != STRING)
return 0;
- return theFontMetrics(font).countExpanders(str);
+ return support::countExpanders(str);
}
break;
case INSET:
case SPACE:
+ case MARGINSPACE:
// those elements contain only one position. Round to
// the closest side.
if (x > (full_width() + 1) / 2) {
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 breaking did not really work, give up
+ * case 1: we do not force break 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)
+ || (breaks.size() > 1 && breaks.front().len == 0)) {
if (dim.wid == 0)
dim.wid = fm.width(str);
return false;
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
// first_e row should be broken after the original element
first_e.row_flags |= BreakAfter;
} else {
- // Restore the after flags of the original element.
+#if 1
+ // remove the BreakAfter that got added above.
first_e.row_flags &= ~BreakAfter;
+#else
+ // FIXME : the code below looks like a good idea, but I do not
+ // have a use case yet. The question is what happens
+ // when breaking at the end of a string with a
+ // trailing space.
+ // if it turns out that no breaking was necessary, remove the
+ // BreakAfter that got added above.
+ if (first_e.dim.wid <= width)
+ first_e.row_flags &= ~BreakAfter;
+#endif
+ // Restore the after flags of the original element.
first_e.row_flags |= row_flags & AfterFlags;
}
void Row::Element::rtrim()
{
- if (type != STRING)
+ if (type != STRING || str.empty() || !isSpace(str.back()))
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.
+ * If There is a trailing space, we remove it and decrease endpos,
+ * since spaces at row break are invisible.
*/
- str = support::rtrim(str);
+ str.pop_back();
endpos = pos + str.length();
+ dim.wid = nspc_wid;
}
break;
case Row::SPACE:
os << "SPACE: ";
+ break;
+ case Row::MARGINSPACE:
+ os << "MARGINSPACE: ";
}
os << "width=" << e.full_width() << ", row_flags=" << e.row_flags;
return os;
ostream & operator<<(ostream & os, Row const & row)
{
- os << " pos: " << row.pos_ << " end: " << row.end_
+ os << " pit: " << row.pit_ << " pos: " << row.pos_ << " end: " << row.end_
<< " left_margin: " << row.left_margin
<< " width: " << row.dim_.wid
<< " right_margin: " << row.right_margin
<< " descent: " << row.dim_.des
<< " separator: " << row.separator
<< " label_hfill: " << row.label_hfill
- << " row_boundary: " << row.right_boundary() << "\n";
+ << " end_boundary: " << row.end_boundary()
+ << " flushed: " << row.flushed_
+ << " rtl=" << row.rtl_ << "\n";
// We cannot use the operator above, unfortunately
double x = row.left_margin;
for (Row::Element const & e : row.elements_) {
}
-int Row::countSeparators() const
-{
- int n = 0;
- const_iterator const end = elements_.end();
- for (const_iterator cit = elements_.begin() ; cit != end ; ++cit)
- n += cit->countSeparators();
- return n;
-}
-
-
bool Row::setExtraWidth(int w)
{
if (w < 0)
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;
to.insert(to.end(), it, from.end());
from.erase(it, from.end());
if (!from.empty())
- from.back().row_flags = (from.back().row_flags & ~AfterFlags) | BreakAfter;
+ from.back().row_flags = (from.back().row_flags & ~AfterFlags) | AlwaysBreakAfter;
}
}
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 inset, then cut right after this element.
+ * this element, then cut right after it.
*/
if (wid_brk <= w && brk.row_flags & CanBreakAfter) {
end_ = brk.endpos;
}
// 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 (wid_brk <= w && brk.row_flags & CanBreakBefore && cit_brk != beg) {
+ end_ = (cit_brk -1)->endpos;
+ dim_.wid = wid_brk;
+ moveElements(elements_, cit_brk, tail);
+ return tail;
+ }
/* We have found a suitable separable element. This is the common case.
* Try to break it cleanly at a length that is both
* - less than the available space on the row
*/
if (wid_brk + cit_brk->dim.wid < w
&& dim_.wid - (wid_brk + brk.dim.wid) >= next_width) {
+ tail.clear();
break;
}
end_ = brk.endpos;
* splitting this time.
*/
if (cit->splitAt(w - wid, next_width, true, tail)) {
- LYXERR0(*cit);
end_ = cit->endpos;
dim_.wid = wid + cit->dim.wid;
// If there are other elements, they should be removed.
return tail;
}
- return Elements();
+ // 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