X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FRowPainter.cpp;h=77e0ff67e61a005f33a11e7b21c43bf735733226;hb=6d62d8009f3c41874cf84aa6577aae3293ebb5e6;hp=fbe35792a201b0462095de6cbbbfaa9f5dc94b3e;hpb=93b0f9c080cbb3dd807850ad60dbe211fc5bc703;p=lyx.git diff --git a/src/RowPainter.cpp b/src/RowPainter.cpp index fbe35792a2..77e0ff67e6 100644 --- a/src/RowPainter.cpp +++ b/src/RowPainter.cpp @@ -10,7 +10,6 @@ */ #include -#include #include "RowPainter.h" @@ -19,6 +18,7 @@ #include "Cursor.h" #include "BufferParams.h" #include "BufferView.h" +#include "Bullet.h" #include "Changes.h" #include "Language.h" #include "Layout.h" @@ -26,24 +26,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; @@ -54,104 +49,83 @@ using frontend::FontMetrics; RowPainter::RowPainter(PainterInfo & pi, - Text const & text, pit_type pit, Row const & row, int x, int y) + Text const & text, Row const & row, int x, int y) : pi_(pi), text_(text), - text_metrics_(pi_.base.bv->textMetrics(&text)), - pars_(text.paragraphs()), - row_(row), pit_(pit), par_(text.paragraphs()[pit]), - pm_(text_metrics_.parMetrics(pit)), change_(pi_.change_), - xo_(x), yo_(y), width_(text_metrics_.width()), - solid_line_thickness_(1.0), solid_line_offset_(1), - dotted_line_thickness_(1.0), dotted_line_offset_(2) + tm_(pi_.base.bv->textMetrics(&text)), + row_(row), par_(text.paragraphs()[row.pit()]), + xo_(x), yo_(y) { - bidi_.computeTables(par_, pi_.base.bv->buffer(), row_); - - if (lyxrc.zoom >= 200) { - // derive the line thickness from zoom factor - // the zoom is given in percent - // (increase thickness at 250%, 450% etc.) - solid_line_thickness_ = (float)(int((lyxrc.zoom + 50) / 200.0)); - // adjust line_offset_ too - solid_line_offset_ = 1 + int(0.5 * solid_line_thickness_); - } - if (lyxrc.zoom >= 100) { - // derive the line thickness from zoom factor - // the zoom is given in percent - // (increase thickness at 150%, 250% etc.) - dotted_line_thickness_ = (float)(int((lyxrc.zoom + 50) / 100.0)); - // adjust line_offset_ too - dotted_line_offset_ = int(0.5 * dotted_line_thickness_) + 1; - } - x_ = row_.left_margin + xo_; //lyxerr << "RowPainter: x: " << x_ << " xo: " << xo_ << " yo: " << yo_ << endl; //row_.dump(); - LBUFERR(pit >= 0); - LBUFERR(pit < int(text.paragraphs().size())); + LBUFERR(row.pit() >= 0); + LBUFERR(row.pit() < int(text.paragraphs().size())); } -FontInfo RowPainter::labelFont() const +FontInfo RowPainter::labelFont(bool end) const { - FontInfo f = text_.labelFont(par_); + FontInfo f = tm_.labelDisplayFont(row_.pit()).fontInfo(); // 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; } -int RowPainter::leftMargin() const -{ - return text_metrics_.leftMargin(text_metrics_.width(), pit_, - row_.pos()); -} - // If you want to debug inset metrics uncomment the following line: //#define DEBUG_METRICS // This draws green lines around each inset. -void RowPainter::paintInset(Inset const * inset, pos_type const pos) +void RowPainter::paintInset(Row::Element const & e) const { - Font const font = text_metrics_.displayFont(pit_, pos); - - LASSERT(inset, return); + // Handle selection (first left/right, then middle). + pi_.selected_left = pi_.selected + || (row_.isRTL() ? row_.end_margin_sel : row_.begin_margin_sel); + pi_.selected_right = pi_.selected + || (row_.isRTL() ? row_.begin_margin_sel : row_.end_margin_sel); + bool const pi_selected = pi_.selected; + Cursor const & cur = pi_.base.bv->cursor(); + if (cur.selection() && cur.text() == &text_ + && cur.normalAnchor().text() == &text_) + pi_.selected = row_.sel_beg <= e.pos && row_.sel_end > e.pos; + + LASSERT(e.inset, return); // Backup full_repaint status because some insets (InsetTabular) // 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; - pi_.base.font = inset->inheritFont() ? font.fontInfo() : + pi_.base.font = e.inset->inheritFont() ? e.font.fontInfo() : pi_.base.bv->buffer().params().getFont().fontInfo(); - pi_.ltr_pos = (bidi_.level(pos) % 2 == 0); - Change prev_change = change_; - pi_.change_ = change_.changed() ? change_ : par_.lookupChange(pos); - pi_.do_spellcheck &= inset->allowSpellCheck(); + pi_.base.outer_font = e.font.fontInfo(); + pi_.ltr_pos = !e.font.isVisibleRightToLeft(); + pi_.change = pi_.change.changed() ? pi_.change : e.change; + pi_.do_spellcheck &= e.inset->allowSpellCheck(); int const x1 = int(x_); - pi_.base.bv->coordCache().insets().add(inset, x1, yo_); + pi_.base.bv->coordCache().insets().add(e.inset, x1, yo_); // insets are painted completely. Recursive // FIXME: it is wrong to completely paint the background // if we want to do single row painting. - inset->drawBackground(pi_, x1, yo_); - inset->drawSelection(pi_, x1, yo_); - inset->draw(pi_, x1, yo_); - - Dimension const & dim = pm_.insetDimension(inset); - - paintForeignMark(x_, font.language(), dim.descent()); - - x_ += dim.width(); + 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_ = prev_change; + pi_.change = pi_change; pi_.do_spellcheck = pi_do_spellcheck; + pi_.selected = pi_selected; #ifdef DEBUG_METRICS + Dimension const & dim = pi_.base.bv->coordCache().insets().dim(e.inset); int const x2 = x1 + dim.wid; int const y1 = yo_ + dim.des; int const y2 = yo_ - dim.asc; @@ -163,202 +137,172 @@ void RowPainter::paintInset(Inset const * inset, pos_type const pos) } -void RowPainter::paintChars(pos_type & vpos, Font const & font) +void RowPainter::paintLanguageMarkings(Row::Element const & e) const { - // This method takes up 70% of time when typing - pos_type pos = bidi_.vis2log(vpos); - pos_type start_pos = pos; - // first character - docstring str; - str.reserve(100); - char_type const c = par_.getChar(pos); - str.push_back(c); - - FontSpan const font_span = par_.fontSpan(pos); - // Track-change status. - Change const & change_running = par_.lookupChange(pos); - // spelling correct? - bool const spell_state = - lyxrc.spellcheck_continuously && par_.isMisspelled(pos); - - // collect as much similar chars as we can - pos_type const end = row_.endpos(); - for (++vpos ; vpos < end ; ++vpos) { - pos = bidi_.vis2log(vpos); - - if (!font_span.contains(pos)) - break; + paintForeignMark(e); + paintNoSpellingMark(e); +} - bool const new_spell_state = - lyxrc.spellcheck_continuously && par_.isMisspelled(pos); - if (new_spell_state != spell_state) - // Spell checker state changed here. - break; - Change const & change = par_.lookupChange(pos); - if (!change_running.isSimilarTo(change)) - // Track change type or author has changed. - break; +void RowPainter::paintForeignMark(Row::Element const & e) const +{ + Language const * lang = e.font.language(); + if (!lyxrc.mark_foreign_language) + return; + if (lang == latex_language) + return; + if (lang == pi_.base.bv->buffer().params().language) + return; - char_type const c = par_.getChar(pos); + int const desc = e.inset ? e.dim.descent() : 0; + 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()); +} - if (c == '\t') - break; - if (!isPrintableNonspace(c)) - break; +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()); +} - str.push_back(c); + +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 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 + // don't draw misspelled marker for words at cursor position + // we don't want to disturb the process of text editing + DocIterator const nw = pi_.base.bv->cursor().newWord(); + pos_type cpos = -1; + if (!nw.empty() && par_.id() == nw.paragraph().id()) { + cpos = nw.pos(); + if (cpos > 0 && cpos == par_.size() && !par_.isWordSeparator(cpos-1)) + --cpos; + else if (cpos > 0 && par_.isWordSeparator(cpos)) + --cpos; } - // Make pos point to the last character in the string. - // Using "pos = bidi_.vis2log(vpos)" does not work for some reason. - if (vpos < end) - pos = bidi_.vis2log(vpos - 1); + pos_type pos = e.pos; + while (pos < e.pos + pos_type(e.str.length())) { + if (!par_.isMisspelled(pos)) { + ++pos; + continue; + } - // Now make pos point to the position _after_ the string. - // Using vis2log for that is not a good idea in general, we - // want logical ordering. - if (font.isVisibleRightToLeft()) - --pos; - else - ++pos; - - if (str[0] == '\t') - str.replace(0,1,from_ascii(" ")); - - /* Because we do our own bidi, at this point the strings are - * already in visual order. However, Qt also applies its own - * bidi algorithm to strings that it paints to the screen. - * Therefore, if we were to paint Hebrew/Arabic words as a - * single string, the letters in the words would get reversed - * again. In order to avoid that, we force LTR drawing. - * See also http://thread.gmane.org/gmane.editors.lyx.devel/79740 - * for an earlier thread on the subject - */ - if (font.isVisibleRightToLeft()) { - reverse(str.begin(), str.end()); - // If the string is reversed, the positions need to be adjusted - ++pos; - ++start_pos; - swap(start_pos, pos); + FontSpan const & range = par_.getSpellRange(pos); + + // Skip element which are being edited + if (range.contains(cpos)) { + // the range includes the last element + pos = range.last + 1; + continue; + } + + 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, + pos_type(e.str.length())), + e.isRTL(), e.extra); + if (x1 > x2) + swap(x1, x2); + + pi_.pain.line(int(x_ + x1), y, int(x_ + x2), y, + Color_error, + Painter::line_onoffdash, thickness); + pos = range.last + 1; } +} + +void RowPainter::paintStringAndSel(Row::Element const & e) const +{ // at least part of text selected? - bool const some_sel = (pos >= row_.sel_beg && start_pos < row_.sel_end) + bool const some_sel = (e.endpos >= row_.sel_beg && e.pos < row_.sel_end) || pi_.selected; // all the text selected? - bool const all_sel = (start_pos >= row_.sel_beg && pos < row_.sel_end) + bool const all_sel = (e.pos >= row_.sel_beg && e.endpos < row_.sel_end) || pi_.selected; - if (all_sel) { - Font copy = font; - copy.fontInfo().setPaintColor(Color_selectiontext); - x_ += pi_.pain.text(int(x_), yo_, str, copy); - } else if (change_running.changed()) { - Font copy = font; - copy.fontInfo().setPaintColor(change_running.color()); - x_ += pi_.pain.text(int(x_), yo_, str, copy); + if (all_sel || e.change.changed()) { + Font copy = e.font; + Color const col = e.change.changed() ? e.change.color() + : Color_selectiontext; + copy.fontInfo().setPaintColor(col); + pi_.pain.text(int(x_), yo_, e.str, copy, e.extra, e.full_width()); } else if (!some_sel) { - x_ += pi_.pain.text(int(x_), yo_, str, font); + pi_.pain.text(int(x_), yo_, e.str, e.font, e.extra, e.full_width()); } else { - x_ += pi_.pain.text(int(x_), yo_, str, font, Color_selectiontext, - max(row_.sel_beg, start_pos) - start_pos, - min(row_.sel_end, pos) - start_pos); + pi_.pain.text(int(x_), yo_, e.str, e.font, Color_selectiontext, + max(row_.sel_beg, e.pos) - e.pos, + min(row_.sel_end, e.endpos) - e.pos, + e.extra, e.full_width()); } } -void RowPainter::paintSeparator(double orig_x, double width, - FontInfo const & font) +void RowPainter::paintTextDecoration(Row::Element const & e) const { - pi_.pain.textDecoration(font, int(orig_x), yo_, int(width)); - x_ += width; -} - - -void RowPainter::paintForeignMark(double orig_x, Language const * lang, - int desc) -{ - if (!lyxrc.mark_foreign_language) - return; - if (lang == latex_language) - return; - if (lang == pi_.base.bv->buffer().params().language) - return; - - int const y = yo_ + solid_line_offset_ + desc + int(solid_line_thickness_/2); - pi_.pain.line(int(orig_x), y, int(x_), y, Color_language, - Painter::line_solid, solid_line_thickness_); -} - - -void RowPainter::paintMisspelledMark(double orig_x, bool changed) -{ - // if changed the misspelled marker gets placed slightly lower than normal - // to avoid drawing at the same vertical offset - float const y = yo_ + solid_line_offset_ + solid_line_thickness_ - + (changed ? solid_line_thickness_ + 1 : 0) - + dotted_line_offset_; - pi_.pain.line(int(orig_x), int(y), int(x_), int(y), Color_error, - Painter::line_onoffdash, dotted_line_thickness_); + // 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::paintFromPos(pos_type & vpos, bool changed) +void RowPainter::paintChange(Row::Element const & e) const { - pos_type const pos = bidi_.vis2log(vpos); - Font const font = text_metrics_.displayFont(pit_, pos); - double const orig_x = x_; - - paintChars(vpos, font); - paintForeignMark(orig_x, font.language()); - - // Paint the spelling mark if needed. - if (lyxrc.spellcheck_continuously && par_.isMisspelled(pos)) { - // check for cursor position - // don't draw misspelled marker for words at cursor position - // we don't want to disturb the process of text editing - BufferView const * bv = pi_.base.bv; - DocIterator const nw = bv->cursor().newWord(); - bool new_word = false; - if (!nw.empty() && par_.id() == nw.paragraph().id()) { - pos_type cpos = nw.pos(); - if (cpos > 0 && cpos == par_.size() && !par_.isWordSeparator(cpos-1)) - --cpos; - else if (cpos > 0 && par_.isWordSeparator(cpos)) - --cpos; - new_word = par_.isSameSpellRange(pos, cpos) ; - } - if (!new_word) - paintMisspelledMark(orig_x, changed); - } + e.change.paintCue(pi_, x_, yo_, x_ + e.full_width(), e.font.fontInfo()); } -void RowPainter::paintChangeBar() +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(pit_, row_) - ? row_.ascent() - : row_.height(); - - pi_.pain.fillRectangle(5, yo_ - row_.ascent(), 3, height, Color_changebar); + int const x = pi_.base.bv->leftMargin() - pi_.base.bv->zoomedPixels(7); + Dimension const & cdim = row_.contents_dim(); + pi_.pain.fillRectangle(x, yo_ - cdim.ascent(), + 3, cdim.height(), Color_changebar); } -void RowPainter::paintAppendix() +void RowPainter::paintAppendix() const { // only draw the appendix frame once (for the main text) if (!par_.params().appendix() || !text_.isMainText()) @@ -370,31 +314,32 @@ void RowPainter::paintAppendix() 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() +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(pit_, row_)) { - pit_type pit2 = pit_; + 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(pit_, row_)) { - pit_type pit2 = pit_; - if (row_.endpos() >= pars_[pit2].size()) + if (!tm_.isLastRow(row_)) { + pit_type pit2 = row_.pit(); + 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) { @@ -402,7 +347,7 @@ void RowPainter::paintDepthBar() int x = int(xo_) + w * i; // only consider the changebar space if we're drawing outermost text if (text_.isMainText()) - x += changebarMargin(); + x += pi_.base.bv->leftMargin() - changebarMargin(); int const starty = yo_ - row_.ascent(); int const h = row_.height() - 1 - (i - next_depth - 1) * 3; @@ -417,7 +362,7 @@ void RowPainter::paintDepthBar() } -int RowPainter::paintAppendixStart(int y) +void RowPainter::paintAppendixStart(int y) const { FontInfo pb_font = sane_font; pb_font.setColor(Color_appendix); @@ -430,105 +375,88 @@ int RowPainter::paintAppendixStart(int y) 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); - - return 3 * defaultRowHeight(); + pi_.pain.line(text_end, y, int(xo_ + tm_.width() - 2), y, Color_appendix); } -void RowPainter::paintTooLargeMarks(bool const left, bool const right) +void RowPainter::paintTooLargeMarks(bool const left, bool const right) const { - if (left) - pi_.pain.line(int(dotted_line_thickness_), yo_ - row_.ascent(), - int(dotted_line_thickness_), yo_ + row_.descent(), - Color_scroll, - Painter::line_onoffdash, dotted_line_thickness_); + int const lwid = pi_.base.dottedLineThickness(); + Dimension const & cdim = row_.contents_dim(); + if (left) { + int const x = pi_.base.bv->leftMargin() - lwid; + pi_.pain.line(x, yo_ - cdim.ascent(), x, yo_ + cdim.descent(), + Color_scroll, Painter::line_onoffdash, lwid); + } if (right) { - int const wwidth = pi_.base.bv->workWidth() - int(dotted_line_thickness_); - pi_.pain.line(wwidth, yo_ - row_.ascent(), - wwidth, yo_ + row_.descent(), - Color_scroll, - Painter::line_onoffdash, dotted_line_thickness_); + int const x = pi_.base.bv->workWidth() - pi_.base.bv->rightMargin(); + pi_.pain.line(x, yo_ - cdim.ascent(), x, yo_ + cdim.descent(), + Color_scroll, Painter::line_onoffdash, lwid); } } -void RowPainter::paintFirst() +void RowPainter::paintFirst() const { - BufferParams const & bparams = pi_.base.bv->buffer().params(); Layout const & layout = par_.layout(); - int y_top = 0; - // start of appendix? if (par_.params().startOfAppendix()) - y_top += paintAppendixStart(yo_ - row_.ascent() + 2 * defaultRowHeight()); - - if (bparams.paragraph_separation == BufferParams::ParagraphSkipSeparation - && pit_ != 0) { - if (layout.latextype == LATEX_PARAGRAPH - && !par_.getDepth()) { - y_top += bparams.getDefSkip().inPixels(*pi_.base.bv); - } else { - Layout const & playout = pars_[pit_ - 1].layout(); - if (playout.latextype == LATEX_PARAGRAPH - && !pars_[pit_ - 1].getDepth()) { - // is it right to use defskip here, too? (AS) - y_top += bparams.getDefSkip().inPixels(*pi_.base.bv); - } - } - } + paintAppendixStart(yo_ - row_.ascent() + 2 * defaultRowHeight()); bool const is_first = - text_.isFirstInSequence(pit_) || !layout.isParagraphGroup(); + text_.isFirstInSequence(row_.pit()) || !layout.isParagraphGroup(); //lyxerr << "paintFirst: " << par_.id() << " is_seq: " << is_seq << endl; if (layout.labelIsInline() - && (layout.labeltype != LABEL_STATIC || is_first)) { + && (layout.labeltype != LABEL_STATIC || is_first)) paintLabel(); - } else if (is_first && layout.labelIsAbove()) { + else if (is_first && layout.labelIsAbove()) paintTopLevelLabel(); - } } -void RowPainter::paintLabel() +void RowPainter::paintLabel() const { - docstring const str = par_.labelString(); + docstring const & str = par_.labelString(); if (str.empty()) return; - bool const is_rtl = text_.isRTL(par_); + // different font for label separation and string 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_ - leftMargin() - + fm.width(layout.labelsep); - } else { - x = x_ - fm.width(layout.labelsep) - - fm.width(str); + FontInfo lfont = font; + + // bullet? + if (layout.labeltype == LABEL_ITEMIZE && par_.itemdepth < 4) { + // get label font size from document properties + lfont.setSize(pi_.base.bv->buffer().params().user_defined_bullet(par_.itemdepth).getFontSize()); + // realize to avoid assertion + lfont.realize(sane_font); } - pi_.pain.text(int(x), yo_, str, font); + FontMetrics const & lfm = theFontMetrics(lfont); + + int const x = row_.isRTL() ? row_.width() + fm.width(layout.labelsep) + : row_.left_margin - fm.width(layout.labelsep) - lfm.width(str); + + pi_.pain.text(int(xo_) + x, yo_, str, lfont); } -void RowPainter::paintTopLevelLabel() +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; @@ -550,117 +478,66 @@ void RowPainter::paintTopLevelLabel() double x = x_; if (layout.labeltype == LABEL_CENTERED) { - if (is_rtl) - x = leftMargin(); - x += (width_ - text_metrics_.rightMargin(pm_) - leftMargin()) / 2; - x -= fm.width(str) / 2; - } else if (is_rtl) { - x = width_ - leftMargin() - fm.width(str); + // The 'size + 1' is weird, but it makes sure that we get the + // left margin of non-first row. + int leftm = tm_.leftMargin(row_.pit(), par_.size() + 1); + int rightm = tm_.rightMargin(row_.pit()); + if (row_.isRTL()) + swap(leftm, rightm); + /* 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. + */ + 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) +void RowPainter::paintLast() const { - 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() -{ - bool const is_rtl = text_.isRTL(par_); - int const endlabel = getEndLabel(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 - text_metrics_.rightMargin(pm_); // 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_; - pi_.pain.text(int(x), yo_, str, font); + double const x = row_.isRTL() ? row_.left_margin - fm.width(str) : row_.width(); + pi_.pain.text(xo_ + x, yo_, str, font); break; } case END_LABEL_NO_LABEL: - if (lyxrc.paragraph_markers && size_type(pit_ + 1) < pars_.size()) { - docstring const s = docstring(1, char_type(0x00B6)); - FontInfo f = FontInfo(text_.layoutFont(pit_)); - f.setColor(Color_paragraphmarker); - pi_.pain.text(int(x_), yo_, s, f); - x_ += theFontMetrics(f).width(s); - } break; } } @@ -668,328 +545,136 @@ void RowPainter::paintLast() void RowPainter::paintOnlyInsets() { - CoordCache const & cache = pi_.base.bv->coordCache(); - pos_type const end = row_.endpos(); - for (pos_type pos = row_.pos(); pos != end; ++pos) { - // If outer row has changed, nested insets are repaint completely. - Inset const * inset = par_.getInset(pos); - bool const nested_inset = inset && - ((inset->asInsetMath() && - !inset->asInsetMath()->asMacroTemplate()) - || inset->asInsetText() - || inset->asInsetTabular()); - if (!nested_inset) - continue; - if (x_ > pi_.base.bv->workWidth() - || !cache.getInsets().has(inset)) - continue; - x_ = cache.getInsets().x(inset); - - bool const pi_selected = pi_.selected; - Cursor const & cur = pi_.base.bv->cursor(); - if (cur.selection() && cur.text() == &text_ - && cur.normalAnchor().text() == &text_) - pi_.selected = row_.sel_beg <= pos && row_.sel_end > pos; - paintInset(inset, pos); - pi_.selected = pi_selected; + for (Row::Element const & e : row_) { + if (e.type == Row::INSET) { + 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(); } } void RowPainter::paintText() { - //LYXERR0("-------------------------------------------------------"); - pos_type const end = row_.endpos(); - // Spaces at logical line breaks in bidi text must be skipped during - // painting. However, they may appear visually in the middle - // of a row; they must be skipped, wherever they are... - // * logically "abc_[HEBREW_\nHEBREW]" - // * visually "abc_[_WERBEH\nWERBEH]" - pos_type skipped_sep_vpos = -1; - pos_type body_pos = par_.beginOfBody(); - if (body_pos > 0 && - (body_pos > end || !par_.isLineSeparator(body_pos - 1))) { - body_pos = 0; - } - - Layout const & layout = par_.layout(); - - Change change_running; - int change_last_x = 0; - - // check for possible inline completion - DocIterator const & inlineCompletionPos = pi_.base.bv->inlineCompletionPos(); - pos_type inlineCompletionVPos = -1; - if (inlineCompletionPos.inTexted() - && inlineCompletionPos.text() == &text_ - && inlineCompletionPos.pit() == pit_ - && inlineCompletionPos.pos() - 1 >= row_.pos() - && inlineCompletionPos.pos() - 1 < row_.endpos()) { - // draw logically behind the previous character - inlineCompletionVPos = bidi_.log2vis(inlineCompletionPos.pos() - 1); - } - - // Use font span to speed things up, see below - FontSpan font_span; - Font font; - - // If the last logical character is a separator, don't paint it, unless - // 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); - - for (pos_type vpos = row_.pos(); vpos < end; ) { - if (x_ > pi_.base.bv->workWidth()) + 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.isNull()) + paintMisspelledMark(e); break; - // Skip the separator at the logical end of the row - if (vpos == skipped_sep_vpos) { - ++vpos; - continue; - } - - pos_type const pos = bidi_.vis2log(vpos); - - if (pos >= par_.size()) { - ++vpos; - continue; - } - - // Use font span to speed things up, see above - if (!font_span.contains(pos)) { - font_span = par_.fontSpan(pos); - font = text_metrics_.displayFont(pit_, pos); - - // split font span if inline completion is inside - if (inlineCompletionVPos != -1 - && font_span.contains(inlineCompletionPos.pos())) - font_span.last = inlineCompletionPos.pos(); - } - - // Note that this value will only be used in - // situations where no ligature of composition of - // characters is needed. (see comments in uses of width_pos). - const int width_pos = pm_.singleWidth(pos, font); - - Change const & change = par_.lookupChange(pos); - if (change.changed() && !change_running.changed()) { - change_running = change; - change_last_x = int(x_); - } - - Inset const * inset = par_.getInset(pos); - bool const highly_editable_inset = inset - && inset->editable(); - - // If we reach the end of a change or if the author changes, paint it. - // We also don't paint across things like tables - if (change_running.changed() && (highly_editable_inset - || !change.changed() || !change_running.isSimilarTo(change))) { - // Calculate 1/3 height of the buffer's default font - FontMetrics const & fm - = theFontMetrics(pi_.base.bv->buffer().params().getFont()); - float const y_bar = change_running.deleted() ? - yo_ - fm.maxAscent() / 3 : yo_ + 2 * solid_line_offset_ + solid_line_thickness_; - pi_.pain.line(change_last_x, int(y_bar), int(x_), int(y_bar), - change_running.color(), Painter::line_solid, solid_line_thickness_); - - // Change might continue with a different author or type - if (change.changed() && !highly_editable_inset) { - change_running = change; - change_last_x = int(x_); - } else - change_running.setUnchanged(); - } - - if (body_pos > 0 && pos == body_pos - 1) { - int const lwidth = theFontMetrics(labelFont()) - .width(layout.labelsep); + case Row::INSET: + paintInset(e); + break; - // width_pos is either the width of a space or an inset - x_ += row_.label_hfill + lwidth - width_pos; + case Row::SPACE: + case Row::MARGINSPACE: + paintTextDecoration(e); } - // Is the inline completion in front of character? - if (font.isRightToLeft() && vpos == inlineCompletionVPos) - paintInlineCompletion(font); - - if (par_.isSeparator(pos)) { - Font const orig_font = text_metrics_.displayFont(pit_, pos); - double const orig_x = x_; - // width_pos is the width of a space - double separator_width = width_pos; - if (pos >= body_pos) - separator_width += row_.separator; - paintSeparator(orig_x, separator_width, orig_font.fontInfo()); - paintForeignMark(orig_x, orig_font.language()); - ++vpos; - - } else if (inset) { - // If outer row has changed, nested insets are repaint completely. - pi_.base.bv->coordCache().insets().add(inset, int(x_), yo_); - - bool const pi_selected = pi_.selected; - Cursor const & cur = pi_.base.bv->cursor(); - if (cur.selection() && cur.text() == &text_ - && cur.normalAnchor().text() == &text_) - pi_.selected = row_.sel_beg <= pos && row_.sel_end > pos; - paintInset(inset, pos); - pi_.selected = pi_selected; - ++vpos; + // The markings of foreign languages + // and of text ignored for spellchecking + paintLanguageMarkings(e); - } else { - // paint as many characters as possible. - paintFromPos(vpos, change_running.changed()); - } + // change tracking (not for insets that handle it themselves) + if (e.type != Row::INSET || ! e.inset->canPaintChange(*pi_.base.bv)) + paintChange(e); - // Is the inline completion after character? - if (!font.isRightToLeft() && vpos - 1 == inlineCompletionVPos) - paintInlineCompletion(font); - } - - // if we reach the end of a struck out range, paint it - if (change_running.changed()) { - FontMetrics const & fm - = theFontMetrics(pi_.base.bv->buffer().params().getFont()); - float const y_bar = change_running.deleted() ? - yo_ - fm.maxAscent() / 3 : yo_ + 2 * solid_line_offset_ + solid_line_thickness_; - pi_.pain.line(change_last_x, int(y_bar), int(x_), int(y_bar), - change_running.color(), Painter::line_solid, solid_line_thickness_); - change_running.setUnchanged(); + x_ += e.full_width(); } } -void RowPainter::paintSelection() +void RowPainter::paintSelection() const { if (!row_.selection()) return; - Cursor const & curs = pi_.base.bv->cursor(); - 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(); - - 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); - - // 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); - } + int const y1 = yo_ - row_.contents_dim().asc; + int const y2 = yo_ + row_.contents_dim().des; - if (x1 == -1) { - // the previous segment was just drawn, now the next starts - x1 = text_metrics_.cursorX(cur.top(), cur.boundary()); - } + // The top selection + if (row_.begin_margin_sel) + pi_.pain.fillRectangle(int(xo_), yo_ - row_.ascent(), + tm_.width(), row_.ascent() - row_.contents_dim().asc, + Color_selection); - 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); + // The left margin selection + if (row_.isRTL() ? row_.end_margin_sel : row_.begin_margin_sel) + pi_.pain.fillRectangle(int(xo_), y1, row_.left_margin, 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; + // go through row and draw from RTL boundary to RTL 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(); } + + // the right margin 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); + // The bottom selection + if (row_.end_margin_sel) + pi_.pain.fillRectangle(int(xo_), yo_ + row_.contents_dim().des, + tm_.width(), row_.descent() - row_.contents_dim().des, + Color_selection); } -void RowPainter::paintInlineCompletion(Font const & font) +void RowPainter::paintBookmark(int num) const { - docstring completion = pi_.base.bv->inlineCompletion(); - FontInfo f = font.fontInfo(); - bool rtl = font.isRightToLeft(); - - // draw the unique and the non-unique completion part - // Note: this is not time-critical as it is - // only done once per screen. - size_t uniqueTo = pi_.base.bv->inlineCompletionUniqueChars(); - docstring s1 = completion.substr(0, uniqueTo); - docstring s2 = completion.substr(uniqueTo); - ColorCode c1 = Color_inlinecompletion; - ColorCode c2 = Color_nonunique_inlinecompletion; - - // right to left? - if (rtl) { - swap(s1, s2); - swap(c1, c2); - } - - if (!s1.empty()) { - f.setColor(c1); - pi_.pain.text(int(x_), yo_, s1, f); - x_ += theFontMetrics(font).width(s1); - } - - if (!s2.empty()) { - f.setColor(c2); - pi_.pain.text(int(x_), yo_, s2, f); - x_ += theFontMetrics(font).width(s2); - } + BufferView const * bv = pi_.base.bv; + FontInfo fi = bv->buffer().params().getFont().fontInfo(); + FontMetrics const & fm = theFontMetrics(fi); + fi.setColor(Color_bookmark); + // ❶ U+2776 DINGBAT NEGATIVE CIRCLED DIGIT ONE + char_type const ch = 0x2775 + num; + int const x = row_.isRTL() + ? bv->workWidth() - bv->rightMargin() + (bv->defaultMargin() - fm.width(ch)) / 2 + : bv->leftMargin() - (bv->defaultMargin() + fm.width(ch)) / 2; + pi_.pain.text(x, yo_, ch, fi); } + } // namespace lyx