X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FBufferView.cpp;h=af0ad368b32d29188f56f3c5a03138b82d5b7e62;hb=62af7ee772f16f154225d2d0b65d77f4376b6001;hp=dd18b25bd88cebe77acff0b2a173ab768a0c094a;hpb=8f86ee74cddc6d3d9f8eea4d98ad4d4bab842411;p=lyx.git diff --git a/src/BufferView.cpp b/src/BufferView.cpp index dd18b25bd8..af0ad368b3 100644 --- a/src/BufferView.cpp +++ b/src/BufferView.cpp @@ -65,11 +65,13 @@ #include "insets/InsetText.h" #include "mathed/MathData.h" +#include "mathed/InsetMathNest.h" #include "frontends/alert.h" #include "frontends/Application.h" #include "frontends/Delegates.h" #include "frontends/FontMetrics.h" +#include "frontends/NullPainter.h" #include "frontends/Painter.h" #include "frontends/Selection.h" @@ -80,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" @@ -162,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; @@ -216,7 +219,7 @@ enum ScreenUpdateStrategy { DecorationUpdate }; -} // anon namespace +} // namespace ///////////////////////////////////////////////////////////////////// @@ -227,7 +230,9 @@ enum ScreenUpdateStrategy { struct BufferView::Private { - Private(BufferView & bv) : update_strategy_(NoScreenUpdate), + Private(BufferView & bv) : + update_strategy_(FullScreenUpdate), + update_flags_(Update::Force), wh_(0), cursor_(bv), anchor_pit_(0), anchor_ypos_(0), inlineCompletionUniqueChars_(0), @@ -244,7 +249,12 @@ struct BufferView::Private /// ScreenUpdateStrategy update_strategy_; /// + Update::flags update_flags_; + /// CoordCache coord_cache_; + /// + typedef map MathRows; + MathRows math_rows_; /// Estimated average par height for scrollbar. int wh_; @@ -308,9 +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_; }; @@ -338,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); @@ -351,8 +359,8 @@ BufferView::~BufferView() int BufferView::rightMargin() const { - // The value used to be hardcoded to 10, which is 2.5mm at 100dpi - int const default_margin = Length(2.5, Length::MM).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) @@ -368,6 +376,28 @@ int BufferView::leftMargin() const } +int BufferView::inPixels(Length const & len) const +{ + Font const font = buffer().params().getFont(); + return len.inPixels(workWidth(), theFontMetrics(font).em()); +} + + +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; @@ -404,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_; @@ -431,81 +475,96 @@ bool BufferView::needsFitCursor() const } -void BufferView::processUpdateFlags(Update::flags flags) +namespace { + +// this is for debugging only. +string flagsAsString(Update::flags flags) { - // This is close to a hot-path. - LYXERR(Debug::PAINTING, "BufferView::processUpdateFlags()" - << "[fitcursor = " << (flags & Update::FitCursor) - << ", forceupdate = " << (flags & Update::Force) - << ", singlepar = " << (flags & Update::SinglePar) - << "] buffer: " << &buffer_); + if (flags == Update::None) + return "None "; + return string((flags & Update::FitCursor) ? "FitCursor " : "") + + ((flags & Update::Force) ? "Force " : "") + + ((flags & Update::ForceDraw) ? "ForceDraw " : "") + + ((flags & Update::SinglePar) ? "SinglePar " : "") + + ((flags & Update::Decoration) ? "Decoration " : ""); +} - // FIXME Does this really need doing here? It's done in updateBuffer, and - // if the Buffer doesn't need updating, then do the macros? - buffer_.updateMacros(); +} - // Now do the first drawing step if needed. This consists on updating - // the CoordCache in updateMetrics(). - // The second drawing step is done in WorkArea::redraw() if needed. - // FIXME: is this still true now that Buffer::changed() is used all over? +void BufferView::processUpdateFlags(Update::flags flags) +{ + LYXERR(Debug::PAINTING, "BufferView::processUpdateFlags( " + << flagsAsString(flags) << ") buffer: " << &buffer_); // Case when no explicit update is requested. - if (!flags) { - // no need to redraw anything. - d->update_strategy_ = NoScreenUpdate; + if (flags == Update::None) return; - } - if (flags == Update::Decoration) { - d->update_strategy_ = DecorationUpdate; - buffer_.changed(false); - return; + /* 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) { + // This will update the CoordCache items and replace Force + // with ForceDraw in flags. + updateMetrics(flags); } - if (flags == Update::FitCursor - || flags == (Update::Decoration | Update::FitCursor)) { - // tell the frontend to update the screen if needed. + // 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()) { - showCursor(); - return; + // 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); } - if (flags & Update::Decoration) { - d->update_strategy_ = DecorationUpdate; - buffer_.changed(false); - return; - } - // no screen update is needed in principle, but this - // could change if cursor row needs horizontal scrolling. - d->update_strategy_ = NoScreenUpdate; - buffer_.changed(false); - return; + flags = flags & ~Update::FitCursor; } - bool const full_metrics = flags & Update::Force || !singleParUpdate(); - - if (full_metrics) - // We have to update the full screen metrics. - updateMetrics(); - - if (!(flags & Update::FitCursor)) { - // Nothing to do anymore. Trigger a redraw and return - buffer_.changed(false); - return; - } + // 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)); - // updateMetrics() does not update paragraph position - // This is done at draw() time. So we need a redraw! - // We pass true so that metrics are computed for the sake - // of having MacroData updated. - buffer_.changed(true); + // Now compute the update strategy + // Possibly values in flag are None, SinglePar, Decoration, ForceDraw + LATTEST((d->update_flags_ & ~(Update::None | Update::SinglePar + | Update::Decoration | Update::ForceDraw)) == 0); - if (needsFitCursor()) { - // The cursor is off screen so ensure it is visible. - // refresh it: - showCursor(); + if (d->update_flags_ & Update::ForceDraw) + d->update_strategy_ = FullScreenUpdate; + else if (d->update_flags_ & Update::Decoration) + d->update_strategy_ = DecorationUpdate; + else if (d->update_flags_ & Update::SinglePar) + d->update_strategy_ = SingleParUpdate; + else { + // no need to redraw anything. + d->update_strategy_ = NoScreenUpdate; } updateHoveredInset(); + + // Trigger a redraw. + buffer_.changed(false); } @@ -620,8 +679,7 @@ void BufferView::scrollDocView(int const value, bool update) // If the offset is less than 2 screen height, prefer to scroll instead. if (abs(value) <= 2 * height_) { d->anchor_ypos_ -= value; - buffer_.changed(true); - updateHoveredInset(); + processUpdateFlags(Update::Force); return; } @@ -782,7 +840,7 @@ bool BufferView::moveToPosition(pit_type bottom_pit, pos_type bottom_pos, if (!dit.atEnd()) { dit.pos() = min(dit.paragraph().size(), top_pos); // Some slices of the iterator may not be - // reachable (e.g. closed collapsable inset) + // reachable (e.g. closed collapsible inset) // so the dociterator may need to be // shortened. Otherwise, setCursor may crash // lyx when the cursor can not be set to these @@ -818,12 +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(); - // To center the screen on this new position we need the - // paragraph position which is computed at draw() time. - // So we need a redraw! - buffer_.changed(false); - if (needsFitCursor()) - showCursor(); + processUpdateFlags(Update::Force | Update::FitCursor); } return success; @@ -865,19 +918,15 @@ void BufferView::showCursor() void BufferView::showCursor(DocIterator const & dit, bool recenter, bool update) { - if (scrollToCursor(dit, recenter) && update) { - buffer_.changed(true); - updateHoveredInset(); - } + if (scrollToCursor(dit, recenter) && update) + processUpdateFlags(Update::Force); } void BufferView::scrollToCursor() { - if (scrollToCursor(d->cursor_, false)) { - buffer_.changed(true); - updateHoveredInset(); - } + if (scrollToCursor(d->cursor_, false)) + processUpdateFlags(Update::Force); } @@ -915,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); @@ -959,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; @@ -1030,7 +1079,10 @@ bool BufferView::getStatus(FuncRequest const & cmd, FuncStatus & flag) if (buffer_.isReadonly() && !lyxaction.funcHasFlag(act, LyXAction::ReadOnly) && !lyxaction.funcHasFlag(act, LyXAction::NoBuffer)) { - flag.message(from_utf8(N_("Document is read-only"))); + if (buffer_.hasReadonlyFlag()) + flag.message(from_utf8(N_("Document is read-only"))); + else + flag.message(from_utf8(N_("Document has been modified externally"))); flag.setEnabled(false); return true; } @@ -1120,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())); @@ -1216,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); } @@ -1318,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(); @@ -1342,48 +1401,55 @@ 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(); - // we only need to do this if we have deleted or restored a - // BiBTeX inset. but there is no other place to do it. one - // obvious idea is to try to do it in a copy constructor for - // InsetBibTeX, but when that is invoked, the buffer_ member - // is not yet set. another idea is to look at the InsetLists - // of the various paragraphs. but we'd have to recurse through - // the contained insets to make that work. it doesn't seem to - // be worth it, as this will not happen that often. - buffer().invalidateBibfileCache(); - buffer().removeBiblioTempFiles(); + 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(); - // see above - buffer().invalidateBibfileCache(); - buffer().removeBiblioTempFiles(); + dr.forceBufferUpdate(); + if (buffer().params().citeEngine() != engine || + buffer().params().citeEngineType() != enginetype) + buffer().invalidateCiteLabels(); + } break; + } case LFUN_FONT_STATE: - dr.setMessage(cur.currentState()); + dr.setMessage(cur.currentState(false)); break; case LFUN_BOOKMARK_SAVE: @@ -1413,27 +1479,41 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr) case LFUN_PARAGRAPH_GOTO: { int const id = convert(cmd.getArg(0)); - int const pos = convert(cmd.getArg(1)); + pos_type const pos = convert(cmd.getArg(1)); + if (id < 0) + break; + string const str_id_end = cmd.getArg(2); + string const str_pos_end = cmd.getArg(3); int i = 0; 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() << "'."); if (b == &buffer_) { - // Set the cursor - cur.pos() = pos; - mouseSetCursor(cur); - dr.screenUpdate(Update::Force | Update::FitCursor); + bool success; + if (str_id_end.empty() || str_pos_end.empty()) { + // Set the cursor + curs.pos() = pos; + mouseSetCursor(curs); + success = true; + } else { + int const id_end = convert(str_id_end); + pos_type const pos_end = convert(str_pos_end); + success = setCursorFromEntries({id, pos}, + {id_end, pos_end}); + } + if (success) + dr.screenUpdate(Update::Force | Update::FitCursor); } else { // Switch to other buffer view and resend cmd lyx::dispatch(FuncRequest( @@ -1459,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; @@ -1477,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: { @@ -1525,14 +1622,8 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr) docstring const data = find2string(searched_string, true, false, fw); bool found = lyxfind(this, FuncRequest(LFUN_WORD_FIND, data)); - if (found) { + if (found) dr.screenUpdate(Update::Force | Update::FitCursor); - cur.dispatched(); - dispatched = true; - } else { - cur.undispatched(); - dispatched = false; - } break; } @@ -1544,14 +1635,9 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr) lyx::dispatch(FuncRequest(LFUN_DIALOG_SHOW, "findreplace")); break; } - if (lyxfind(this, req)) { + if (lyxfind(this, req)) dr.screenUpdate(Update::Force | Update::FitCursor); - cur.dispatched(); - dispatched = true; - } else { - cur.undispatched(); - dispatched = false; - } + d->search_request_cache_ = req; break; } @@ -1573,11 +1659,6 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr) if (lyxreplace(this, cmd, has_deleted)) { dr.forceBufferUpdate(); dr.screenUpdate(Update::Force | Update::FitCursor); - cur.dispatched(); - dispatched = true; - } else { - cur.undispatched(); - dispatched = false; } break; } @@ -1634,10 +1715,8 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr) InsetBibtex * inset = getInsetByCode(tmpcur, BIBTEX_CODE); if (inset) { - if (inset->addDatabase(cmd.argument())) { - buffer_.invalidateBibfileCache(); + if (inset->addDatabase(cmd.argument())) dr.forceBufferUpdate(); - } } break; } @@ -1648,11 +1727,48 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr) InsetBibtex * inset = getInsetByCode(tmpcur, BIBTEX_CODE); if (inset) { - if (inset->delDatabase(cmd.argument())) { - buffer_.invalidateBibfileCache(); + if (inset->delDatabase(cmd.argument())) dr.forceBufferUpdate(); + } + 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; } @@ -1715,8 +1831,8 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr) bool const in_texted = cur.inTexted(); cur.setCursor(doc_iterator_begin(cur.buffer())); cur.selHandle(false); - buffer_.changed(true); - updateHoveredInset(); + // Force an immediate computation of metrics because we need it below + processUpdateFlags(Update::Force); d->text_metrics_[&buffer_.text()].editXY(cur, p.x_, p.y_, true, act == LFUN_SCREEN_UP); @@ -1750,8 +1866,7 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr) if (scroll_value) scroll(scroll_step * scroll_value); } - buffer_.changed(true); - updateHoveredInset(); + dr.screenUpdate(Update::ForceDraw); dr.forceBufferUpdate(); break; } @@ -1814,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 @@ -1834,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: { @@ -1844,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; @@ -1868,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) @@ -1880,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(); @@ -1907,14 +2051,9 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr) Alert::warning(_("Branch already exists"), drtmp.message()); break; } - BranchList & branch_list = buffer_.params().branchlist(); - vector const branches = - getVectorFromString(branch_name, branch_list.separator()); - for (vector::const_iterator it = branches.begin(); - it != branches.end(); ++it) { - branch_name = *it; - lyx::dispatch(FuncRequest(LFUN_BRANCH_INSERT, branch_name)); - } + docstring const sep = buffer_.params().branchlist().separator(); + for (docstring const & branch : getVectorFromString(branch_name, sep)) + lyx::dispatch(FuncRequest(LFUN_BRANCH_INSERT, branch)); break; } @@ -1981,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); @@ -2183,9 +2324,7 @@ void BufferView::updateHoveredInset() const // This event (moving without mouse click) is not passed further. // This should be changed if it is further utilized. - // We pass true so that metrics are computed for the sake - // of having MacroData updated. - buffer_.changed(true); + buffer_.changed(false); } } @@ -2349,58 +2488,35 @@ int BufferView::scrollUp(int offset) } -void BufferView::setCursorFromRow(int row) +bool BufferView::setCursorFromRow(int row) { - setCursorFromRow(row, buffer_.texrow()); + TexRow::TextEntry start, end; + tie(start,end) = buffer_.texrow().getEntriesFromRow(row); + LYXERR(Debug::LATEX, + "setCursorFromRow: for row " << row << ", TexRow has found " + "start (id=" << start.id << ",pos=" << start.pos << "), " + "end (id=" << end.id << ",pos=" << end.pos << ")"); + return setCursorFromEntries(start, end); } -void BufferView::setCursorFromRow(int row, TexRow const & texrow) +bool BufferView::setCursorFromEntries(TexRow::TextEntry start, + TexRow::TextEntry end) { - int tmpid; - int tmppos; - pit_type newpit = 0; - pos_type newpos = 0; - - texrow.getIdFromRow(row, tmpid, tmppos); - - bool posvalid = (tmpid != -1); - if (posvalid) { - // we need to make sure that the row and position - // we got back are valid, because the buffer may well - // have changed since we last generated the LaTeX. - DocIterator dit = buffer_.getParFromID(tmpid); - if (dit == doc_iterator_end(&buffer_)) - posvalid = false; - else if (dit.depth() > 1) { - // We are in an inset. - pos_type lastpos = dit.lastpos(); - dit.pos() = tmppos > lastpos ? lastpos : tmppos; - setCursor(dit); - recenter(); - return; - } else { - newpit = dit.pit(); - // now have to check pos. - newpos = tmppos; - Paragraph const & par = buffer_.text().getPar(newpit); - if (newpos > par.size()) { - LYXERR0("Requested position no longer valid."); - newpos = par.size() - 1; - } - } - } - if (!posvalid) { - frontend::Alert::error(_("Inverse Search Failed"), - _("Invalid position requested by inverse search.\n" - "You need to update the viewed document.")); - return; + DocIterator dit_start, dit_end; + tie(dit_start,dit_end) = + TexRow::getDocIteratorsFromEntries(start, end, buffer_); + if (!dit_start) + return false; + // Setting selection start + d->cursor_.clearSelection(); + setCursor(dit_start); + // Setting selection end + if (dit_end) { + d->cursor_.resetAnchor(); + setCursorSelectionTo(dit_end); } - d->cursor_.reset(); - buffer_.text().setCursor(d->cursor_, newpit, newpos); - d->cursor_.selection(false); - d->cursor_.resetAnchor(); - recenter(); + return true; } @@ -2426,22 +2542,26 @@ bool BufferView::setCursorFromInset(Inset const * inset) void BufferView::gotoLabel(docstring const & label) { - ListOfBuffers bufs = buffer().allRelatives(); - ListOfBuffers::iterator it = bufs.begin(); - for (; it != bufs.end(); ++it) { - Buffer const * buf = *it; - + FuncRequest action; + bool have_inactive = false; + for (Buffer const * buf : buffer().allRelatives()) { // find label - shared_ptr toc = buf->tocBackend().toc("label"); - Toc::const_iterator toc_it = toc->begin(); - Toc::const_iterator end = toc->end(); - for (; toc_it != end; ++toc_it) { - if (label == toc_it->str()) { - lyx::dispatch(toc_it->action()); + for (TocItem const & item : *buf->tocBackend().toc("label")) { + 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); } @@ -2456,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; } @@ -2494,6 +2615,18 @@ void BufferView::setCursor(DocIterator const & dit) } +void BufferView::setCursorSelectionTo(DocIterator const & dit) +{ + size_t const n = dit.depth(); + for (size_t i = 0; i < n; ++i) + dit[i].inset().edit(d->cursor_, true); + + d->cursor_.selection(true); + d->cursor_.setCursorSelectionTo(dit); + d->cursor_.setCurrentFont(); +} + + bool BufferView::checkDepm(Cursor & cur, Cursor & old) { // Would be wrong to delete anything if we have a selection. @@ -2501,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) @@ -2521,7 +2654,7 @@ bool BufferView::checkDepm(Cursor & cur, Cursor & old) } -bool BufferView::mouseSetCursor(Cursor & cur, bool select) +bool BufferView::mouseSetCursor(Cursor & cur, bool const select) { LASSERT(&cur.bv() == this, return false); @@ -2539,27 +2672,23 @@ bool BufferView::mouseSetCursor(Cursor & cur, bool select) if (leftinset) d->cursor_.fixIfBroken(); - // FIXME: shift-mouse selection doesn't work well across insets. - bool const do_selection = - select && &d->cursor_.normalAnchor().inset() == &cur.inset(); - // do the dEPM magic if needed // FIXME: (1) move this to InsetText::notifyCursorLeaves? // FIXME: (2) if we had a working InsetText::notifyCursorLeaves, // the leftinset bool would not be necessary (badcursor instead). bool update = leftinset; - if (!do_selection && d->cursor_.inTexted()) - update |= checkDepm(cur, d->cursor_); - if (!do_selection) - d->cursor_.resetAnchor(); - d->cursor_.setCursor(cur); - d->cursor_.boundary(cur.boundary()); - if (do_selection) + if (select) { d->cursor_.setSelection(); - else + d->cursor_.setCursorSelectionTo(cur); + } else { + if (d->cursor_.inTexted()) + update |= checkDepm(cur, d->cursor_); + d->cursor_.resetAnchor(); + d->cursor_.setCursor(cur); d->cursor_.clearSelection(); - + } + d->cursor_.boundary(cur.boundary()); d->cursor_.finishUndo(); d->cursor_.setCurrentFont(); if (update) @@ -2634,12 +2763,6 @@ Cursor const & BufferView::cursor() const } -pit_type BufferView::anchor_ref() const -{ - return d->anchor_pit_; -} - - bool BufferView::singleParUpdate() { Text & buftext = buffer_.text(); @@ -2662,7 +2785,7 @@ bool BufferView::singleParUpdate() // the singlePar optimisation. return false; - d->update_strategy_ = SingleParUpdate; + tm.updatePosCache(bottom_pit); LYXERR(Debug::PAINTING, "\ny1: " << pm.position() - pm.ascent() << " y2: " << pm.position() + pm.descent() @@ -2673,6 +2796,13 @@ bool BufferView::singleParUpdate() void BufferView::updateMetrics() +{ + updateMetrics(d->update_flags_); + d->update_strategy_ = FullScreenUpdate; +} + + +void BufferView::updateMetrics(Update::flags & update_flags) { if (height_ == 0 || width_ == 0) return; @@ -2682,6 +2812,7 @@ void BufferView::updateMetrics() // 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 @@ -2709,12 +2840,13 @@ void BufferView::updateMetrics() // Complete buffer visible? Then it's easy. if (scrollRange == 0) d->anchor_ypos_ = anchor_pm.ascent(); - - // FIXME: Some clever handling needed to show - // the _first_ paragraph up to the top if the cursor is - // in the first line. + else { + // avoid empty space above the first row + d->anchor_ypos_ = min(d->anchor_ypos_, anchor_pm.ascent()); + } } anchor_pm.setPosition(d->anchor_ypos_); + tm.updatePosCache(d->anchor_pit_); LYXERR(Debug::PAINTING, "metrics: " << " anchor pit = " << d->anchor_pit_ @@ -2730,6 +2862,7 @@ void BufferView::updateMetrics() y1 -= pm.descent(); // Save the paragraph position in the cache. pm.setPosition(y1); + tm.updatePosCache(pit1); y1 -= pm.ascent(); } @@ -2743,6 +2876,7 @@ void BufferView::updateMetrics() y2 += pm.ascent(); // Save the paragraph position in the cache. pm.setPosition(y2); + tm.updatePosCache(pit2); y2 += pm.descent(); } @@ -2754,7 +2888,11 @@ void BufferView::updateMetrics() << " pit1 = " << pit1 << " pit2 = " << pit2); - d->update_strategy_ = FullScreenUpdate; + // metrics is done, full drawing is necessary now + update_flags = (update_flags & ~Update::Force) | Update::ForceDraw; + + // Now update the positions of insets in the cache. + updatePosCache(); if (lyxerr.debugging(Debug::WORKAREA)) { LYXERR(Debug::WORKAREA, "BufferView::updateMetrics"); @@ -2763,7 +2901,16 @@ void BufferView::updateMetrics() } -void BufferView::insertLyXFile(FileName const & fname) +void BufferView::updatePosCache() +{ + // this is the "nodraw" drawing stage: only set the positions of the + // insets in metrics cache. + frontend::NullPainter np; + draw(np, false); +} + + +void BufferView::insertLyXFile(FileName const & fname, bool const ignorelang) { LASSERT(d->cursor_.inTexted(), return); @@ -2781,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 { @@ -2825,19 +2976,7 @@ Point BufferView::coordOffset(DocIterator const & dit) const } // remember width for the case that sl.inset() is positioned in an RTL inset - if (i && dit[i - 1].text()) { - // If this Inset is inside a Text Inset, retrieve the Dimension - // from the containing text instead of using Inset::dimension() which - // might not be implemented. - // FIXME (Abdel 23/09/2007): this is a bit messy because of the - // elimination of Inset::dim_ cache. This coordOffset() method needs - // to be rewritten in light of the new design. - Dimension const & dim = coordCache().getInsets().dim(&sl.inset()); - lastw = dim.wid; - } else { - Dimension const dim = sl.inset().dimension(*this); - lastw = dim.wid; - } + lastw = sl.inset().dimension(*this).wid; //lyxerr << "Cursor::getPos, i: " // << i << " x: " << xx << " y: " << y << endl; @@ -2909,24 +3048,36 @@ bool BufferView::paragraphVisible(DocIterator const & dit) const } -void BufferView::cursorPosAndHeight(Point & p, int & h) const +void BufferView::caretPosAndHeight(Point & p, int & h) const { + int asc, des; Cursor const & cur = cursor(); - Font const font = cur.getFont(); - 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; } @@ -2951,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; @@ -2982,7 +3127,7 @@ void BufferView::setCurrentRowSlice(CursorSlice const & rowSlice) } -void BufferView::checkCursorScrollOffset(PainterInfo & pi) +void BufferView::checkCursorScrollOffset() { CursorSlice rowSlice = d->cursor_.bottom(); TextMetrics const & tm = textMetrics(rowSlice.text()); @@ -2999,35 +3144,6 @@ void BufferView::checkCursorScrollOffset(PainterInfo & pi) // Set the row on which the cursor lives. setCurrentRowSlice(rowSlice); - // If insets referred to by cursor are not all in the cache, the positions - // need to be recomputed. - if (!d->cursor_.inCoordCache()) { - /** FIXME: the code below adds an extraneous computation of - * inset positions, and can therefore be bad for performance - * (think for example about a very large tabular inset. - * Redawing the row where it is means redrawing the whole - * screen). - * - * The bug that this fixes is the following: assume that there - * is a very large math inset. Upon entering the inset, when - * pressing `End', the row is not scrolled and the cursor is - * not visible. The extra row computation makes sure that the - * inset positions are correctly computed and set in the - * cache. This would not happen if we did not have two-stage - * drawing. - * - * A proper fix would be to always have proper inset positions - * at this point. - */ - // Force the recomputation of inset positions - bool const drawing = pi.pain.isDrawingEnabled(); - pi.pain.setDrawingEnabled(false); - // No need to care about vertical position. - RowPainter rp(pi, buffer().text(), row, -d->horiz_scroll_offset_, 0); - rp.paintText(); - pi.pain.setDrawingEnabled(drawing); - } - // Current x position of the cursor in pixels int cur_x = getPos(d->cursor_).x_; @@ -3060,8 +3176,7 @@ void BufferView::checkCursorScrollOffset(PainterInfo & pi) << 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; @@ -3071,12 +3186,12 @@ void BufferView::checkCursorScrollOffset(PainterInfo & pi) } -void BufferView::draw(frontend::Painter & pain) +void BufferView::draw(frontend::Painter & pain, bool paint_caret) { if (height_ == 0 || width_ == 0) return; - LYXERR(Debug::PAINTING, "\t\t*** START DRAWING ***"); - + LYXERR(Debug::PAINTING, (pain.isNull() ? "\t\t--- START NODRAW ---" + : "\t\t*** START DRAWING ***")); Text & text = buffer_.text(); TextMetrics const & tm = d->text_metrics_[&text]; int const y = tm.first().second->position(); @@ -3084,17 +3199,22 @@ void BufferView::draw(frontend::Painter & pain) // Check whether the row where the cursor lives needs to be scrolled. // Update the drawing strategy if needed. - checkCursorScrollOffset(pi); + checkCursorScrollOffset(); switch (d->update_strategy_) { case NoScreenUpdate: - // If no screen painting is actually needed, only some the different - // coordinates of insets and paragraphs needs to be updated. + // no screen painting is actually needed. In nodraw stage + // however, the different coordinates of insets and paragraphs + // needs to be updated. LYXERR(Debug::PAINTING, "Strategy: NoScreenUpdate"); - pi.full_repaint = true; - pi.pain.setDrawingEnabled(false); - tm.draw(pi, 0, y); + if (pain.isNull()) { + pi.full_repaint = true; + tm.draw(pi, 0, y); + } else { + pi.full_repaint = false; + tm.draw(pi, 0, y); + } break; case SingleParUpdate: @@ -3139,7 +3259,8 @@ void BufferView::draw(frontend::Painter & pain) } break; } - LYXERR(Debug::PAINTING, "\n\t\t*** END DRAWING ***"); + LYXERR(Debug::PAINTING, (pain.isNull() ? "\t\t --- END NODRAW ---" + : "\t\t *** END DRAWING ***")); // The scrollbar needs an update. updateScrollbar(); @@ -3150,13 +3271,29 @@ void BufferView::draw(frontend::Painter & pain) for (pit_type pit = firstpm.first; pit <= lastpm.first; ++pit) { ParagraphMetrics const & pm = tm.parMetrics(pit); if (pm.position() + pm.descent() > 0) { + if (d->anchor_pit_ != pit + || d->anchor_ypos_ != pm.position()) + LYXERR(Debug::PAINTING, "Found new anchor pit = " << d->anchor_pit_ + << " anchor ypos = " << d->anchor_ypos_); d->anchor_pit_ = pit; d->anchor_ypos_ = pm.position(); break; } } - LYXERR(Debug::PAINTING, "Found new anchor pit = " << d->anchor_pit_ - << " anchor ypos = " << d->anchor_ypos_); + if (!pain.isNull()) { + // reset the update flags, everything has been done + d->update_flags_ = Update::None; + } + + // 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) { + Row const & caret_row = d->cursor_.textRow(); + caret_row.changed(true); + } }