X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FBufferView.cpp;h=af0ad368b32d29188f56f3c5a03138b82d5b7e62;hb=62af7ee772f16f154225d2d0b65d77f4376b6001;hp=3832982395d6a2d40dd252d2422de4efdea5edc8;hpb=1de6d3f3f027919c8fa44bc08f3edd517a1874cb;p=lyx.git diff --git a/src/BufferView.cpp b/src/BufferView.cpp index 3832982395..af0ad368b3 100644 --- a/src/BufferView.cpp +++ b/src/BufferView.cpp @@ -65,6 +65,7 @@ #include "insets/InsetText.h" #include "mathed/MathData.h" +#include "mathed/InsetMathNest.h" #include "frontends/alert.h" #include "frontends/Application.h" @@ -81,6 +82,7 @@ #include "support/gettext.h" #include "support/lassert.h" #include "support/lstrings.h" +#include "support/lyxlib.h" #include "support/Package.h" #include "support/types.h" @@ -163,7 +165,7 @@ bool findInset(DocIterator & dit, vector const & codes, if (!findNextInset(tmpdit, codes, contents)) { if (dit.depth() != 1 || dit.pit() != 0 || dit.pos() != 0) { - Inset * inset = &tmpdit.bottom().inset(); + inset = &tmpdit.bottom().inset(); tmpdit = doc_iterator_begin(&inset->buffer(), inset); if (!findNextInset(tmpdit, codes, contents)) return false; @@ -228,7 +230,8 @@ enum ScreenUpdateStrategy { struct BufferView::Private { - Private(BufferView & bv) : update_strategy_(FullScreenUpdate), + Private(BufferView & bv) : + update_strategy_(FullScreenUpdate), update_flags_(Update::Force), wh_(0), cursor_(bv), anchor_pit_(0), anchor_ypos_(0), @@ -236,7 +239,7 @@ struct BufferView::Private last_inset_(0), clickable_inset_(false), mouse_position_cache_(), bookmark_edit_position_(-1), gui_(0), - horiz_scroll_offset_(0), repaint_caret_row_(false) + horiz_scroll_offset_(0) { xsel_cache_.set = false; } @@ -249,6 +252,9 @@ struct BufferView::Private Update::flags update_flags_; /// CoordCache coord_cache_; + /// + typedef map MathRows; + MathRows math_rows_; /// Estimated average par height for scrollbar. int wh_; @@ -312,15 +318,6 @@ struct BufferView::Private /// a slice pointing to the start of the row where the cursor /// is (at last draw time) CursorSlice current_row_slice_; - /// a slice pointing to the start of the row where cursor was - /// at previous draw event - CursorSlice last_row_slice_; - - /// a slice pointing to where the cursor has been drawn after the current - /// draw() call. - CursorSlice caret_slice_; - /// indicates whether the caret slice needs to be repainted in this draw() run. - bool repaint_caret_row_; }; @@ -348,9 +345,10 @@ BufferView::~BufferView() // That is to say, if a cursor is in a nested inset, it will be // restore to the left of the top level inset. LastFilePosSection::FilePos fp; + fp.file = buffer_.fileName(); fp.pit = d->cursor_.bottom().pit(); fp.pos = d->cursor_.bottom().pos(); - theSession().lastFilePos().save(buffer_.fileName(), fp); + theSession().lastFilePos().save(fp); if (d->last_inset_) d->last_inset_->setMouseHover(this, false); @@ -361,8 +359,8 @@ BufferView::~BufferView() int BufferView::rightMargin() const { - // The value used to be hardcoded to 10, which is 0.1in at 100dpi - int const default_margin = Length(0.1, Length::IN).inPixels(0); + // The value used to be hardcoded to 10 + int const default_margin = zoomedPixels(10); // The additional test for the case the outliner is opened. if (!full_screen_ || !lyxrc.full_screen_limit || width_ < lyxrc.full_screen_width + 2 * default_margin) @@ -385,6 +383,21 @@ int BufferView::inPixels(Length const & len) const } +int BufferView::zoomedPixels(int pix) const +{ + // FIXME: the dpi setting should really depend on the BufferView + // (think different monitors). + + // Zoom factor specified by user in percent + double const zoom = lyxrc.currentZoom / 100.0; // [percent] + + // DPI setting for monitor relative to 100dpi + double const dpizoom = lyxrc.dpi / 100.0; // [per 100dpi] + + return support::iround(pix * zoom * dpizoom); +} + + bool BufferView::isTopScreen() const { return 0 == d->scrollbarParameters_.min; @@ -421,6 +434,20 @@ CoordCache const & BufferView::coordCache() const } +MathRow const & BufferView::mathRow(MathData const * cell) const +{ + auto it = d->math_rows_.find(cell); + LATTEST(it != d->math_rows_.end()); + return it->second; +} + + +void BufferView::setMathRow(MathData const * cell, MathRow const & mrow) +{ + d->math_rows_[cell] = mrow; +} + + Buffer & BufferView::buffer() { return buffer_; @@ -458,7 +485,8 @@ string flagsAsString(Update::flags flags) return string((flags & Update::FitCursor) ? "FitCursor " : "") + ((flags & Update::Force) ? "Force " : "") + ((flags & Update::ForceDraw) ? "ForceDraw " : "") - + ((flags & Update::SinglePar) ? "SinglePar " : ""); + + ((flags & Update::SinglePar) ? "SinglePar " : "") + + ((flags & Update::Decoration) ? "Decoration " : ""); } } @@ -472,10 +500,13 @@ void BufferView::processUpdateFlags(Update::flags flags) if (flags == Update::None) return; - // SinglePar is ignored for now (this should probably change). We - // set it ourselves below, at the price of always rebreaking the - // paragraph at cursor. This can be expensive for large tables. - flags = flags & ~Update::SinglePar; + /* FIXME We would like to avoid doing this here, since it is very + * expensive and is called in updateBuffer already. However, even + * inserting a plain character can invalidate the overly fragile + * tables of child documents built by updateMacros. Some work is + * needed to avoid doing that when not necessary. + */ + buffer_.updateMacros(); // First check whether the metrics and inset positions should be updated if (flags & Update::Force) { @@ -484,31 +515,38 @@ void BufferView::processUpdateFlags(Update::flags flags) updateMetrics(flags); } + // Detect whether we can only repaint a single paragraph (if we + // are not already redrawing all). + // We handle this before FitCursor because the later will require + // correct metrics at cursor position. + if (!(flags & Update::ForceDraw) + && (flags & Update::SinglePar) + && !singleParUpdate()) + updateMetrics(flags); + // Then make sure that the screen contains the cursor if needed if (flags & Update::FitCursor) { if (needsFitCursor()) { - scrollToCursor(d->cursor_, false); + // First try to make the selection start visible + // (which is just the cursor when there is no selection) + scrollToCursor(d->cursor_.selectionBegin(), false); + // Is the cursor visible? (only useful if cursor is at end of selection) + if (needsFitCursor()) + // then try to make cursor visible instead + scrollToCursor(d->cursor_, false); // Metrics have to be recomputed (maybe again) updateMetrics(flags); } flags = flags & ~Update::FitCursor; } - // Finally detect whether we can only repaint a single paragraph - if (!(flags & Update::ForceDraw)) { - if (singleParUpdate()) - flags = flags | Update::SinglePar; - else - updateMetrics(flags); - } - // Add flags to the the update flags. These will be reset to None // after the redraw is actually done d->update_flags_ = d->update_flags_ | flags; LYXERR(Debug::PAINTING, "Cumulative flags: " << flagsAsString(flags)); // Now compute the update strategy - // Possibly values in flag are None, Decoration, ForceDraw + // Possibly values in flag are None, SinglePar, Decoration, ForceDraw LATTEST((d->update_flags_ & ~(Update::None | Update::SinglePar | Update::Decoration | Update::ForceDraw)) == 0); @@ -838,7 +876,7 @@ bool BufferView::moveToPosition(pit_type bottom_pit, pos_type bottom_pos, d->cursor_.setCurrentFont(); // Do not forget to reset the anchor (see #9912) d->cursor_.resetAnchor(); - processUpdateFlags(Update::FitCursor); + processUpdateFlags(Update::Force | Update::FitCursor); } return success; @@ -926,7 +964,7 @@ bool BufferView::scrollToCursor(DocIterator const & dit, bool const recenter) int offset = coordOffset(dit).y_; int ypos = pm.position() + offset; Dimension const & row_dim = - pm.getRow(cs.pos(), dit.boundary()).dimension(); + pm.getRow(cs.pos(), dit.boundary()).dim(); int scrolled = 0; if (recenter) scrolled = scroll(ypos - height_/2); @@ -970,7 +1008,7 @@ bool BufferView::scrollToCursor(DocIterator const & dit, bool const recenter) d->anchor_pit_ = bot_pit; CursorSlice const & cs = dit.innerTextSlice(); Dimension const & row_dim = - pm.getRow(cs.pos(), dit.boundary()).dimension(); + pm.getRow(cs.pos(), dit.boundary()).dim(); if (recenter) d->anchor_ypos_ = height_/2; @@ -1134,6 +1172,10 @@ bool BufferView::getStatus(FuncRequest const & cmd, FuncStatus & flag) flag.setEnabled(true); break; + case LFUN_GRAPHICS_UNIFY: + flag.setEnabled(cur.countInsetsInSelection(GRAPHICS_CODE)>1); + break; + case LFUN_WORD_FINDADV: { FindAndReplaceOptions opt; istringstream iss(to_utf8(cmd.argument())); @@ -1230,7 +1272,10 @@ Inset * BufferView::editedInset(string const & name) const void BufferView::editInset(string const & name, Inset * inset) { - d->edited_insets_[name] = inset; + if (inset) + d->edited_insets_[name] = inset; + else + d->edited_insets_.erase(name); } @@ -1332,7 +1377,7 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr) // without calling recordUndo. Fix this before using // recordUndoBufferParams(). cur.recordUndoFullBuffer(); - buffer_.params().setBaseClass(argument); + buffer_.params().setBaseClass(argument, buffer_.layoutPos()); makeDocumentClass(); dr.screenUpdate(Update::Force); dr.forceBufferUpdate(); @@ -1356,32 +1401,52 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr) case LFUN_LAYOUT_RELOAD: { LayoutFileIndex bc = buffer_.params().baseClassID(); LayoutFileList::get().reset(bc); - buffer_.params().setBaseClass(bc); + buffer_.params().setBaseClass(bc, buffer_.layoutPos()); makeDocumentClass(); dr.screenUpdate(Update::Force); dr.forceBufferUpdate(); break; } - case LFUN_UNDO: + case LFUN_UNDO: { dr.setMessage(_("Undo")); cur.clearSelection(); - if (!cur.textUndo()) + // We need to find out if the bibliography information + // has changed. See bug #11055. + // So these should not be references... + string const engine = buffer().params().citeEngine(); + CiteEngineType const enginetype = buffer().params().citeEngineType(); + if (!cur.undoAction()) dr.setMessage(_("No further undo information")); - else + else { dr.screenUpdate(Update::Force | Update::FitCursor); - dr.forceBufferUpdate(); + dr.forceBufferUpdate(); + if (buffer().params().citeEngine() != engine || + buffer().params().citeEngineType() != enginetype) + buffer().invalidateCiteLabels(); + } break; + } - case LFUN_REDO: + case LFUN_REDO: { dr.setMessage(_("Redo")); cur.clearSelection(); - if (!cur.textRedo()) + // We need to find out if the bibliography information + // has changed. See bug #11055. + // So these should not be references... + string const engine = buffer().params().citeEngine(); + CiteEngineType const enginetype = buffer().params().citeEngineType(); + if (!cur.redoAction()) dr.setMessage(_("No further redo information")); - else + else { dr.screenUpdate(Update::Force | Update::FitCursor); - dr.forceBufferUpdate(); + dr.forceBufferUpdate(); + if (buffer().params().citeEngine() != engine || + buffer().params().citeEngineType() != enginetype) + buffer().invalidateCiteLabels(); + } break; + } case LFUN_FONT_STATE: dr.setMessage(cur.currentState(false)); @@ -1423,14 +1488,14 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr) for (Buffer * b = &buffer_; i == 0 || b != &buffer_; b = theBufferList().next(b)) { - Cursor cur(*this); - cur.setCursor(b->getParFromID(id)); - if (cur.atEnd()) { + Cursor curs(*this); + curs.setCursor(b->getParFromID(id)); + if (curs.atEnd()) { LYXERR(Debug::INFO, "No matching paragraph found! [" << id << "]."); ++i; continue; } - LYXERR(Debug::INFO, "Paragraph " << cur.paragraph().id() + LYXERR(Debug::INFO, "Paragraph " << curs.paragraph().id() << " found in buffer `" << b->absFileName() << "'."); @@ -1438,8 +1503,8 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr) bool success; if (str_id_end.empty() || str_pos_end.empty()) { // Set the cursor - cur.pos() = pos; - mouseSetCursor(cur); + curs.pos() = pos; + mouseSetCursor(curs); success = true; } else { int const id_end = convert(str_id_end); @@ -1474,12 +1539,18 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr) case LFUN_CHANGE_NEXT: findNextChange(this); + if (cur.inset().isTable()) + // In tables, there might be whole changed rows or columns + cur.dispatch(cmd); // FIXME: Move this LFUN to Buffer so that we don't have to do this: dr.screenUpdate(Update::Force | Update::FitCursor); break; case LFUN_CHANGE_PREVIOUS: findPreviousChange(this); + if (cur.inset().isTable()) + // In tables, there might be whole changed rows or columns + cur.dispatch(cmd); // FIXME: Move this LFUN to Buffer so that we don't have to do this: dr.screenUpdate(Update::Force | Update::FitCursor); break; @@ -1492,32 +1563,43 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr) } break; - case LFUN_ALL_CHANGES_ACCEPT: + case LFUN_ALL_CHANGES_ACCEPT: { // select complete document cur.reset(); cur.selHandle(true); buffer_.text().cursorBottom(cur); // accept everything in a single step to support atomic undo + // temporarily disable track changes in order to end with really + // no new (e.g., DPSM-caused) changes (see #7487) + bool const track = buffer_.params().track_changes; + buffer_.params().track_changes = false; buffer_.text().acceptOrRejectChanges(cur, Text::ACCEPT); + buffer_.params().track_changes = track; cur.resetAnchor(); // FIXME: Move this LFUN to Buffer so that we don't have to do this: dr.screenUpdate(Update::Force | Update::FitCursor); dr.forceBufferUpdate(); break; + } - case LFUN_ALL_CHANGES_REJECT: + case LFUN_ALL_CHANGES_REJECT: { // select complete document cur.reset(); cur.selHandle(true); buffer_.text().cursorBottom(cur); // reject everything in a single step to support atomic undo - // Note: reject does not work recursively; the user may have to repeat the operation + // temporarily disable track changes in order to end with really + // no new (e.g., DPSM-caused) changes (see #7487) + bool const track = buffer_.params().track_changes; + buffer_.params().track_changes = false; buffer_.text().acceptOrRejectChanges(cur, Text::REJECT); + buffer_.params().track_changes = track; cur.resetAnchor(); // FIXME: Move this LFUN to Buffer so that we don't have to do this: dr.screenUpdate(Update::Force | Update::FitCursor); dr.forceBufferUpdate(); break; + } case LFUN_WORD_FIND_FORWARD: case LFUN_WORD_FIND_BACKWARD: { @@ -1651,6 +1733,45 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr) break; } + case LFUN_GRAPHICS_UNIFY: { + + cur.recordUndoFullBuffer(); + + DocIterator from, to; + from = cur.selectionBegin(); + to = cur.selectionEnd(); + + string const newId = cmd.getArg(0); + bool fetchId = newId.empty(); //if we wait for groupId from first graphics inset + + InsetGraphicsParams grp_par; + if (!fetchId) + InsetGraphics::string2params(graphics::getGroupParams(buffer_, newId), buffer_, grp_par); + + if (!from.nextInset()) //move to closest inset + from.forwardInset(); + + while (!from.empty() && from < to) { + Inset * inset = from.nextInset(); + if (!inset) + break; + InsetGraphics * ig = inset->asInsetGraphics(); + if (ig) { + InsetGraphicsParams inspar = ig->getParams(); + if (fetchId) { + grp_par = inspar; + fetchId = false; + } else { + grp_par.filename = inspar.filename; + ig->setParams(grp_par); + } + } + from.forwardInset(); + } + dr.screenUpdate(Update::Force); //needed if triggered from context menu + break; + } + case LFUN_STATISTICS: { DocIterator from, to; if (cur.selection()) { @@ -1808,10 +1929,12 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr) // At least one complete cell is selected and inset is a table. // Select all cells cur.idx() = 0; + cur.pit() = 0; cur.pos() = 0; cur.resetAnchor(); cur.selection(true); cur.idx() = cur.lastidx(); + cur.pit() = cur.lastpit(); cur.pos() = cur.lastpos(); } else { // select current cell @@ -1828,6 +1951,33 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr) } + case LFUN_UNICODE_INSERT: { + if (cmd.argument().empty()) + break; + + FuncCode code = cur.inset().currentMode() == Inset::MATH_MODE ? + LFUN_MATH_INSERT : LFUN_SELF_INSERT; + int i = 0; + while (true) { + docstring const arg = from_utf8(cmd.getArg(i)); + if (arg.empty()) + break; + if (!isHex(arg)) { + LYXERR0("Not a hexstring: " << arg); + ++i; + continue; + } + char_type c = hexToInt(arg); + if (c >= 32 && c < 0x10ffff) { + LYXERR(Debug::KEY, "Inserting c: " << c); + lyx::dispatch(FuncRequest(code, docstring(1, c))); + } + ++i; + } + break; + } + + // This would be in Buffer class if only Cursor did not // require a bufferview case LFUN_INSET_FORALL: { @@ -1838,20 +1988,20 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr) // an arbitrary number to limit number of iterations const int max_iter = 100000; int iterations = 0; - Cursor & cur = d->cursor_; - Cursor const savecur = cur; - cur.reset(); - if (!cur.nextInset()) - cur.forwardInset(); - cur.beginUndoGroup(); - while(cur && iterations < max_iter) { - Inset * const ins = cur.nextInset(); + Cursor & curs = d->cursor_; + Cursor const savecur = curs; + curs.reset(); + if (!curs.nextInset()) + curs.forwardInset(); + curs.beginUndoGroup(); + while(curs && iterations < max_iter) { + Inset * const ins = curs.nextInset(); if (!ins) break; docstring insname = ins->layoutName(); while (!insname.empty()) { if (insname == name || name == from_utf8("*")) { - cur.recordUndo(); + curs.recordUndo(); lyx::dispatch(fr, dr); ++iterations; break; @@ -1862,11 +2012,11 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr) insname = insname.substr(0, i); } // if we did not delete the inset, skip it - if (!cur.nextInset() || cur.nextInset() == ins) - cur.forwardInset(); + if (!curs.nextInset() || curs.nextInset() == ins) + curs.forwardInset(); } - cur = savecur; - cur.fixIfBroken(); + curs = savecur; + curs.fixIfBroken(); /** This is a dummy undo record only to remember the cursor * that has just been set; this will be used on a redo action * (see ticket #10097) @@ -1874,8 +2024,8 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr) * FIXME: a better fix would be to have a way to set the * cursor value directly, but I am not sure it is worth it. */ - cur.recordUndo(); - cur.endUndoGroup(); + curs.recordUndo(); + curs.endUndoGroup(); dr.screenUpdate(Update::Force); dr.forceBufferUpdate(); @@ -1970,6 +2120,8 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr) icp["key"] = from_utf8(arg); if (!opt1.empty()) icp["before"] = from_utf8(opt1); + icp["literal"] = + from_ascii(InsetCitation::last_literal ? "true" : "false"); string icstr = InsetCommand::params2string(icp); FuncRequest fr(LFUN_INSET_INSERT, icstr); lyx::dispatch(fr); @@ -2390,15 +2542,26 @@ bool BufferView::setCursorFromInset(Inset const * inset) void BufferView::gotoLabel(docstring const & label) { + FuncRequest action; + bool have_inactive = false; for (Buffer const * buf : buffer().allRelatives()) { // find label for (TocItem const & item : *buf->tocBackend().toc("label")) { - if (label == item.str()) { + if (label == item.str() && item.isOutput()) { lyx::dispatch(item.action()); return; } + // If we find an inactive label, save it for the case + // that no active one is there + if (label == item.str() && !have_inactive) { + have_inactive = true; + action = item.action(); + } } } + // We only found an inactive label. Go there. + if (have_inactive) + lyx::dispatch(action); } @@ -2413,8 +2576,9 @@ TextMetrics & BufferView::textMetrics(Text const * t) LBUFERR(t); TextMetricsCache::iterator tmc_it = d->text_metrics_.find(t); if (tmc_it == d->text_metrics_.end()) { - tmc_it = d->text_metrics_.insert( - make_pair(t, TextMetrics(this, const_cast(t)))).first; + tmc_it = d->text_metrics_.emplace(std::piecewise_construct, + std::forward_as_tuple(t), + std::forward_as_tuple(this, const_cast(t))).first; } return tmc_it->second; } @@ -2470,7 +2634,7 @@ bool BufferView::checkDepm(Cursor & cur, Cursor & old) return false; bool need_anchor_change = false; - bool changed = d->cursor_.text()->deleteEmptyParagraphMechanism(cur, old, + bool changed = Text::deleteEmptyParagraphMechanism(cur, old, need_anchor_change); if (need_anchor_change) @@ -2648,6 +2812,7 @@ void BufferView::updateMetrics(Update::flags & update_flags) // Clear out the position cache in case of full screen redraw, d->coord_cache_.clear(); + d->math_rows_.clear(); // Clear out paragraph metrics to avoid having invalid metrics // in the cache from paragraphs not relayouted below @@ -2745,7 +2910,7 @@ void BufferView::updatePosCache() } -void BufferView::insertLyXFile(FileName const & fname) +void BufferView::insertLyXFile(FileName const & fname, bool const ignorelang) { LASSERT(d->cursor_.inTexted(), return); @@ -2763,8 +2928,12 @@ void BufferView::insertLyXFile(FileName const & fname) ErrorList & el = buffer_.errorList("Parse"); // Copy the inserted document error list into the current buffer one. el = buf.errorList("Parse"); + ParagraphList & pars = buf.paragraphs(); + if (ignorelang) + // set main language of imported file to context language + buf.changeLanguage(buf.language(), d->cursor_.getFont().language()); buffer_.undo().recordUndo(d->cursor_); - cap::pasteParagraphList(d->cursor_, buf.paragraphs(), + cap::pasteParagraphList(d->cursor_, pars, buf.params().documentClassPtr(), el); res = _("Document %1$s inserted."); } else { @@ -2881,22 +3050,34 @@ bool BufferView::paragraphVisible(DocIterator const & dit) const void BufferView::caretPosAndHeight(Point & p, int & h) const { + int asc, des; Cursor const & cur = cursor(); - Font const font = cur.real_current_font; - frontend::FontMetrics const & fm = theFontMetrics(font); - int const asc = fm.maxAscent(); - int const des = fm.maxDescent(); + if (cur.inMathed()) { + MathRow const & mrow = mathRow(&cur.cell()); + asc = mrow.caret_ascent; + des = mrow.caret_descent; + } else { + Font const font = cur.real_current_font; + frontend::FontMetrics const & fm = theFontMetrics(font); + asc = fm.maxAscent(); + des = fm.maxDescent(); + } h = asc + des; p = getPos(cur); p.y_ -= asc; } -bool BufferView::cursorInView(Point const & p, int h) const +bool BufferView::caretInView() const { - Cursor const & cur = cursor(); + if (!paragraphVisible(cursor())) + return false; + Point p; + int h; + caretPosAndHeight(p, h); + // does the cursor touch the screen ? - if (p.y_ + h < 0 || p.y_ >= workHeight() || !paragraphVisible(cur)) + if (p.y_ + h < 0 || p.y_ >= workHeight()) return false; return true; } @@ -2921,30 +3102,24 @@ int BufferView::horizScrollOffset(Text const * text, } -bool BufferView::hadHorizScrollOffset(Text const * text, - pit_type pit, pos_type pos) const -{ - return !d->last_row_slice_.empty() - && &text->inset() == d->last_row_slice_.inset().asInsetText() - && pit == d->last_row_slice_.pit() - && pos == d->last_row_slice_.pos(); -} - - void BufferView::setCurrentRowSlice(CursorSlice const & rowSlice) { // nothing to do if the cursor was already on this row - if (d->current_row_slice_ == rowSlice) { - d->last_row_slice_ = CursorSlice(); + if (d->current_row_slice_ == rowSlice) return; - } // if the (previous) current row was scrolled, we have to // remember it in order to repaint it next time. - if (d->horiz_scroll_offset_ != 0) - d->last_row_slice_ = d->current_row_slice_; - else - d->last_row_slice_ = CursorSlice(); + if (d->horiz_scroll_offset_ != 0) { + // search the old row in cache and mark it changed + for (auto & tm_pair : d->text_metrics_) { + if (&tm_pair.first->inset() == rowSlice.inset().asInsetText()) { + tm_pair.second.setRowChanged(rowSlice.pit(), rowSlice.pos()); + // We found it, no need to continue. + break; + } + } + } // Since we changed row, the scroll offset is not valid anymore d->horiz_scroll_offset_ = 0; @@ -2952,29 +3127,6 @@ void BufferView::setCurrentRowSlice(CursorSlice const & rowSlice) } -namespace { - -bool sliceInRow(CursorSlice const & cs, Text const * text, Row const & row) -{ - /* The normal case is the last line. The previous line takes care - * of empty rows (e.g. empty paragraphs). Cursor boundary issues - * are taken care of when setting caret_slice_ in - * BufferView::draw. - */ - return !cs.empty() && cs.text() == text && cs.pit() == row.pit() - && ((row.pos() == row.endpos() && row.pos() == cs.pos()) - || (row.pos() <= cs.pos() && cs.pos() < row.endpos())); -} - -} - - -bool BufferView::needRepaint(Text const * text, Row const & row) const -{ - return d->repaint_caret_row_ && sliceInRow(d->caret_slice_, text, row); -} - - void BufferView::checkCursorScrollOffset() { CursorSlice rowSlice = d->cursor_.bottom(); @@ -3024,8 +3176,7 @@ void BufferView::checkCursorScrollOffset() << d->horiz_scroll_offset_ << " to " << offset); if (d->update_strategy_ == NoScreenUpdate - && (offset != d->horiz_scroll_offset_ - || !d->last_row_slice_.empty())) { + && offset != d->horiz_scroll_offset_) { // FIXME: if one uses SingleParUpdate, then home/end // will not work on long rows. Why? d->update_strategy_ = FullScreenUpdate; @@ -3046,16 +3197,6 @@ void BufferView::draw(frontend::Painter & pain, bool paint_caret) int const y = tm.first().second->position(); PainterInfo pi(this, pain); - /** A repaint of the previous caret row is needed if there is - * caret painted on screen and either - * 1/ a new caret has to be painted at a place different from - * the existing one; - * 2/ there is no need for a caret anymore. - */ - d->repaint_caret_row_ = !d->caret_slice_.empty() && - ((paint_caret && d->cursor_.top() != d->caret_slice_) - || ! paint_caret); - // Check whether the row where the cursor lives needs to be scrolled. // Update the drawing strategy if needed. checkCursorScrollOffset(); @@ -3067,11 +3208,10 @@ void BufferView::draw(frontend::Painter & pain, bool paint_caret) // however, the different coordinates of insets and paragraphs // needs to be updated. LYXERR(Debug::PAINTING, "Strategy: NoScreenUpdate"); - pi.full_repaint = false; if (pain.isNull()) { pi.full_repaint = true; tm.draw(pi, 0, y); - } else if (d->repaint_caret_row_) { + } else { pi.full_repaint = false; tm.draw(pi, 0, y); } @@ -3145,15 +3285,15 @@ void BufferView::draw(frontend::Painter & pain, bool paint_caret) d->update_flags_ = Update::None; } - // Remember what has just been done for the next draw() step + // If a caret has to be painted, mark its text row as dirty to + //make sure that it will be repainted on next redraw. + /* FIXME: investigate whether this can be avoided when the cursor did not + * move at all + */ if (paint_caret) { - d->caret_slice_ = d->cursor_.top(); - if (d->caret_slice_.pos() > 0 - && (d->cursor_.boundary() - || d->caret_slice_.pos() == d->caret_slice_.lastpos())) - --d->caret_slice_.pos(); - } else - d->caret_slice_ = CursorSlice(); + Row const & caret_row = d->cursor_.textRow(); + caret_row.changed(true); + } }