X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FTextMetrics.C;h=63a287a160ca8be97b465852b4d10454c1bc6822;hb=e5a46922e916a06ad1b958d5895cc3cfb4f13d2c;hp=272e5a5b3c19428adf91fb899f01f7ee95b6f365;hpb=79d76916142a88153ae1b5211fa98e4120e79b5e;p=lyx.git diff --git a/src/TextMetrics.C b/src/TextMetrics.C index 272e5a5b3c..63a287a160 100644 --- a/src/TextMetrics.C +++ b/src/TextMetrics.C @@ -30,6 +30,7 @@ #include "FontIterator.h" #include "LColor.h" #include "lyxlength.h" +#include "lyxrc.h" #include "lyxtext.h" #include "metricsinfo.h" #include "ParagraphParameters.h" @@ -84,18 +85,16 @@ int numberOfLabelHfills(Paragraph const & par, Row const & row) int numberOfHfills(Paragraph const & par, Row const & row) { - pos_type last = row.endpos(); + pos_type const last = row.endpos(); pos_type first = row.pos(); - pos_type const par_size = par.size(); // hfill *DO* count at the beginning of paragraphs! if (first) { - while (first < last && first < par_size && par.isHfill(first)) + while (first < last && par.isHfill(first)) ++first; } first = max(first, par.beginOfBody()); - last = min(last, par_size); int n = 0; for (pos_type p = first; p < last; ++p) { @@ -259,6 +258,10 @@ bool TextMetrics::redoParagraph(pit_type const pit) par_metrics_[pit] = pm; + // Update the row change statuses. The painter will need that info + // in order to know which row has to be repainted. + par_metrics_[pit].updateRowChangeStatus(); + return changed; } @@ -704,11 +707,12 @@ void TextMetrics::setHeightOfRow(pit_type const pit, // environment. pit_type prev = depthHook(pit, pars, par.getDepth()); + Paragraph const & prevpar = pars[prev]; if (prev != pit - && pars[prev].layout() == layout - && pars[prev].getDepth() == par.getDepth() - && pars[prev].getLabelWidthString() == par.getLabelWidthString()) - { + && prevpar.layout() == layout + && prevpar.getDepth() == par.getDepth() + && prevpar.getLabelWidthString() + == par.getLabelWidthString()) { layoutasc = layout->itemsep * dh; } else if (pit != 0 || row.pos() != 0) { if (layout->topsep > 0) @@ -719,8 +723,9 @@ void TextMetrics::setHeightOfRow(pit_type const pit, if (prev != pit_type(pars.size())) { maxasc += int(pars[prev].layout()->parsep * dh); } else if (pit != 0) { - if (pars[pit - 1].getDepth() != 0 || - pars[pit - 1].layout() == layout) { + Paragraph const & prevpar = pars[pit - 1]; + if (prevpar.getDepth() != 0 || + prevpar.layout() == layout) { maxasc += int(layout->parsep * dh); } } @@ -775,6 +780,169 @@ void TextMetrics::setHeightOfRow(pit_type const pit, } +// x is an absolute screen coord +// returns the column near the specified x-coordinate of the row +// x is set to the real beginning of this column +pos_type TextMetrics::getColumnNearX(pit_type const pit, + Row const & row, int & x, bool & boundary) const +{ + Buffer const & buffer = *bv_->buffer(); + + /// For the main LyXText, it is possible that this pit is not + /// yet in the CoordCache when moving cursor up. + /// x Paragraph coordinate is always 0 for main text anyway. + int const xo = main_text_? 0 : bv_->coordCache().get(text_, pit).x_; + x -= xo; + RowMetrics const r = computeRowMetrics(pit, row); + Paragraph const & par = text_->getPar(pit); + + pos_type vc = row.pos(); + pos_type end = row.endpos(); + pos_type c = 0; + LyXLayout_ptr const & layout = par.layout(); + + bool left_side = false; + + pos_type body_pos = par.beginOfBody(); + + double tmpx = r.x; + double last_tmpx = tmpx; + + if (body_pos > 0 && + (body_pos > end || !par.isLineSeparator(body_pos - 1))) + body_pos = 0; + + // check for empty row + if (vc == end) { + x = int(tmpx) + xo; + return 0; + } + + frontend::FontMetrics const & fm + = theFontMetrics(text_->getLabelFont(buffer, par)); + + while (vc < end && tmpx <= x) { + c = text_->bidi.vis2log(vc); + last_tmpx = tmpx; + if (body_pos > 0 && c == body_pos - 1) { + // FIXME UNICODE + docstring const lsep = from_utf8(layout->labelsep); + tmpx += r.label_hfill + fm.width(lsep); + if (par.isLineSeparator(body_pos - 1)) + tmpx -= text_->singleWidth(buffer, par, body_pos - 1); + } + + if (par.hfillExpansion(row, c)) { + tmpx += text_->singleWidth(buffer, par, c); + if (c >= body_pos) + tmpx += r.hfill; + else + tmpx += r.label_hfill; + } else if (par.isSeparator(c)) { + tmpx += text_->singleWidth(buffer, par, c); + if (c >= body_pos) + tmpx += r.separator; + } else { + tmpx += text_->singleWidth(buffer, par, c); + } + ++vc; + } + + if ((tmpx + last_tmpx) / 2 > x) { + tmpx = last_tmpx; + left_side = true; + } + + BOOST_ASSERT(vc <= end); // This shouldn't happen. + + boundary = false; + // This (rtl_support test) is not needed, but gives + // some speedup if rtl_support == false + bool const lastrow = lyxrc.rtl_support && row.endpos() == par.size(); + + // If lastrow is false, we don't need to compute + // the value of rtl. + bool const rtl = lastrow ? text_->isRTL(buffer, par) : false; + if (lastrow && + ((rtl && left_side && vc == row.pos() && x < tmpx - 5) || + (!rtl && !left_side && vc == end && x > tmpx + 5))) + c = end; + else if (vc == row.pos()) { + c = text_->bidi.vis2log(vc); + if (text_->bidi.level(c) % 2 == 1) + ++c; + } else { + c = text_->bidi.vis2log(vc - 1); + bool const rtl = (text_->bidi.level(c) % 2 == 1); + if (left_side == rtl) { + ++c; + boundary = text_->bidi.isBoundary(buffer, par, c); + } + } + +// I believe this code is not needed anymore (Jug 20050717) +#if 0 + // The following code is necessary because the cursor position past + // the last char in a row is logically equivalent to that before + // the first char in the next row. That's why insets causing row + // divisions -- Newline and display-style insets -- must be treated + // specially, so cursor up/down doesn't get stuck in an air gap -- MV + // Newline inset, air gap below: + if (row.pos() < end && c >= end && par.isNewline(end - 1)) { + if (text_->bidi.level(end -1) % 2 == 0) + tmpx -= text_->singleWidth(buffer, par, end - 1); + else + tmpx += text_->singleWidth(buffer, par, end - 1); + c = end - 1; + } + + // Air gap above display inset: + if (row.pos() < end && c >= end && end < par.size() + && par.isInset(end) && par.getInset(end)->display()) { + c = end - 1; + } + // Air gap below display inset: + if (row.pos() < end && c >= end && par.isInset(end - 1) + && par.getInset(end - 1)->display()) { + c = end - 1; + } +#endif + + x = int(tmpx) + xo; + pos_type const col = c - row.pos(); + + if (!c || end == par.size()) + return col; + + if (c==end && !par.isLineSeparator(c-1) && !par.isNewline(c-1)) { + boundary = true; + return col; + } + + return min(col, end - 1 - row.pos()); +} + + +pos_type TextMetrics::x2pos(pit_type pit, int row, int x) const +{ + ParagraphMetrics const & pm = parMetrics(pit); + BOOST_ASSERT(!pm.rows().empty()); + BOOST_ASSERT(row < int(pm.rows().size())); + bool bound = false; + Row const & r = pm.rows()[row]; + return r.pos() + getColumnNearX(pit, r, x, bound); +} + + +//int LyXText::pos2x(pit_type pit, pos_type pos) const +//{ +// ParagraphMetrics const & pm = parMetrics(pit); +// Row const & r = pm.rows()[row]; +// int x = 0; +// pos -= r.pos(); +//} + + int defaultRowHeight() { return int(theFontMetrics(LyXFont(LyXFont::ALL_SANE)).maxHeight() * 1.2);