X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FBufferView.cpp;h=acf80d7871ee27895f9ee615637b78497c99f639;hb=26ba2a65838731ce639a09539f617cb0f0be3b22;hp=d3cf909ea351fd2c74547bd3f41adc9c85814725;hpb=9fc190d61c55f23c8dfccf0b6a237a6d358fce24;p=lyx.git diff --git a/src/BufferView.cpp b/src/BufferView.cpp index d3cf909ea3..acf80d7871 100644 --- a/src/BufferView.cpp +++ b/src/BufferView.cpp @@ -186,7 +186,7 @@ bool gotoInset(BufferView * bv, vector const & codes, tmpcur.clearSelection(); bv->setCursor(tmpcur); - return bv->scrollToCursor(bv->cursor(), false, true); + return bv->scrollToCursor(bv->cursor(), SCROLL_TOP); } @@ -283,11 +283,11 @@ struct BufferView::Private /// map edited_insets_; - /// When the row where the cursor lies is scrolled, this - /// contains the scroll offset // cache for id of the paragraph which was edited the last time int bookmark_edit_position_; + /// When the row where the cursor lies is scrolled, this + /// contains the scroll offset int horiz_scroll_offset_; /// a slice pointing to the start of the row where the cursor /// is (at last draw time) @@ -298,6 +298,13 @@ struct BufferView::Private frontend::CaretGeometry caret_geometry_; /// bool mouse_selecting_ = false; + /// Reference value for statistics (essentially subtract this from the actual value to see relative counts) + /// (words/chars/chars no blanks) + int stats_ref_value_w_ = 0; + int stats_ref_value_c_ = 0; + int stats_ref_value_nb_ = 0; + bool stats_update_trigger_ = false; + }; @@ -337,6 +344,14 @@ BufferView::~BufferView() } +void BufferView::copySettingsFrom(BufferView const & bv) +{ + setCursor(bv.cursor()); + d->anchor_pit_ = bv.d->anchor_pit_; + d->anchor_ypos_ = bv.d->anchor_ypos_; +} + + int BufferView::defaultMargin() const { // The value used to be hardcoded to 10 @@ -435,6 +450,12 @@ CoordCache const & BufferView::coordCache() const } +bool BufferView::hasMathRow(MathData const * cell) const +{ + return d->math_rows_.find(cell) != d->math_rows_.end(); +} + + MathRow const & BufferView::mathRow(MathData const * cell) const { auto it = d->math_rows_.find(cell); @@ -518,7 +539,7 @@ void BufferView::processUpdateFlags(Update::flags flags) << flagsAsString(flags) << ") buffer: " << &buffer_); // Case when no explicit update is requested. - if (flags == Update::None) + if (flags == Update::None || !ready()) return; /* FIXME We would like to avoid doing this here, since it is very @@ -531,10 +552,13 @@ void BufferView::processUpdateFlags(Update::flags flags) // 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); - } + // This will compute all metrics and positions. + updateMetrics(true); + // metrics is done, full drawing is necessary now + flags = (flags & ~Update::Force) | Update::ForceDraw; + } else if (flags & Update::ForceDraw) + // This will compute only the needed metrics and update positions. + updateMetrics(false); // Detect whether we can only repaint a single paragraph (if we // are not already redrawing all). @@ -543,22 +567,22 @@ void BufferView::processUpdateFlags(Update::flags flags) if (!(flags & Update::ForceDraw) && (flags & Update::SinglePar) && !singleParUpdate()) - updateMetrics(flags); + updateMetrics(true); // Then make sure that the screen contains the cursor if needed if (flags & Update::FitCursor) { 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, false); + scrollToCursor(d->cursor_.selectionBegin(), SCROLL_VISIBLE); // Metrics have to be recomputed (maybe again) - updateMetrics(); + updateMetrics(true); // 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, false); + scrollToCursor(d->cursor_, SCROLL_VISIBLE); // Metrics have to be recomputed (maybe again) - updateMetrics(flags); + updateMetrics(true); } } flags = flags & ~Update::FitCursor; @@ -594,7 +618,7 @@ void BufferView::processUpdateFlags(Update::flags flags) void BufferView::updateScrollbarParameters() { - if (height_ == 0 && width_ == 0) + if (!ready()) return; // We prefer fixed size line scrolling. @@ -605,7 +629,7 @@ void BufferView::updateScrollbarParameters() Text & t = buffer_.text(); TextMetrics & tm = d->text_metrics_[&t]; - LYXERR(Debug::GUI, " Updating scrollbar: height: " + LYXERR(Debug::SCROLLING, " Updating scrollbar: height: " << t.paragraphs().size() << " curr par: " << d->cursor_.bottom().pit() << " default height " << defaultRowHeight()); @@ -627,8 +651,8 @@ void BufferView::updateScrollbarParameters() << d->par_height_[pit]); } - int top_pos = first.second->position() - first.second->ascent(); - int bottom_pos = last.second->position() + last.second->descent(); + int top_pos = first.second->top(); + int bottom_pos = last.second->bottom(); bool first_visible = first.first == 0 && top_pos >= 0; bool last_visible = last.first + 1 == int(parsize) && bottom_pos <= height_; if (first_visible && last_visible) { @@ -740,17 +764,21 @@ void BufferView::scrollDocView(int const pixels, bool update) if (pixels == 0) return; - // If the offset is less than 2 screen height, prefer to scroll instead. - if (abs(pixels) <= 2 * height_) { + // If part of the existing paragraphs will remain visible, prefer to + // scroll + TextMetrics const & tm = textMetrics(&buffer_.text()); + if (tm.first().second->top() - pixels <= height_ + && tm.last().second->bottom() - pixels >= 0) { + LYXERR(Debug::SCROLLING, "small skip"); d->anchor_ypos_ -= pixels; - processUpdateFlags(Update::Force); + processUpdateFlags(Update::ForceDraw); return; } // cut off at the top if (pixels <= d->scrollbarParameters_.min) { DocIterator dit = doc_iterator_begin(&buffer_); - showCursor(dit, false, false, update); + showCursor(dit, SCROLL_VISIBLE, update); LYXERR(Debug::SCROLLING, "scroll to top"); return; } @@ -759,11 +787,12 @@ void BufferView::scrollDocView(int const pixels, bool update) if (pixels >= d->scrollbarParameters_.max) { DocIterator dit = doc_iterator_end(&buffer_); dit.backwardPos(); - showCursor(dit, false, false, update); + showCursor(dit, SCROLL_VISIBLE, update); LYXERR(Debug::SCROLLING, "scroll to bottom"); return; } + LYXERR(Debug::SCROLLING, "search paragraph"); // find paragraph at target position int par_pos = d->scrollbarParameters_.min; pit_type i = 0; @@ -784,7 +813,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, false, update); + showCursor(dit, SCROLL_VISIBLE, update); } @@ -970,34 +999,36 @@ int BufferView::workWidth() const void BufferView::recenter() { - showCursor(d->cursor_, true, false, true); + showCursor(d->cursor_, SCROLL_CENTER, true); } void BufferView::showCursor() { - showCursor(d->cursor_, false, false, true); + showCursor(d->cursor_, SCROLL_VISIBLE, true); } -void BufferView::showCursor(DocIterator const & dit, - bool recenter, bool force, bool update) +void BufferView::showCursor(DocIterator const & dit, ScrollType how, + bool update) { - if (scrollToCursor(dit, recenter, force) && update) + if (scrollToCursor(dit, how) && update) processUpdateFlags(Update::Force); } -bool BufferView::scrollToCursor(DocIterator const & dit, bool const recenter, bool force) +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()); @@ -1016,7 +1047,7 @@ bool BufferView::scrollToCursor(DocIterator const & dit, bool const recenter, bo else if (bot_pit == tm.last().first + 1) tm.newParMetricsDown(); - if (tm.contains(bot_pit) && !force) { + 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. @@ -1027,14 +1058,12 @@ bool BufferView::scrollToCursor(DocIterator const & dit, bool const recenter, bo 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()) @@ -1063,28 +1092,26 @@ bool BufferView::scrollToCursor(DocIterator const & dit, bool const recenter, bo 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(); + 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; else if (offset > height_) - d->anchor_ypos_ = height_ - offset - row_dim.descent(); + d->anchor_ypos_ = height_ - offset - defaultRowHeight(); else - d->anchor_ypos_ = row_dim.ascent(); + d->anchor_ypos_ = defaultRowHeight() * 2; - return true; + return d->anchor_ypos_ != old_ypos || d->anchor_pit_ != old_pit; } @@ -1323,6 +1350,17 @@ bool BufferView::getStatus(FuncRequest const & cmd, FuncStatus & flag) flag.setEnabled(cur.selection()); break; + case LFUN_STATISTICS_REFERENCE_CLAMP: { + // disable optitem reset if clamp not used + if (cmd.argument() == "reset" && d->stats_ref_value_c_ == 0) { + flag.setEnabled(false); + break; + } + flag.setEnabled(true); + break; + + } + default: return false; } @@ -1589,7 +1627,7 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr) success = setCursorFromEntries({id, pos}, {id_end, pos_end}); } - if (success && scrollToCursor(d->cursor_, false, true)) + if (success && scrollToCursor(d->cursor_, SCROLL_TOP)) dr.screenUpdate(Update::Force); } else { // Switch to other buffer view and resend cmd @@ -1766,6 +1804,10 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr) } case LFUN_INDEX_TAG_ALL: { + if (cur.pos() == 0) + // nothing precedes + break; + Inset * ins = cur.nextInset(); if (!ins || ins->lyxCode() != INDEX_CODE) // not at index inset @@ -1802,6 +1844,8 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr) // Get word or selection cur.text()->selectWord(cur, WHOLE_WORD); docstring const searched_string = cur.selectionAsString(false); + if (searched_string.empty()) + break; // Start from the beginning lyx::dispatch(FuncRequest(LFUN_BUFFER_BEGIN)); while (findOne(this, searched_string, @@ -1988,6 +2032,25 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr) } break; + case LFUN_STATISTICS_REFERENCE_CLAMP: { + d->stats_update_trigger_ = true; + if (cmd.argument() == "reset") { + d->stats_ref_value_w_ = d->stats_ref_value_c_ = d->stats_ref_value_nb_ = 0; + break; + } + + DocIterator from, to; + from = doc_iterator_begin(&buffer_); + to = doc_iterator_end(&buffer_); + buffer_.updateStatistics(from, to); + + d->stats_ref_value_w_ = buffer_.wordCount(); + d->stats_ref_value_c_ = buffer_.charCount(true); + d->stats_ref_value_nb_ = buffer_.charCount(false); + break; + } + + case LFUN_SCREEN_UP: case LFUN_SCREEN_DOWN: { Point p = getPos(cur); @@ -2458,14 +2521,19 @@ void BufferView::clearSelection() void BufferView::resize(int width, int height) { - // Update from work area - width_ = width; height_ = height; + // Update metrics only if width has changed + if (width != width_) { + width_ = width; - // Clear the paragraph height cache. - d->par_height_.clear(); - // Redo the metrics. - updateMetrics(); + // Clear the paragraph height cache. + d->par_height_.clear(); + // Redo the metrics. + updateMetrics(true); + } + // metrics is OK, full drawing is necessary now + d->update_flags_ = (d->update_flags_ & ~Update::Force) | Update::ForceDraw; + d->update_strategy_ = FullScreenUpdate; } @@ -2595,10 +2663,31 @@ bool BufferView::mouseSelecting() const } +int BufferView::stats_ref_value_w() const +{ + return d->stats_ref_value_w_; +} + + +int BufferView::stats_ref_value_c() const +{ + return d->stats_ref_value_c_; +} + + +int BufferView::stats_ref_value_nb() const +{ + return d->stats_ref_value_nb_; +} + + void BufferView::mouseEventDispatch(FuncRequest const & cmd0) { //lyxerr << "[ cmd0 " << cmd0 << "]" << endl; + if (!ready()) + return; + // This is only called for mouse related events including // LFUN_FILE_OPEN generated by drag-and-drop. FuncRequest cmd = cmd0; @@ -2645,7 +2734,7 @@ void BufferView::mouseEventDispatch(FuncRequest const & cmd0) // Put anchor at the same position. cur.resetAnchor(); - cur.beginUndoGroup(); + old.beginUndoGroup(); // Try to dispatch to an non-editable inset near this position // via the temp cursor. If the inset wishes to change the real @@ -2667,7 +2756,7 @@ void BufferView::mouseEventDispatch(FuncRequest const & cmd0) cursor().fixIfBroken(); } - cur.endUndoGroup(); + old.endUndoGroup(); // Do we have a selection? theSelection().haveSelection(cursor().selection()); @@ -2706,7 +2795,7 @@ int BufferView::scrollDown(int pixels) int const ymax = height_ + pixels; while (true) { pair last = tm.last(); - int bottom_pos = last.second->position() + last.second->descent(); + int bottom_pos = last.second->bottom(); if (lyxrc.scroll_below_document) bottom_pos += height_ - minVisiblePart(); if (last.first + 1 == int(text->paragraphs().size())) { @@ -2731,7 +2820,7 @@ int BufferView::scrollUp(int pixels) int ymin = - pixels; while (true) { pair first = tm.first(); - int top_pos = first.second->position() - first.second->ascent(); + int top_pos = first.second->top(); if (first.first == 0) { if (top_pos >= 0) return 0; @@ -2973,6 +3062,25 @@ void BufferView::putSelectionAt(DocIterator const & cur, } +void BufferView::setSelection(DocIterator const & from, + DocIterator const & to) +{ + if (from.pit() != to.pit()) { + // there are multiple paragraphs in selection + cursor().setCursor(from); + cursor().clearSelection(); + cursor().selection(true); + cursor().setCursor(to); + cursor().selection(true); + } else { + // only single paragraph + int const size = to.pos() - from.pos(); + putSelectionAt(from, size, false); + } + processUpdateFlags(Update::Force | Update::FitCursor); +} + + bool BufferView::selectIfEmpty(DocIterator & cur) { if ((cur.inTexted() && !cur.paragraph().empty()) @@ -3024,24 +3132,36 @@ Cursor const & BufferView::cursor() const bool BufferView::singleParUpdate() { - Text & buftext = buffer_.text(); - pit_type const bottom_pit = d->cursor_.bottom().pit(); - TextMetrics & tm = textMetrics(&buftext); - Dimension const old_dim = tm.parMetrics(bottom_pit).dim(); + CursorSlice const & its = d->cursor_.innerTextSlice(); + pit_type const pit = its.pit(); + TextMetrics & tm = textMetrics(its.text()); + Dimension const old_dim = tm.parMetrics(pit).dim(); // make sure inline completion pointer is ok if (d->inlineCompletionPos_.fixIfBroken()) d->inlineCompletionPos_ = DocIterator(); - // In Single Paragraph mode, rebreak only - // the (main text, not inset!) paragraph containing the cursor. - // (if this paragraph contains insets etc., rebreaking will - // recursively descend) - tm.redoParagraph(bottom_pit); - ParagraphMetrics & pm = tm.parMetrics(bottom_pit); - if (pm.height() != old_dim.height()) { - // Paragraph height has changed so we cannot proceed to - // the singlePar optimisation. + /* Try to rebreak only the paragraph containing the cursor (if + * this paragraph contains insets etc., rebreaking will + * recursively descend). We need a full redraw if either + * 1/ the height has changed + * or + * 2/ the width has changed and it was equal to the textmetrics + * width; the goal is to catch the case of a one-row inset that + * grows with its contents, but optimize the case of typing at + * the end of a mmultiple-row paragraph. + * + * NOTE: if only the height has changed, then it should be + * possible to update all metrics at minimal cost. However, + * since this is risky, we do not try that right now. + */ + tm.redoParagraph(pit); + ParagraphMetrics & pm = tm.parMetrics(pit); + if (pm.height() != old_dim.height() + || (pm.width() != old_dim.width() && old_dim.width() == tm.width())) { + // Paragraph height or width has changed so we cannot proceed + // to the singlePar optimisation. + LYXERR(Debug::PAINTING, "SinglePar optimization failed."); return false; } // Since position() points to the baseline of the first row, we @@ -3049,39 +3169,43 @@ bool BufferView::singleParUpdate() // the height does not change but the ascent does. pm.setPosition(pm.position() - old_dim.ascent() + pm.ascent()); - tm.updatePosCache(bottom_pit); + tm.updatePosCache(pit); - LYXERR(Debug::PAINTING, "\ny1: " << pm.position() - pm.ascent() - << " y2: " << pm.position() + pm.descent() - << " pit: " << bottom_pit - << " singlepar: 1"); + LYXERR(Debug::PAINTING, "\ny1: " << pm.top() << " y2: " << pm.bottom() + << " pit: " << pit << " singlepar: 1"); return true; } void BufferView::updateMetrics() { - updateMetrics(d->update_flags_); + updateMetrics(true); + // metrics is done, full drawing is necessary now + d->update_flags_ = (d->update_flags_ & ~Update::Force) | Update::ForceDraw; d->update_strategy_ = FullScreenUpdate; } -void BufferView::updateMetrics(Update::flags & update_flags) +void BufferView::updateMetrics(bool force) { - if (height_ == 0 || width_ == 0) + if (!ready()) return; + //LYXERR0("updateMetrics " << _v_(force)); + Text & buftext = buffer_.text(); - pit_type const npit = int(buftext.paragraphs().size()); + pit_type const lastpit = int(buftext.paragraphs().size()) - 1; - // Clear out the position cache in case of full screen redraw, - d->coord_cache_.clear(); - d->math_rows_.clear(); + if (force) { + // 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 - // The complete text metrics will be redone. - d->text_metrics_.clear(); + // Clear out paragraph metrics to avoid having invalid metrics + // in the cache from paragraphs not relayouted below. The + // complete text metrics will be redone. + d->text_metrics_.clear(); + } TextMetrics & tm = textMetrics(&buftext); @@ -3089,71 +3213,55 @@ void BufferView::updateMetrics(Update::flags & update_flags) if (d->inlineCompletionPos_.fixIfBroken()) d->inlineCompletionPos_ = DocIterator(); - if (d->anchor_pit_ >= npit) + if (d->anchor_pit_ > lastpit) // The anchor pit must have been deleted... - d->anchor_pit_ = npit - 1; + d->anchor_pit_ = lastpit; - // Rebreak anchor paragraph. - tm.redoParagraph(d->anchor_pit_); - ParagraphMetrics & anchor_pm = tm.parMetrics(d->anchor_pit_); + // Update metrics around the anchor + tm.updateMetrics(d->anchor_pit_, d->anchor_ypos_, height_); - // position anchor - if (d->anchor_pit_ == 0) { - int scrollRange = d->scrollbarParameters_.max - d->scrollbarParameters_.min; + // Check that the end of the document is not too high + int const min_visible = lyxrc.scroll_below_document ? minVisiblePart() : height_; + if (tm.last().first == lastpit && tm.last().second->bottom() < min_visible) { + d->anchor_ypos_ += min_visible - tm.last().second->bottom(); + LYXERR(Debug::SCROLLING, "Too high, adjusting anchor ypos to " << d->anchor_ypos_); + tm.updateMetrics(d->anchor_pit_, d->anchor_ypos_, height_); + } - // Complete buffer visible? Then it's easy. - if (scrollRange == 0) - d->anchor_ypos_ = anchor_pm.ascent(); - 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_ - << " anchor ypos = " << d->anchor_ypos_); - - // Redo paragraphs above anchor if necessary. - int y1 = d->anchor_ypos_ - anchor_pm.ascent(); - // We are now just above the anchor paragraph. - pit_type pit1 = d->anchor_pit_ - 1; - for (; pit1 >= 0 && y1 >= 0; --pit1) { - tm.redoParagraph(pit1); - ParagraphMetrics & pm = tm.parMetrics(pit1); - y1 -= pm.descent(); - // Save the paragraph position in the cache. - pm.setPosition(y1); - tm.updatePosCache(pit1); - y1 -= pm.ascent(); - } - - // Redo paragraphs below the anchor if necessary. - int y2 = d->anchor_ypos_ + anchor_pm.descent(); - // We are now just below the anchor paragraph. - pit_type pit2 = d->anchor_pit_ + 1; - for (; pit2 < npit && y2 <= height_; ++pit2) { - tm.redoParagraph(pit2); - ParagraphMetrics & pm = tm.parMetrics(pit2); - y2 += pm.ascent(); - // Save the paragraph position in the cache. - pm.setPosition(y2); - tm.updatePosCache(pit2); - y2 += pm.descent(); - } - - LYXERR(Debug::PAINTING, "Metrics: " - << " anchor pit = " << d->anchor_pit_ - << " anchor ypos = " << d->anchor_ypos_ - << " y1 = " << y1 - << " y2 = " << y2 - << " pit1 = " << pit1 - << " pit2 = " << pit2); + // Check that the start of the document is not too low + if (tm.first().first == 0 && tm.first().second->top() > 0) { + d->anchor_ypos_ -= tm.first().second->top(); + LYXERR(Debug::SCROLLING, "Too low, adjusting anchor ypos to " << d->anchor_ypos_); + tm.updateMetrics(d->anchor_pit_, d->anchor_ypos_, height_); + } - // metrics is done, full drawing is necessary now - update_flags = (update_flags & ~Update::Force) | Update::ForceDraw; + /* FIXME: do we want that? It avoids potential issues with old + * paragraphs that should have been recomputed but have not, at + * the price of potential extra metrics computaiton. I do not + * think that the performance gain is high, so that for now the + * extra paragraphs are removed + */ + // Remove paragraphs that are outside of screen + while(tm.first().second->bottom() <= 0) { + //LYXERR0("Forget pit: " << tm.first().first); + tm.forget(tm.first().first); + } + while(tm.last().second->top() > height_) { + //LYXERR0("Forget pit: " << tm.first().first); + tm.forget(tm.last().first); + } + + /* FIXME: if paragraphs outside of the screen are not removed + * above, one has to search for the first visible one here */ + // Normalize anchor for next time + if (d->anchor_pit_ != tm.first().first + || d->anchor_ypos_ != tm.first().second->position()) { + LYXERR(Debug::PAINTING, __func__ << ": Found new anchor pit = " << tm.first().first + << " anchor ypos = " << tm.first().second->position() + << " (was " << d->anchor_pit_ << ", " << d->anchor_ypos_ << ")"); + d->anchor_pit_ = tm.first().first; + d->anchor_ypos_ = tm.first().second->position(); + } // Now update the positions of insets in the cache. updatePosCache(); @@ -3197,6 +3305,7 @@ void BufferView::insertLyXFile(FileName const & fname, bool const ignorelang) // set main language of imported file to context language buf.changeLanguage(buf.language(), d->cursor_.getFont().language()); buffer_.undo().recordUndo(d->cursor_); + cap::replaceSelection(d->cursor_); cap::pasteParagraphList(d->cursor_, pars, buf.params().documentClassPtr(), buf.params().authors(), el); @@ -3316,7 +3425,7 @@ bool BufferView::paragraphVisible(DocIterator const & dit) const void BufferView::caretPosAndDim(Point & p, Dimension & dim) const { Cursor const & cur = cursor(); - if (cur.inMathed()) { + if (cur.inMathed() && hasMathRow(&cur.cell())) { MathRow const & mrow = mathRow(&cur.cell()); dim = mrow.caret_dim; } else { @@ -3359,8 +3468,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_}} ); @@ -3373,10 +3482,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}} ); } @@ -3389,12 +3498,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}} ); } @@ -3534,9 +3643,15 @@ void BufferView::checkCursorScrollOffset() } +bool BufferView::busy() const +{ + return buffer().undo().activeUndoGroup(); +} + + void BufferView::draw(frontend::Painter & pain, bool paint_caret) { - if (height_ == 0 || width_ == 0) + if (!ready()) return; LYXERR(Debug::PAINTING, (pain.isNull() ? "\t\t--- START NODRAW ---" : "\t\t*** START DRAWING ***")); @@ -3598,7 +3713,7 @@ void BufferView::draw(frontend::Painter & pain, bool paint_caret) // and possibly grey out below pair lastpm = tm.last(); - int const y2 = lastpm.second->position() + lastpm.second->descent(); + int const y2 = lastpm.second->bottom(); if (y2 < height_) { Color color = buffer().isInternal() @@ -3614,21 +3729,25 @@ void BufferView::draw(frontend::Painter & pain, bool paint_caret) // FIXME: does it always? see ticket #11947. updateScrollbarParameters(); - // Normalize anchor for next time + // Normalize anchor for next time (in case updateMetrics did not do it yet) + // FIXME: is this useful? pair firstpm = tm.first(); pair lastpm = tm.last(); for (pit_type pit = firstpm.first; pit <= lastpm.first; ++pit) { ParagraphMetrics const & pm = tm.parMetrics(pit); - if (pm.position() + pm.descent() > 0) { + if (pm.bottom() > 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_); + LYXERR0(__func__ << ": Found new anchor pit = " << pit + << " anchor ypos = " << pm.position() + << " (was " << d->anchor_pit_ << ", " << d->anchor_ypos_ << ")" + "\nIf you see this message, please report."); d->anchor_pit_ = pit; d->anchor_ypos_ = pm.position(); break; } } + if (!pain.isNull()) { // reset the update flags, everything has been done d->update_flags_ = Update::None; @@ -3822,4 +3941,14 @@ bool BufferView::clickableInset() const return d->clickable_inset_; } + +bool BufferView::stats_update_trigger() +{ + if (d->stats_update_trigger_) { + d->stats_update_trigger_ = false; + return true; + } + return false; +} + } // namespace lyx