X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FTextMetrics.cpp;h=ecc9e5219487d3015fde15ecb0d6aaf336fcb139;hb=0bff66b8a5a8a289dfb36bfb339e9586b3a02d51;hp=4471041ff308995b465bec125cdb2f8979d4b768;hpb=f2e8cd3cd990d1314de41e409e93095059546fe7;p=lyx.git diff --git a/src/TextMetrics.cpp b/src/TextMetrics.cpp index 4471041ff3..ecc9e52194 100644 --- a/src/TextMetrics.cpp +++ b/src/TextMetrics.cpp @@ -4,12 +4,12 @@ * Licence details can be found in the file COPYING. * * \author Asger Alstrup - * \author Lars Gullik Bjønnes + * \author Lars Gullik Bjønnes * \author Jean-Marc Lasgouttes * \author John Levon - * \author André Pönitz + * \author André Pönitz * \author Dekel Tsur - * \author Jürgen Vigna + * \author Jürgen Vigna * \author Abdelrazak Younes * * Full author contact details are available in file CREDITS. @@ -27,20 +27,21 @@ #include "CoordCache.h" #include "Cursor.h" #include "CutAndPaste.h" -#include "FontIterator.h" -#include "FuncRequest.h" +#include "HSpace.h" #include "InsetList.h" #include "Layout.h" #include "Length.h" #include "LyXRC.h" #include "MetricsInfo.h" -#include "paragraph_funcs.h" #include "ParagraphParameters.h" #include "ParIterator.h" #include "rowpainter.h" #include "Text.h" #include "TextClass.h" #include "VSpace.h" +#include "WordLangTuple.h" + +#include "insets/InsetText.h" #include "mathed/MacroTable.h" #include "mathed/MathMacroTemplate.h" @@ -49,8 +50,10 @@ #include "frontends/Painter.h" #include "support/debug.h" +#include "support/docstring_list.h" +#include "support/lassert.h" -#include +#include using namespace std; @@ -125,13 +128,11 @@ 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; dim_.des = 10; - - //text_->updateLabels(bv->buffer()); } @@ -157,6 +158,7 @@ pair TextMetrics::first() const pair TextMetrics::last() const { + LASSERT(!par_metrics_.empty(), /**/); ParMetricsCache::const_reverse_iterator it = par_metrics_.rbegin(); return make_pair(it->first, &it->second); } @@ -175,20 +177,9 @@ ParagraphMetrics & TextMetrics::parMetrics(pit_type pit, bool redo) } -int TextMetrics::parPosition(pit_type pit) const -{ - if (pit < par_metrics_.begin()->first) - return -1000000; - if (pit > par_metrics_.rbegin()->first) - return +1000000; - - return par_metrics_[pit].position(); -} - - bool TextMetrics::metrics(MetricsInfo & mi, Dimension & dim, int min_width) { - BOOST_ASSERT(mi.base.textwidth); + LASSERT(mi.base.textwidth > 0, /**/); max_width_ = mi.base.textwidth; // backup old dimension. Dimension const old_dim = dim_; @@ -197,7 +188,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_; @@ -240,17 +231,15 @@ int TextMetrics::rightMargin(pit_type const pit) const void TextMetrics::applyOuterFont(Font & font) const { - Font lf(font_); - lf.fontInfo().reduce(bv_->buffer().params().getFont().fontInfo()); - lf.fontInfo().realize(font.fontInfo()); - lf.setLanguage(font.language()); - font = lf; + FontInfo lf(font_.fontInfo()); + lf.reduce(bv_->buffer().params().getFont().fontInfo()); + font.fontInfo().realize(lf); } 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]; @@ -263,13 +252,13 @@ Font TextMetrics::displayFont(pit_type pit, pos_type pos) const // We specialize the 95% common case: if (!par.getDepth()) { Font f = par.getFontSettings(params, pos); - if (!text_->isMainText(buffer)) + if (!text_->isMainText()) applyOuterFont(f); bool lab = layout.labeltype == LABEL_MANUAL && pos < body_pos; 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,20 +267,20 @@ 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); font.fontInfo().realize(layoutfont); - if (!text_->isMainText(buffer)) + if (!text_->isMainText()) applyOuterFont(font); // Realize against environment font information // NOTE: the cast to pit_type should be removed when pit_type // changes to a unsigned integer. if (pit < pit_type(pars.size())) - font.fontInfo().realize(outerFont(pit, pars).fontInfo()); + font.fontInfo().realize(text_->outerFont(pit).fontInfo()); // Realize with the fonts of lesser depth. font.fontInfo().realize(params.getFont().fontInfo()); @@ -308,45 +297,67 @@ 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(); } bool TextMetrics::isRTLBoundary(pit_type pit, pos_type pos) const { - if (!lyxrc.rtl_support) + // no RTL boundary at paragraph start + if (!lyxrc.rtl_support || pos == 0) return false; - // no RTL boundary at line start - if (pos == 0) - return false; + Font const & left_font = displayFont(pit, pos - 1); - Paragraph const & par = text_->getPar(pit); - - bool left = displayFont(pit, pos - 1).isVisibleRightToLeft(); - bool right; - if (pos == par.size()) - right = par.isRTL(bv_->buffer().params()); - else - right = displayFont(pit, pos).isVisibleRightToLeft(); - return left != right; + return isRTLBoundary(pit, pos, left_font); } +// isRTLBoundary returns false on a real end-of-line boundary, +// because otherwise the two boundary types get mixed up. +// This is the whole purpose of this being in TextMetrics. bool TextMetrics::isRTLBoundary(pit_type pit, pos_type pos, Font const & font) const { - if (!lyxrc.rtl_support) + if (!lyxrc.rtl_support + // no RTL boundary at paragraph start + || pos == 0 + // if the metrics have not been calculated, then we are not + // on screen and can safely ignore issues about boundaries. + || !contains(pit)) + return false; + + ParagraphMetrics & pm = par_metrics_[pit]; + // no RTL boundary in empty paragraph + if (pm.rows().empty()) + return false; + + pos_type endpos = pm.getRow(pos - 1, false).endpos(); + pos_type startpos = pm.getRow(pos, false).pos(); + // no RTL boundary at line start: + // abc\n -> toggle to RTL -> abc\n (and not: abc\n| + // | | ) + if (pos == startpos && pos == endpos) // start of cur row, end of prev row return false; Paragraph const & par = text_->getPar(pit); + // no RTL boundary at line break: + // abc|\n -> move right -> abc\n (and not: abc\n| + // FED FED| FED ) + if (startpos == pos && endpos == pos && endpos != par.size() + && (par.isNewline(pos - 1) + || par.isLineSeparator(pos - 1) + || par.isSeparator(pos - 1))) + return false; + bool left = font.isVisibleRightToLeft(); bool right; if (pos == par.size()) right = par.isRTL(bv_->buffer().params()); else right = displayFont(pit, pos).isVisibleRightToLeft(); + return left != right; } @@ -354,7 +365,7 @@ bool TextMetrics::isRTLBoundary(pit_type pit, pos_type pos, bool TextMetrics::redoParagraph(pit_type const pit) { Paragraph & par = text_->getPar(pit); - // IMPORTANT NOTE: We pass 'false' explicitely in order to not call + // IMPORTANT NOTE: We pass 'false' explicitly in order to not call // redoParagraph() recursively inside parMetrics. Dimension old_dim = parMetrics(pit, false).dim(); ParagraphMetrics & pm = par_metrics_[pit]; @@ -391,25 +402,27 @@ bool TextMetrics::redoParagraph(pit_type const pit) LYXERR(Debug::INFO, "MacroContext not initialised!" << " Going through the buffer again and hope" << " the context is better then."); - updateLabels(bv_->buffer()); + // FIXME audit updateBuffer calls + // This should not be here, but it is not clear yet where else it + // should be. + bv_->buffer().updateBuffer(); 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. Font const bufferfont = buffer.params().getFont(); InsetList::const_iterator ii = par.insetList().begin(); InsetList::const_iterator iend = par.insetList().end(); for (; ii != iend; ++ii) { + // FIXME Doesn't this HAVE to be non-empty? // 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) @@ -420,14 +433,16 @@ bool TextMetrics::redoParagraph(pit_type const pit) Dimension dim; int const w = max_width_ - leftMargin(max_width_, pit, ii->pos) - right_margin; - Font const & font = ii->inset->noFontChange() ? - bufferfont : displayFont(pit, ii->pos); - MacroContext mc(buffer, parPos); + Font const & font = ii->inset->inheritFont() ? + displayFont(pit, ii->pos) : bufferfont; + MacroContext mc(&buffer, parPos); 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 +454,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_; @@ -497,18 +512,17 @@ void TextMetrics::computeRowMetrics(pit_type const pit, row.label_hfill = 0; row.separator = 0; - Buffer & buffer = bv_->buffer(); Paragraph const & par = text_->getPar(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; //lyxerr << "w " << w << endl; - bool const is_rtl = text_->isRTL(buffer, par); + bool const is_rtl = text_->isRTL(par); if (is_rtl) row.x = rightMargin(pit); else @@ -551,7 +565,22 @@ void TextMetrics::computeRowMetrics(pit_type const pit, else align = par.params().align(); - // Display-style insets should always be on a centred row + // handle alignment inside tabular cells + Inset const & owner = text_->inset(); + 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 centered row if (Inset const * inset = par.getInset(row.pos())) { switch (inset->display()) { case Inset::AlignLeft: @@ -561,9 +590,11 @@ void TextMetrics::computeRowMetrics(pit_type const pit, align = LYX_ALIGN_CENTER; break; case Inset::Inline: - case Inset::AlignRight: // unchanged (use align) break; + case Inset::AlignRight: + align = LYX_ALIGN_RIGHT; + break; } } @@ -608,7 +639,7 @@ void TextMetrics::computeRowMetrics(pit_type const pit, if (body_pos > 0 && (body_pos > end || !par.isLineSeparator(body_pos - 1))) { - row.x += theFontMetrics(text_->labelFont(buffer, par)). + row.x += theFontMetrics(text_->labelFont(par)). width(layout.labelsep); if (body_pos <= end) row.x += row.label_hfill; @@ -635,7 +666,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); } @@ -644,11 +675,10 @@ void TextMetrics::computeRowMetrics(pit_type const pit, int TextMetrics::labelFill(pit_type const pit, Row const & row) const { - Buffer & buffer = bv_->buffer(); 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; @@ -666,7 +696,7 @@ int TextMetrics::labelFill(pit_type const pit, Row const & row) const return 0; FontMetrics const & fm - = theFontMetrics(text_->labelFont(buffer, par)); + = theFontMetrics(text_->labelFont(par)); return max(0, fm.width(label) - w); } @@ -694,11 +724,67 @@ int TextMetrics::labelEnd(pit_type const pit) const return leftMargin(max_width_, pit); } +namespace { -pit_type TextMetrics::rowBreakPoint(int width, pit_type const pit, - pit_type pos) const +/** + * 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 + +pos_type TextMetrics::rowBreakPoint(int width, pit_type const pit, + pos_type pos) const { - Buffer & buffer = bv_->buffer(); ParagraphMetrics const & pm = par_metrics_[pit]; Paragraph const & par = text_->getPar(pit); pos_type const end = par.size(); @@ -733,11 +819,24 @@ pit_type TextMetrics::rowBreakPoint(int width, pit_type const pit, // pixel width since last breakpoint int chunkwidth = 0; + docstring const s(1, char_type(0x00B6)); + Font f; + int par_marker_width = theFontMetrics(f).width(s); + FontIterator fi = FontIterator(*this, par, pit, pos); pos_type point = end; pos_type i = pos; + + ParagraphList const & pars_ = text_->paragraphs(); + bool const draw_par_end_marker = lyxrc.paragraph_markers + && size_type(pit + 1) < pars_.size(); + for ( ; i < end; ++i, ++fi) { int thiswidth = pm.singleWidth(i, *fi); + + if (draw_par_end_marker && i == end - 1) + // enlarge the last character to hold the end-of-par marker + thiswidth += par_marker_width; // add inline completion width if (inlineCompletionLPos == i) { @@ -749,7 +848,7 @@ pit_type TextMetrics::rowBreakPoint(int width, pit_type const pit, // add the auto-hfill from label end to the body if (body_pos && i == body_pos) { FontMetrics const & fm = theFontMetrics( - text_->labelFont(buffer, par)); + text_->labelFont(par)); int add = fm.width(layout.labelsep); if (par.isLineSeparator(i - 1)) add -= singleWidth(pit, i - 1); @@ -821,7 +920,6 @@ pit_type TextMetrics::rowBreakPoint(int width, pit_type const pit, int TextMetrics::rowWidth(int right_margin, pit_type const pit, pos_type const first, pos_type const end) const { - Buffer & buffer = bv_->buffer(); // get the pure distance ParagraphMetrics const & pm = par_metrics_[pit]; Paragraph const & par = text_->getPar(pit); @@ -846,13 +944,18 @@ int TextMetrics::rowWidth(int right_margin, pit_type const pit, for ( ; i < end; ++i, ++fi) { if (body_pos > 0 && i == body_pos) { FontMetrics const & fm = theFontMetrics( - text_->labelFont(buffer, par)); + text_->labelFont(par)); w += fm.width(par.layout().labelsep); if (par.isLineSeparator(i - 1)) w -= singleWidth(pit, i - 1); w = max(w, label_end); } - w += pm.singleWidth(i, *fi); + + // a line separator at the end of a line (but not at the end of a + // paragraph) will not be drawn and should therefore not count for + // the row width. + if (!par.isLineSeparator(i) || i != end - 1 || end == par.size()) + w += pm.singleWidth(i, *fi); // add inline completion width if (inlineCompletionLPos == i) { @@ -863,9 +966,21 @@ int TextMetrics::rowWidth(int right_margin, pit_type const pit, } } + // count the paragraph end marker. + if (end == par.size() && lyxrc.paragraph_markers) { + ParagraphList const & pars_ = text_->paragraphs(); + if (size_type(pit + 1) < pars_.size()) { + // enlarge the last character to hold the + // end-of-par marker + docstring const s(1, char_type(0x00B6)); + Font f; + w += theFontMetrics(f).width(s); + } + } + if (body_pos > 0 && body_pos >= end) { FontMetrics const & fm = theFontMetrics( - text_->labelFont(buffer, par)); + text_->labelFont(par)); w += fm.width(par.layout().labelsep); if (end > 0 && par.isLineSeparator(end - 1)) w -= singleWidth(pit, end - 1); @@ -897,18 +1012,18 @@ Dimension TextMetrics::rowHeight(pit_type const pit, pos_type const first, Buffer const & buffer = bv_->buffer(); Font font = displayFont(pit, first); FontSize const tmpsize = font.fontInfo().size(); - font.fontInfo() = text_->layoutFont(buffer, pit); + font.fontInfo() = text_->layoutFont(pit); FontSize const size = font.fontInfo().size(); font.fontInfo().setSize(tmpsize); - FontInfo labelfont = text_->labelFont(buffer, par); + FontInfo labelfont = text_->labelFont(par); FontMetrics const & labelfont_metrics = theFontMetrics(labelfont); FontMetrics const & fontmetrics = theFontMetrics(font); // these are minimum values double const spacing_val = layout.spacing.getValue() - * text_->spacing(buffer, par); + * text_->spacing(par); //lyxerr << "spacing_val = " << spacing_val << endl; int maxasc = int(fontmetrics.maxAscent() * spacing_val); int maxdesc = int(fontmetrics.maxDescent() * spacing_val); @@ -918,8 +1033,8 @@ Dimension TextMetrics::rowHeight(pit_type const pit, pos_type const first, InsetList::const_iterator ii = par.insetList().begin(); InsetList::const_iterator iend = par.insetList().end(); for ( ; ii != iend; ++ii) { - Dimension const & dim = pm.insetDimension(ii->inset); if (ii->pos >= first && ii->pos < end) { + Dimension const & dim = pm.insetDimension(ii->inset); maxasc = max(maxasc, dim.ascent()); maxdesc = max(maxdesc, dim.descent()); } @@ -946,21 +1061,20 @@ Dimension TextMetrics::rowHeight(pit_type const pit, pos_type const first, ++maxdesc; ParagraphList const & pars = text_->paragraphs(); + Inset const & inset = text_->inset(); // is it a top line? if (first == 0 && topBottomSpace) { BufferParams const & bufparams = buffer.params(); // some parskips VERY EASY IMPLEMENTATION - if (bufparams.paragraph_separation - == BufferParams::ParagraphSkipSeparation - && par.ownerCode() != ERT_CODE - && par.ownerCode() != LISTINGS_CODE - && pit > 0 - && ((layout.isParagraph() && par.getDepth() == 0) - || (pars[pit - 1].layout().isParagraph() - && pars[pit - 1].getDepth() == 0))) - { - maxasc += bufparams.getDefSkip().inPixels(*bv_); + if (bufparams.paragraph_separation == BufferParams::ParagraphSkipSeparation + && !inset.getLayout().parbreakIsNewline() + && !par.layout().parbreak_is_newline + && pit > 0 + && ((layout.isParagraph() && par.getDepth() == 0) + || (pars[pit - 1].layout().isParagraph() + && pars[pit - 1].getDepth() == 0))) { + maxasc += bufparams.getDefSkip().inPixels(*bv_); } if (par.params().startOfAppendix()) @@ -972,20 +1086,20 @@ Dimension TextMetrics::rowHeight(pit_type const pit, pos_type const first, && !par.params().labelString().empty()) { labeladdon = int(labelfont_metrics.maxHeight() * layout.spacing.getValue() - * text_->spacing(buffer, par)); + * text_->spacing(par)); } // special code for the top label if ((layout.labeltype == LABEL_TOP_ENVIRONMENT || layout.labeltype == LABEL_BIBLIO || layout.labeltype == LABEL_CENTERED_TOP_ENVIRONMENT) - && isFirstInSequence(pit, pars) + && text_->isFirstInSequence(pit) && !par.labelString().empty()) { labeladdon = int( labelfont_metrics.maxHeight() * layout.spacing.getValue() - * text_->spacing(buffer, par) + * text_->spacing(par) + (layout.topsep + layout.labelbottomsep) * dh); } @@ -993,7 +1107,7 @@ Dimension TextMetrics::rowHeight(pit_type const pit, pos_type const first, // a section, or between the items of a itemize or enumerate // environment. - pit_type prev = depthHook(pit, pars, par.getDepth()); + pit_type prev = text_->depthHook(pit, par.getDepth()); Paragraph const & prevpar = pars[prev]; if (prev != pit && prevpar.layout() == layout @@ -1006,7 +1120,7 @@ Dimension TextMetrics::rowHeight(pit_type const pit, pos_type const first, layoutasc = layout.topsep * dh; } - prev = outerHook(pit, pars); + prev = text_->outerHook(pit); if (prev != pit_type(pars.size())) { maxasc += int(pars[prev].layout().parsep * dh); } else if (pit != 0) { @@ -1031,7 +1145,7 @@ Dimension TextMetrics::rowHeight(pit_type const pit, pos_type const first, if (pars[cpit].getDepth() > pars[nextpit].getDepth()) { usual = pars[cpit].layout().bottomsep * dh; - cpit = depthHook(cpit, pars, pars[nextpit].getDepth()); + cpit = text_->depthHook(cpit, pars[nextpit].getDepth()); if (pars[cpit].layout() != pars[nextpit].layout() || pars[nextpit].getLabelWidthString() != pars[cpit].getLabelWidthString()) { @@ -1106,12 +1220,26 @@ pos_type TextMetrics::getColumnNearX(pit_type const pit, return 0; } + // 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(par) : false; + + // if the first character is a separator, and we are in RTL + // text, this character will not be painted on screen + // and thus we should not count it and skip to the next. + if (rtl && par.isSeparator(bidi.vis2log(vc))) + ++vc; + while (vc < end && tmpx <= x) { c = bidi.vis2log(vc); last_tmpx = tmpx; if (body_pos > 0 && c == body_pos - 1) { FontMetrics const & fm = theFontMetrics( - text_->labelFont(buffer, par)); + text_->labelFont(par)); tmpx += row.label_hfill + fm.width(layout.labelsep); if (par.isLineSeparator(body_pos - 1)) tmpx -= singleWidth(pit, body_pos - 1); @@ -1128,16 +1256,10 @@ 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 - // 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))) { @@ -1207,7 +1329,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); @@ -1244,7 +1366,8 @@ void TextMetrics::newParMetricsUp() // y is screen coordinate pit_type TextMetrics::getPitNearY(int y) { - BOOST_ASSERT(!text_->paragraphs().empty()); + LASSERT(!text_->paragraphs().empty(), return -1); + LASSERT(!par_metrics_.empty(), return -1); LYXERR(Debug::DEBUG, "y: " << y << " cache size: " << par_metrics_.size()); // look for highest numbered paragraph with y coordinate less than given y @@ -1273,7 +1396,7 @@ pit_type TextMetrics::getPitNearY(int y) if (y >= last->second.position() + int(pm_last.descent())) { // We are looking for a position that is after the last paragraph in - // the cache (which is in priciple off-screen, that is before the + // the cache (which is in priciple off-screen), that is before the // visible part. pit = last->first + 1; if (pit == int(text_->paragraphs().size())) @@ -1302,36 +1425,66 @@ pit_type TextMetrics::getPitNearY(int y) } -Row const & TextMetrics::getRowNearY(int y, pit_type pit) const +Row const & TextMetrics::getPitAndRowNearY(int & y, pit_type & pit, + bool assert_in_view, bool up) { 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; for (; rit != rlast; yy += rit->height(), ++rit) if (yy + rit->height() > y) break; + + if (assert_in_view) { + if (!up && yy + rit->height() > y) { + if (rit != pm.rows().begin()) { + y = yy; + --rit; + } else if (pit != 0) { + --pit; + newParMetricsUp(); + ParagraphMetrics const & pm2 = par_metrics_[pit]; + rit = pm2.rows().end(); + --rit; + y = yy; + } + } else if (up && yy != y) { + if (rit != rlast) { + y = yy + rit->height(); + ++rit; + } else if (pit < int(text_->paragraphs().size()) - 1) { + ++pit; + newParMetricsDown(); + ParagraphMetrics const & pm2 = par_metrics_[pit]; + rit = pm2.rows().begin(); + y = pm2.position(); + } + } + } return *rit; } // x,y are absolute screen coordinates // sets cursor recursively descending into nested editable insets -Inset * TextMetrics::editXY(Cursor & cur, int x, int y) +Inset * TextMetrics::editXY(Cursor & cur, int x, int y, + bool assert_in_view, bool up) { if (lyxerr.debugging(Debug::WORKAREA)) { LYXERR0("TextMetrics::editXY(cur, " << x << ", " << y << ")"); cur.bv().coordCache().dump(); } pit_type pit = getPitNearY(y); - BOOST_ASSERT(pit != -1); - - Row const & row = getRowNearY(y, pit); - bool bound = false; + LASSERT(pit != -1, return 0); + + int yy = y; // is modified by getPitAndRowNearY + Row const & row = getPitAndRowNearY(yy, pit, assert_in_view, up); + bool bound = false; // is modified by getColumnNearX int xx = x; // is modified by getColumnNearX pos_type const pos = row.pos() + getColumnNearX(pit, row, xx, bound); @@ -1341,7 +1494,7 @@ Inset * TextMetrics::editXY(Cursor & cur, int x, int y) cur.setTargetX(x); // try to descend into nested insets - Inset * inset = checkInsetHit(x, y); + Inset * inset = checkInsetHit(x, yy); //lyxerr << "inset " << inset << " hit at x: " << x << " y: " << y << endl; if (!inset) { // Either we deconst editXY or better we move current_font @@ -1353,23 +1506,22 @@ Inset * TextMetrics::editXY(Cursor & cur, int x, int y) } ParagraphList const & pars = text_->paragraphs(); - Inset const * insetBefore = pos? pars[pit].getInset(pos - 1): 0; - //Inset * insetBehind = pars[pit].getInset(pos); + Inset const * inset_before = pos ? pars[pit].getInset(pos - 1) : 0; // 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(inset == inset_before + || inset == pars[pit].getInset(pos), return 0); // Make sure the cursor points to the position before // this inset. - if (inset == insetBefore) { + if (inset == inset_before) { --cur.pos(); cur.boundary(false); } // Try to descend recursively inside the inset. - inset = inset->editXY(cur, x, y); + inset = inset->editXY(cur, x, yy); if (cur.top().text() == text_) cur.setCurrentFont(); @@ -1379,8 +1531,9 @@ 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); + LASSERT(pit != -1, return); ParagraphMetrics const & pm = par_metrics_[pit]; @@ -1389,7 +1542,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) @@ -1417,7 +1570,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, return 0); Paragraph const & par = text_->paragraphs()[pit]; ParagraphMetrics const & pm = par_metrics_[pit]; @@ -1459,7 +1612,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]; @@ -1483,7 +1636,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]" @@ -1493,8 +1646,10 @@ int TextMetrics::cursorX(CursorSlice const & sl, if (end <= row_pos) cursor_vpos = row_pos; else if (ppos >= end) - cursor_vpos = text_->isRTL(buffer, par) ? row_pos : end; + cursor_vpos = text_->isRTL(par) ? row_pos : end; else if (ppos > row_pos && ppos >= end) + //FIXME: this code is never reached! + // (see http://www.lyx.org/trac/changeset/8251) // Place cursor after char at (logical) position pos - 1 cursor_vpos = (bidi.level(ppos - 1) % 2 == 0) ? bidi.log2vis(ppos - 1) + 1 : bidi.log2vis(ppos - 1); @@ -1528,7 +1683,16 @@ 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); - + + if (lyxrc.paragraph_markers && text_->isRTL(par)) { + ParagraphList const & pars_ = text_->paragraphs(); + if (size_type(pit + 1) < pars_.size()) { + FontInfo f; + docstring const s = docstring(1, char_type(0x00B6)); + x += theFontMetrics(f).width(s); + } + } + // Inline completion RTL special case row_pos == cursor_pos: // "__|b" => cursor_pos is right of __ if (row_pos == inlineCompletionVPos && row_pos == cursor_vpos) { @@ -1537,7 +1701,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) @@ -1545,7 +1709,7 @@ int TextMetrics::cursorX(CursorSlice const & sl, pos_type pos = bidi.vis2log(vpos); if (body_pos > 0 && pos == body_pos - 1) { FontMetrics const & labelfm = theFontMetrics( - text_->labelFont(buffer, par)); + text_->labelFont(par)); x += row.label_hfill + labelfm.width(par.layout().labelsep); if (par.isLineSeparator(body_pos - 1)) x -= singleWidth(pit, body_pos - 1); @@ -1561,14 +1725,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 @@ -1578,7 +1742,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; } @@ -1623,7 +1787,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()); @@ -1632,7 +1796,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. @@ -1654,13 +1818,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) @@ -1689,8 +1853,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()); } @@ -1700,11 +1864,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(); @@ -1714,7 +1878,7 @@ int TextMetrics::leftMargin(int max_width, int l_margin = 0; - if (text_->isMainText(buffer)) + if (text_->isMainText()) l_margin += bv_->leftMargin(); l_margin += theFontMetrics(buffer.params().getFont()).signedWidth( @@ -1722,13 +1886,13 @@ int TextMetrics::leftMargin(int max_width, if (par.getDepth() != 0) { // find the next level paragraph - pit_type newpar = outerHook(pit, pars); + pit_type newpar = text_->outerHook(pit); if (newpar != pit_type(pars.size())) { 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 @@ -1744,7 +1908,7 @@ int TextMetrics::leftMargin(int max_width, && pit > 0 && pars[pit - 1].layout().nextnoindent) parindent.erase(); - FontInfo const labelfont = text_->labelFont(buffer, par); + FontInfo const labelfont = text_->labelFont(par); FontMetrics const & labelfont_metrics = theFontMetrics(labelfont); switch (layout.margintype) { @@ -1781,17 +1945,17 @@ int TextMetrics::leftMargin(int max_width, case MARGIN_FIRST_DYNAMIC: if (layout.labeltype == LABEL_MANUAL) { - if (pos >= par.beginOfBody()) { + // if we are at position 0, we are never in the body + if (pos > 0 && pos >= par.beginOfBody()) l_margin += labelfont_metrics.signedWidth(layout.leftmargin); - } else { + else l_margin += labelfont_metrics.signedWidth(layout.labelindent); - } } else if (pos != 0 // Special case to fix problems with // theorems (JMarc) || (layout.labeltype == LABEL_STATIC && layout.latextype == LATEX_ENVIRONMENT - && !isFirstInSequence(pit, pars))) { + && !text_->isFirstInSequence(pit))) { l_margin += labelfont_metrics.signedWidth(layout.leftmargin); } else if (layout.labeltype != LABEL_TOP_ENVIRONMENT && layout.labeltype != LABEL_BIBLIO @@ -1840,24 +2004,30 @@ int TextMetrics::leftMargin(int max_width, || layout.labeltype == LABEL_CENTERED_TOP_ENVIRONMENT || (layout.labeltype == LABEL_STATIC && layout.latextype == LATEX_ENVIRONMENT - && !isFirstInSequence(pit, pars))) - && align == LYX_ALIGN_BLOCK + && !text_->isFirstInSequence(pit))) + && (align == LYX_ALIGN_BLOCK || align == LYX_ALIGN_LEFT) && !par.params().noindent() // in some insets, paragraphs are never indented - && !(par.inInset() && par.inInset()->neverIndent()) + && !text_->inset().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())) - || buffer.params().paragraph_separation == BufferParams::ParagraphIndentSeparation) + && (!(tclass.isDefaultLayout(par.layout()) + || tclass.isPlainLayout(par.layout())) + || buffer.params().paragraph_separation + == BufferParams::ParagraphIndentSeparation) ) - { - l_margin += theFontMetrics(buffer.params().getFont()).signedWidth( - parindent); - } - + { + // use the parindent of the layout when the default indentation is + // used otherwise use the indentation set in the document settings + if (buffer.params().getIndentation().asLyXCommand() == "default") + l_margin += theFontMetrics( + buffer.params().getFont()).signedWidth(parindent); + else + l_margin += buffer.params().getIndentation().inPixels(*bv_); + } + return l_margin; } @@ -1911,19 +2081,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 - && cur.anchor().text() == text_ + // if the anchor is outside, this is not our selection + && cur.normalAnchor().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(); } } @@ -1940,14 +2114,28 @@ 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(); - + + // Take this opportunity to spellcheck the row contents. + if (row_has_changed && lyxrc.spellcheck_continuously) { + text_->getPar(pit).spellCheck(); + } + // 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) { @@ -1964,28 +2152,15 @@ 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); - } - + // Instrumentation for testing row cache (see also // 12 lines lower): if (lyxerr.debugging(Debug::PAINTING) && inside - && (row_selection || pi.full_repaint || row_has_changed)) { - string const foreword = text_->isMainText(bv_->buffer()) ? + && (row.selection() || pi.full_repaint || row_has_changed)) { + string const foreword = text_->isMainText() ? "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); } @@ -1994,15 +2169,23 @@ void TextMetrics::drawParagraph(PainterInfo & pi, pit_type pit, int x, int y) co // for inner insets as the Row has been cleared out. bool tmp = pi.full_repaint; pi.full_repaint = true; + + rp.paintSelection(); rp.paintAppendix(); rp.paintDepthBar(); rp.paintChangeBar(); - if (i == 0) + bool const is_rtl = text_->isRTL(text_->getPar(pit)); + if (i == 0 && !is_rtl) rp.paintFirst(); + if (i == nrows - 1 && is_rtl) + rp.paintLast(); rp.paintText(); - if (i == nrows - 1) + if (i == nrows - 1 && !is_rtl) rp.paintLast(); + if (i == 0 && is_rtl) + rp.paintFirst(); y += row.descent(); + // Restore full_repaint status. pi.full_repaint = tmp; } @@ -2013,105 +2196,30 @@ 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 -{ - 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(); - - // 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 (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 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 (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 - ++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 - // right side of a boundary or at the selection end) - x1 = -1; - } - } -} - - -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()); - + //FIXME: Is it necessary to explicitly set this to false? + wordStart.boundary(false); + Point lxy = cur.bv().getPos(wordStart); + Point rxy = cur.bv().getPos(bvcur); + // 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; }