X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FRowPainter.cpp;h=e378f433e8ebc6d09b8d3c3012f9fd861d365dc4;hb=c3a0136ad1912b34dd458d51c6a52cdb247b08f3;hp=a50d8f8120f33bd929d1bdd0283fe68507f51398;hpb=499fc04c9a417cb91ddc97a2110ac59882fd4909;p=lyx.git diff --git a/src/RowPainter.cpp b/src/RowPainter.cpp index a50d8f8120..e378f433e8 100644 --- a/src/RowPainter.cpp +++ b/src/RowPainter.cpp @@ -10,7 +10,6 @@ */ #include -#include #include "RowPainter.h" @@ -26,24 +25,19 @@ #include "Row.h" #include "MetricsInfo.h" #include "Paragraph.h" -#include "ParagraphMetrics.h" +#include "ParagraphList.h" #include "ParagraphParameters.h" +#include "Text.h" #include "TextMetrics.h" -#include "VSpace.h" #include "frontends/FontMetrics.h" #include "frontends/Painter.h" -#include "insets/InsetText.h" - -#include "mathed/InsetMath.h" - #include "support/debug.h" #include "support/gettext.h" -#include "support/textutils.h" - #include "support/lassert.h" -#include + +#include using namespace std; @@ -56,11 +50,9 @@ using frontend::FontMetrics; RowPainter::RowPainter(PainterInfo & pi, Text const & text, Row const & row, int x, int y) : pi_(pi), text_(text), - text_metrics_(pi_.base.bv->textMetrics(&text)), - pars_(text.paragraphs()), + tm_(pi_.base.bv->textMetrics(&text)), row_(row), par_(text.paragraphs()[row.pit()]), - pm_(text_metrics_.parMetrics(row.pit())), change_(pi_.change_), - xo_(x), yo_(y), width_(text_metrics_.width()) + xo_(x), yo_(y) { x_ = row_.left_margin + xo_; @@ -72,11 +64,12 @@ RowPainter::RowPainter(PainterInfo & pi, } -FontInfo RowPainter::labelFont() const +FontInfo RowPainter::labelFont(bool end) const { FontInfo f = text_.labelFont(par_); // selected text? - if (row_.begin_margin_sel || pi_.selected) + if ((end ? row_.end_margin_sel : row_.begin_margin_sel) + || pi_.selected) f.setPaintColor(Color_selectiontext); return f; } @@ -101,12 +94,12 @@ void RowPainter::paintInset(Row::Element const & e) const // requires a full repaint bool const pi_full_repaint = pi_.full_repaint; bool const pi_do_spellcheck = pi_.do_spellcheck; - Change const pi_change = pi_.change_; + Change const pi_change = pi_.change; pi_.base.font = e.inset->inheritFont() ? e.font.fontInfo() : pi_.base.bv->buffer().params().getFont().fontInfo(); pi_.ltr_pos = !e.font.isVisibleRightToLeft(); - pi_.change_ = change_.changed() ? change_ : e.change; + pi_.change = pi_.change.changed() ? pi_.change : e.change; pi_.do_spellcheck &= e.inset->allowSpellCheck(); int const x1 = int(x_); @@ -117,10 +110,11 @@ void RowPainter::paintInset(Row::Element const & e) const e.inset->drawBackground(pi_, x1, yo_); e.inset->drawSelection(pi_, x1, yo_); e.inset->draw(pi_, x1, yo_); + paintTextDecoration(e); // Restore full_repaint status. pi_.full_repaint = pi_full_repaint; - pi_.change_ = pi_change; + pi_.change = pi_change; pi_.do_spellcheck = pi_do_spellcheck; pi_.selected = pi_selected; @@ -137,6 +131,13 @@ void RowPainter::paintInset(Row::Element const & e) const } +void RowPainter::paintLanguageMarkings(Row::Element const & e) const +{ + paintForeignMark(e); + paintNoSpellingMark(e); +} + + void RowPainter::paintForeignMark(Row::Element const & e) const { Language const * lang = e.font.language(); @@ -148,22 +149,50 @@ void RowPainter::paintForeignMark(Row::Element const & e) const return; int const desc = e.inset ? e.dim.descent() : 0; - int const y = yo_ + pi_.base.solidLineOffset() - + desc + pi_.base.solidLineThickness() / 2; - pi_.pain.line(int(x_), y, int(x_ + e.full_width()), y, Color_language, + int const y = yo_ + min(3 * pi_.base.solidLineOffset() / 2 + desc, + row_.descent() - 1); + pi_.pain.line(int(x_), y, int(x_ + e.full_width() - 1), y, Color_language, Painter::line_solid, pi_.base.solidLineThickness()); } +void RowPainter::paintNoSpellingMark(Row::Element const & e) const +{ + //if (!lyxrc.mark_no_spelling) + // return; + if (e.font.language() == latex_language) + return; + if (e.font.fontInfo().nospellcheck() != FONT_ON) + return; + + // We at the same voffset than the misspelled mark, since + // these two are mutually exclusive + int const desc = e.inset ? e.dim.descent() : 0; + int y = yo_ + pi_.base.solidLineOffset() + desc + + pi_.base.solidLineThickness() + + (e.change.changed() ? pi_.base.solidLineThickness() + 1 : 0) + + 1; + // Make sure that the mark does not go below the row rectangle + y = min(y, yo_ + row_.descent() - 1); + + pi_.pain.line(int(x_), y, int(x_ + e.full_width()), y, Color_language, + Painter::line_onoffdash, pi_.base.solidLineThickness()); +} + + void RowPainter::paintMisspelledMark(Row::Element const & e) const { + if (e.font.fontInfo().nospellcheck() == FONT_ON) + return; // if changed the misspelled marker gets placed slightly lower than normal // to avoid drawing at the same vertical offset FontMetrics const & fm = theFontMetrics(e.font); int const thickness = max(fm.lineWidth(), 2); - int const y = yo_ + pi_.base.solidLineOffset() + pi_.base.solidLineThickness() + int y = yo_ + pi_.base.solidLineOffset() + pi_.base.solidLineThickness() + (e.change.changed() ? pi_.base.solidLineThickness() + 1 : 0) + 1 + thickness / 2; + // Make sure that the mark does not go below the row rectangle + y = min(y, yo_ + row_.descent() - 1); //FIXME: this could be computed only once, it is probably not costly. // check for cursor position @@ -195,7 +224,6 @@ void RowPainter::paintMisspelledMark(Row::Element const & e) const continue; } - FontMetrics const & fm = theFontMetrics(e.font); int x1 = fm.pos2x(e.str, range.first - e.pos, e.isRTL(), e.extra); int x2 = fm.pos2x(e.str, min(range.last - e.pos + 1, @@ -204,7 +232,8 @@ void RowPainter::paintMisspelledMark(Row::Element const & e) const if (x1 > x2) swap(x1, x2); - pi_.pain.line(x_ + x1, y, x_ + x2, y, Color_error, + pi_.pain.line(int(x_ + x1), y, int(x_ + x2), y, + Color_error, Painter::line_onoffdash, thickness); pos = range.last + 1; } @@ -237,6 +266,21 @@ void RowPainter::paintStringAndSel(Row::Element const & e) const } +void RowPainter::paintTextDecoration(Row::Element const & e) const +{ + // element selected? + bool const sel = (e.pos >= row_.sel_beg && e.endpos <= row_.sel_end) + || pi_.selected; + FontInfo copy = e.font.fontInfo(); + if (sel || e.change.changed()) { + Color const col = e.change.changed() ? e.change.color() + : Color_selectiontext; + copy.setPaintColor(col); + } + pi_.pain.textDecoration(copy, int(x_), yo_, int(e.full_width())); +} + + void RowPainter::paintChange(Row::Element const & e) const { e.change.paintCue(pi_, x_, yo_, x_ + e.full_width(), e.font.fontInfo()); @@ -245,23 +289,7 @@ void RowPainter::paintChange(Row::Element const & e) const void RowPainter::paintChangeBar() const { - pos_type const start = row_.pos(); - pos_type end = row_.endpos(); - - if (par_.size() == end) { - // this is the last row of the paragraph; - // thus, we must also consider the imaginary end-of-par character - end++; - } - - if (start == end || !par_.isChanged(start, end)) - return; - - int const height = text_metrics_.isLastRow(row_) - ? row_.ascent() - : row_.height(); - - pi_.pain.fillRectangle(5, yo_ - row_.ascent(), 3, height, Color_changebar); + pi_.pain.fillRectangle(5, yo_ - row_.ascent(), 3, row_.height(), Color_changebar); } @@ -277,39 +305,40 @@ void RowPainter::paintAppendix() const y += 2 * defaultRowHeight(); pi_.pain.line(1, y, 1, yo_ + row_.height(), Color_appendix); - pi_.pain.line(width_ - 2, y, width_ - 2, yo_ + row_.height(), Color_appendix); + pi_.pain.line(tm_.width() - 2, y, tm_.width() - 2, yo_ + row_.height(), Color_appendix); } void RowPainter::paintDepthBar() const { depth_type const depth = par_.getDepth(); + ParagraphList const & pars = text_.paragraphs(); if (depth <= 0) return; depth_type prev_depth = 0; - if (!text_metrics_.isFirstRow(row_)) { + if (!tm_.isFirstRow(row_)) { pit_type pit2 = row_.pit(); if (row_.pos() == 0) --pit2; - prev_depth = pars_[pit2].getDepth(); + prev_depth = pars[pit2].getDepth(); } depth_type next_depth = 0; - if (!text_metrics_.isLastRow(row_)) { + if (!tm_.isLastRow(row_)) { pit_type pit2 = row_.pit(); - if (row_.endpos() >= pars_[pit2].size()) + if (row_.endpos() >= pars[pit2].size()) ++pit2; - next_depth = pars_[pit2].getDepth(); + next_depth = pars[pit2].getDepth(); } for (depth_type i = 1; i <= depth; ++i) { int const w = nestMargin() / 5; int x = int(xo_) + w * i; - // only consider the changebar space if we're drawing outermost text + // consider the bufferview left margin if we're drawing outermost text if (text_.isMainText()) - x += changebarMargin(); + x += pi_.base.bv->leftMargin(); int const starty = yo_ - row_.ascent(); int const h = row_.height() - 1 - (i - next_depth - 1) * 3; @@ -337,13 +366,13 @@ void RowPainter::paintAppendixStart(int y) const docstring const label = _("Appendix"); theFontMetrics(pb_font).rectText(label, w, a, d); - int const text_start = int(xo_ + (width_ - w) / 2); + int const text_start = int(xo_ + (tm_.width() - w) / 2); int const text_end = text_start + w; pi_.pain.rectText(text_start, y + d, label, pb_font, Color_none, Color_none); pi_.pain.line(int(xo_ + 1), y, text_start, y, Color_appendix); - pi_.pain.line(text_end, y, int(xo_ + width_ - 2), y, Color_appendix); + pi_.pain.line(text_end, y, int(xo_ + tm_.width() - 2), y, Color_appendix); } @@ -391,28 +420,22 @@ void RowPainter::paintLabel() const if (str.empty()) return; - bool const is_rtl = text_.isRTL(par_); Layout const & layout = par_.layout(); - FontInfo const font = labelFont(); + FontInfo const font = labelFont(false); FontMetrics const & fm = theFontMetrics(font); - double x = x_; - - if (is_rtl) - x = width_ - row_.right_margin + fm.width(layout.labelsep); - else - x = x_ - fm.width(layout.labelsep) - fm.width(str); + int const x = row_.isRTL() ? row_.width() + fm.width(layout.labelsep) + : row_.left_margin - fm.width(layout.labelsep) - fm.width(str); - pi_.pain.text(int(x), yo_, str, font); + pi_.pain.text(int(xo_) + x, yo_, str, font); } void RowPainter::paintTopLevelLabel() const { BufferParams const & bparams = pi_.base.bv->buffer().params(); - bool const is_rtl = text_.isRTL(par_); ParagraphParameters const & pparams = par_.params(); Layout const & layout = par_.layout(); - FontInfo const font = labelFont(); + FontInfo const font = labelFont(false); docstring const str = par_.labelString(); if (str.empty()) return; @@ -434,103 +457,59 @@ void RowPainter::paintTopLevelLabel() const double x = x_; if (layout.labeltype == LABEL_CENTERED) { - x = row_.left_margin + (width_ - row_.left_margin - row_.right_margin) / 2; - x -= fm.width(str) / 2; - } else if (is_rtl) { - x = width_ - row_.right_margin - fm.width(str); + /* Currently, x points at row_.left_margin (which contains the + * indent). First remove that, and then center the title with + * respect to the left and right margins. + */ + int const leftm = row_.isRTL() ? tm_.rightMargin(row_.pit()) + : tm_.leftMargin(row_.pit()); + int const rightm = row_.isRTL() ? tm_.leftMargin(row_.pit()) + : tm_.rightMargin(row_.pit()); + x += leftm - row_.left_margin + (tm_.width() - leftm -rightm) / 2 + - fm.width(str) / 2; + } else if (row_.isRTL()) { + x = xo_ + tm_.width() - row_.right_margin - fm.width(str); } pi_.pain.text(int(x), yo_ - maxdesc - labeladdon, str, font); } -/** Check if the current paragraph is the last paragraph in a - proof environment */ -static int getEndLabel(pit_type p, Text const & text) -{ - ParagraphList const & pars = text.paragraphs(); - pit_type pit = p; - depth_type par_depth = pars[p].getDepth(); - while (pit != pit_type(pars.size())) { - Layout const & layout = pars[pit].layout(); - int const endlabeltype = layout.endlabeltype; - - if (endlabeltype != END_LABEL_NO_LABEL) { - if (p + 1 == pit_type(pars.size())) - return endlabeltype; - - depth_type const next_depth = - pars[p + 1].getDepth(); - if (par_depth > next_depth || - (par_depth == next_depth && layout != pars[p + 1].layout())) - return endlabeltype; - break; - } - if (par_depth == 0) - break; - pit = text.outerHook(pit); - if (pit != pit_type(pars.size())) - par_depth = pars[pit].getDepth(); - } - return END_LABEL_NO_LABEL; -} - - void RowPainter::paintLast() const { - bool const is_rtl = text_.isRTL(par_); - int const endlabel = getEndLabel(row_.pit(), text_); - - // paint imaginary end-of-paragraph character - - Change const & change = par_.lookupChange(par_.size()); - if (change.changed()) { - FontMetrics const & fm = - theFontMetrics(pi_.base.bv->buffer().params().getFont()); - int const length = fm.maxAscent() / 2; - Color col = change.color(); - - pi_.pain.line(int(x_) + 1, yo_ + 2, int(x_) + 1, yo_ + 2 - length, col, - Painter::line_solid, 3); - - if (change.deleted()) { - pi_.pain.line(int(x_) + 1 - length, yo_ + 2, int(x_) + 1 + length, - yo_ + 2, col, Painter::line_solid, 3); - } else { - pi_.pain.line(int(x_) + 1 - length, yo_ + 2, int(x_) + 1, - yo_ + 2, col, Painter::line_solid, 3); - } - } - - // draw an endlabel - + int const endlabel = text_.getEndLabel(row_.pit()); switch (endlabel) { case END_LABEL_BOX: case END_LABEL_FILLED_BOX: { - FontInfo const font = labelFont(); + FontInfo font = labelFont(true); + if (font.realColor() != Color_selectiontext) + font.setPaintColor(Color_eolmarker); FontMetrics const & fm = theFontMetrics(font); int const size = int(0.75 * fm.maxAscent()); int const y = yo_ - size; - int const max_row_width = width_ - size - Inset::TEXT_TO_INSET_OFFSET; - int x = is_rtl ? nestMargin() + changebarMargin() - : max_row_width - row_.right_margin; // If needed, move the box a bit to avoid overlapping with text. - int const rem = max_row_width - row_.width(); - if (rem <= 0) - x += is_rtl ? rem : - rem; + int x = 0; + if (row_.isRTL()) { + int const normal_x = nestMargin() + changebarMargin(); + x = min(normal_x, row_.left_margin - size - Inset::textOffset(pi_.base.bv)); + } else { + int const normal_x = tm_.width() - row_.right_margin + - size - Inset::textOffset(pi_.base.bv); + x = max(normal_x, row_.width()); + } if (endlabel == END_LABEL_BOX) - pi_.pain.rectangle(x, y, size, size, Color_eolmarker); + pi_.pain.rectangle(int(xo_) + x, y, size, size, font.realColor()); else - pi_.pain.fillRectangle(x, y, size, size, Color_eolmarker); + pi_.pain.fillRectangle(int(xo_) + x, y, size, size, font.realColor()); break; } case END_LABEL_STATIC: { - FontInfo const font = labelFont(); + FontInfo const font = labelFont(true); FontMetrics const & fm = theFontMetrics(font); docstring const & str = par_.layout().endlabelstring(); - double const x = is_rtl ? x_ - fm.width(str) : x_; + double const x = row_.isRTL() ? x_ - fm.width(str) : x_; pi_.pain.text(int(x), yo_, str, font); break; } @@ -543,19 +522,17 @@ void RowPainter::paintLast() const void RowPainter::paintOnlyInsets() { - Row::const_iterator cit = row_.begin(); - Row::const_iterator const & end = row_.end(); - for ( ; cit != end ; ++cit) { - Row::Element const & e = *cit; + for (Row::Element const & e : row_) { if (e.type == Row::INSET) { - // If outer row has changed, nested insets are repainted completely. - // FIXME: check what this really does. The test is weird. - bool const nested_inset = - (e.inset->asInsetMath() && !e.inset->asInsetMath()->asMacroTemplate()) - || e.inset->asInsetText() || e.inset->asInsetTabular(); - if (nested_inset) - paintInset(e); + paintInset(e); + // The markings of foreign languages + // and of text ignored for spellchecking + paintLanguageMarkings(e); + // change tracking (not for insets that handle it themselves) + if (!e.inset->canPaintChange(*pi_.base.bv)) + paintChange(e); } + x_ += e.full_width(); } } @@ -563,18 +540,14 @@ void RowPainter::paintOnlyInsets() void RowPainter::paintText() { - Row::const_iterator cit = row_.begin(); - Row::const_iterator const & end = row_.end(); - for ( ; cit != end ; ++cit) { - Row::Element const & e = *cit; - + for (Row::Element const & e : row_) { switch (e.type) { case Row::STRING: case Row::VIRTUAL: paintStringAndSel(e); // Paint the spelling marks if enabled. - if (lyxrc.spellcheck_continuously && pi_.do_spellcheck && pi_.pain.isDrawingEnabled()) + if (lyxrc.spellcheck_continuously && pi_.do_spellcheck && !pi_.pain.isNull()) paintMisspelledMark(e); break; @@ -583,11 +556,12 @@ void RowPainter::paintText() break; case Row::SPACE: - pi_.pain.textDecoration(e.font.fontInfo(), int(x_), yo_, int(e.full_width())); + paintTextDecoration(e); } - // The line that indicates word in a different language - paintForeignMark(e); + // The markings of foreign languages + // and of text ignored for spellchecking + paintLanguageMarkings(e); // change tracking (not for insets that handle it themselves) if (e.type != Row::INSET || ! e.inset->canPaintChange(*pi_.base.bv)) @@ -602,97 +576,54 @@ void RowPainter::paintSelection() const { if (!row_.selection()) return; - Cursor const & curs = pi_.base.bv->cursor(); - DocIterator beg = curs.selectionBegin(); - beg.pit() = row_.pit(); - beg.pos() = row_.sel_beg; - - DocIterator end = curs.selectionEnd(); - end.pit() = row_.pit(); - end.pos() = row_.sel_end; - - bool const begin_boundary = beg.pos() >= row_.endpos(); - bool const end_boundary = row_.sel_end == row_.endpos(); - - DocIterator cur = beg; - cur.boundary(begin_boundary); - int x1 = text_metrics_.cursorX(beg.top(), begin_boundary); - int x2 = text_metrics_.cursorX(end.top(), end_boundary); + int const y1 = yo_ - row_.ascent(); int const y2 = y1 + row_.height(); - int const rm = text_.isMainText() ? pi_.base.bv->rightMargin() : 0; - int const lm = text_.isMainText() ? pi_.base.bv->leftMargin() : 0; - // draw the margins - if (row_.begin_margin_sel) { - if (text_.isRTL(beg.paragraph())) { - pi_.pain.fillRectangle(int(xo_ + x1), y1, - text_metrics_.width() - rm - x1, y2 - y1, Color_selection); - } else { - pi_.pain.fillRectangle(int(xo_ + lm), y1, x1 - lm, y2 - y1, - Color_selection); - } - } - - if (row_.end_margin_sel) { - if (text_.isRTL(beg.paragraph())) { - pi_.pain.fillRectangle(int(xo_ + lm), y1, x2 - lm, y2 - y1, - Color_selection); - } else { - pi_.pain.fillRectangle(int(xo_ + x2), y1, text_metrics_.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); + if (row_.isRTL() ? row_.end_margin_sel : row_.begin_margin_sel) + pi_.pain.fillRectangle(int(xo_), y1, row_.left_margin, y2 - y1, + Color_selection); // go through row and draw from RTL boundary to RTL boundary - while (cur < end) { - bool draw_now = 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 (text_metrics_.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); - draw_now = 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 = text_metrics_.cursorX(cur.top(), cur.boundary()); + double x = xo_ + row_.left_margin; + for (auto const & e : row_) { + // These are the same tests as in paintStringAndSel, except + // that all_sel has an additional clause that triggers for end + // of paragraph markers. The clause was not used in + // paintStringAndSel to avoid changing the drawing color. + // at least part of text selected? + bool const some_sel = (e.endpos >= row_.sel_beg && e.pos < row_.sel_end) + || pi_.selected; + // all the text selected? + bool const all_sel = (e.pos >= row_.sel_beg && e.endpos < row_.sel_end) + || (e.isVirtual() && e.pos == row_.endpos() && row_.end_margin_sel) + || pi_.selected; + + if (all_sel) { + // the 3rd argument is written like that to avoid rounding issues + pi_.pain.fillRectangle(int(x), y1, + int(x + e.full_width()) - int(x), y2 - y1, + Color_selection); + } else if (some_sel) { + pos_type const from = min(max(row_.sel_beg, e.pos), e.endpos); + pos_type const to = max(min(row_.sel_end, e.endpos), e.pos); + double x1 = e.pos2x(from); + double x2 = e.pos2x(to); + if (x1 > x2) + swap(x1, x2); + // the 3rd argument is written like that to avoid rounding issues + pi_.pain.fillRectangle(int(x + x1), y1, int(x2 + x) - int(x1 + x), + y2 - y1, Color_selection); } + x += e.full_width(); + } - if (!(cur < end) || draw_now) { - x2 = text_metrics_.cursorX(cur.top(), cur.boundary()); - pi_.pain.fillRectangle(int(xo_ + min(x1, x2)), y1, abs(x2 - x1), - y2 - y1, Color_selection); + if (row_.isRTL() ? row_.begin_margin_sel : row_.end_margin_sel) + pi_.pain.fillRectangle(int(x), y1, + int(xo_ + tm_.width()) - int(x), 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; - } - } }