X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FRow.cpp;h=02ea13319a58404613757cb530432f924d047237;hb=c7d29be153debac82e3d2e8865fcc849f0a5f40d;hp=1bd11c97cd41aacb9749e603bc6c88991cc395cb;hpb=25727ee5a898a5ade763a344ebac28b49df89076;p=lyx.git diff --git a/src/Row.cpp b/src/Row.cpp index 1bd11c97cd..02ea13319a 100644 --- a/src/Row.cpp +++ b/src/Row.cpp @@ -19,6 +19,7 @@ #include "Row.h" #include "DocIterator.h" +#include "Language.h" #include "frontends/FontMetrics.h" @@ -37,6 +38,10 @@ using support::rtrim; using frontend::FontMetrics; +// Maximum length that a space can be stretched when justifying text +static double const MAX_SPACE_STRETCH = 1.5; //em + + int Row::Element::countSeparators() const { if (type != STRING) @@ -45,6 +50,30 @@ int Row::Element::countSeparators() const } +int Row::Element::countExpanders() const +{ + if (type != STRING) + return 0; + return theFontMetrics(font).countExpanders(str); +} + + +int Row::Element::expansionAmount() const +{ + if (type != STRING) + return 0; + return countExpanders() * theFontMetrics(font).em(); +} + + +void Row::Element::setExtra(double extra_per_em) +{ + if (type != STRING) + return; + extra = extra_per_em * theFontMetrics(font).em(); +} + + double Row::Element::pos2x(pos_type const i) const { // This can happen with inline completion when clicking on the @@ -52,18 +81,15 @@ 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 && type != VIRTUAL - && !(inset && inset->lyxCode() == SEPARATOR_CODE)) - w = rtl ? 0 : full_width(); + if (i == endpos && type != VIRTUAL) + w = isRTL() ? 0 : full_width(); else if (i == pos || type != STRING) - w = rtl ? full_width() : 0; + w = isRTL() ? full_width() : 0; else { FontMetrics const & fm = theFontMetrics(font); - w = fm.pos2x(str, i - pos, font.isVisibleRightToLeft(), extra); + w = fm.pos2x(str, i - pos, isRTL(), extra); } return w; @@ -73,37 +99,33 @@ double Row::Element::pos2x(pos_type const i) 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); - i = fm.x2pos(str, x, rtl, extra); + i = fm.x2pos(str, x, isRTL(), extra); break; } case VIRTUAL: // those elements are actually empty (but they have a width) i = 0; - x = rtl ? int(full_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 > full_width()) { + if (x > (full_width() + 1) / 2) { x = int(full_width()); - i = !rtl; + i = !isRTL(); } else { x = 0; - i = rtl; + i = isRTL(); } - } //lyxerr << "=> p=" << pos + i << " x=" << x << endl; return pos + i; - } @@ -112,28 +134,28 @@ bool Row::Element::breakAt(int w, bool force) if (type != STRING || dim.wid <= w) return false; - bool const rtl = font.isVisibleRightToLeft(); FontMetrics const & fm = theFontMetrics(font); int x = w; - if(fm.breakAt(str, x, rtl, force)) { + 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; } @@ -141,17 +163,13 @@ Row::Row() : 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_(true), + pit_(0), pos_(0), end_(0), + right_boundary_(false), flushed_(false), rtl_(false), + changebar_(false) {} -void Row::setCrc(size_type crc) const -{ - changed_ = crc != crc_; - crc_ = crc; -} - - bool Row::isMarginSelected(bool left_margin, DocIterator const & beg, DocIterator const & end) const { @@ -186,8 +204,8 @@ void Row::setSelectionAndMargins(DocIterator const & beg, setSelection(beg.pos(), end.pos()); if (selection()) { - end_margin_sel = isMarginSelected(false, beg, end); - begin_margin_sel = isMarginSelected(true, beg, end); + change(end_margin_sel, isMarginSelected(false, beg, end)); + change(begin_margin_sel, isMarginSelected(true, beg, end)); } } @@ -195,18 +213,18 @@ void Row::setSelectionAndMargins(DocIterator const & beg, void Row::setSelection(pos_type beg, pos_type end) const { if (pos_ >= beg && pos_ <= end) - sel_beg = pos_; + change(sel_beg, pos_); else if (beg > pos_ && beg <= end_) - sel_beg = beg; + change(sel_beg, beg); else - sel_beg = -1; + change(sel_beg, -1); if (end_ >= beg && end_ <= end) - sel_end = end_; + change(sel_end,end_); else if (end < end_ && end >= pos_) - sel_end = end; + change(sel_end, end); else - sel_end = -1; + change(sel_end, -1); } @@ -218,14 +236,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.countExpanders() << " expanders.), "; break; case Row::VIRTUAL: os << "VIRTUAL: `" << to_utf8(e.str) << "', "; @@ -233,9 +252,6 @@ 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; @@ -254,7 +270,7 @@ ostream & operator<<(ostream & os, Row const & row) << " ascent: " << row.dim_.asc << " descent: " << row.dim_.des << " separator: " << row.separator - << " label_hfill: " << row.label_hfill + << " label_hfill: " << row.label_hfill << " row_boundary: " << row.right_boundary() << "\n"; double x = row.left_margin; Row::Elements::const_iterator it = row.elements_.begin(); @@ -266,6 +282,35 @@ ostream & operator<<(ostream & os, Row const & row) } +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; @@ -276,13 +321,30 @@ int Row::countSeparators() const } -void Row::setSeparatorExtraWidth(double w) +bool Row::setExtraWidth(int w) { - separator = w; - iterator const end = elements_.end(); - for (iterator it = elements_.begin() ; it != end ; ++it) - if (it->type == Row::STRING) - it->extra = w; + if (w < 0) + // this is not expected to happen (but it does) + return false; + // amount of expansion: number of expanders time the em value for each + // string element + int exp_amount = 0; + for (Row::Element const & e : elements_) + exp_amount += e.expansionAmount(); + if (!exp_amount) + return false; + // extra length per expander per em + double extra_per_em = double(w) / exp_amount; + if (extra_per_em > MAX_SPACE_STRETCH) + // 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) + e.setExtra(extra_per_em); + // update row dimension + dim_.wid += w; + return true; } @@ -304,6 +366,8 @@ void Row::finalizeLast() if (elt.final) return; elt.final = true; + if (elt.change.changed()) + changebar_ = true; if (elt.type == STRING) { dim_.wid -= elt.dim.wid; @@ -360,18 +424,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) { @@ -390,17 +442,19 @@ void Row::pop_back() } -void Row::shortenIfNeeded(pos_type const keep, int const w) +bool Row::shortenIfNeeded(pos_type const keep, int const w, int const next_width) { if (empty() || width() <= w) - return; + return false; + Elements::iterator const beg = elements_.begin(); Elements::iterator const end = elements_.end(); int wid = left_margin; + // Search for the first element that goes beyond right margin Elements::iterator cit = beg; for ( ; cit != end ; ++cit) { - if (cit->endpos >= keep && wid + cit->dim.wid > w) + if (wid + cit->dim.wid > w) break; wid += cit->dim.wid; } @@ -408,7 +462,70 @@ void Row::shortenIfNeeded(pos_type const keep, int const w) if (cit == end) { // This should not happen since the row is too long. LYXERR0("Something is wrong cannot shorten row: " << *this); - return; + return false; + } + + // 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; + /* + * 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. + * + * FIXME: hardcoding languages is bad. Put this information in + * `languages' file. + */ + string const lang = brk.font.language()->lang(); + bool force = lang == "chinese-simplified" + || lang == "chinese-traditional" + || lang == "japanese" + || lang == "japanese-cjk" + || lang == "korean"; + // FIXME: is it important to check for separators? + if ((!force && 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), force)) { + /* 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) >= next_width) { + 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) { @@ -418,29 +535,13 @@ void Row::shortenIfNeeded(pos_type const keep, int const w) wid -= cit->dim.wid; } - // Try to break this row cleanly (at word boundary) - if (cit->breakAt(w - wid, false)) { - end_ = cit->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 endo of the row, since the spaces at row break - // are invisible. - 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; - } - if (cit != beg) { - // There is no separator, but several elements have been - // added. We can cut right here. + // 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 @@ -455,7 +556,9 @@ void Row::shortenIfNeeded(pos_type const keep, int const w) dim_.wid = wid + cit->dim.wid; // If there are other elements, they should be removed. elements_.erase(next(cit, 1), end); + return true; } + return false; } @@ -465,9 +568,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. @@ -478,6 +581,56 @@ void Row::reverseRTL(bool const rtl_par) // If the paragraph itself is RTL, reverse everything if (rtl_par) reverse(elements_.begin(), elements_.end()); + rtl_ = rtl_par; } +Row::const_iterator const +Row::findElement(pos_type const pos, bool const boundary, double & x) const +{ + /** + * When boundary is true, position i is in the row element (pos, endpos) + * if + * pos < i <= endpos + * whereas, when boundary is false, the test is + * pos <= i < endpos + * The correction below allows to handle both cases. + */ + int const boundary_corr = (boundary && pos) ? -1 : 0; + + x = left_margin; + + /** Early return in trivial cases + * 1) the row is empty + * 2) the position is the left-most position of the row; there + * is a quirk here however: if the first element is virtual + * (end-of-par marker for example), then we have to look + * closer + */ + if (empty() + || (pos == begin()->left_pos() && !boundary + && !begin()->isVirtual())) + return begin(); + + Row::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. + */ + if (pos + boundary_corr >= cit->pos + && (pos + boundary_corr < cit->endpos || cit->isVirtual())) { + x += cit->pos2x(pos); + break; + } + x += cit->full_width(); + } + + if (cit == end()) + --cit; + + return cit; +} + + } // namespace lyx