X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FTextMetrics.cpp;h=7d6235426a557362f174a8263c392c440800d24c;hb=da640391fc82fab25708a074d54ee4dce1fe26e7;hp=73e50a8f8ebc8005f0ba6d73c9c5a0ad991901ce;hpb=cdbebdf0933d5acb9880b5fafa6584e4fcb7cfbb;p=lyx.git diff --git a/src/TextMetrics.cpp b/src/TextMetrics.cpp index 73e50a8f8e..7d6235426a 100644 --- a/src/TextMetrics.cpp +++ b/src/TextMetrics.cpp @@ -27,7 +27,6 @@ #include "CoordCache.h" #include "Cursor.h" #include "CutAndPaste.h" -#include "FontIterator.h" #include "FuncRequest.h" #include "InsetList.h" #include "Layout.h" @@ -49,8 +48,8 @@ #include "frontends/Painter.h" #include "support/debug.h" - -#include +#include +#include "support/lassert.h" using namespace std; @@ -125,7 +124,7 @@ static int numberOfHfills(Paragraph const & par, Row const & row) TextMetrics::TextMetrics(BufferView * bv, Text * text) : bv_(bv), text_(text) { - BOOST_ASSERT(bv_); + LASSERT(bv_, /**/); max_width_ = bv_->workWidth(); dim_.wid = max_width_; dim_.asc = 10; @@ -188,7 +187,7 @@ int TextMetrics::parPosition(pit_type pit) const bool TextMetrics::metrics(MetricsInfo & mi, Dimension & dim, int min_width) { - BOOST_ASSERT(mi.base.textwidth); + LASSERT(mi.base.textwidth, /**/); max_width_ = mi.base.textwidth; // backup old dimension. Dimension const old_dim = dim_; @@ -197,7 +196,7 @@ bool TextMetrics::metrics(MetricsInfo & mi, Dimension & dim, int min_width) dim_.wid = min_width; pit_type const npar = text_->paragraphs().size(); if (npar > 1) - // If there is more than one row, expand the text to + // If there is more than one row, expand the text to // the full allowable width. dim_.wid = max_width_; @@ -250,7 +249,7 @@ void TextMetrics::applyOuterFont(Font & font) const Font TextMetrics::displayFont(pit_type pit, pos_type pos) const { - BOOST_ASSERT(pos >= 0); + LASSERT(pos >= 0, /**/); ParagraphList const & pars = text_->paragraphs(); Paragraph const & par = pars[pit]; @@ -269,7 +268,7 @@ Font TextMetrics::displayFont(pit_type pit, pos_type pos) const FontInfo const & lf = lab ? layout.labelfont : layout.font; FontInfo rlf = lab ? layout.reslabelfont : layout.resfont; - + // In case the default family has been customized if (lf.family() == INHERIT_FAMILY) rlf.setFamily(params.getFont().fontInfo().family()); @@ -278,7 +277,7 @@ Font TextMetrics::displayFont(pit_type pit, pos_type pos) const } // The uncommon case need not be optimized as much - FontInfo const & layoutfont = pos < body_pos ? + FontInfo const & layoutfont = pos < body_pos ? layout.labelfont : layout.font; Font font = par.getFontSettings(params, pos); @@ -308,7 +307,7 @@ bool TextMetrics::isRTL(CursorSlice const & sl, bool boundary) const int correction = 0; if (boundary && sl.pos() > 0) correction = -1; - + return displayFont(sl.pit(), sl.pos() + correction).isVisibleRightToLeft(); } @@ -393,10 +392,10 @@ bool TextMetrics::redoParagraph(pit_type const pit) << " the context is better then."); updateLabels(bv_->buffer()); parPos = text_->macrocontextPosition(); - BOOST_ASSERT(!parPos.empty()); + LASSERT(!parPos.empty(), /**/); parPos.pit() = pit; } - + // redo insets // FIXME: We should always use getFont(), see documentation of // noFontChange() in Inset.h. @@ -407,9 +406,9 @@ bool TextMetrics::redoParagraph(pit_type const pit) // position already initialized? if (!parPos.empty()) { parPos.pos() = ii->pos; - - // A macro template would normally not be visible - // by itself. But the tex macro semantics allow + + // A macro template would normally not be visible + // by itself. But the tex macro semantics allow // recursion, so we artifically take the context // after the macro template to simulate this. if (ii->inset->lyxCode() == MATHMACRO_CODE) @@ -426,8 +425,10 @@ bool TextMetrics::redoParagraph(pit_type const pit) MetricsInfo mi(bv_, font.fontInfo(), w, mc); ii->inset->metrics(mi, dim); Dimension const old_dim = pm.insetDimension(ii->inset); - pm.setInsetDimension(ii->inset, dim); - changed |= (old_dim != dim); + if (old_dim != dim) { + pm.setInsetDimension(ii->inset, dim); + changed = true; + } } par.setBeginOfBody(); @@ -439,7 +440,7 @@ bool TextMetrics::redoParagraph(pit_type const pit) Dimension dim; pos_type end = rowBreakPoint(width, pit, first); if (row_index || end < par.size()) - // If there is more than one row, expand the text to + // If there is more than one row, expand the text to // the full allowable width. This setting here is needed // for the computeRowMetrics() below. dim_.wid = max_width_; @@ -502,7 +503,7 @@ void TextMetrics::computeRowMetrics(pit_type const pit, double w = width - row.width(); // FIXME: put back this assertion when the crash on new doc is solved. - //BOOST_ASSERT(w >= 0); + //LASSERT(w >= 0, /**/); //lyxerr << "\ndim_.wid " << dim_.wid << endl; //lyxerr << "row.width() " << row.width() << endl; @@ -551,6 +552,21 @@ void TextMetrics::computeRowMetrics(pit_type const pit, else align = par.params().align(); + // handle alignment inside tabular cells + Inset const & owner = par.inInset(); + switch (owner.contentAlignment()) { + case LYX_ALIGN_CENTER: + case LYX_ALIGN_LEFT: + case LYX_ALIGN_RIGHT: + if (align == LYX_ALIGN_NONE + || align == LYX_ALIGN_BLOCK) + align = owner.contentAlignment(); + break; + default: + // unchanged (use align) + break; + } + // Display-style insets should always be on a centred row if (Inset const * inset = par.getInset(row.pos())) { switch (inset->display()) { @@ -626,7 +642,8 @@ void TextMetrics::computeRowMetrics(pit_type const pit, InsetList::const_iterator iend = par.insetList().end(); for ( ; ii != iend; ++ii) { if (ii->pos >= endpos || ii->pos < row.pos() - || ii->inset->lyxCode() != HFILL_CODE) + || (ii->inset->lyxCode() != SPACE_CODE || + !ii->inset->isStretchableSpace())) continue; Dimension dim = row.dimension(); if (pm.hfillExpansion(row, ii->pos)) @@ -634,7 +651,7 @@ void TextMetrics::computeRowMetrics(pit_type const pit, max(hfill, 5.0) : row.label_hfill); else dim.wid = 5; - // Cache the inset dimension. + // Cache the inset dimension. bv_->coordCache().insets().add(ii->inset, dim); pm.setInsetDimension(ii->inset, dim); } @@ -647,7 +664,7 @@ int TextMetrics::labelFill(pit_type const pit, Row const & row) const Paragraph const & par = text_->getPar(pit); pos_type last = par.beginOfBody(); - BOOST_ASSERT(last > 0); + LASSERT(last > 0, /**/); // -1 because a label ends with a space that is in the label --last; @@ -693,6 +710,63 @@ int TextMetrics::labelEnd(pit_type const pit) const return leftMargin(max_width_, pit); } +namespace { + +/** + * Calling Text::getFont is slow. While rebreaking we scan a + * paragraph from left to right calling getFont for every char. This + * simple class address this problem by hidding an optimization trick + * (not mine btw -AB): the font is reused in the whole font span. The + * class handles transparently the "hidden" (not part of the fontlist) + * label font (as getFont does). + **/ +class FontIterator +{ +public: + /// + FontIterator(TextMetrics const & tm, + Paragraph const & par, pit_type pit, pos_type pos) + : tm_(tm), par_(par), pit_(pit), pos_(pos), + font_(tm.displayFont(pit, pos)), + endspan_(par.fontSpan(pos).last), + bodypos_(par.beginOfBody()) + {} + + /// + Font const & operator*() const { return font_; } + + /// + FontIterator & operator++() + { + ++pos_; + if (pos_ > endspan_ || pos_ == bodypos_) { + font_ = tm_.displayFont(pit_, pos_); + endspan_ = par_.fontSpan(pos_).last; + } + return *this; + } + + /// + Font * operator->() { return &font_; } + +private: + /// + TextMetrics const & tm_; + /// + Paragraph const & par_; + /// + pit_type pit_; + /// + pos_type pos_; + /// + Font font_; + /// + pos_type endspan_; + /// + pos_type bodypos_; +}; + +} // anon namespace pit_type TextMetrics::rowBreakPoint(int width, pit_type const pit, pit_type pos) const @@ -1127,7 +1201,7 @@ pos_type TextMetrics::getColumnNearX(pit_type const pit, left_side = true; } - BOOST_ASSERT(vc <= end); // This shouldn't happen. + LASSERT(vc <= end, /**/); // This shouldn't happen. boundary = false; // This (rtl_support test) is not needed, but gives @@ -1206,7 +1280,7 @@ pos_type TextMetrics::x2pos(pit_type pit, int row, int x) const // upDownInText() while in selection mode. ParagraphMetrics const & pm = parMetrics(pit); - BOOST_ASSERT(row < int(pm.rows().size())); + LASSERT(row < int(pm.rows().size()), /**/); bool bound = false; Row const & r = pm.rows()[row]; return r.pos() + getColumnNearX(pit, r, x, bound); @@ -1243,7 +1317,7 @@ void TextMetrics::newParMetricsUp() // y is screen coordinate pit_type TextMetrics::getPitNearY(int y) { - BOOST_ASSERT(!text_->paragraphs().empty()); + LASSERT(!text_->paragraphs().empty(), /**/); LYXERR(Debug::DEBUG, "y: " << y << " cache size: " << par_metrics_.size()); // look for highest numbered paragraph with y coordinate less than given y @@ -1306,7 +1380,7 @@ Row const & TextMetrics::getRowNearY(int y, pit_type pit) const ParagraphMetrics const & pm = par_metrics_[pit]; int yy = pm.position() - pm.ascent(); - BOOST_ASSERT(!pm.rows().empty()); + LASSERT(!pm.rows().empty(), /**/); RowList::const_iterator rit = pm.rows().begin(); RowList::const_iterator rlast = pm.rows().end(); --rlast; @@ -1326,7 +1400,7 @@ Inset * TextMetrics::editXY(Cursor & cur, int x, int y) cur.bv().coordCache().dump(); } pit_type pit = getPitNearY(y); - BOOST_ASSERT(pit != -1); + LASSERT(pit != -1, /**/); Row const & row = getRowNearY(y, pit); bool bound = false; @@ -1357,8 +1431,8 @@ Inset * TextMetrics::editXY(Cursor & cur, int x, int y) // This should be just before or just behind the // cursor position set above. - BOOST_ASSERT((pos != 0 && inset == insetBefore) - || inset == pars[pit].getInset(pos)); + LASSERT((pos != 0 && inset == insetBefore) + || inset == pars[pit].getInset(pos), /**/); // Make sure the cursor points to the position before // this inset. @@ -1378,7 +1452,7 @@ Inset * TextMetrics::editXY(Cursor & cur, int x, int y) void TextMetrics::setCursorFromCoordinates(Cursor & cur, int const x, int const y) { - BOOST_ASSERT(text_ == cur.text()); + LASSERT(text_ == cur.text(), /**/); pit_type pit = getPitNearY(y); ParagraphMetrics const & pm = par_metrics_[pit]; @@ -1388,7 +1462,7 @@ void TextMetrics::setCursorFromCoordinates(Cursor & cur, int const x, int const " pit: " << pit << " yy: " << yy); int r = 0; - BOOST_ASSERT(pm.rows().size()); + LASSERT(pm.rows().size(), /**/); for (; r < int(pm.rows().size()) - 1; ++r) { Row const & row = pm.rows()[r]; if (int(yy + row.height()) > y) @@ -1416,7 +1490,7 @@ void TextMetrics::setCursorFromCoordinates(Cursor & cur, int const x, int const Inset * TextMetrics::checkInsetHit(int x, int y) { pit_type pit = getPitNearY(y); - BOOST_ASSERT(pit != -1); + LASSERT(pit != -1, /**/); Paragraph const & par = text_->paragraphs()[pit]; ParagraphMetrics const & pm = par_metrics_[pit]; @@ -1458,7 +1532,7 @@ Inset * TextMetrics::checkInsetHit(int x, int y) int TextMetrics::cursorX(CursorSlice const & sl, bool boundary) const { - BOOST_ASSERT(sl.text() == text_); + LASSERT(sl.text() == text_, /**/); pit_type const pit = sl.pit(); Paragraph const & par = text_->paragraphs()[pit]; ParagraphMetrics const & pm = par_metrics_[pit]; @@ -1482,7 +1556,7 @@ int TextMetrics::cursorX(CursorSlice const & sl, pos_type const row_pos = row.pos(); pos_type const end = row.endpos(); - // Spaces at logical line breaks in bidi text must be skipped during + // Spaces at logical line breaks in bidi text must be skipped during // cursor positioning. However, they may appear visually in the middle // of a row; they must be skipped, wherever they are... // * logically "abc_[HEBREW_\nHEBREW]" @@ -1527,7 +1601,7 @@ int TextMetrics::cursorX(CursorSlice const & sl, // it's in the last row of a paragraph; see skipped_sep_vpos declaration if (end > 0 && end < par.size() && par.isSeparator(end - 1)) skipped_sep_vpos = bidi.log2vis(end - 1); - + // Inline completion RTL special case row_pos == cursor_pos: // "__|b" => cursor_pos is right of __ if (row_pos == inlineCompletionVPos && row_pos == cursor_vpos) { @@ -1536,7 +1610,7 @@ int TextMetrics::cursorX(CursorSlice const & sl, if (font.isRightToLeft() && completion.length() > 0) x += theFontMetrics(font.fontInfo()).width(completion); } - + for (pos_type vpos = row_pos; vpos < cursor_vpos; ++vpos) { // Skip the separator which is at the logical end of the row if (vpos == skipped_sep_vpos) @@ -1560,14 +1634,14 @@ int TextMetrics::cursorX(CursorSlice const & sl, // Inline completion RTL case: // "a__|b", __ of b => non-boundary a-pos is right of __ - if (vpos + 1 == inlineCompletionVPos + if (vpos + 1 == inlineCompletionVPos && (vpos + 1 < cursor_vpos || !boundary_correction)) { font = displayFont(pit, vpos + 1); docstring const & completion = bv_->inlineCompletion(); if (font.isRightToLeft() && completion.length() > 0) x += theFontMetrics(font.fontInfo()).width(completion); } - + // Inline completion LTR case: // "b|__a", __ of b => non-boundary a-pos is in front of __ if (vpos == inlineCompletionVPos @@ -1577,7 +1651,7 @@ int TextMetrics::cursorX(CursorSlice const & sl, if (!font.isRightToLeft() && completion.length() > 0) x += theFontMetrics(font.fontInfo()).width(completion); } - + if (par.isSeparator(pos) && pos >= body_pos) x += row.separator; } @@ -1622,7 +1696,7 @@ int TextMetrics::cursorY(CursorSlice const & sl, bool boundary) const bool TextMetrics::cursorHome(Cursor & cur) { - BOOST_ASSERT(text_ == cur.text()); + LASSERT(text_ == cur.text(), /**/); ParagraphMetrics const & pm = par_metrics_[cur.pit()]; Row const & row = pm.getRow(cur.pos(),cur.boundary()); return text_->setCursor(cur, cur.pit(), row.pos()); @@ -1631,7 +1705,7 @@ bool TextMetrics::cursorHome(Cursor & cur) bool TextMetrics::cursorEnd(Cursor & cur) { - BOOST_ASSERT(text_ == cur.text()); + LASSERT(text_ == cur.text(), /**/); // if not on the last row of the par, put the cursor before // the final space exept if I have a spanning inset or one string // is so long that we force a break. @@ -1653,13 +1727,13 @@ bool TextMetrics::cursorEnd(Cursor & cur) void TextMetrics::deleteLineForward(Cursor & cur) { - BOOST_ASSERT(text_ == cur.text()); + LASSERT(text_ == cur.text(), /**/); if (cur.lastpos() == 0) { // Paragraph is empty, so we just go forward text_->cursorForward(cur); } else { cur.resetAnchor(); - cur.selection() = true; // to avoid deletion + cur.setSelection(true); // to avoid deletion cursorEnd(cur); cur.setSelection(); // What is this test for ??? (JMarc) @@ -1688,8 +1762,8 @@ bool TextMetrics::isFirstRow(pit_type pit, Row const & row) const int TextMetrics::leftMargin(int max_width, pit_type pit) const { - BOOST_ASSERT(pit >= 0); - BOOST_ASSERT(pit < int(text_->paragraphs().size())); + LASSERT(pit >= 0, /**/); + LASSERT(pit < int(text_->paragraphs().size()), /**/); return leftMargin(max_width, pit, text_->paragraphs()[pit].size()); } @@ -1699,11 +1773,11 @@ int TextMetrics::leftMargin(int max_width, { ParagraphList const & pars = text_->paragraphs(); - BOOST_ASSERT(pit >= 0); - BOOST_ASSERT(pit < int(pars.size())); + LASSERT(pit >= 0, /**/); + LASSERT(pit < int(pars.size()), /**/); Paragraph const & par = pars[pit]; - BOOST_ASSERT(pos >= 0); - BOOST_ASSERT(pos <= par.size()); + LASSERT(pos >= 0, /**/); + LASSERT(pos <= par.size(), /**/); Buffer const & buffer = bv_->buffer(); //lyxerr << "TextMetrics::leftMargin: pit: " << pit << " pos: " << pos << endl; DocumentClass const & tclass = buffer.params().documentClass(); @@ -1726,8 +1800,8 @@ int TextMetrics::leftMargin(int max_width, if (pars[newpar].layout().isEnvironment()) { l_margin = leftMargin(max_width, newpar); } - if (tclass.isDefaultLayout(par.layout()) - || tclass.isEmptyLayout(par.layout())) { + if (tclass.isDefaultLayout(par.layout()) + || tclass.isPlainLayout(par.layout())) { if (pars[newpar].params().noindent()) parindent.erase(); else @@ -1843,13 +1917,13 @@ int TextMetrics::leftMargin(int max_width, && align == LYX_ALIGN_BLOCK && !par.params().noindent() // in some insets, paragraphs are never indented - && !(par.inInset() && par.inInset()->neverIndent()) + && !par.inInset().neverIndent() // display style insets are always centered, omit indentation && !(!par.empty() && par.isInset(pos) && par.getInset(pos)->display()) - && ((tclass.isDefaultLayout(par.layout()) - || tclass.isEmptyLayout(par.layout())) + && (!(tclass.isDefaultLayout(par.layout()) + || tclass.isPlainLayout(par.layout())) || buffer.params().paragraph_separation == BufferParams::ParagraphIndentSeparation) ) { @@ -1910,19 +1984,23 @@ void TextMetrics::drawParagraph(PainterInfo & pi, pit_type pit, int x, int y) co bool selection = cur.selection() // This is our text. && cur.text() == text_ - // if the anchor is outside, this is not our selection + // if the anchor is outside, this is not our selection && cur.anchor().text() == text_ && pit >= sel_beg.pit() && pit <= sel_end.pit(); + // We store the begin and end pos of the selection relative to this par + DocIterator sel_beg_par = cur.selectionBegin(); + DocIterator sel_end_par = cur.selectionEnd(); + // We care only about visible selection. if (selection) { if (pit != sel_beg.pit()) { - sel_beg.pit() = pit; - sel_beg.pos() = 0; + sel_beg_par.pit() = pit; + sel_beg_par.pos() = 0; } if (pit != sel_end.pit()) { - sel_end.pit() = pit; - sel_end.pos() = sel_end.lastpos(); + sel_end_par.pit() = pit; + sel_end_par.pos() = sel_end_par.lastpos(); } } @@ -1939,14 +2017,23 @@ void TextMetrics::drawParagraph(PainterInfo & pi, pit_type pit, int x, int y) co RowPainter rp(pi, *text_, pit, row, bidi, x, y); if (selection) - row.setSelection(sel_beg.pos(), sel_end.pos()); + row.setSelectionAndMargins(sel_beg_par, sel_end_par); else row.setSelection(-1, -1); + + // The row knows nothing about the paragraph, so we have to check + // whether this row is the first or last and update the margins. + if (row.selection()) { + if (row.sel_beg == 0) + row.begin_margin_sel = sel_beg.pit() < pit; + if (row.sel_end == sel_end_par.lastpos()) + row.end_margin_sel = sel_end.pit() > pit; + } // Row signature; has row changed since last paint? row.setCrc(pm.computeRowSignature(row, bparams)); bool row_has_changed = row.changed(); - + // Don't paint the row if a full repaint has not been requested // and if it has not changed. if (!pi.full_repaint && !row_has_changed) { @@ -1963,28 +2050,18 @@ void TextMetrics::drawParagraph(PainterInfo & pi, pit_type pit, int x, int y) co pi.pain.fillRectangle(x, y - row.ascent(), width(), row.height(), pi.background_color); } - - bool row_selection = row.sel_beg != -1 && row.sel_end != -1; - if (row_selection) { - DocIterator beg = bv_->cursor().selectionBegin(); - DocIterator end = bv_->cursor().selectionEnd(); - bool const beg_margin = beg.pit() < pit && i == 0; - bool const end_margin = end.pit() > pit && i == nrows - 1; - beg.pit() = pit; - beg.pos() = row.sel_beg; - end.pit() = pit; - end.pos() = row.sel_end; - drawRowSelection(pi, x, row, beg, end, beg_margin, end_margin); - } + + if (row.selection()) + drawRowSelection(pi, x, row, cur, pit); // Instrumentation for testing row cache (see also // 12 lines lower): if (lyxerr.debugging(Debug::PAINTING) && inside - && (row_selection || pi.full_repaint || row_has_changed)) { + && (row.selection() || pi.full_repaint || row_has_changed)) { string const foreword = text_->isMainText(bv_->buffer()) ? "main text redraw " : "inset text redraw: "; LYXERR(Debug::PAINTING, foreword << "pit=" << pit << " row=" << i - << " row_selection=" << row_selection + << " row_selection=" << row.selection() << " full_repaint=" << pi.full_repaint << " row_has_changed=" << row_has_changed); } @@ -2013,75 +2090,95 @@ void TextMetrics::drawParagraph(PainterInfo & pi, pit_type pit, int x, int y) co void TextMetrics::drawRowSelection(PainterInfo & pi, int x, Row const & row, - DocIterator const & beg, DocIterator const & end, - bool drawOnBegMargin, bool drawOnEndMargin) const + Cursor const & curs, pit_type pit) const { + DocIterator beg = curs.selectionBegin(); + beg.pit() = pit; + beg.pos() = row.sel_beg; + + DocIterator end = curs.selectionEnd(); + end.pit() = pit; + end.pos() = row.sel_end; + + bool const begin_boundary = beg.pos() >= row.endpos(); + bool const end_boundary = row.sel_end == row.endpos(); + Buffer & buffer = bv_->buffer(); DocIterator cur = beg; - int x1 = cursorX(beg.top(), beg.boundary()); - int x2 = cursorX(end.top(), end.boundary()); - int y1 = bv_->getPos(cur, cur.boundary()).y_ - row.ascent(); - int y2 = y1 + row.height(); - + cur.boundary(begin_boundary); + int x1 = cursorX(beg.top(), begin_boundary); + int x2 = cursorX(end.top(), end_boundary); + int const y1 = bv_->getPos(cur, cur.boundary()).y_ - row.ascent(); + int const y2 = y1 + row.height(); + + int const rm = text_->isMainText(buffer) ? bv_->rightMargin() : 0; + int const lm = text_->isMainText(buffer) ? bv_->leftMargin() : 0; + // draw the margins - if (drawOnBegMargin) { - if (text_->isRTL(buffer, beg.paragraph())) - pi.pain.fillRectangle(x + x1, y1, width() - x1, y2 - y1, Color_selection); - else - pi.pain.fillRectangle(x, y1, x1, y2 - y1, Color_selection); + if (row.begin_margin_sel) { + if (text_->isRTL(buffer, beg.paragraph())) { + pi.pain.fillRectangle(x + x1, y1, width() - rm - x1, y2 - y1, + Color_selection); + } else { + pi.pain.fillRectangle(x + lm, y1, x1 - lm, y2 - y1, + Color_selection); + } } - - if (drawOnEndMargin) { - if (text_->isRTL(buffer, beg.paragraph())) - pi.pain.fillRectangle(x, y1, x2, y2 - y1, Color_selection); - else - pi.pain.fillRectangle(x + x2, y1, width() - x2, y2 - y1, Color_selection); + + if (row.end_margin_sel) { + if (text_->isRTL(buffer, beg.paragraph())) { + pi.pain.fillRectangle(x + lm, y1, x2 - lm, y2 - y1, + Color_selection); + } else { + pi.pain.fillRectangle(x + x2, y1, width() - rm - x2, y2 - y1, + Color_selection); + } } - + // if we are on a boundary from the beginning, it's probably // a RTL boundary and we jump to the other side directly as this // segement is 0-size and confuses the logic below if (cur.boundary()) cur.boundary(false); - + // go through row and draw from RTL boundary to RTL boundary while (cur < end) { bool drawNow = false; - + // simplified cursorForward code below which does not // descend into insets and which does not go into the // next line. Compare the logic with the original cursorForward - - // if left of boundary -> just jump to right side - // but for RTL boundaries don't, because: abc|DDEEFFghi -> abcDDEEF|Fghi + + // if left of boundary -> just jump to right side, but + // for RTL boundaries don't, because: abc|DDEEFFghi -> abcDDEEF|Fghi if (cur.boundary()) { cur.boundary(false); } else if (isRTLBoundary(cur.pit(), cur.pos() + 1)) { - // in front of RTL boundary -> Stay on this side of the boundary because: - // ab|cDDEEFFghi -> abc|DDEEFFghi + // in front of RTL boundary -> Stay on this side of the boundary + // because: ab|cDDEEFFghi -> abc|DDEEFFghi ++cur.pos(); cur.boundary(true); drawNow = true; } else { // move right ++cur.pos(); - + // line end? if (cur.pos() == row.endpos()) cur.boundary(true); } - + if (x1 == -1) { // the previous segment was just drawn, now the next starts x1 = cursorX(cur.top(), cur.boundary()); } - + if (!(cur < end) || drawNow) { x2 = cursorX(cur.top(), cur.boundary()); pi.pain.fillRectangle(x + min(x1,x2), y1, abs(x2 - x1), y2 - y1, Color_selection); - - // reset x1, so it is set again next round (which will be on the + + // reset x1, so it is set again next round (which will be on the // right side of a boundary or at the selection end) x1 = -1; } @@ -2089,28 +2186,28 @@ void TextMetrics::drawRowSelection(PainterInfo & pi, int x, Row const & row, } -void TextMetrics::completionPosAndDim(Cursor const & cur, int & x, int & y, +void TextMetrics::completionPosAndDim(Cursor const & cur, int & x, int & y, Dimension & dim) const { Cursor const & bvcur = cur.bv().cursor(); - + // get word in front of cursor docstring word = text_->previousWord(bvcur.top()); DocIterator wordStart = bvcur; wordStart.pos() -= word.length(); - + // get position on screen of the word start and end Point lxy = cur.bv().getPos(wordStart, false); Point rxy = cur.bv().getPos(bvcur, bvcur.boundary()); - + // calculate dimensions of the word dim = rowHeight(bvcur.pit(), wordStart.pos(), bvcur.pos(), false); dim.wid = abs(rxy.x_ - lxy.x_); - + // calculate position of word y = lxy.y_; x = min(rxy.x_, lxy.x_); - + //lyxerr << "wid=" << dim.width() << " x=" << x << " y=" << y << " lxy.x_=" << lxy.x_ << " rxy.x_=" << rxy.x_ << " word=" << word << std::endl; //lyxerr << " wordstart=" << wordStart << " bvcur=" << bvcur << " cur=" << cur << std::endl; }