X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Frowpainter.C;h=b992b00143a71425bccc3eff85218e728ef80add;hb=9ee46b846e5e84ad40ceda4f4af94aeb86cd90a2;hp=f69d693f85cf877d57217014cff09c6f134aed92;hpb=0fe5cc3913c96a3f9a9d12a2dd594a2256bdddc7;p=lyx.git diff --git a/src/rowpainter.C b/src/rowpainter.C index f69d693f85..b992b00143 100644 --- a/src/rowpainter.C +++ b/src/rowpainter.C @@ -40,11 +40,14 @@ #include "support/textutils.h" +#include + using lyx::pos_type; -using lyx::par_type; +using lyx::pit_type; using std::endl; using std::max; +using std::min; using std::string; @@ -56,39 +59,33 @@ namespace { class RowPainter { public: /// initialise and run painter - RowPainter(BufferView const & bv, Painter & pain, LyXText const & text, - par_type pit, RowList::iterator rit, int y); -private: + RowPainter(PainterInfo & pi, LyXText const & text, + pit_type pit, Row const & row, int x, int y); + // paint various parts - void paintBackground(); - void paintSelection(); void paintAppendix(); void paintDepthBar(); void paintChangeBar(); void paintFirst(); void paintLast(); - void paintForeignMark(double orig_x, LyXFont const & orig_font); - void paintHebrewComposeChar(lyx::pos_type & vpos); - void paintArabicComposeChar(lyx::pos_type & vpos); - void paintChars(lyx::pos_type & vpos, bool hebrew, bool arabic); - int paintAppendixStart(int y); void paintText(); + +private: + void paintForeignMark(double orig_x, LyXFont const & font); + void paintHebrewComposeChar(lyx::pos_type & vpos, LyXFont const & font); + void paintArabicComposeChar(lyx::pos_type & vpos, LyXFont const & font); + void paintChars(lyx::pos_type & vpos, LyXFont font, + bool hebrew, bool arabic); + int paintAppendixStart(int y); void paintFromPos(lyx::pos_type & vpos); - void paintInset(lyx::pos_type const pos); + void paintInset(lyx::pos_type const pos, LyXFont const & font); /// return left margin int leftMargin() const; - /// return the font at the given pos - LyXFont const getFont(lyx::pos_type pos) const; - /// return the label font for this row LyXFont const getLabelFont() const; - /// return pixel width for the given pos - int singleWidth(lyx::pos_type pos) const; - int singleWidth(lyx::pos_type pos, char c) const; - /// bufferview to paint on BufferView const & bv_; @@ -97,18 +94,21 @@ private: /// LyXText for the row LyXText const & text_; - ParagraphList & pars_; + ParagraphList const & pars_; /// The row to paint - RowList::iterator const rit_; - Row & row_; + Row const & row_; /// Row's paragraph - mutable par_type pit_; + pit_type const pit_; + Paragraph const & par_; + + /// is row erased? (change tracking) + bool erased_; // Looks ugly - is - double xo_; - int yo_; + double const xo_; + int const yo_; // current baseline double x_; int width_; double separator_; @@ -117,74 +117,31 @@ private: }; -RowPainter::RowPainter(BufferView const & bv, Painter & pain, - LyXText const & text, par_type pit, RowList::iterator rit, int y) - : bv_(bv), pain_(pain), text_(text), pars_(text.paragraphs()), - rit_(rit), row_(*rit), pit_(pit), - xo_(text_.xo_), yo_(y), width_(text_.width()) +RowPainter::RowPainter(PainterInfo & pi, + LyXText const & text, pit_type pit, Row const & row, int x, int y) + : bv_(*pi.base.bv), pain_(pi.pain), text_(text), pars_(text.paragraphs()), + row_(row), pit_(pit), par_(text.paragraphs()[pit]), + erased_(pi.erased_), + xo_(x), yo_(y), width_(text_.width()) { - //lyxerr << "RowPainter: x: " << x_ << " xo: " << xo << " yo: " << yo - // << " pit->y: " << pit_->y - // << " row: " << (pars_[pit_].size() ? pars_[pit_].getChar(row_.pos()) : 'X') << endl; - RowMetrics m = text_.computeRowMetrics(pit, row_); x_ = m.x + xo_; + //lyxerr << "RowPainter: x: " << x_ << " xo: " << xo_ << " yo: " << yo_ << endl; + //row_.dump(); + separator_ = m.separator; hfill_ = m.hfill; label_hfill_ = m.label_hfill; - // background has already been cleared. - if (&text_ == bv_.text()) - paintBackground(); - - // paint the selection background - if (bv_.cursor().selection() && &text_ == bv_.cursor().text()) - paintSelection(); - - // vertical lines for appendix - paintAppendix(); - - // environment depth brackets - paintDepthBar(); - - // changebar - paintChangeBar(); - - if (row_.pos() == 0) - paintFirst(); - - if (row_.endpos() >= pars_[pit_].size()) - paintLast(); - - // paint text - paintText(); -} - - -/// "temporary" -LyXFont const RowPainter::getFont(pos_type pos) const -{ - return text_.getFont(pit_, pos); -} - - -int RowPainter::singleWidth(lyx::pos_type pos) const -{ - return text_.singleWidth(pit_, pos); -} - - -int RowPainter::singleWidth(lyx::pos_type pos, char c) const -{ - LyXFont const & font = text_.getFont(pit_, pos); - return text_.singleWidth(pit_, pos, c, font); + BOOST_ASSERT(pit >= 0); + BOOST_ASSERT(pit < int(text.paragraphs().size())); } LyXFont const RowPainter::getLabelFont() const { - return text_.getLabelFont(pit_); + return text_.getLabelFont(par_); } @@ -194,40 +151,45 @@ int RowPainter::leftMargin() const } -void RowPainter::paintInset(pos_type const pos) +void RowPainter::paintInset(pos_type const pos, LyXFont const & font) { - InsetBase const * inset = pars_[pit_].getInset(pos); + InsetBase const * inset = par_.getInset(pos); BOOST_ASSERT(inset); PainterInfo pi(const_cast(&bv_), pain_); - pi.base.font = getFont(pos); + // FIXME: We should always use font, see documentation of + // noFontChange() in insetbase.h. + pi.base.font = inset->noFontChange() ? + bv_.buffer()->params().getLyXTextClass().defaultfont() : + font; pi.ltr_pos = (text_.bidi.level(pos) % 2 == 0); - theCoords.insets_.add(inset, int(x_), yo_ + row_.baseline()); - inset->drawSelection(pi, int(x_), yo_ + row_.baseline()); - inset->draw(pi, int(x_), yo_ + row_.baseline()); + pi.erased_ = erased_ || isDeletedText(par_, pos); + theCoords.insets().add(inset, int(x_), yo_); + inset->drawSelection(pi, int(x_), yo_); + inset->draw(pi, int(x_), yo_); x_ += inset->width(); } -void RowPainter::paintHebrewComposeChar(pos_type & vpos) +void RowPainter::paintHebrewComposeChar(pos_type & vpos, LyXFont const & font) { pos_type pos = text_.bidi.vis2log(vpos); string str; // first char - char c = pars_[pit_].getChar(pos); + char c = par_.getChar(pos); str += c; ++vpos; - LyXFont const & font = getFont(pos); int const width = font_metrics::width(c, font); int dx = 0; for (pos_type i = pos - 1; i >= 0; --i) { - c = pars_[pit_].getChar(i); + c = par_.getChar(i); if (!Encodings::IsComposeChar_hebrew(c)) { if (IsPrintableNonspace(c)) { - int const width2 = singleWidth(i, c); + int const width2 = + text_.singleWidth(par_, i, c, text_.getFont(par_, i)); // dalet / resh dx = (c == 'ø' || c == 'ã') ? width2 - width @@ -238,68 +200,68 @@ void RowPainter::paintHebrewComposeChar(pos_type & vpos) } // Draw nikud - pain_.text(int(x_) + dx, yo_ + row_.baseline(), str, font); + pain_.text(int(x_) + dx, yo_, str, font); } -void RowPainter::paintArabicComposeChar(pos_type & vpos) +void RowPainter::paintArabicComposeChar(pos_type & vpos, LyXFont const & font) { pos_type pos = text_.bidi.vis2log(vpos); string str; // first char - char c = pars_[pit_].getChar(pos); - c = pars_[pit_].transformChar(c, pos); + char c = par_.getChar(pos); + c = par_.transformChar(c, pos); str += c; ++vpos; - LyXFont const & font = getFont(pos); int const width = font_metrics::width(c, font); int dx = 0; for (pos_type i = pos - 1; i >= 0; --i) { - c = pars_[pit_].getChar(i); + c = par_.getChar(i); if (!Encodings::IsComposeChar_arabic(c)) { if (IsPrintableNonspace(c)) { - int const width2 = singleWidth(i, c); + int const width2 = + text_.singleWidth(par_, i, c, text_.getFont(par_, i)); dx = (width2 - width) / 2; } break; } } // Draw nikud - pain_.text(int(x_) + dx, yo_ + row_.baseline(), str, font); + pain_.text(int(x_) + dx, yo_, str, font); } -void RowPainter::paintChars(pos_type & vpos, bool hebrew, bool arabic) +void RowPainter::paintChars(pos_type & vpos, LyXFont font, + bool hebrew, bool arabic) { pos_type pos = text_.bidi.vis2log(vpos); pos_type const end = row_.endpos(); - LyXFont orig_font = getFont(pos); + FontSpan const font_span = par_.fontSpan(pos); + Change::Type const prev_change = par_.lookupChange(pos); // first character string str; - str += pars_[pit_].getChar(pos); + str += par_.getChar(pos); if (arabic) { unsigned char c = str[0]; - str[0] = pars_[pit_].transformChar(c, pos); + str[0] = par_.transformChar(c, pos); } - bool prev_struckout = isDeletedText(pars_[pit_], pos); - bool prev_newtext = isInsertedText(pars_[pit_], pos); - // collect as much similar chars as we can - for (++vpos; vpos < end && (pos = text_.bidi.vis2log(vpos)) >= 0; ++vpos) { - char c = pars_[pit_].getChar(pos); - - if (!IsPrintableNonspace(c)) + for (++vpos ; vpos < end ; ++vpos) { + pos = text_.bidi.vis2log(vpos); + if (pos < font_span.first || pos > font_span.last) break; - if (prev_struckout != isDeletedText(pars_[pit_], pos)) + if (prev_change != par_.lookupChange(pos)) break; - if (prev_newtext != isInsertedText(pars_[pit_], pos)) + char c = par_.getChar(pos); + + if (!IsPrintableNonspace(c)) break; if (arabic && Encodings::IsComposeChar_arabic(c)) @@ -308,38 +270,34 @@ void RowPainter::paintChars(pos_type & vpos, bool hebrew, bool arabic) if (hebrew && Encodings::IsComposeChar_hebrew(c)) break; - if (orig_font != getFont(pos)) - break; - if (arabic) - c = pars_[pit_].transformChar(c, pos); + c = par_.transformChar(c, pos); str += c; } - if (prev_struckout) - orig_font.setColor(LColor::strikeout); - else if (prev_newtext) - orig_font.setColor(LColor::newtext); + if (prev_change == Change::DELETED) + font.setColor(LColor::strikeout); + else if (prev_change == Change::INSERTED) + font.setColor(LColor::newtext); // Draw text and set the new x position - //lyxerr << "paint row: yo_ " << yo_ << " baseline: " << row_.baseline() - // << "\n"; - pain_.text(int(x_), yo_ + row_.baseline(), str, orig_font); - x_ += font_metrics::width(str, orig_font); + //lyxerr << "paint row: yo_ " << yo_ << "\n"; + pain_.text(int(x_), yo_, str, font); + x_ += font_metrics::width(str, font); } -void RowPainter::paintForeignMark(double orig_x, LyXFont const & orig_font) +void RowPainter::paintForeignMark(double orig_x, LyXFont const & font) { if (!lyxrc.mark_foreign_language) return; - if (orig_font.language() == latex_language) + if (font.language() == latex_language) return; - if (orig_font.language() == bv_.buffer()->params().language) + if (font.language() == bv_.buffer()->params().language) return; - int const y = yo_ + row_.baseline() + 1; + int const y = yo_ + 1; pain_.line(int(orig_x), y, int(x_), y, LColor::language); } @@ -347,26 +305,25 @@ void RowPainter::paintForeignMark(double orig_x, LyXFont const & orig_font) void RowPainter::paintFromPos(pos_type & vpos) { pos_type const pos = text_.bidi.vis2log(vpos); - - LyXFont const & orig_font = getFont(pos); + LyXFont orig_font = text_.getFont(par_, pos); + text_.applyOuterFont(orig_font); double const orig_x = x_; - char const c = pars_[pit_].getChar(pos); - - if (c == Paragraph::META_INSET) { - paintInset(pos); + if (par_.isInset(pos)) { + paintInset(pos, orig_font); ++vpos; paintForeignMark(orig_x, orig_font); return; } // usual characters, no insets + char const c = par_.getChar(pos); // special case languages - bool const hebrew = (orig_font.language()->lang() == "hebrew"); - bool const arabic = - orig_font.language()->lang() == "arabic" && + std::string const & lang = orig_font.language()->lang(); + bool const hebrew = lang == "hebrew"; + bool const arabic = lang == "arabic" && (lyxrc.font_norm_type == LyXRC::ISO_8859_6_8 || lyxrc.font_norm_type == LyXRC::ISO_10646_1); @@ -374,145 +331,41 @@ void RowPainter::paintFromPos(pos_type & vpos) if ((!hebrew && !arabic) || (hebrew && !Encodings::IsComposeChar_hebrew(c)) || (arabic && !Encodings::IsComposeChar_arabic(c))) { - paintChars(vpos, hebrew, arabic); + paintChars(vpos, orig_font, hebrew, arabic); } else if (hebrew) { - paintHebrewComposeChar(vpos); + paintHebrewComposeChar(vpos, orig_font); } else if (arabic) { - paintArabicComposeChar(vpos); + paintArabicComposeChar(vpos, orig_font); } paintForeignMark(orig_x, orig_font); } -void RowPainter::paintBackground() -{ - int const x = int(xo_); - int const y = yo_ < 0 ? 0 : yo_; - int const h = yo_ < 0 ? row_.height() + yo_ : row_.height(); - pain_.fillRectangle(x, y, width_, h, text_.backgroundColor()); -} - - -void RowPainter::paintSelection() -{ - bool const is_rtl = text_.isRTL(pars_[pit_]); - - // the current selection - LCursor const & cur = bv_.cursor(); - int const starty = text_.cursorY(cur.selBegin()); - int const endy = text_.cursorY(cur.selEnd()); - par_type startpit = cur.selBegin().par(); - par_type endpit = cur.selEnd().par(); - RowList::iterator startrow = pars_[startpit].getRow(cur.selBegin().pos()); - RowList::iterator endrow = pars_[endpit].getRow(cur.selEnd().pos()); - int const h = row_.height(); - - int const row_y = text_.yo_ + pars_[pit_].y + row_.y_offset(); - - bool const sel_starts_here = startpit == pit_ && startrow == rit_; - bool const sel_ends_here = endpit == pit_ && endrow == rit_; - bool const sel_on_one_row = sel_starts_here && sel_ends_here; - - if (text_.bidi.same_direction()) { - if (sel_on_one_row) { - int const startx = text_.cursorX(cur.selBegin()); - int const endx = text_.cursorX(cur.selEnd()); - int const x1 = is_rtl ? endx : startx; - int const x2 = is_rtl ? startx : endx; - pain_.fillRectangle(x1, yo_, x2 - x1, h, LColor::selection); - } else if (sel_starts_here) { - int const startx = text_.cursorX(cur.selBegin()); - int const x1 = is_rtl ? int(xo_) : startx; - int const x2 = is_rtl ? startx : int(xo_) + width_; - pain_.fillRectangle(x1, yo_, x2 - x1, h, LColor::selection); - } else if (sel_ends_here) { - int const endx = text_.cursorX(cur.selEnd()); - int const x1 = is_rtl ? endx : int(xo_); - int const x2 = is_rtl ? int(xo_) + width_ : endx; - pain_.fillRectangle(x1, yo_, x2 - x1, h, LColor::selection); - } else if (row_y > starty && row_y < endy) { - pain_.fillRectangle(int(xo_), yo_, width_, h, LColor::selection); - } - return; - } - - if ((startpit != pit_ && startrow != rit_ && !is_rtl) - || (endpit != pit_ && endrow != rit_ && is_rtl)) - pain_.fillRectangle(int(xo_), yo_, - int(x_), h, LColor::selection); - - pos_type const body_pos = pars_[pit_].beginOfBody(); - pos_type const end = row_.endpos(); - double tmpx = x_; - - for (pos_type vpos = row_.pos(); vpos < end; ++vpos) { - pos_type pos = text_.bidi.vis2log(vpos); - double const old_tmpx = tmpx; - if (body_pos > 0 && pos == body_pos - 1) { - LyXLayout_ptr const & layout = pars_[pit_].layout(); - LyXFont const lfont = getLabelFont(); - - tmpx += label_hfill_ + font_metrics::width(layout->labelsep, lfont); - - if (pars_[pit_].isLineSeparator(body_pos - 1)) - tmpx -= singleWidth(body_pos - 1); - } - - tmpx += singleWidth(pos); - - if (hfillExpansion(pars_[pit_], row_, pos)) { - if (pos >= body_pos) - tmpx += hfill_; - else - tmpx += label_hfill_; - } else { - if (pars_[pit_].isSeparator(pos) && pos >= body_pos) - tmpx += separator_; - } - - if (((startpit != pit_ && startrow != rit_) - || cur.selBegin().pos() <= pos) && - ((endpit != pit_ && endrow != rit_) - || pos < cur.selEnd().pos())) { - // Here we do not use x_ as xo_ was added to x_. - pain_.fillRectangle(int(old_tmpx), yo_, - int(tmpx - old_tmpx + 1), h, LColor::selection); - } - } - - if ((startpit != pit_ && startrow != rit_ && is_rtl) || - (endpit != pit_ && endrow != rit_ && !is_rtl)) { - pain_.fillRectangle(int(xo_ + tmpx), - yo_, int(width_ - tmpx), h, LColor::selection); - } -} - - void RowPainter::paintChangeBar() { pos_type const start = row_.pos(); pos_type const end = row_.endpos(); - if (start == end || !pars_[pit_].isChanged(start, end - 1)) + if (start == end || !par_.isChanged(start, end - 1)) return; int const height = text_.isLastRow(pit_, row_) - ? row_.baseline() - : row_.height() + boost::next(rit_)->top_of_text(); + ? row_.ascent() + : row_.height(); - pain_.fillRectangle(4, yo_, 5, height, LColor::changebar); + pain_.fillRectangle(4, yo_ - row_.ascent(), 5, height, LColor::changebar); } void RowPainter::paintAppendix() { - if (!pars_[pit_].params().appendix()) + if (!par_.params().appendix()) return; - int y = yo_; + int y = yo_ - row_.ascent(); - if (pars_[pit_].params().startOfAppendix()) + if (par_.params().startOfAppendix()) y += 2 * defaultRowHeight(); pain_.line(1, y, 1, yo_ + row_.height(), LColor::appendix); @@ -522,14 +375,14 @@ void RowPainter::paintAppendix() void RowPainter::paintDepthBar() { - Paragraph::depth_type const depth = pars_[pit_].getDepth(); + Paragraph::depth_type const depth = par_.getDepth(); if (depth <= 0) return; Paragraph::depth_type prev_depth = 0; if (!text_.isFirstRow(pit_, row_)) { - par_type pit2 = pit_; + pit_type pit2 = pit_; if (row_.pos() == 0) --pit2; prev_depth = pars_[pit2].getDepth(); @@ -537,7 +390,7 @@ void RowPainter::paintDepthBar() Paragraph::depth_type next_depth = 0; if (!text_.isLastRow(pit_, row_)) { - par_type pit2 = pit_; + pit_type pit2 = pit_; if (row_.endpos() >= pars_[pit2].size()) ++pit2; next_depth = pars_[pit2].getDepth(); @@ -550,14 +403,15 @@ void RowPainter::paintDepthBar() if (text_.isMainText()) x += changebarMargin(); - int const h = yo_ + row_.height() - 1 - (i - next_depth - 1) * 3; + int const starty = yo_ - row_.ascent(); + int const h = row_.height() - 1 - (i - next_depth - 1) * 3; - pain_.line(x, yo_, x, h, LColor::depthbar); + pain_.line(x, starty, x, starty + h, LColor::depthbar); if (i > prev_depth) - pain_.fillRectangle(x, yo_, w, 2, LColor::depthbar); + pain_.fillRectangle(x, starty, w, 2, LColor::depthbar); if (i > next_depth) - pain_.fillRectangle(x, h, w, 2, LColor::depthbar); + pain_.fillRectangle(x, starty + h, w, 2, LColor::depthbar); } } @@ -588,22 +442,22 @@ int RowPainter::paintAppendixStart(int y) void RowPainter::paintFirst() { - ParagraphParameters const & parparams = pars_[pit_].params(); + ParagraphParameters const & parparams = par_.params(); int y_top = 0; // start of appendix? if (parparams.startOfAppendix()) - y_top += paintAppendixStart(yo_ + y_top + 2 * defaultRowHeight()); + y_top += paintAppendixStart(yo_ - row_.ascent() + 2 * defaultRowHeight()); Buffer const & buffer = *bv_.buffer(); - LyXLayout_ptr const & layout = pars_[pit_].layout(); + LyXLayout_ptr const & layout = par_.layout(); if (buffer.params().paragraph_separation == BufferParams::PARSEP_SKIP) { if (pit_ != 0) { if (layout->latextype == LATEX_PARAGRAPH - && !pars_[pit_].getDepth()) { + && !par_.getDepth()) { y_top += buffer.params().getDefSkip().inPixels(bv_); } else { LyXLayout_ptr const & playout = pars_[pit_ - 1].layout(); @@ -616,9 +470,9 @@ void RowPainter::paintFirst() } } - bool const is_rtl = text_.isRTL(pars_[pit_]); + bool const is_rtl = text_.isRTL(par_); bool const is_seq = isFirstInSequence(pit_, text_.paragraphs()); - //lyxerr << "paintFirst: " << pars_[pit_].id() << " is_seq: " << is_seq << std::endl; + //lyxerr << "paintFirst: " << par_.id() << " is_seq: " << is_seq << std::endl; // should we print a label? if (layout->labeltype >= LABEL_STATIC @@ -626,37 +480,33 @@ void RowPainter::paintFirst() || layout->latextype != LATEX_ENVIRONMENT || is_seq)) { - LyXFont font = getLabelFont(); - if (!pars_[pit_].getLabelstring().empty()) { + LyXFont const font = getLabelFont(); + string const str = par_.getLabelstring(); + if (!str.empty()) { double x = x_; - string const str = pars_[pit_].getLabelstring(); // 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") { - if (buffer.params().secnumdepth >= 0) { - float spacing_val = 1.0; - if (!parparams.spacing().isDefault()) { - spacing_val = parparams.spacing().getValue(); - } else { - spacing_val = buffer.params().spacing().getValue(); - } - - int const maxdesc = - int(font_metrics::maxDescent(font) * layout->spacing.getValue() * spacing_val) - + int(layout->parsep) * defaultRowHeight(); - - if (is_rtl) { - x = width_ - leftMargin() - - font_metrics::width(str, font); - } - - pain_.text(int(x), - yo_ + row_.baseline() - - row_.ascent_of_text() - maxdesc, - str, font); + 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(font_metrics::maxHeight(font) * layout->spacing.getValue() * spacing_val); + + int const maxdesc = int(font_metrics::maxDescent(font) * layout->spacing.getValue() * spacing_val) + + int(layout->parsep) * defaultRowHeight(); + + if (is_rtl) { + x = width_ - leftMargin() - + font_metrics::width(str, font); } + + pain_.text(int(x), yo_ - maxdesc - labeladdon, str, font); } else { if (is_rtl) { x = width_ - leftMargin() @@ -666,7 +516,7 @@ void RowPainter::paintFirst() - font_metrics::width(str, font); } - pain_.text(int(x), yo_ + row_.baseline(), str, font); + pain_.text(int(x), yo_, str, font); } } @@ -677,14 +527,15 @@ void RowPainter::paintFirst() layout->labeltype == LABEL_BIBLIO || layout->labeltype == LABEL_CENTERED_TOP_ENVIRONMENT)) { LyXFont font = getLabelFont(); - if (!pars_[pit_].getLabelstring().empty()) { - string const str = pars_[pit_].getLabelstring(); - float spacing_val = 1.0; - if (!parparams.spacing().isDefault()) { + if (!par_.getLabelstring().empty()) { + string const str = par_.getLabelstring(); + double spacing_val = 1.0; + if (!parparams.spacing().isDefault()) spacing_val = parparams.spacing().getValue(); - } else { + else spacing_val = buffer.params().spacing().getValue(); - } + + int const labeladdon = int(font_metrics::maxHeight(font) * layout->spacing.getValue() * spacing_val); int maxdesc = int(font_metrics::maxDescent(font) * layout->spacing.getValue() * spacing_val @@ -692,16 +543,15 @@ void RowPainter::paintFirst() double x = x_; if (layout->labeltype == LABEL_CENTERED_TOP_ENVIRONMENT) { - x = ((is_rtl ? leftMargin() : x_) - + width_ - text_.rightMargin(pars_[pit_])) / 2; + if (is_rtl) + x = leftMargin(); + x += (width_ - text_.rightMargin(par_) - leftMargin()) / 2; x -= font_metrics::width(str, font) / 2; } else if (is_rtl) { x = width_ - leftMargin() - font_metrics::width(str, font); } - pain_.text(int(x), - yo_ + row_.baseline() - row_.ascent_of_text() - maxdesc, - str, font); + pain_.text(int(x), yo_ - maxdesc - labeladdon, str, font); } } } @@ -709,7 +559,7 @@ void RowPainter::paintFirst() void RowPainter::paintLast() { - bool const is_rtl = text_.isRTL(pars_[pit_]); + bool const is_rtl = text_.isRTL(par_); int const endlabel = getEndLabel(pit_, text_.paragraphs()); // draw an endlabel @@ -718,7 +568,7 @@ void RowPainter::paintLast() case END_LABEL_FILLED_BOX: { LyXFont const font = getLabelFont(); int const size = int(0.75 * font_metrics::maxAscent(font)); - int const y = yo_ + row_.baseline() - size; + int const y = yo_ - size; int x = is_rtl ? nestMargin() + changebarMargin() : width_ - size; if (width_ - int(row_.width()) <= size) @@ -733,11 +583,11 @@ void RowPainter::paintLast() case END_LABEL_STATIC: { LyXFont font = getLabelFont(); - string const & str = pars_[pit_].layout()->endlabelstring(); + string const & str = par_.layout()->endlabelstring(); double const x = is_rtl ? x_ - font_metrics::width(str, font) - : - text_.rightMargin(pars_[pit_]) - row_.width(); - pain_.text(int(x), yo_ + row_.baseline(), str, font); + : - text_.rightMargin(par_) - row_.width(); + pain_.text(int(x), yo_, str, font); break; } @@ -750,49 +600,64 @@ void RowPainter::paintLast() void RowPainter::paintText() { pos_type const end = row_.endpos(); - pos_type body_pos = pars_[pit_].beginOfBody(); + pos_type body_pos = par_.beginOfBody(); if (body_pos > 0 && - (body_pos > end || !pars_[pit_].isLineSeparator(body_pos - 1))) { + (body_pos > end || !par_.isLineSeparator(body_pos - 1))) { body_pos = 0; } - LyXLayout_ptr const & layout = pars_[pit_].layout(); + LyXLayout_ptr const & layout = par_.layout(); bool running_strikeout = false; bool is_struckout = false; int last_strikeout_x = 0; + // Use font span to speed things up, see below + FontSpan font_span; + LyXFont font; + for (pos_type vpos = row_.pos(); vpos < end; ) { if (x_ > bv_.workWidth()) break; - pos_type pos = text_.bidi.vis2log(vpos); + pos_type const pos = text_.bidi.vis2log(vpos); - if (pos >= pars_[pit_].size()) { + if (pos >= par_.size()) { ++vpos; continue; } - if (x_ + singleWidth(pos) < 0) { - x_ += singleWidth(pos); + // Use font span to speed things up, see above + if (vpos < font_span.first || vpos > font_span.last) { + font_span = par_.fontSpan(vpos); + font = text_.getFont(par_, vpos); + } + + const int width_pos = + text_.singleWidth(par_, pos, par_.getChar(pos), font); + + if (x_ + width_pos < 0) { + x_ += width_pos; ++vpos; continue; } - is_struckout = isDeletedText(pars_[pit_], pos); + is_struckout = isDeletedText(par_, pos); if (is_struckout && !running_strikeout) { running_strikeout = true; last_strikeout_x = int(x_); } - bool const highly_editable_inset = pars_[pit_].isInset(pos) - && isHighlyEditableInset(pars_[pit_].getInset(pos)); + bool const highly_editable_inset = par_.isInset(pos) + && isHighlyEditableInset(par_.getInset(pos)); - // if we reach the end of a struck out range, paint it - // we also don't paint across things like tables + // If we reach the end of a struck out range, paint it. + // We also don't paint across things like tables if (running_strikeout && (highly_editable_inset || !is_struckout)) { - int const middle = yo_ + (row_.baseline() + row_.top_of_text()) / 2; + // Calculate 1/3 height of the buffer's default font + int const middle = + yo_ - font_metrics::maxAscent(text_.defaultfont_) / 3; pain_.line(last_strikeout_x, middle, int(x_), middle, LColor::strikeout, Painter::line_solid, Painter::line_thin); running_strikeout = false; @@ -802,18 +667,18 @@ void RowPainter::paintText() int const lwidth = font_metrics::width(layout->labelsep, getLabelFont()); - x_ += label_hfill_ + lwidth - singleWidth(body_pos - 1); + x_ += label_hfill_ + lwidth - width_pos; } - if (pars_[pit_].isHfill(pos)) { + if (par_.isHfill(pos)) { x_ += 1; - int const y0 = yo_ + row_.baseline(); + int const y0 = yo_; int const y1 = y0 - defaultRowHeight() / 2; pain_.line(int(x_), y1, int(x_), y0, LColor::added_space); - if (hfillExpansion(pars_[pit_], row_, pos)) { + if (hfillExpansion(par_, row_, pos)) { int const y2 = (y0 + y1) / 2; if (pos >= body_pos) { @@ -831,8 +696,8 @@ void RowPainter::paintText() } x_ += 2; ++vpos; - } else if (pars_[pit_].isSeparator(pos)) { - x_ += singleWidth(pos); + } else if (par_.isSeparator(pos)) { + x_ += width_pos; if (pos >= body_pos) x_ += separator_; ++vpos; @@ -843,7 +708,9 @@ void RowPainter::paintText() // if we reach the end of a struck out range, paint it if (running_strikeout) { - int const middle = yo_ + (row_.baseline() + row_.top_of_text()) / 2; + // calculate 1/3 height of the buffer's default font + int const middle = + yo_ - font_metrics::maxAscent(text_.defaultfont_) / 3; pain_.line(last_strikeout_x, middle, int(x_), middle, LColor::strikeout, Painter::line_solid, Painter::line_thin); running_strikeout = false; @@ -851,53 +718,154 @@ void RowPainter::paintText() } -int paintPars(BufferView const & bv, Painter & pain, - LyXText const & text, par_type pit, par_type end) +lyx::size_type calculateRowSignature(Row const & row, Paragraph const & par) { - //lyxerr << " paintRows: pit: " << &*pit << endl; - ParagraphList & pars = text.paragraphs(); - - int y = pars[pit].y + text.yo_ - bv.top_y(); - - for (; pit != end; ++pit) { - RowList::iterator row = pars[pit].rows.begin(); - RowList::iterator rend = pars[pit].rows.end(); - - // We draw full paragraphs to get the (xo, yo) cache of all - // contained insets right. This is needed for properly working - // editXY. And maybe not even sufficient. - // FIXME: Alfredo, please have a look at the coordinate business - // again. - for ( ; row != rend; ++row) { - RowPainter(bv, pain, text, pit, row, y); - y += row->height(); - } - + boost::crc_32_type crc; + for (lyx::pos_type i = row.pos(); i < row.endpos(); ++i) { + const unsigned char b[] = { par.getChar(i) }; + crc.process_bytes(b, 1); } - return y; + return crc.checksum(); } -} // namespace anon + +bool isCursorOnRow(PainterInfo & pi, pit_type pit, RowList::const_iterator rit) +{ + LCursor & cur = pi.base.bv->cursor(); + for (lyx::size_type d = 0; d < cur.depth(); d++) + if (cur[d].pit() == pit + && cur[d].pos() >= rit->pos() + && cur[d].pos() <= rit->endpos()) + return true; + return false; +} -void refreshPar(BufferView const & bv, LyXText const & text, par_type pit) +void paintPar + (PainterInfo & pi, LyXText const & text, pit_type pit, int x, int y, + bool repaintAll) { +// lyxerr << " paintPar: pit: " << pit << " at y: " << y << endl; static NullPainter nop; - paintPars(bv, nop, text, pit, pit + 1); + static PainterInfo nullpi(pi.base.bv, nop); + int const ww = pi.base.bv->workHeight(); + + Paragraph const & par = text.paragraphs()[pit]; + + RowList::const_iterator const rb = par.rows().begin(); + RowList::const_iterator const re = par.rows().end(); + theCoords.parPos()[&text][pit] = Point(x, y); + + y -= rb->ascent(); + lyx::size_type rowno(0); + for (RowList::const_iterator rit = rb; rit != re; ++rit, ++rowno) { + y += rit->ascent(); + + // Row signature; has row changed since last paint? + lyx::size_type const row_sig = calculateRowSignature(*rit, par); + + bool cursor_on_row = isCursorOnRow(pi, pit, rit); + + // If selection is on, the current row signature differs from + // from cache, or cursor is inside an inset _on this row_, + // then paint the row + if (repaintAll || par.rowSignature()[rowno] != row_sig + || cursor_on_row) { + // Add to row signature cache + par.rowSignature()[rowno] = row_sig; + + bool const inside = (y + rit->descent() >= 0 + && y - rit->ascent() < ww); + RowPainter rp(inside ? pi : nullpi, text, pit, *rit, x, y); + // Clear background of this row + // (if paragraph background was not cleared) + if (!repaintAll) { + pi.pain.fillRectangle(x, y - rit->ascent(), + pi.base.bv->workWidth(), rit->height(), + text.backgroundColor()); + } + + // Instrumentation for testing row cache (see also + // 12 lines lower): + //lyxerr << "#"; + rp.paintAppendix(); + rp.paintDepthBar(); + rp.paintChangeBar(); + if (rit == rb) + rp.paintFirst(); + if (rit + 1 == re) + rp.paintLast(); + rp.paintText(); + } + y += rit->descent(); + } + //lyxerr << "." << endl; } +} // namespace anon + -int paintText(BufferView const & bv) +void paintText(BufferView const & bv, ViewMetricsInfo const & vi) { - par_type pit, end; - getParsInRange(bv.text()->paragraphs(), bv.top_y(), - bv.top_y() + bv.workHeight(), pit, end); - //lyxerr << "top_y: " << bv.top_y() << " y: " << pit->y << endl; - return paintPars(bv, bv.painter(), *bv.text(), pit, end); + Painter & pain = bv.painter(); + LyXText * const text = bv.text(); + bool const select = bv.cursor().selection(); + + PainterInfo pi(const_cast(&bv), pain); + if (select || !vi.singlepar) { + // Clear background (Delegated to rows if no selection) + pain.fillRectangle(0, vi.y1, bv.workWidth(), vi.y2 - vi.y1, + text->backgroundColor()); + } + if (select) { + text->drawSelection(pi, 0, 0); + } + + int yy = vi.y1; + // draw contents + for (pit_type pit = vi.p1; pit <= vi.p2; ++pit) { + Paragraph const & par = text->getPar(pit); + yy += par.ascent(); + paintPar(pi, *bv.text(), pit, 0, yy, select || !vi.singlepar); + yy += par.descent(); + } + + // Cache one paragraph above and one below + // Note MV: this cannot be suppressed even for singlepar. + // Try viewing the User Guide Mobius figure + + if (vi.p1 > 0) { + text->redoParagraph(vi.p1 - 1); + theCoords.parPos()[bv.text()][vi.p1 - 1] = + Point(0, vi.y1 - text->getPar(vi.p1 - 1).descent()); + } + + if (vi.p2 < lyx::pit_type(text->paragraphs().size()) - 1) { + text->redoParagraph(vi.p2 + 1); + theCoords.parPos()[bv.text()][vi.p2 + 1] = + Point(0, vi.y2 + text->getPar(vi.p2 + 1).ascent()); + } + + // and grey out above (should not happen later) +// lyxerr << "par ascent: " << text->getPar(vi.p1).ascent() << endl; + if (vi.y1 > 0 && !vi.singlepar) + pain.fillRectangle(0, 0, bv.workWidth(), vi.y1, LColor::bottomarea); + + // and possibly grey out below +// lyxerr << "par descent: " << text->getPar(vi.p1).ascent() << endl; + if (vi.y2 < bv.workHeight() && !vi.singlepar) + pain.fillRectangle(0, vi.y2, bv.workWidth(), bv.workHeight() - vi.y2, LColor::bottomarea); } -void paintTextInset(LyXText const & text, PainterInfo & pi) +void paintTextInset(LyXText const & text, PainterInfo & pi, int x, int y) { - paintPars(*pi.base.bv, pi.pain, text, 0, text.paragraphs().size()); +// lyxerr << " paintTextInset: y: " << y << endl; + + y -= text.getPar(0).ascent(); + for (int pit = 0; pit < int(text.paragraphs().size()); ++pit) { + y += text.getPar(pit).ascent(); + paintPar(pi, text, pit, x, y, true); + y += text.getPar(pit).descent(); + } }