X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FRow.cpp;h=58a23805f2ff35491df7fe56d265fcda40e85b52;hb=79be66bdf1ad1bc58231402579d59a8b7189c95e;hp=34be0529aa944208beedf86b2741cbb9380ca4dc;hpb=46ee67995d9bd1836463eeadb3b341c925061752;p=lyx.git diff --git a/src/Row.cpp b/src/Row.cpp index 34be0529aa..58a23805f2 100644 --- a/src/Row.cpp +++ b/src/Row.cpp @@ -24,18 +24,39 @@ #include "support/debug.h" #include "support/lassert.h" +#include "support/lstrings.h" +#include "support/lyxalgo.h" -#include #include -#include - using namespace std; namespace lyx { +using support::rtrim; using frontend::FontMetrics; + +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; +} + + double Row::Element::pos2x(pos_type const i) const { // This can happen with inline completion when clicking on the @@ -43,54 +64,47 @@ double Row::Element::pos2x(pos_type const i) const if (i < pos || i > endpos) return 0; - bool const rtl = font.isVisibleRightToLeft(); - double w = 0; //handle first the two bounds of the element - if (i == endpos) - w = rtl ? 0 : width(); + if (i == endpos && type != VIRTUAL) + w = isRTL() ? 0 : full_width(); else if (i == pos || type != STRING) - w = rtl ? width() : 0; + w = isRTL() ? full_width() : 0; else { FontMetrics const & fm = theFontMetrics(font); - w = fm.pos2x(str, i - pos, font.isVisibleRightToLeft()); + w = fm.pos2x(str, i - pos, isRTL(), extra); } return w; } -pos_type Row::Element::x2pos(double &x) const +pos_type Row::Element::x2pos(int &x) const { //lyxerr << "x2pos: x=" << x << " w=" << width() << " " << *this; - bool const rtl = font.isVisibleRightToLeft(); size_t i = 0; switch (type) { case STRING: { FontMetrics const & fm = theFontMetrics(font); - // FIXME: is it really necessary for x to be a double? - int xx = int(x); - i = fm.x2pos(str, xx, rtl); - x = xx; + i = fm.x2pos(str, x, isRTL(), extra); break; } case VIRTUAL: // those elements are actually empty (but they have a width) i = 0; - x = rtl ? width() : 0; + x = isRTL() ? int(full_width()) : 0; break; - case SEPARATOR: case INSET: case SPACE: // those elements contain only one position. Round to // the closest side. - if (x > width()) { - x = width(); - i = !rtl; + if (x > full_width()) { + x = int(full_width()); + i = !isRTL(); } else { x = 0; - i = rtl; + i = isRTL(); } } @@ -100,44 +114,42 @@ pos_type Row::Element::x2pos(double &x) const } -bool Row::Element::breakAt(double w) +bool Row::Element::breakAt(int w, bool force) { - if (type != STRING || width() <= w) + if (type != STRING || dim.wid <= w) return false; - bool const rtl = font.isVisibleRightToLeft(); - if (rtl) - w = width() - w; - pos_type new_pos = x2pos(w); - if (new_pos == pos) - return false; - str = str.substr(0, new_pos - pos); - if (rtl) - dim.wid -= int(w); - else - dim.wid = int(w); - endpos = new_pos; - return true; + FontMetrics const & fm = theFontMetrics(font); + int x = w; + if(fm.breakAt(str, x, isRTL(), force)) { + dim.wid = x; + endpos = pos + str.length(); + //lyxerr << "breakAt(" << w << ") Row element Broken at " << x << "(w(str)=" << fm.width(str) << "): e=" << *this << endl; + return true; + } + + return false; } pos_type Row::Element::left_pos() const { - return font.isVisibleRightToLeft() ? endpos : pos; + return isRTL() ? endpos : pos; } pos_type Row::Element::right_pos() const { - return font.isVisibleRightToLeft() ? pos : endpos; + return isRTL() ? pos : endpos; } Row::Row() - : separator(0), label_hfill(0), x(0), right_margin(0), + : separator(0), label_hfill(0), left_margin(0), right_margin(0), sel_beg(-1), sel_end(-1), begin_margin_sel(false), end_margin_sel(false), - changed_(false), crc_(0), pos_(0), end_(0), right_boundary_(false) + changed_(false), crc_(0), + pit_(0), pos_(0), end_(0), right_boundary_(false) {} @@ -214,14 +226,15 @@ bool Row::selection() const ostream & operator<<(ostream & os, Row::Element const & e) { - if (e.font.isVisibleRightToLeft()) + if (e.isRTL()) os << e.endpos << "<<" << e.pos << " "; else os << e.pos << ">>" << e.endpos << " "; switch (e.type) { case Row::STRING: - os << "STRING: `" << to_utf8(e.str) << "', "; + os << "STRING: `" << to_utf8(e.str) << "' (" + << e.countSeparators() << " sep.), "; break; case Row::VIRTUAL: os << "VIRTUAL: `" << to_utf8(e.str) << "', "; @@ -229,14 +242,11 @@ ostream & operator<<(ostream & os, Row::Element const & e) case Row::INSET: os << "INSET: " << to_utf8(e.inset->layoutName()) << ", "; break; - case Row::SEPARATOR: - os << "SEPARATOR: extra=" << e.extra << ", "; - break; case Row::SPACE: os << "SPACE: "; break; } - os << "width=" << e.width(); + os << "width=" << e.full_width(); return os; } @@ -244,23 +254,73 @@ ostream & operator<<(ostream & os, Row::Element const & e) ostream & operator<<(ostream & os, Row const & row) { os << " pos: " << row.pos_ << " end: " << row.end_ - << " x: " << row.x + << " left_margin: " << row.left_margin << " width: " << row.dim_.wid << " right_margin: " << row.right_margin << " ascent: " << row.dim_.asc << " descent: " << row.dim_.des << " separator: " << row.separator - << " label_hfill : " << row.label_hfill << "\n"; - double x = row.x; + << " label_hfill: " << row.label_hfill + << " row_boundary: " << row.right_boundary() << "\n"; + 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->width(); + x += it->full_width(); } return os; } +int Row::left_x() const +{ + double x = left_margin; + const_iterator const end = elements_.end(); + const_iterator cit = elements_.begin(); + while (cit != end && cit->isVirtual()) { + x += cit->full_width(); + ++cit; + } + return int(x + 0.5); +} + + +int Row::right_x() const +{ + double x = dim_.wid; + const_iterator const begin = elements_.begin(); + const_iterator cit = elements_.end(); + while (cit != begin) { + --cit; + if (cit->isVirtual()) + x -= cit->full_width(); + else + break; + } + return int(x + 0.5); +} + + +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; +} + + +void Row::setSeparatorExtraWidth(double w) +{ + separator = w; + iterator const end = elements_.end(); + for (iterator it = elements_.begin() ; it != end ; ++it) + if (it->type == Row::STRING) + it->extra = w; +} + + bool Row::sameString(Font const & f, Change const & ch) const { if (elements_.empty()) @@ -281,6 +341,7 @@ void Row::finalizeLast() elt.final = true; if (elt.type == STRING) { + dim_.wid -= elt.dim.wid; elt.dim.wid = theFontMetrics(elt.font).width(elt.str); dim_.wid += elt.dim.wid; } @@ -307,8 +368,16 @@ void Row::add(pos_type const pos, char_type const c, Element e(STRING, pos, f, ch); elements_.push_back(e); } - back().str += c; - back().endpos = pos + 1; + if (back().str.length() % 30 == 0) { + dim_.wid -= back().dim.wid; + back().str += c; + back().endpos = pos + 1; + back().dim.wid = theFontMetrics(back().font).width(back().str); + dim_.wid += back().dim.wid; + } else { + back().str += c; + back().endpos = pos + 1; + } } @@ -326,18 +395,6 @@ void Row::addVirtual(pos_type const pos, docstring const & s, } -void Row::addSeparator(pos_type const pos, char_type const c, - Font const & f, Change const & ch) -{ - finalizeLast(); - Element e(SEPARATOR, pos, f, ch); - e.str += c; - e.dim.wid = theFontMetrics(f).width(c); - elements_.push_back(e); - dim_.wid += e.dim.wid; -} - - void Row::addSpace(pos_type const pos, int const width, Font const & f, Change const & ch) { @@ -356,63 +413,104 @@ void Row::pop_back() } -void Row::shortenIfNeeded(pos_type const keep, int const w) +bool Row::shortenIfNeeded(pos_type const keep, int const w) { if (empty() || width() <= w) - return; + return false; - /** First, we try to remove elements one by one from the end - * until a separator is found. cit points to the first element - * we want to remove from the row. - */ Elements::iterator const beg = elements_.begin(); Elements::iterator const end = elements_.end(); - Elements::iterator cit = end; - Elements::iterator first_below = end; - int new_end = end_; - int new_wid = dim_.wid; - // if the row ends with a separator, skip it. - if (cit != beg && boost::prior(cit)->type == SEPARATOR && new_end > keep) { - --cit; - new_end = cit->pos; - new_wid -= cit->dim.wid; + int wid = left_margin; + + // Search for the first element that goes beyond right margin + Elements::iterator cit = beg; + for ( ; cit != end ; ++cit) { + if (wid + cit->dim.wid > w) + break; + wid += cit->dim.wid; + } + + if (cit == end) { + // This should not happen since the row is too long. + LYXERR0("Something is wrong cannot shorten row: " << *this); + return false; } - // Search for a separator where the row can be broken. - while (cit != beg && boost::prior(cit)->type != SEPARATOR && new_end > keep) { + // 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; + while (cit_brk != beg) { + --cit_brk; + // make a copy of the element to work on it. + Element brk = *cit_brk; + wid_brk -= brk.dim.wid; + if (brk.countSeparators() == 0 || 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 + * - 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), false)) { + /* 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. + */ + if (wid_brk + cit_brk->dim.wid < w + && dim_.wid - (wid_brk + brk.dim.wid) >= w) { + 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; + } + } + + if (cit != beg && cit->type == VIRTUAL) { + // It is not possible to separate a virtual element from the + // previous one. --cit; - new_end = cit->pos; - new_wid -= cit->dim.wid; - if (new_wid < w && first_below == end) - first_below = cit; + wid -= cit->dim.wid; } if (cit != beg) { - // We have found a suitable separator. This is the - // common case. - end_ = new_end; - dim_.wid = new_wid; + // There is no usable separator, but several elements have + // been added. We can cut right here. + end_ = cit->pos; + dim_.wid = wid; elements_.erase(cit, end); - return; + return true; } - /* If we are here, it means that we have not found a separator - * to shorten the row. There is one case where we can do - * something: when we have one big string, maybe with some - * other things after it. + /* 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. */ - double max_w = w - x; - if (first_below->breakAt(max_w)) { - end_ = first_below->endpos; - dim_.wid = int(x + first_below->width()); + if (cit->breakAt(w - wid, true)) { + 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(boost::next(first_below), end); - } else if (first_below->pos > pos_) { - end_ = first_below->pos; - dim_.wid = new_wid; - // Remove all elements from first_below. - elements_.erase(first_below, end); + elements_.erase(next(cit, 1), end); + return true; } + return false; } @@ -422,9 +520,9 @@ void Row::reverseRTL(bool const rtl_par) pos_type const end = elements_.size(); while (i < end) { // gather a sequence of elements with the same direction - bool const rtl = elements_[i].font.isVisibleRightToLeft(); + bool const rtl = elements_[i].isRTL(); pos_type j = i; - while (j < end && elements_[j].font.isVisibleRightToLeft() == rtl) + while (j < end && elements_[j].isRTL() == rtl) ++j; // if the direction is not the same as the paragraph // direction, the sequence has to be reverted.