X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FBufferView.cpp;h=9931c3f3dd949d510dc7017d7bc7e041283ad262;hb=4ed0312c51704780af1c452d3a82a84171b3725a;hp=730f0e50dab698e76ed68d31aa15ba89a05813b7;hpb=b87a81c39477ea86499f67db31003dbb1b3f76d1;p=lyx.git diff --git a/src/BufferView.cpp b/src/BufferView.cpp index 730f0e50da..9931c3f3dd 100644 --- a/src/BufferView.cpp +++ b/src/BufferView.cpp @@ -20,6 +20,7 @@ #include "Buffer.h" #include "BufferList.h" #include "BufferParams.h" +#include "BiblioInfo.h" #include "CoordCache.h" #include "Cursor.h" #include "CutAndPaste.h" @@ -38,6 +39,7 @@ #include "MetricsInfo.h" #include "Paragraph.h" #include "Session.h" +#include "texstream.h" #include "Text.h" #include "TextMetrics.h" #include "TexRow.h" @@ -47,6 +49,7 @@ #include "insets/InsetCitation.h" #include "insets/InsetCommand.h" // ChangeRefs #include "insets/InsetGraphics.h" +#include "insets/InsetIndex.h" #include "insets/InsetRef.h" #include "insets/InsetText.h" @@ -67,6 +70,7 @@ #include "support/convert.h" #include "support/debug.h" #include "support/docstring.h" +#include "support/docstring_list.h" #include "support/filetools.h" #include "support/gettext.h" #include "support/lassert.h" @@ -171,18 +175,18 @@ bool findInset(DocIterator & dit, vector const & codes, /// Moves cursor to the next inset with one of the given codes. -void gotoInset(BufferView * bv, vector const & codes, +bool gotoInset(BufferView * bv, vector const & codes, bool same_content) { Cursor tmpcur = bv->cursor(); if (!findInset(tmpcur, codes, same_content)) { bv->cursor().message(_("No more insets")); - return; + return false; } tmpcur.clearSelection(); bv->setCursor(tmpcur); - bv->showCursor(); + return bv->scrollToCursor(bv->cursor(), SCROLL_TOP); } @@ -228,7 +232,7 @@ struct BufferView::Private /// CoordCache coord_cache_; /// - typedef map MathRows; + typedef unordered_map MathRows; MathRows math_rows_; /// this is used to handle XSelection events in the right manner. @@ -292,6 +296,8 @@ struct BufferView::Private bool clickable_inset_; /// shape of the caret frontend::CaretGeometry caret_geometry_; + /// + bool mouse_selecting_ = false; }; @@ -331,16 +337,23 @@ BufferView::~BufferView() } -int BufferView::rightMargin() const +int BufferView::defaultMargin() const { // 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) - return default_margin; + return zoomedPixels(20); +} - return (width_ - lyxrc.full_screen_width) / 2; + +int BufferView::rightMargin() const +{ + const int screen_width = inPixels(lyxrc.screen_width); + + // The additional test for the case the outliner is opened. + if (!lyxrc.screen_limit || width_ < screen_width + 2 * defaultMargin()) { + return defaultMargin(); + } else { + return (width_ - screen_width) / 2; + } } @@ -537,13 +550,13 @@ void BufferView::processUpdateFlags(Update::flags flags) if (needsFitCursor()) { // First try to make the selection start visible // (which is just the cursor when there is no selection) - scrollToCursor(d->cursor_.selectionBegin(), false); + scrollToCursor(d->cursor_.selectionBegin(), SCROLL_VISIBLE); // Metrics have to be recomputed (maybe again) updateMetrics(); // 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); + scrollToCursor(d->cursor_, SCROLL_VISIBLE); // Metrics have to be recomputed (maybe again) updateMetrics(flags); } @@ -579,7 +592,7 @@ void BufferView::processUpdateFlags(Update::flags flags) } -void BufferView::updateScrollbar() +void BufferView::updateScrollbarParameters() { if (height_ == 0 && width_ == 0) return; @@ -737,7 +750,7 @@ void BufferView::scrollDocView(int const pixels, bool update) // cut off at the top if (pixels <= d->scrollbarParameters_.min) { DocIterator dit = doc_iterator_begin(&buffer_); - showCursor(dit, false, update); + showCursor(dit, SCROLL_VISIBLE, update); LYXERR(Debug::SCROLLING, "scroll to top"); return; } @@ -746,7 +759,7 @@ void BufferView::scrollDocView(int const pixels, bool update) if (pixels >= d->scrollbarParameters_.max) { DocIterator dit = doc_iterator_end(&buffer_); dit.backwardPos(); - showCursor(dit, false, update); + showCursor(dit, SCROLL_VISIBLE, update); LYXERR(Debug::SCROLLING, "scroll to bottom"); return; } @@ -771,7 +784,7 @@ void BufferView::scrollDocView(int const pixels, bool update) DocIterator dit = doc_iterator_begin(&buffer_); dit.pit() = i; LYXERR(Debug::SCROLLING, "pixels = " << pixels << " -> scroll to pit " << i); - showCursor(dit, false, update); + showCursor(dit, SCROLL_VISIBLE, update); } @@ -913,7 +926,7 @@ bool BufferView::moveToPosition(pit_type bottom_pit, pos_type bottom_pos, // restoration is inaccurate. If a bookmark was within an inset, // it will be restored to the left of the outmost inset that contains // the bookmark. - if (bottom_pit < int(buffer_.paragraphs().size())) { + if (!success && bottom_pit < int(buffer_.paragraphs().size())) { dit = doc_iterator_begin(&buffer_); dit.pit() = bottom_pit; @@ -957,41 +970,36 @@ int BufferView::workWidth() const void BufferView::recenter() { - showCursor(d->cursor_, true, true); + showCursor(d->cursor_, SCROLL_CENTER, true); } void BufferView::showCursor() { - showCursor(d->cursor_, false, true); -} - - -void BufferView::showCursor(DocIterator const & dit, - bool recenter, bool update) -{ - if (scrollToCursor(dit, recenter) && update) - processUpdateFlags(Update::Force); + showCursor(d->cursor_, SCROLL_VISIBLE, true); } -void BufferView::scrollToCursor() +void BufferView::showCursor(DocIterator const & dit, ScrollType how, + bool update) { - if (scrollToCursor(d->cursor_, false)) + if (scrollToCursor(dit, how) && update) processUpdateFlags(Update::Force); } -bool BufferView::scrollToCursor(DocIterator const & dit, bool const recenter) +bool BufferView::scrollToCursor(DocIterator const & dit, ScrollType how) { // We are not properly started yet, delay until resizing is done. if (height_ == 0) return false; - if (recenter) - LYXERR(Debug::SCROLLING, "recentering and scrolling to cursor"); + if (how == SCROLL_CENTER) + LYXERR(Debug::SCROLLING, "Centering cursor in workarea"); + else if (how == SCROLL_TOP) + LYXERR(Debug::SCROLLING, "Setting cursor to top of workarea"); else - LYXERR(Debug::SCROLLING, "scrolling to cursor"); + LYXERR(Debug::SCROLLING, "Making sure cursor is visible in workarea"); CursorSlice const & bot = dit.bottom(); TextMetrics & tm = textMetrics(bot.text()); @@ -1010,7 +1018,7 @@ bool BufferView::scrollToCursor(DocIterator const & dit, bool const recenter) else if (bot_pit == tm.last().first + 1) tm.newParMetricsDown(); - if (tm.contains(bot_pit)) { + if (tm.contains(bot_pit) && how == SCROLL_VISIBLE) { ParagraphMetrics const & pm = tm.parMetrics(bot_pit); LBUFERR(!pm.rows().empty()); // FIXME: smooth scrolling doesn't work in mathed. @@ -1021,14 +1029,12 @@ bool BufferView::scrollToCursor(DocIterator const & dit, bool const recenter) Dimension const & row_dim = inner_pm.getRow(cs.pos(), dit.boundary()).dim(); int scrolled = 0; - if (recenter) - scrolled = scroll(ypos - height_/2); // We try to visualize the whole row, if the row height is larger than // the screen height, we scroll to a heuristic value of height_ / 4. // FIXME: This heuristic value should be replaced by a recursive search // for a row in the inset that can be visualized completely. - else if (row_dim.height() > height_) { + if (row_dim.height() > height_) { if (ypos < defaultRowHeight()) scrolled = scroll(ypos - height_ / 4); else if (ypos > height_ - defaultRowHeight()) @@ -1057,28 +1063,21 @@ bool BufferView::scrollToCursor(DocIterator const & dit, bool const recenter) d->inlineCompletionPos_ = DocIterator(); tm.redoParagraph(bot_pit); - ParagraphMetrics const & pm = tm.parMetrics(bot_pit); int const offset = coordOffset(dit).y_; - + pit_type const old_pit = d->anchor_pit_; d->anchor_pit_ = bot_pit; + CursorSlice const & cs = dit.innerTextSlice(); ParagraphMetrics const & inner_pm = textMetrics(cs.text()).parMetrics(cs.pit()); Dimension const & row_dim = inner_pm.getRow(cs.pos(), dit.boundary()).dim(); - if (recenter) - d->anchor_ypos_ = height_/2; - else if (d->anchor_pit_ == 0) - d->anchor_ypos_ = offset + pm.ascent(); - else if (d->anchor_pit_ == max_pit) - d->anchor_ypos_ = height_ - offset - row_dim.descent(); - else if (offset > height_) - d->anchor_ypos_ = height_ - offset - defaultRowHeight(); - else - d->anchor_ypos_ = defaultRowHeight() * 2; - - return true; + int const old_ypos = d->anchor_ypos_; + d->anchor_ypos_ = - offset + row_dim.ascent(); + if (how == SCROLL_CENTER) + d->anchor_ypos_ += height_/2 - row_dim.height() / 2; + return d->anchor_ypos_ != old_ypos || d->anchor_pit_ != old_pit; } @@ -1092,8 +1091,6 @@ void BufferView::makeDocumentClass() void BufferView::updateDocumentClass(DocumentClassConstPtr olddc) { - message(_("Converting document to new document class...")); - StableDocIterator backcur(d->cursor_); ErrorList & el = buffer_.errorList("Class Switch"); cap::switchBetweenClasses( @@ -1221,6 +1218,7 @@ bool BufferView::getStatus(FuncRequest const & cmd, FuncStatus & flag) case LFUN_SCREEN_SHOW_CURSOR: case LFUN_BIBTEX_DATABASE_ADD: case LFUN_BIBTEX_DATABASE_DEL: + case LFUN_BIBTEX_DATABASE_LIST: case LFUN_STATISTICS: case LFUN_KEYMAP_OFF: case LFUN_KEYMAP_PRIMARY: @@ -1484,6 +1482,7 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr) else { dr.screenUpdate(Update::Force | Update::FitCursor); dr.forceBufferUpdate(); + resetInlineCompletionPos(); if (buffer().params().citeEngine() != engine || buffer().params().citeEngineType() != enginetype) buffer().invalidateCiteLabels(); @@ -1504,6 +1503,7 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr) else { dr.screenUpdate(Update::Force | Update::FitCursor); dr.forceBufferUpdate(); + resetInlineCompletionPos(); if (buffer().params().citeEngine() != engine || buffer().params().citeEngineType() != enginetype) buffer().invalidateCiteLabels(); @@ -1582,8 +1582,8 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr) success = setCursorFromEntries({id, pos}, {id_end, pos_end}); } - if (success) - dr.screenUpdate(Update::Force | Update::FitCursor); + if (success && scrollToCursor(d->cursor_, SCROLL_TOP)) + dr.screenUpdate(Update::Force); } else { // Switch to other buffer view and resend cmd lyx::dispatch(FuncRequest( @@ -1596,19 +1596,13 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr) } case LFUN_NOTE_NEXT: - gotoInset(this, { NOTE_CODE }, false); - // FIXME: if SinglePar is changed to act on the inner - // paragraph, this will not be OK anymore. The update is - // useful for auto-open collapsible insets. - dr.screenUpdate(Update::SinglePar | Update::FitCursor); + if (gotoInset(this, { NOTE_CODE }, false)) + dr.screenUpdate(Update::Force); break; case LFUN_REFERENCE_NEXT: { - gotoInset(this, { LABEL_CODE, REF_CODE }, true); - // FIXME: if SinglePar is changed to act on the inner - // paragraph, this will not be OK anymore. The update is - // useful for auto-open collapsible insets. - dr.screenUpdate(Update::SinglePar | Update::FitCursor); + if (gotoInset(this, { LABEL_CODE, REF_CODE }, true)) + dr.screenUpdate(Update::Force); break; } @@ -1726,6 +1720,8 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr) } if (cur.selection()) pattern = cur.selectionAsString(false); + else if (!cur.inTexted()) + break; // not suitable for selectWord at cursor else { pos_type spos = cur.pos(); cur.innerText()->selectWord(cur, WHOLE_WORD); @@ -1762,6 +1758,78 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr) break; } + case LFUN_INDEX_TAG_ALL: { + Inset * ins = cur.nextInset(); + if (!ins || ins->lyxCode() != INDEX_CODE) + // not at index inset + break; + + // clone the index inset + InsetIndex * cins = + new InsetIndex(static_cast(*cur.nextInset())); + // In order to avoid duplication, we compare the + // LaTeX output if we find another index inset after + // the word + odocstringstream oilatex; + otexstream oits(oilatex); + OutputParams rp(&cur.buffer()->params().encoding()); + ins->latex(oits, rp); + cap::copyInsetToTemp(cur, cins); + + // move backwards into preceding word + // skip over other index insets + cur.backwardPosIgnoreCollapsed(); + while (true) { + if (cur.inset().lyxCode() == INDEX_CODE) + cur.pop_back(); + else if (cur.prevInset() && cur.prevInset()->lyxCode() == INDEX_CODE) + cur.backwardPosIgnoreCollapsed(); + else + break; + } + if (!cur.inTexted()) { + // Nothing to do here. + setCursorFromInset(ins); + break; + } + // Get word or selection + cur.text()->selectWord(cur, WHOLE_WORD); + docstring const searched_string = cur.selectionAsString(false); + // Start from the beginning + lyx::dispatch(FuncRequest(LFUN_BUFFER_BEGIN)); + while (findOne(this, searched_string, + false,// case sensitive + true,// match whole word only + true,// forward + false,//find deleted + false,//check wrap + false,// auto-wrap + false,// instant + false// only selection + )) { + cur.clearSelection(); + Inset * ains = cur.nextInset(); + if (ains && ains->lyxCode() == INDEX_CODE) { + // We have an index inset. + // Check whether it has the same + // LaTeX content and move on if so. + odocstringstream filatex; + otexstream fits(filatex); + ains->latex(fits, rp); + if (oilatex.str() == filatex.str()) + continue; + } + // Paste the inset and possibly continue + cap::pasteFromTemp(cursor(), cursor().buffer()->errorList("Paste")); + } + // Go back to start position. + setCursorFromInset(ins); + dr.screenUpdate(cur.result().screenUpdate()); + if (cur.result().needBufferUpdate()) + dr.forceBufferUpdate(); + break; + } + case LFUN_MARK_OFF: cur.clearSelection(); dr.setMessage(from_utf8(N_("Mark off"))); @@ -1856,6 +1924,25 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr) break; } + case LFUN_BIBTEX_DATABASE_LIST: { + docstring_list const & files = buffer_.getBibfiles(); + bool first = true; + docstring result; + char const separator(os::path_separator()); + for (auto const & file : files) { + if (first) + first = false; + else + result += separator; + + FileName const fn = buffer_.getBibfilePath(file); + string const path = fn.realPath(); + result += from_utf8(os::external_path(path)); + } + dr.setMessage(result); + break; + } + case LFUN_STATISTICS: { DocIterator from, to; if (cur.selection()) { @@ -1881,16 +1968,14 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr) message += _("One word"); message += "\n"; if (chars_blanks != 1) - message += bformat(_("%1$d characters (including blanks)"), - chars_blanks); + message += bformat(_("%1$d characters"), chars_blanks); else - message += _("One character (including blanks)"); + message += _("One character"); message += "\n"; if (chars != 1) - message += bformat(_("%1$d characters (excluding blanks)"), - chars); + message += bformat(_("%1$d characters (no blanks)"), chars); else - message += _("One character (excluding blanks)"); + message += _("One character (no blanks)"); Alert::information(_("Statistics"), message); } @@ -1916,7 +2001,8 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr) cur.setCursor(doc_iterator_begin(cur.buffer())); cur.selHandle(false); // Force an immediate computation of metrics because we need it below - updateMetrics(); + if (scrolled) + processUpdateFlags(Update::Force); d->text_metrics_[&buffer_.text()].editXY(cur, p.x_, p.y_, true, act == LFUN_SCREEN_UP); @@ -2072,21 +2158,22 @@ 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 & 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(); + Cursor & bvcur = d->cursor_; + Cursor const savecur = bvcur; + bvcur.reset(); + if (!bvcur.nextInset()) + bvcur.forwardInset(); + bvcur.beginUndoGroup(); + while(bvcur && iterations < max_iter) { + Inset * const ins = bvcur.nextInset(); if (!ins) break; docstring insname = ins->layoutName(); while (!insname.empty()) { if (insname == name || name == from_utf8("*")) { - curs.recordUndo(); lyx::dispatch(fr, dr); + // we do not want to remember selection here + bvcur.clearSelection(); ++iterations; break; } @@ -2096,11 +2183,11 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr) insname = insname.substr(0, i); } // if we did not delete the inset, skip it - if (!curs.nextInset() || curs.nextInset() == ins) - curs.forwardInset(); + if (!bvcur.nextInset() || bvcur.nextInset() == ins) + bvcur.forwardInset(); } - curs = savecur; - curs.fixIfBroken(); + bvcur = savecur; + bvcur.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) @@ -2108,8 +2195,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. */ - curs.recordUndo(); - curs.endUndoGroup(); + bvcur.recordUndo(); + bvcur.endUndoGroup(); dr.screenUpdate(Update::Force); dr.forceBufferUpdate(); @@ -2209,6 +2296,28 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr) string icstr = InsetCommand::params2string(icp); FuncRequest fr(LFUN_INSET_INSERT, icstr); lyx::dispatch(fr); + + // if the request comes from the LyX server, then we + // return a list of the undefined keys, in case some + // action could be taken. + if (cmd.origin() != FuncRequest::LYXSERVER) + break; + + vector keys = getVectorFromString(from_utf8(arg)); + vector::iterator it = keys.begin(); + vector::const_iterator end = keys.end(); + + BiblioInfo const & bibInfo = buffer_.masterBibInfo(); + const BiblioInfo::const_iterator bibEnd = bibInfo.end(); + while (it != end) { + if (bibInfo.find(*it) != bibEnd) { + it = keys.erase(it); + end = keys.end(); + } else + ++it; + } + dr.setMessage(getStringFromVector(keys)); + break; } @@ -2264,6 +2373,13 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr) } case LFUN_COPY: + // With multi-cell table content, we pass down to the inset + if (cur.inTexted() && cur.selection() + && cur.selectionBegin().idx() != cur.selectionEnd().idx()) { + buffer_.dispatch(cmd, dr); + dispatched = dr.dispatched(); + break; + } cap::copySelection(cur); cur.message(_("Copy")); break; @@ -2376,12 +2492,50 @@ Inset const * BufferView::getCoveringInset(Text const & text, } +Inset const * BufferView::clickableMathInset(InsetMathNest const * inset, + CoordCache::Insets const & inset_cache, int x, int y) const +{ + for (size_t i = 0; i < inset->nargs(); ++i) { + MathData const & ar = inset->cell(i); + for (size_t j = 0; j < ar.size(); ++j) { + string const name = lyxerr.debugging(Debug::MATHED) + ? insetName(ar[j].nucleus()->lyxCode()) + : string(); + LYXERR(Debug::MATHED, "Checking inset: " << name); + if (ar[j].nucleus()->clickable(*this, x, y)) { + if (inset_cache.covers(ar[j].nucleus(), x, y)) { + LYXERR(Debug::MATHED, "Clickable inset: " + << name); + return ar[j].nucleus(); + } + } + InsetMathNest const * imn = + ar[j].nucleus()->asNestInset(); + if (imn) { + Inset const * inner = + clickableMathInset(imn, inset_cache, x, y); + if (inner) + return inner; + } + } + } + return nullptr; +} + + void BufferView::updateHoveredInset() const { // Get inset under mouse, if there is one. int const x = d->mouse_position_cache_.x_; int const y = d->mouse_position_cache_.y_; Inset const * covering_inset = getCoveringInset(buffer_.text(), x, y); + if (covering_inset && covering_inset->asInsetMath()) { + Inset const * inner_inset = clickableMathInset( + covering_inset->asInsetMath()->asNestInset(), + coordCache().getInsets(), x, y); + if (inner_inset) + covering_inset = inner_inset; + } d->clickable_inset_ = covering_inset && covering_inset->clickable(*this, x, y); @@ -2428,6 +2582,12 @@ void BufferView::clearLastInset(Inset * inset) const } +bool BufferView::mouseSelecting() const +{ + return d->mouse_selecting_; +} + + void BufferView::mouseEventDispatch(FuncRequest const & cmd0) { //lyxerr << "[ cmd0 " << cmd0 << "]" << endl; @@ -2450,6 +2610,9 @@ void BufferView::mouseEventDispatch(FuncRequest const & cmd0) d->mouse_position_cache_.x_ = cmd.x(); d->mouse_position_cache_.y_ = cmd.y(); + d->mouse_selecting_ = + cmd.action() == LFUN_MOUSE_MOTION && cmd.button() == mouse_button::button1; + if (cmd.action() == LFUN_MOUSE_MOTION && cmd.button() == mouse_button::none) { updateHoveredInset(); return; @@ -2491,8 +2654,8 @@ void BufferView::mouseEventDispatch(FuncRequest const & cmd0) // Notify left insets if (cur != old) { - bool badcursor = old.fixIfBroken() | cur.fixIfBroken(); - badcursor |= notifyCursorLeavesOrEnters(old, cur); + bool badcursor = old.fixIfBroken() || cur.fixIfBroken(); + badcursor = badcursor || notifyCursorLeavesOrEnters(old, cur); if (badcursor) cursor().fixIfBroken(); } @@ -2581,7 +2744,7 @@ bool BufferView::setCursorFromRow(int row) { TexRow::TextEntry start, end; tie(start,end) = buffer_.texrow().getEntriesFromRow(row); - LYXERR(Debug::LATEX, + LYXERR(Debug::OUTFILE, "setCursorFromRow: for row " << row << ", TexRow has found " "start (id=" << start.id << ",pos=" << start.pos << "), " "end (id=" << end.id << ",pos=" << end.pos << ")"); @@ -3152,7 +3315,9 @@ void BufferView::caretPosAndDim(Point & p, Dimension & dim) const } else { Font const font = cur.real_current_font; frontend::FontMetrics const & fm = theFontMetrics(font); - dim.wid = fm.lineWidth(); + // lineWidth() can be 0 to mean 'thin line' on HiDpi, but the + // caret drawing code is not prepared for that. + dim.wid = max(fm.lineWidth(), 1); dim.asc = fm.maxAscent(); dim.des = fm.maxDescent(); } @@ -3187,8 +3352,8 @@ void BufferView::buildCaretGeometry(bool complet) bool const slant = fm.italic() && cur.inTexted() && !cur.selection(); double const slope = slant ? fm.italicSlope() : 0; cg.shapes.push_back( - {{iround(p.x_ + dim.asc * slope), p.y_}, - {iround(p.x_ - dim.des * slope), p.y_ + dim.height()}, + {{iround(p.x_ + dim.asc * slope), p.y_}, + {iround(p.x_ - dim.des * slope), p.y_ + dim.height()}, {iround(p.x_ + dir * dim.wid - dim.des * slope), p.y_ + dim.height()}, {iround(p.x_ + dir * dim.wid + dim.asc * slope), p.y_}} ); @@ -3201,10 +3366,10 @@ void BufferView::buildCaretGeometry(bool complet) int const xx = iround(p.x_ - dim.des * slope); int const yy = p.y_ + dim.height(); cg.shapes.push_back( - {{xx, yy - dim.wid}, + {{xx, yy - dim.wid}, {xx + dir * (dim.wid + lx - 1), yy - dim.wid}, {xx + dir * (dim.wid + lx - 1), yy}, - {xx, yy}} + {xx, yy}} ); } @@ -3217,12 +3382,12 @@ void BufferView::buildCaretGeometry(bool complet) // starting position x int const xx = p.x_ + dir * dim.wid + sx; cg.shapes.push_back( - {{xx, m - d}, - {xx + dir * d, m}, - {xx, m + d}, - {xx, m + d - dim.wid}, + {{xx, m - d}, + {xx + dir * d, m}, + {xx, m + d}, + {xx, m + d - dim.wid}, {xx + dir * d - dim.wid, m}, - {xx, m - d + dim.wid}} + {xx, m - d + dim.wid}} ); } @@ -3350,21 +3515,24 @@ void BufferView::checkCursorScrollOffset() //lyxerr << "cur_x=" << cur_x << ", offset=" << offset << ", row.wid=" << row.width() << ", margin=" << MARGIN << endl; - if (offset != d->horiz_scroll_offset_) + if (offset != d->horiz_scroll_offset_) { LYXERR(Debug::PAINTING, "Horiz. scroll offset changed from " << d->horiz_scroll_offset_ << " to " << offset); - - if (d->update_strategy_ == NoScreenUpdate - && offset != d->horiz_scroll_offset_) { - // FIXME: if one uses SingleParUpdate, then home/end - // will not work on long rows. Why? - d->update_strategy_ = FullScreenUpdate; + row.changed(true); + if (d->update_strategy_ == NoScreenUpdate) + d->update_strategy_ = SingleParUpdate; } d->horiz_scroll_offset_ = offset; } +bool BufferView::busy() const +{ + return buffer().undo().activeUndoGroup(); +} + + void BufferView::draw(frontend::Painter & pain, bool paint_caret) { if (height_ == 0 || width_ == 0) @@ -3443,7 +3611,7 @@ void BufferView::draw(frontend::Painter & pain, bool paint_caret) // The scrollbar needs an update. // FIXME: does it always? see ticket #11947. - updateScrollbar(); + updateScrollbarParameters(); // Normalize anchor for next time pair firstpm = tm.first();