X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Frowpainter.cpp;h=5810fd66e5c4726ceea15c59fa20bf6094936b98;hb=3b9caa3b0d4ceb5e89f170c8dfa9fe27ab28cbd6;hp=cc10856e51d558554216f955791d184bcf3c39e9;hpb=1cca0a86bdd43b08af7cb02db78e2621abe9465d;p=lyx.git diff --git a/src/rowpainter.cpp b/src/rowpainter.cpp index cc10856e51..5810fd66e5 100644 --- a/src/rowpainter.cpp +++ b/src/rowpainter.cpp @@ -10,6 +10,7 @@ */ #include +#include #include "rowpainter.h" @@ -21,7 +22,6 @@ #include "BufferView.h" #include "Changes.h" #include "Encoding.h" -#include "support/gettext.h" #include "Language.h" #include "Layout.h" #include "LyXRC.h" @@ -29,7 +29,6 @@ #include "MetricsInfo.h" #include "Paragraph.h" #include "ParagraphMetrics.h" -#include "paragraph_funcs.h" #include "ParagraphParameters.h" #include "TextMetrics.h" #include "VSpace.h" @@ -39,13 +38,15 @@ #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; namespace lyx { @@ -53,6 +54,7 @@ namespace lyx { using frontend::Painter; using frontend::FontMetrics; + RowPainter::RowPainter(PainterInfo & pi, Text const & text, pit_type pit, Row const & row, Bidi & bidi, int x, int y) : pi_(pi), text_(text), @@ -60,23 +62,47 @@ RowPainter::RowPainter(PainterInfo & pi, pars_(text.paragraphs()), row_(row), pit_(pit), par_(text.paragraphs()[pit]), pm_(text_metrics_.parMetrics(pit)), - bidi_(bidi), erased_(pi_.erased_), - xo_(x), yo_(y), width_(text_metrics_.width()) + bidi_(bidi), 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) { 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_.x + xo_; //lyxerr << "RowPainter: x: " << x_ << " xo: " << xo_ << " yo: " << yo_ << endl; //row_.dump(); - BOOST_ASSERT(pit >= 0); - BOOST_ASSERT(pit < int(text.paragraphs().size())); + LASSERT(pit >= 0, /**/); + LASSERT(pit < int(text.paragraphs().size()), /**/); } FontInfo RowPainter::labelFont() const { - return text_.labelFont(pi_.base.bv->buffer(), par_); + FontInfo f = text_.labelFont(par_); + // selected text? + if (row_.begin_margin_sel || pi_.selected) + f.setPaintColor(Color_selectiontext); + return f; } @@ -95,22 +121,25 @@ void RowPainter::paintInset(Inset const * inset, pos_type const pos) { Font const font = text_metrics_.displayFont(pit_, pos); - BOOST_ASSERT(inset); + LASSERT(inset, return); // Backup full_repaint status because some insets (InsetTabular) // requires a full repaint bool pi_full_repaint = pi_.full_repaint; - // FIXME: We should always use font, see documentation of - // noFontChange() in Inset.h. - pi_.base.font = inset->noFontChange() ? - pi_.base.bv->buffer().params().getFont().fontInfo() : - font.fontInfo(); + pi_.base.font = inset->inheritFont() ? font.fontInfo() : + pi_.base.bv->buffer().params().getFont().fontInfo(); pi_.ltr_pos = (bidi_.level(pos) % 2 == 0); - pi_.erased_ = erased_ || par_.isDeleted(pos); - pi_.base.bv->coordCache().insets().add(inset, int(x_), yo_); + Change prev_change = change_; + pi_.change_ = change_.changed() ? change_ : par_.lookupChange(pos); + + int const x1 = int(x_); + pi_.base.bv->coordCache().insets().add(inset, x1, yo_); // insets are painted completely. Recursive - inset->drawSelection(pi_, int(x_), yo_); - inset->draw(pi_, int(x_), yo_); + // 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); @@ -120,30 +149,9 @@ void RowPainter::paintInset(Inset const * inset, pos_type const pos) // Restore full_repaint status. pi_.full_repaint = pi_full_repaint; + pi_.change_ = prev_change; #ifdef DEBUG_METRICS - int const x1 = int(x_ - dim.width()); - Dimension dim2; - BOOST_ASSERT(max_witdh_ > 0); - int right_margin = text_metrics_.rightMargin(pm_); - int const w = max_witdh_ - leftMargin() - right_margin; - MetricsInfo mi(pi_.base.bv, font.fontInfo(), w); - inset->metrics(mi, dim2); - if (dim.wid != dim2.wid) - lyxerr << "Error: inset " << to_ascii(inset->getInsetName()) - << " draw width " << dim.width() - << "> metrics width " << dim2.wid << "." << endl; - if (dim->asc != dim2.asc) - lyxerr << "Error: inset " << to_ascii(inset->getInsetName()) - << " draw ascent " << dim.ascent() - << "> metrics ascent " << dim2.asc << "." << endl; - if (dim2.descent() != dim.des) - lyxerr << "Error: inset " << to_ascii(inset->getInsetName()) - << " draw ascent " << dim.descent() - << "> metrics descent " << dim2.des << "." << endl; - BOOST_ASSERT(dim2.wid == dim.wid); - BOOST_ASSERT(dim2.asc == dim.asc); - BOOST_ASSERT(dim2.des == dim.des); int const x2 = x1 + dim.wid; int const y1 = yo_ + dim.des; int const y2 = yo_ - dim.asc; @@ -171,7 +179,7 @@ void RowPainter::paintHebrewComposeChar(pos_type & vpos, FontInfo const & font) for (pos_type i = pos - 1; i >= 0; --i) { c = par_.getChar(i); - if (!Encodings::isComposeChar_hebrew(c)) { + if (!Encodings::isHebrewComposeChar(c)) { if (isPrintableNonspace(c)) { int const width2 = pm_.singleWidth(i, text_metrics_.displayFont(pit_, i)); @@ -205,7 +213,7 @@ void RowPainter::paintArabicComposeChar(pos_type & vpos, FontInfo const & font) for (pos_type i = pos - 1; i >= 0; --i) { c = par_.getChar(i); - if (!Encodings::isComposeChar_arabic(c)) { + if (!Encodings::isArabicComposeChar(c)) { if (isPrintableNonspace(c)) { int const width2 = pm_.singleWidth(i, text_metrics_.displayFont(pit_, i)); @@ -224,15 +232,14 @@ void RowPainter::paintChars(pos_type & vpos, FontInfo const & font, { // This method takes up 70% of time when typing pos_type pos = bidi_.vis2log(vpos); - pos_type const end = row_.endpos(); - FontSpan const font_span = par_.fontSpan(pos); - Change::Type const prev_change = par_.lookupChange(pos).type; - // first character + char_type prev_char = par_.getChar(pos); vector str; str.reserve(100); - str.push_back(par_.getChar(pos)); + str.push_back(prev_char); + // FIXME: Why only round brackets and why the difference to + // Hebrew? See also Paragraph::getUChar if (arabic) { char_type c = str[0]; if (c == '(') @@ -242,17 +249,57 @@ void RowPainter::paintChars(pos_type & vpos, FontInfo const & font, str[0] = par_.transformChar(c, pos); } + pos_type const end = row_.endpos(); + FontSpan const font_span = par_.fontSpan(pos); + // Track-change status. + Change const & change_running = par_.lookupChange(pos); + + // selected text? + bool const selection = (pos >= row_.sel_beg && pos < row_.sel_end) + || pi_.selected; + + // spelling correct? + bool const spell_state = + lyxrc.spellcheck_continuously && par_.isMisspelled(pos); + // collect as much similar chars as we can for (++vpos ; vpos < end ; ++vpos) { + // Work-around bug #6920 + // The bug can be reproduced with DejaVu font under Linux. + // The issue is that we compute the metrics character by character + // in ParagraphMetrics::singleWidth(); but we paint word by word + // for performance reason. + // Maybe a more general fix would be draw character by character + // for some predefined fonts on some platform. In arabic and + // Hebrew we already do paint this way. + if (prev_char == 'f' || lyxrc.force_paint_single_char) + break; + pos = bidi_.vis2log(vpos); if (pos < font_span.first || pos > font_span.last) break; - if (prev_change != par_.lookupChange(pos).type) + bool const new_selection = pos >= row_.sel_beg && pos < row_.sel_end; + if (new_selection != selection) + // Selection ends or starts here. + break; + + 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; char_type c = par_.getChar(pos); + if (c == '\t') + break; + if (!isPrintableNonspace(c)) break; @@ -275,13 +322,15 @@ void RowPainter::paintChars(pos_type & vpos, FontInfo const & font, * of arabic and hebrew characters, then these breaks may have * to be re-applied. - if (arabic && Encodings::isComposeChar_arabic(c)) + if (arabic && Encodings::isArabicComposeChar(c)) break; - if (hebrew && Encodings::isComposeChar_hebrew(c)) + if (hebrew && Encodings::isHebrewComposeChar(c)) break; */ + // FIXME: Why only round brackets and why the difference to + // Hebrew? See also Paragraph::getUChar if (arabic) { if (c == '(') c = ')'; @@ -293,21 +342,34 @@ void RowPainter::paintChars(pos_type & vpos, FontInfo const & font, } str.push_back(c); + prev_char = c; } docstring s(&str[0], str.size()); - if (prev_change != Change::UNCHANGED) { - FontInfo copy = font; - if (prev_change == Change::DELETED) { - copy.setColor(Color_deletedtext); - } else if (prev_change == Change::INSERTED) { - copy.setColor(Color_addedtext); - } - x_ += pi_.pain.text(int(x_), yo_, s, copy); - } else { + if (s[0] == '\t') + s.replace(0,1,from_ascii(" ")); + + if (!selection && !change_running.changed()) { x_ += pi_.pain.text(int(x_), yo_, s, font); + return; } + + FontInfo copy = font; + if (change_running.changed()) + copy.setPaintColor(change_running.color()); + else if (selection) + copy.setPaintColor(Color_selectiontext); + + x_ += pi_.pain.text(int(x_), yo_, s, copy); +} + + +void RowPainter::paintSeparator(double orig_x, double width, + FontInfo const & font) +{ + pi_.pain.textDecoration(font, int(orig_x), yo_, int(width)); + x_ += width; } @@ -321,12 +383,25 @@ void RowPainter::paintForeignMark(double orig_x, Language const * lang, if (lang == pi_.base.bv->buffer().params().language) return; - int const y = yo_ + 1 + desc; - pi_.pain.line(int(orig_x), y, int(x_), y, Color_language); + 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::paintFromPos(pos_type & vpos) +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_); +} + + +void RowPainter::paintFromPos(pos_type & vpos, bool changed) { pos_type const pos = bidi_.vis2log(vpos); Font const orig_font = text_metrics_.displayFont(pit_, pos); @@ -338,13 +413,17 @@ void RowPainter::paintFromPos(pos_type & vpos) // special case languages string const & lang = orig_font.language()->lang(); bool const hebrew = lang == "hebrew"; - bool const arabic = lang == "arabic_arabtex" || lang == "arabic_arabi" || + bool const arabic = lang == "arabic_arabtex" || lang == "arabic_arabi" || lang == "farsi"; + // spelling correct? + bool const misspelled = + lyxrc.spellcheck_continuously && par_.isMisspelled(pos); + // draw as many chars as we can if ((!hebrew && !arabic) - || (hebrew && !Encodings::isComposeChar_hebrew(c)) - || (arabic && !Encodings::isComposeChar_arabic(c))) { + || (hebrew && !Encodings::isHebrewComposeChar(c)) + || (arabic && !Encodings::isArabicComposeChar(c))) { paintChars(vpos, orig_font.fontInfo(), hebrew, arabic); } else if (hebrew) { paintHebrewComposeChar(vpos, orig_font.fontInfo()); @@ -353,6 +432,25 @@ void RowPainter::paintFromPos(pos_type & vpos) } paintForeignMark(orig_x, orig_font.language()); + + if (lyxrc.spellcheck_continuously && misspelled) { + // 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); + } } @@ -381,7 +479,7 @@ void RowPainter::paintChangeBar() void RowPainter::paintAppendix() { // only draw the appendix frame once (for the main text) - if (!par_.params().appendix() || !text_.isMainText(pi_.base.bv->buffer())) + if (!par_.params().appendix() || !text_.isMainText()) return; int y = yo_ - row_.ascent(); @@ -421,7 +519,7 @@ void RowPainter::paintDepthBar() int const w = nestMargin() / 5; int x = int(xo_) + w * i; // only consider the changebar space if we're drawing outermost text - if (text_.isMainText(pi_.base.bv->buffer())) + if (text_.isMainText()) x += changebarMargin(); int const starty = yo_ - row_.ascent(); @@ -464,141 +562,195 @@ int RowPainter::paintAppendixStart(int y) void RowPainter::paintFirst() { - ParagraphParameters const & parparams = par_.params(); + BufferParams const & bparams = pi_.base.bv->buffer().params(); + Layout const & layout = par_.layout(); int y_top = 0; // start of appendix? - if (parparams.startOfAppendix()) + if (par_.params().startOfAppendix()) y_top += paintAppendixStart(yo_ - row_.ascent() + 2 * defaultRowHeight()); - Buffer const & buffer = pi_.base.bv->buffer(); - - LayoutPtr const & layout = par_.layout(); - - if (buffer.params().paragraph_separation == BufferParams::PARSEP_SKIP) { - if (pit_ != 0) { - if (layout->latextype == LATEX_PARAGRAPH - && !par_.getDepth()) { - y_top += buffer.params().getDefSkip().inPixels(*pi_.base.bv); - } else { - LayoutPtr 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 += buffer.params().getDefSkip().inPixels(*pi_.base.bv); - } + 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); } } } - bool const is_rtl = text_.isRTL(buffer, par_); - bool const is_seq = isFirstInSequence(pit_, text_.paragraphs()); + bool const is_seq = text_.isFirstInSequence(pit_); //lyxerr << "paintFirst: " << par_.id() << " is_seq: " << is_seq << endl; - // should we print a label? - if (layout->labeltype >= LABEL_STATIC - && (layout->labeltype != LABEL_STATIC - || layout->latextype != LATEX_ENVIRONMENT - || is_seq)) { + if (layout.labeltype >= LABEL_STATIC + && (layout.labeltype != LABEL_STATIC + || layout.latextype != LATEX_ENVIRONMENT + || is_seq)) { + paintLabel(); + } else if (is_seq + && (layout.labeltype == LABEL_TOP_ENVIRONMENT + || layout.labeltype == LABEL_BIBLIO + || layout.labeltype == LABEL_CENTERED_TOP_ENVIRONMENT)) { + // the labels at the top of an environment. + // More or less for bibliography + paintTopLevelLabel(); + } +} - FontInfo const font = labelFont(); - FontMetrics const & fm = theFontMetrics(font); - docstring const str = par_.labelString(); - if (!str.empty()) { - double x = x_; - - // this is special code for the chapter layout. This is - // printed in an extra row and has a pagebreak at - // the top. - if (layout->counter == "chapter") { - double spacing_val = 1.0; - if (!parparams.spacing().isDefault()) { - spacing_val = parparams.spacing().getValue(); - } else { - spacing_val = buffer.params().spacing().getValue(); - } - - int const labeladdon = int(fm.maxHeight() * layout->spacing.getValue() * spacing_val); - - int const maxdesc = int(fm.maxDescent() * layout->spacing.getValue() * spacing_val) - + int(layout->parsep) * defaultRowHeight(); - - if (is_rtl) { - x = width_ - leftMargin() - - fm.width(str); - } - - pi_.pain.text(int(x), yo_ - maxdesc - labeladdon, str, font); - } else { - if (is_rtl) { - x = width_ - leftMargin() - + fm.width(layout->labelsep); - } else { - x = x_ - fm.width(layout->labelsep) - - fm.width(str); - } - - pi_.pain.text(int(x), yo_, str, font); - } +void RowPainter::paintLabel() +{ + docstring const str = par_.labelString(); + if (str.empty()) + return; + + BufferParams const & bparams = pi_.base.bv->buffer().params(); + bool const is_rtl = text_.isRTL(par_); + Layout const & layout = par_.layout(); + ParagraphParameters const & pparams = par_.params(); + FontInfo const font = labelFont(); + FontMetrics const & fm = theFontMetrics(font); + + double x = x_; + + // this is special code for the chapter layout. This is + // printed in an extra row and has a pagebreak at + // the top. + if (layout.counter == "chapter") { + double spacing_val = 1.0; + if (!pparams.spacing().isDefault()) { + spacing_val = pparams.spacing().getValue(); + } else { + spacing_val = bparams.spacing().getValue(); } - // the labels at the top of an environment. - // More or less for bibliography - } else if (is_seq && - (layout->labeltype == LABEL_TOP_ENVIRONMENT || - layout->labeltype == LABEL_BIBLIO || - layout->labeltype == LABEL_CENTERED_TOP_ENVIRONMENT)) { - FontInfo const font = labelFont(); - docstring const str = par_.labelString(); - if (!str.empty()) { - double spacing_val = 1.0; - if (!parparams.spacing().isDefault()) - spacing_val = parparams.spacing().getValue(); - else - spacing_val = buffer.params().spacing().getValue(); - - FontMetrics const & fm = theFontMetrics(font); - - int const labeladdon = int(fm.maxHeight() - * layout->spacing.getValue() * spacing_val); - - int maxdesc = - int(fm.maxDescent() * layout->spacing.getValue() * spacing_val - + (layout->labelbottomsep * defaultRowHeight())); - - double x = x_; - if (layout->labeltype == LABEL_CENTERED_TOP_ENVIRONMENT) { - 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); - } - pi_.pain.text(int(x), yo_ - maxdesc - labeladdon, str, font); + int const labeladdon = int(fm.maxHeight() * layout.spacing.getValue() * spacing_val); + + int const maxdesc = int(fm.maxDescent() * layout.spacing.getValue() * spacing_val) + + int(layout.parsep) * defaultRowHeight(); + + if (is_rtl) { + x = width_ - leftMargin() - + fm.width(str); + } + + pi_.pain.text(int(x), yo_ - maxdesc - labeladdon, str, font); + } else { + if (is_rtl) { + x = width_ - leftMargin() + + fm.width(layout.labelsep); + } else { + x = x_ - fm.width(layout.labelsep) + - fm.width(str); + } + + pi_.pain.text(int(x), yo_, str, font); + } +} + + +void RowPainter::paintTopLevelLabel() +{ + 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(); + docstring const str = par_.labelString(); + if (str.empty()) + return; + + double spacing_val = 1.0; + if (!pparams.spacing().isDefault()) + spacing_val = pparams.spacing().getValue(); + else + spacing_val = bparams.spacing().getValue(); + + FontMetrics const & fm = theFontMetrics(font); + + int const labeladdon = int(fm.maxHeight() + * layout.spacing.getValue() * spacing_val); + + int maxdesc = + int(fm.maxDescent() * layout.spacing.getValue() * spacing_val + + (layout.labelbottomsep * defaultRowHeight())); + + double x = x_; + if (layout.labeltype == LABEL_CENTERED_TOP_ENVIRONMENT) { + 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); + } + 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() { - bool const is_rtl = text_.isRTL(pi_.base.bv->buffer(), par_); - int const endlabel = getEndLabel(pit_, text_.paragraphs()); + bool const is_rtl = text_.isRTL(par_); + int const endlabel = getEndLabel(pit_, text_); // paint imaginary end-of-paragraph character - if (par_.isInserted(par_.size()) || par_.isDeleted(par_.size())) { - FontMetrics const & fm = theFontMetrics(pi_.base.bv->buffer().params().getFont()); + 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; - ColorCode col = par_.isInserted(par_.size()) ? Color_addedtext : Color_deletedtext; + Color col = change.color(); pi_.pain.line(int(x_) + 1, yo_ + 2, int(x_) + 1, yo_ + 2 - length, col, - Painter::line_solid, Painter::line_thick); - pi_.pain.line(int(x_) + 1 - length, yo_ + 2, int(x_) + 1, yo_ + 2, col, - Painter::line_solid, Painter::line_thick); + 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 @@ -629,15 +781,21 @@ void RowPainter::paintLast() case END_LABEL_STATIC: { FontInfo const font = labelFont(); FontMetrics const & fm = theFontMetrics(font); - docstring const & str = par_.layout()->endlabelstring(); - double const x = is_rtl ? - x_ - fm.width(str) - : - text_metrics_.rightMargin(pm_) - row_.width(); + docstring const & str = par_.layout().endlabelstring(); + double const x = is_rtl ? x_ - fm.width(str) : x_; pi_.pain.text(int(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(); + FontMetrics const & fm = theFontMetrics(f); + f.setColor(Color_paragraphmarker); + pi_.pain.text(int(x_), yo_, s, f); + x_ += fm.width(s); + } break; } } @@ -645,16 +803,30 @@ 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); - if (!inset) + bool const nested_inset = inset && + ((inset->asInsetMath() && + !inset->asInsetMath()->asMacroTemplate()) + || inset->asInsetText() + || inset->asInsetTabular()); + if (!nested_inset) continue; - if (x_ > pi_.base.bv->workWidth()) + if (x_ > pi_.base.bv->workWidth() + || !cache.getInsets().has(inset)) continue; - x_ = pi_.base.bv->coordCache().getInsets().x(inset); + 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; } } @@ -662,7 +834,7 @@ void RowPainter::paintOnlyInsets() void RowPainter::paintText() { 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 // painting. However, they may appear visually in the middle // of a row; they must be skipped, wherever they are... // * logically "abc_[HEBREW_\nHEBREW]" @@ -674,11 +846,10 @@ void RowPainter::paintText() body_pos = 0; } - LayoutPtr const & layout = par_.layout(); + Layout const & layout = par_.layout(); - bool running_strikeout = false; - bool is_struckout = false; - int last_strikeout_x = 0; + Change change_running; + int change_last_x = 0; // check for possible inline completion DocIterator const & inlineCompletionPos = pi_.base.bv->inlineCompletionPos(); @@ -686,8 +857,8 @@ void RowPainter::paintText() if (inlineCompletionPos.inTexted() && inlineCompletionPos.text() == &text_ && inlineCompletionPos.pit() == pit_ - && inlineCompletionPos.pos() >= row_.pos() - && inlineCompletionPos.pos() <= row_.endpos()) { + && inlineCompletionPos.pos() - 1 >= row_.pos() + && inlineCompletionPos.pos() - 1 < row_.endpos()) { // draw logically behind the previous character inlineCompletionVPos = bidi_.log2vis(inlineCompletionPos.pos() - 1); } @@ -736,37 +907,43 @@ void RowPainter::paintText() ++vpos; continue; } - - is_struckout = par_.isDeleted(pos); - - if (is_struckout && !running_strikeout) { - running_strikeout = true; - last_strikeout_x = int(x_); + 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() == Inset::HIGHLY_EDITABLE; + && inset->editable(); - // If we reach the end of a struck out range, paint it. + // 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 (running_strikeout && (highly_editable_inset || !is_struckout)) { + 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()); - int const middle = yo_ - fm.maxAscent() / 3; - pi_.pain.line(last_strikeout_x, middle, int(x_), middle, - Color_deletedtext, Painter::line_solid, Painter::line_thin); - running_strikeout = false; + 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); + .width(layout.labelsep); x_ += row_.label_hfill + lwidth - width_pos; } - + // Is the inline completion in front of character? if (font.isRightToLeft() && vpos == inlineCompletionVPos) paintInlineCompletion(font); @@ -774,21 +951,29 @@ void RowPainter::paintText() if (par_.isSeparator(pos)) { Font const orig_font = text_metrics_.displayFont(pit_, pos); double const orig_x = x_; - x_ += width_pos; + double separator_width = width_pos; if (pos >= body_pos) - x_ += row_.separator; + 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; } else { // paint as many characters as possible. - paintFromPos(vpos); + paintFromPos(vpos, change_running.changed()); } // Is the inline completion after character? @@ -797,14 +982,112 @@ void RowPainter::paintText() } // if we reach the end of a struck out range, paint it - if (running_strikeout) { - // calculate 1/3 height of the buffer's default font + if (change_running.changed()) { FontMetrics const & fm = theFontMetrics(pi_.base.bv->buffer().params().getFont()); - int const middle = yo_ - fm.maxAscent() / 3; - pi_.pain.line(last_strikeout_x, middle, int(x_), middle, - Color_deletedtext, Painter::line_solid, Painter::line_thin); - running_strikeout = false; + 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(); + } +} + + +void RowPainter::paintSelection() +{ + 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); + } + + if (x1 == -1) { + // the previous segment was just drawn, now the next starts + x1 = text_metrics_.cursorX(cur.top(), cur.boundary()); + } + + 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); + + // 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; + } } } @@ -813,26 +1096,31 @@ void RowPainter::paintInlineCompletion(Font const & font) { docstring completion = pi_.base.bv->inlineCompletion(); FontInfo f = font.fontInfo(); - - // right to left? - if (font.isRightToLeft()) - reverse(completion.begin(), completion.end()); - + 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); - - if (s1.size() > 0) { - f.setColor(Color_inlinecompletion); + 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.size() > 0) { - f.setColor(Color_nonunique_inlinecompletion); + + if (!s2.empty()) { + f.setColor(c2); pi_.pain.text(int(x_), yo_, s2, f); x_ += theFontMetrics(font).width(s2); }