X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FBufferView.cpp;h=af0ad368b32d29188f56f3c5a03138b82d5b7e62;hb=62af7ee772f16f154225d2d0b65d77f4376b6001;hp=a06b6fec4561d10a01bf02d006f931043d0d43d4;hpb=9928a67e3224113d214de5e1e66d9de0a42fff59;p=lyx.git diff --git a/src/BufferView.cpp b/src/BufferView.cpp index a06b6fec45..af0ad368b3 100644 --- a/src/BufferView.cpp +++ b/src/BufferView.cpp @@ -35,6 +35,7 @@ #include "Language.h" #include "LaTeXFeatures.h" #include "LayoutFile.h" +#include "Length.h" #include "Lexer.h" #include "LyX.h" #include "LyXAction.h" @@ -45,6 +46,7 @@ #include "Paragraph.h" #include "ParagraphParameters.h" #include "ParIterator.h" +#include "RowPainter.h" #include "Session.h" #include "Text.h" #include "TextClass.h" @@ -54,6 +56,7 @@ #include "WordLangTuple.h" #include "insets/InsetBibtex.h" +#include "insets/InsetCitation.h" #include "insets/InsetCommand.h" // ChangeRefs #include "insets/InsetExternal.h" #include "insets/InsetGraphics.h" @@ -61,10 +64,14 @@ #include "insets/InsetRef.h" #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" @@ -75,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" @@ -105,6 +113,7 @@ T * getInsetByCode(Cursor const & cur, InsetCode code) return 0; } + /// Note that comparing contents can only be used for InsetCommand bool findNextInset(DocIterator & dit, vector const & codes, docstring const & contents) @@ -114,12 +123,12 @@ bool findNextInset(DocIterator & dit, vector const & codes, while (tmpdit) { Inset const * inset = tmpdit.nextInset(); if (inset) { - bool const valid_code = std::find(codes.begin(), codes.end(), + bool const valid_code = std::find(codes.begin(), codes.end(), inset->lyxCode()) != codes.end(); InsetCommand const * ic = inset->asInsetCommand(); bool const same_or_no_contents = contents.empty() || (ic && (ic->getFirstNonOptParam() == contents)); - + if (valid_code && same_or_no_contents) { dit = tmpdit; return true; @@ -156,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; @@ -210,7 +219,7 @@ enum ScreenUpdateStrategy { DecorationUpdate }; -} // anon namespace +} // namespace ///////////////////////////////////////////////////////////////////// @@ -221,20 +230,31 @@ enum ScreenUpdateStrategy { struct BufferView::Private { - Private(BufferView & bv): wh_(0), cursor_(bv), + Private(BufferView & bv) : + update_strategy_(FullScreenUpdate), + update_flags_(Update::Force), + wh_(0), cursor_(bv), anchor_pit_(0), anchor_ypos_(0), inlineCompletionUniqueChars_(0), - last_inset_(0), clickable_inset_(false), + last_inset_(0), clickable_inset_(false), mouse_position_cache_(), - bookmark_edit_position_(-1), gui_(0) - {} + bookmark_edit_position_(-1), gui_(0), + horiz_scroll_offset_(0) + { + xsel_cache_.set = false; + } /// ScrollbarParameters scrollbarParameters_; /// ScreenUpdateStrategy update_strategy_; /// + Update::flags update_flags_; + /// CoordCache coord_cache_; + /// + typedef map MathRows; + MathRows math_rows_; /// Estimated average par height for scrollbar. int wh_; @@ -291,6 +311,13 @@ struct BufferView::Private /// map edited_insets_; + + /// 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) + CursorSlice current_row_slice_; }; @@ -318,12 +345,13 @@ 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); + d->last_inset_->setMouseHover(this, false); delete d; } @@ -331,11 +359,12 @@ BufferView::~BufferView() int BufferView::rightMargin() 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 + 20) - return 10; + if (!full_screen_ || !lyxrc.full_screen_limit + || width_ < lyxrc.full_screen_width + 2 * default_margin) + return default_margin; return (width_ - lyxrc.full_screen_width) / 2; } @@ -347,15 +376,37 @@ 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 d->scrollbarParameters_.position == d->scrollbarParameters_.min; + return 0 == d->scrollbarParameters_.min; } bool BufferView::isBottomScreen() const { - return d->scrollbarParameters_.position == d->scrollbarParameters_.max; + return 0 == d->scrollbarParameters_.max; } @@ -383,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_; @@ -395,7 +460,7 @@ Buffer const & BufferView::buffer() const } -bool BufferView::fitCursor() +bool BufferView::needsFitCursor() const { if (cursorStatus(d->cursor_) == CUR_INSIDE) { frontend::FontMetrics const & fm = @@ -410,76 +475,96 @@ bool BufferView::fitCursor() } -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::DEBUG, "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. +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(); - if (flags == Update::FitCursor - || flags == (Update::Decoration | Update::FitCursor)) { - // tell the frontend to update the screen if needed. - if (fitCursor()) { - showCursor(); - return; - } - if (flags & Update::Decoration) { - d->update_strategy_ = DecorationUpdate; - buffer_.changed(false); - return; + // 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); + } + + // 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()) { + // 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); } - // no screen update is needed. - d->update_strategy_ = NoScreenUpdate; - return; + flags = flags & ~Update::FitCursor; } - bool const full_metrics = flags & Update::Force || !singleParUpdate(); + // 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)); - 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; - } - - // updateMetrics() does not update paragraph position - // This is done at draw() time. So we need a redraw! - buffer_.changed(false); + // 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 (fitCursor()) { - // 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); } @@ -494,7 +579,7 @@ void BufferView::updateScrollbar() d->scrollbarParameters_.page_step = height_; Text & t = buffer_.text(); - TextMetrics & tm = d->text_metrics_[&t]; + TextMetrics & tm = d->text_metrics_[&t]; LYXERR(Debug::GUI, " Updating scrollbar: height: " << t.paragraphs().size() @@ -535,12 +620,17 @@ void BufferView::updateScrollbar() for (size_t i = last.first + 1; i != parsize; ++i) d->scrollbarParameters_.max += d->par_height_[i]; - d->scrollbarParameters_.position = 0; // The reference is the top position so we remove one page. if (lyxrc.scroll_below_document) d->scrollbarParameters_.max -= minVisiblePart(); else d->scrollbarParameters_.max -= d->scrollbarParameters_.page_step; + + // 0 must be inside the range as it denotes the current position + if (d->scrollbarParameters_.max < 0) + d->scrollbarParameters_.max = 0; + if (d->scrollbarParameters_.min > 0) + d->scrollbarParameters_.min = 0; } @@ -576,19 +666,20 @@ string BufferView::contextMenu(int x, int y) const } -void BufferView::scrollDocView(int value, bool update) + +void BufferView::scrollDocView(int const value, bool update) { - int const offset = value - d->scrollbarParameters_.position; + // The scrollbar values are relative to the top of the screen, therefore the + // offset is equal to the target value. // No scrolling at all? No need to redraw anything - if (offset == 0) + if (value == 0) return; // If the offset is less than 2 screen height, prefer to scroll instead. - if (abs(offset) <= 2 * height_) { - d->anchor_ypos_ -= offset; - buffer_.changed(true); - updateHoveredInset(); + if (abs(value) <= 2 * height_) { + d->anchor_ypos_ -= value; + processUpdateFlags(Update::Force); return; } @@ -654,7 +745,7 @@ void BufferView::setCursorFromScrollbar() case CUR_INSIDE: int const y = getPos(oldcur).y_; newy = min(last, max(y, first)); - if (y == newy) + if (y == newy) return; } // We reset the cursor because cursorStatus() does not @@ -682,6 +773,8 @@ Change const BufferView::getCurrentChange() const return Change(Change::UNCHANGED); DocIterator dit = d->cursor_.selectionBegin(); + // The selected content might have been changed (see #7685) + dit = dit.getInnerText(); return dit.paragraph().lookupChange(dit.pos()); } @@ -747,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 @@ -770,7 +863,7 @@ bool BufferView::moveToPosition(pit_type bottom_pit, pos_type bottom_pos, // the bookmark. if (bottom_pit < int(buffer_.paragraphs().size())) { dit = doc_iterator_begin(&buffer_); - + dit.pit() = bottom_pit; dit.pos() = min(bottom_pos, dit.paragraph().size()); success = true; @@ -781,12 +874,9 @@ bool BufferView::moveToPosition(pit_type bottom_pit, pos_type bottom_pos, setCursor(dit); // set the current font. d->cursor_.setCurrentFont(); - // 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 (fitCursor()) - showCursor(); + // Do not forget to reset the anchor (see #9912) + d->cursor_.resetAnchor(); + processUpdateFlags(Update::Force | Update::FitCursor); } return success; @@ -795,14 +885,12 @@ bool BufferView::moveToPosition(pit_type bottom_pit, pos_type bottom_pos, void BufferView::translateAndInsert(char_type c, Text * t, Cursor & cur) { - if (lyxrc.rtl_support) { - if (d->cursor_.real_current_font.isRightToLeft()) { - if (d->intl_.keymap == Intl::PRIMARY) - d->intl_.keyMapSec(); - } else { - if (d->intl_.keymap == Intl::SECONDARY) - d->intl_.keyMapPrim(); - } + if (d->cursor_.real_current_font.isRightToLeft()) { + if (d->intl_.keymap == Intl::PRIMARY) + d->intl_.keyMapSec(); + } else { + if (d->intl_.keymap == Intl::SECONDARY) + d->intl_.keyMapPrim(); } d->intl_.getTransManager().translateAndInsert(c, t, cur); @@ -830,23 +918,19 @@ 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); } -bool BufferView::scrollToCursor(DocIterator const & dit, bool recenter) +bool BufferView::scrollToCursor(DocIterator const & dit, bool const recenter) { // We are not properly started yet, delay until resizing is // done. @@ -874,13 +958,13 @@ bool BufferView::scrollToCursor(DocIterator const & dit, bool recenter) if (tm.contains(bot_pit)) { ParagraphMetrics const & pm = tm.parMetrics(bot_pit); - LASSERT(!pm.rows().empty(), /**/); + LBUFERR(!pm.rows().empty()); // FIXME: smooth scrolling doesn't work in mathed. CursorSlice const & cs = dit.innerTextSlice(); 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); @@ -924,7 +1008,7 @@ bool BufferView::scrollToCursor(DocIterator const & dit, bool 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; @@ -941,10 +1025,18 @@ bool BufferView::scrollToCursor(DocIterator const & dit, bool recenter) } -void BufferView::updateDocumentClass(DocumentClass const * const olddc) +void BufferView::makeDocumentClass() +{ + DocumentClassConstPtr olddc = buffer_.params().documentClassPtr(); + buffer_.params().makeDocumentClass(); + updateDocumentClass(olddc); +} + + +void BufferView::updateDocumentClass(DocumentClassConstPtr olddc) { message(_("Converting document to new document class...")); - + StableDocIterator backcur(d->cursor_); ErrorList & el = buffer_.errorList("Class Switch"); cap::switchBetweenClasses( @@ -956,7 +1048,8 @@ void BufferView::updateDocumentClass(DocumentClass const * const olddc) buffer_.errors("Class Switch"); } -/** Return the change status at cursor position, taking in account the + +/** Return the change status at cursor position, taking into account the * status at each level of the document iterator (a table in a deleted * footnote is deleted). * When \param outer is true, the top slice is not looked at. @@ -986,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; } @@ -1034,9 +1130,17 @@ bool BufferView::getStatus(FuncRequest const & cmd, FuncStatus & flag) // buffer clean/dirty status by itself. flag.setEnabled(!buffer_.isReadonly() && buffer_.undo().hasRedoStack()); break; - case LFUN_FILE_INSERT: case LFUN_FILE_INSERT_PLAINTEXT_PARA: - case LFUN_FILE_INSERT_PLAINTEXT: + case LFUN_FILE_INSERT_PLAINTEXT: { + docstring const fname = cmd.argument(); + if (!FileName::isAbsolute(to_utf8(fname))) { + flag.message(_("Absolute filename expected.")); + return false; + } + flag.setEnabled(cur.inTexted()); + break; + } + case LFUN_FILE_INSERT: case LFUN_BOOKMARK_SAVE: // FIXME: Actually, these LFUNS should be moved to Text flag.setEnabled(cur.inTexted()); @@ -1051,7 +1155,6 @@ bool BufferView::getStatus(FuncRequest const & cmd, FuncStatus & flag) case LFUN_WORD_FIND: case LFUN_WORD_FIND_FORWARD: case LFUN_WORD_FIND_BACKWARD: - case LFUN_WORD_FINDADV: case LFUN_WORD_REPLACE: case LFUN_MARK_OFF: case LFUN_MARK_ON: @@ -1061,28 +1164,30 @@ bool BufferView::getStatus(FuncRequest const & cmd, FuncStatus & flag) case LFUN_BIBTEX_DATABASE_ADD: case LFUN_BIBTEX_DATABASE_DEL: case LFUN_STATISTICS: - case LFUN_BRANCH_ADD_INSERT: case LFUN_KEYMAP_OFF: case LFUN_KEYMAP_PRIMARY: case LFUN_KEYMAP_SECONDARY: case LFUN_KEYMAP_TOGGLE: + case LFUN_INSET_SELECT_ALL: flag.setEnabled(true); break; - case LFUN_LABEL_GOTO: { - flag.setEnabled(!cmd.argument().empty() - || getInsetByCode(cur, REF_CODE)); + case LFUN_GRAPHICS_UNIFY: + flag.setEnabled(cur.countInsetsInSelection(GRAPHICS_CODE)>1); break; - } - case LFUN_CHANGES_TRACK: - flag.setEnabled(true); - flag.setOnOff(buffer_.params().trackChanges); + case LFUN_WORD_FINDADV: { + FindAndReplaceOptions opt; + istringstream iss(to_utf8(cmd.argument())); + iss >> opt; + flag.setEnabled(opt.repl_buf_name.empty() + || !buffer_.isReadonly()); break; + } - case LFUN_CHANGES_OUTPUT: - flag.setEnabled(true); - flag.setOnOff(buffer_.params().outputChanges); + case LFUN_LABEL_GOTO: + flag.setEnabled(!cmd.argument().empty() + || getInsetByCode(cur, REF_CODE)); break; case LFUN_CHANGES_MERGE: @@ -1090,23 +1195,9 @@ bool BufferView::getStatus(FuncRequest const & cmd, FuncStatus & flag) case LFUN_CHANGE_PREVIOUS: case LFUN_ALL_CHANGES_ACCEPT: case LFUN_ALL_CHANGES_REJECT: - // TODO: context-sensitive enabling of LFUNs - // In principle, these command should only be enabled if there - // is a change in the document. However, without proper - // optimizations, this will inevitably result in poor performance. - flag.setEnabled(true); + flag.setEnabled(buffer_.areChangesPresent()); break; - case LFUN_BUFFER_TOGGLE_COMPRESSION: { - flag.setOnOff(buffer_.params().compressed); - break; - } - - case LFUN_BUFFER_TOGGLE_OUTPUT_SYNC: { - flag.setOnOff(buffer_.params().output_sync); - break; - } - case LFUN_SCREEN_UP: case LFUN_SCREEN_DOWN: case LFUN_SCROLL: @@ -1128,6 +1219,10 @@ bool BufferView::getStatus(FuncRequest const & cmd, FuncStatus & flag) flag.setEnabled(cur.inset().allowParagraphCustomization(cur.idx())); break; + case LFUN_BRANCH_ADD_INSERT: + flag.setEnabled(!(cur.inTexted() && cur.paragraph().isPassThru())); + break; + case LFUN_DIALOG_SHOW_NEW_INSET: // FIXME: this is wrong, but I do not understand the // intent (JMarc) @@ -1160,17 +1255,6 @@ bool BufferView::getStatus(FuncRequest const & cmd, FuncStatus & flag) break; } - // FIXME We do not really want this here, but at present we need to - // handle their dispatch here, for reasons explained there, so we'll - // handle this here, too, for consistency. - case LFUN_BRANCH_ACTIVATE: - case LFUN_BRANCH_DEACTIVATE: { - BranchList const & branchList = buffer().params().branchlist(); - docstring const branchName = cmd.argument(); - flag.setEnabled(!branchName.empty() && branchList.find(branchName)); - break; - } - default: return false; } @@ -1188,26 +1272,23 @@ 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); } void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr) { - //lyxerr << [ cmd = " << cmd << "]" << endl; - - // Make sure that the cached BufferView is correct. - LYXERR(Debug::ACTION, " action[" << cmd.action() << ']' - << " arg[" << to_utf8(cmd.argument()) << ']' - << " x[" << cmd.x() << ']' - << " y[" << cmd.y() << ']' - << " button[" << cmd.button() << ']'); + LYXERR(Debug::ACTION, "BufferView::dispatch: cmd: " << cmd); string const argument = to_utf8(cmd.argument()); Cursor & cur = d->cursor_; + Cursor old = cur; // Don't dispatch function that does not apply to internal buffers. - if (buffer_.isInternal() + if (buffer_.isInternal() && lyxaction.funcHasFlag(cmd.action(), LyXAction::NoInternal)) return; @@ -1219,8 +1300,8 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr) switch (act) { case LFUN_BUFFER_PARAMS_APPLY: { - DocumentClass const * const oldClass = buffer_.params().documentClassPtr(); - cur.recordUndoFullDocument(); + DocumentClassConstPtr olddc = buffer_.params().documentClassPtr(); + cur.recordUndoBufferParams(); istringstream ss(to_utf8(cmd.argument())); Lexer lex; lex.setStream(ss); @@ -1230,8 +1311,8 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr) << unknown_tokens << " unknown token" << (unknown_tokens == 1 ? "" : "s")); } - updateDocumentClass(oldClass); - + updateDocumentClass(olddc); + // We are most certainly here because of a change in the document // It is then better to make sure that all dialogs are in sync with // current document settings. @@ -1239,14 +1320,14 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr) dr.forceBufferUpdate(); break; } - + case LFUN_LAYOUT_MODULES_CLEAR: { - DocumentClass const * const oldClass = - buffer_.params().documentClassPtr(); - cur.recordUndoFullDocument(); + // FIXME: this modifies the document in cap::switchBetweenClasses + // without calling recordUndo. Fix this before using + // recordUndoBufferParams(). + cur.recordUndoFullBuffer(); buffer_.params().clearLayoutModules(); - buffer_.params().makeDocumentClass(); - updateDocumentClass(oldClass); + makeDocumentClass(); dr.screenUpdate(Update::Force); dr.forceBufferUpdate(); break; @@ -1254,26 +1335,27 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr) case LFUN_LAYOUT_MODULE_ADD: { BufferParams const & params = buffer_.params(); - if (!params.moduleCanBeAdded(argument)) { - LYXERR0("Module `" << argument << + if (!params.layoutModuleCanBeAdded(argument)) { + LYXERR0("Module `" << argument << "' cannot be added due to failed requirements or " "conflicts with installed modules."); break; } - DocumentClass const * const oldClass = params.documentClassPtr(); - cur.recordUndoFullDocument(); + // FIXME: this modifies the document in cap::switchBetweenClasses + // without calling recordUndo. Fix this before using + // recordUndoBufferParams(). + cur.recordUndoFullBuffer(); buffer_.params().addLayoutModule(argument); - buffer_.params().makeDocumentClass(); - updateDocumentClass(oldClass); + makeDocumentClass(); dr.screenUpdate(Update::Force); dr.forceBufferUpdate(); break; } case LFUN_TEXTCLASS_APPLY: { - // since this shortcircuits, the second call is made only if + // since this shortcircuits, the second call is made only if // the first fails - bool const success = + bool const success = LayoutFileList::get().load(argument, buffer_.temppath()) || LayoutFileList::get().load(argument, buffer_.filePath()); if (!success) { @@ -1291,24 +1373,24 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr) break; // Save the old, possibly modular, layout for use in conversion. - DocumentClass const * const oldDocClass = - buffer_.params().documentClassPtr(); - cur.recordUndoFullDocument(); - buffer_.params().setBaseClass(argument); - buffer_.params().makeDocumentClass(); - updateDocumentClass(oldDocClass); + // FIXME: this modifies the document in cap::switchBetweenClasses + // without calling recordUndo. Fix this before using + // recordUndoBufferParams(). + cur.recordUndoFullBuffer(); + buffer_.params().setBaseClass(argument, buffer_.layoutPos()); + makeDocumentClass(); dr.screenUpdate(Update::Force); dr.forceBufferUpdate(); break; } case LFUN_TEXTCLASS_LOAD: { - // since this shortcircuits, the second call is made only if + // since this shortcircuits, the second call is made only if // the first fails - bool const success = + bool const success = LayoutFileList::get().load(argument, buffer_.temppath()) || LayoutFileList::get().load(argument, buffer_.filePath()); - if (!success) { + if (!success) { docstring s = bformat(_("The document class `%1$s' " "could not be loaded."), from_utf8(argument)); frontend::Alert::error(_("Could not load class"), s); @@ -1317,39 +1399,57 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr) } case LFUN_LAYOUT_RELOAD: { - DocumentClass const * const oldClass = buffer_.params().documentClassPtr(); LayoutFileIndex bc = buffer_.params().baseClassID(); LayoutFileList::get().reset(bc); - buffer_.params().setBaseClass(bc); - buffer_.params().makeDocumentClass(); - updateDocumentClass(oldClass); + buffer_.params().setBaseClass(bc, buffer_.layoutPos()); + makeDocumentClass(); dr.screenUpdate(Update::Force); dr.forceBufferUpdate(); break; } - case LFUN_UNDO: + case LFUN_UNDO: { dr.setMessage(_("Undo")); cur.clearSelection(); - if (!cur.textUndo()) + // We need to find out if the bibliography information + // has changed. See bug #11055. + // So these should not be references... + string const engine = buffer().params().citeEngine(); + CiteEngineType const enginetype = buffer().params().citeEngineType(); + if (!cur.undoAction()) dr.setMessage(_("No further undo information")); - else + else { dr.screenUpdate(Update::Force | Update::FitCursor); - dr.forceBufferUpdate(); + dr.forceBufferUpdate(); + if (buffer().params().citeEngine() != engine || + buffer().params().citeEngineType() != enginetype) + buffer().invalidateCiteLabels(); + } break; + } - case LFUN_REDO: + case LFUN_REDO: { dr.setMessage(_("Redo")); cur.clearSelection(); - if (!cur.textRedo()) + // We need to find out if the bibliography information + // has changed. See bug #11055. + // So these should not be references... + string const engine = buffer().params().citeEngine(); + CiteEngineType const enginetype = buffer().params().citeEngineType(); + if (!cur.redoAction()) dr.setMessage(_("No further redo information")); - else + else { dr.screenUpdate(Update::Force | Update::FitCursor); - dr.forceBufferUpdate(); + dr.forceBufferUpdate(); + if (buffer().params().citeEngine() != engine || + buffer().params().citeEngineType() != enginetype) + buffer().invalidateCiteLabels(); + } break; + } case LFUN_FONT_STATE: - dr.setMessage(cur.currentState()); + dr.setMessage(cur.currentState(false)); break; case LFUN_BOOKMARK_SAVE: @@ -1376,29 +1476,44 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr) } break; } - + 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)) { - DocIterator dit = b->getParFromID(id); - if (dit.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 " << dit.paragraph().id() + LYXERR(Debug::INFO, "Paragraph " << curs.paragraph().id() << " found in buffer `" << b->absFileName() << "'."); if (b == &buffer_) { - // Set the cursor - dit.pos() = pos; - setCursor(dit); - 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( @@ -1422,41 +1537,20 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr) break; } - case LFUN_CHANGES_TRACK: - buffer_.params().trackChanges = !buffer_.params().trackChanges; - break; - - case LFUN_CHANGES_OUTPUT: - buffer_.params().outputChanges = !buffer_.params().outputChanges; - if (buffer_.params().outputChanges) { - bool dvipost = LaTeXFeatures::isAvailable("dvipost"); - bool xcolorulem = LaTeXFeatures::isAvailable("ulem") && - LaTeXFeatures::isAvailable("xcolor"); - - if (!dvipost && !xcolorulem) { - Alert::warning(_("Changes not shown in LaTeX output"), - _("Changes will not be highlighted in LaTeX output, " - "because neither dvipost nor xcolor/ulem are installed.\n" - "Please install these packages or redefine " - "\\lyxadded and \\lyxdeleted in the LaTeX preamble.")); - } else if (!xcolorulem) { - Alert::warning(_("Changes not shown in LaTeX output"), - _("Changes will not be highlighted in LaTeX output " - "when using pdflatex, because xcolor and ulem are not installed.\n" - "Please install both packages or redefine " - "\\lyxadded and \\lyxdeleted in the LaTeX preamble.")); - } - } - break; - 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; @@ -1469,35 +1563,48 @@ 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: { + // FIXME THREAD + // Would it maybe be better if this variable were view specific anyway? static docstring last_search; docstring searched_string; @@ -1530,8 +1637,7 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr) } if (lyxfind(this, req)) dr.screenUpdate(Update::Force | Update::FitCursor); - else - message(_("String not found!")); + d->search_request_cache_ = req; break; } @@ -1584,7 +1690,7 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr) break; case LFUN_MARK_TOGGLE: - cur.setSelection(false); + cur.selection(false); if (cur.mark()) { cur.setMark(false); dr.setMessage(from_utf8(N_("Mark removed"))); @@ -1598,7 +1704,7 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr) case LFUN_SCREEN_SHOW_CURSOR: showCursor(); break; - + case LFUN_SCREEN_RECENTER: recenter(); break; @@ -1609,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; } @@ -1623,14 +1727,51 @@ 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; + } + case LFUN_STATISTICS: { DocIterator from, to; if (cur.selection()) { @@ -1640,9 +1781,10 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr) from = doc_iterator_begin(&buffer_); to = doc_iterator_end(&buffer_); } - int const words = countWords(from, to); - int const chars = countChars(from, to, false); - int const chars_blanks = countChars(from, to, true); + buffer_.updateStatistics(from, to); + int const words = buffer_.wordCount(); + int const chars = buffer_.charCount(false); + int const chars_blanks = buffer_.charCount(true); docstring message; if (cur.selection()) message = _("Statistics for the selection:"); @@ -1670,15 +1812,6 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr) } break; - case LFUN_BUFFER_TOGGLE_COMPRESSION: - // turn compression on/off - buffer_.params().compressed = !buffer_.params().compressed; - break; - - case LFUN_BUFFER_TOGGLE_OUTPUT_SYNC: - buffer_.params().output_sync = !buffer_.params().output_sync; - break; - case LFUN_SCREEN_UP: case LFUN_SCREEN_DOWN: { Point p = getPos(cur); @@ -1695,22 +1828,22 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr) p = Point(0, 0); if (act == LFUN_SCREEN_DOWN && scrolled < height_) p = Point(width_, height_); - Cursor old = cur; 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); + true, act == LFUN_SCREEN_UP); //FIXME: what to do with cur.x_target()? bool update = in_texted && cur.bv().checkDepm(cur, old); cur.finishUndo(); - if (update || cur.selection()) { + + if (update || cur.mark()) dr.screenUpdate(Update::Force | Update::FitCursor); + if (update) dr.forceBufferUpdate(); - } break; } @@ -1733,13 +1866,13 @@ 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; } case LFUN_SCREEN_UP_SELECT: { + // FIXME: why is the algorithm different from LFUN_SCREEN_UP? cur.selHandle(true); if (isTopScreen()) { lyx::dispatch(FuncRequest(LFUN_BUFFER_BEGIN_SELECT)); @@ -1757,6 +1890,7 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr) } case LFUN_SCREEN_DOWN_SELECT: { + // FIXME: why is the algorithm different from LFUN_SCREEN_DOWN? cur.selHandle(true); if (isBottomScreen()) { lyx::dispatch(FuncRequest(LFUN_BUFFER_END_SELECT)); @@ -1774,6 +1908,76 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr) } + case LFUN_INSET_SELECT_ALL: { + // true if all cells are selected + bool const all_selected = cur.depth() > 1 + && cur.selBegin().at_begin() + && cur.selEnd().at_end(); + // true if some cells are selected + bool const cells_selected = cur.depth() > 1 + && cur.selBegin().at_cell_begin() + && cur.selEnd().at_cell_end(); + if (all_selected || (cells_selected && !cur.inset().isTable())) { + // All the contents of the inset if selected, or only at + // least one cell but inset is not a table. + // Select the inset from outside. + cur.pop(); + cur.resetAnchor(); + cur.selection(true); + cur.posForward(); + } else if (cells_selected) { + // 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 + cur.pit() = 0; + cur.pos() = 0; + cur.resetAnchor(); + cur.selection(true); + cur.pit() = cur.lastpit(); + cur.pos() = cur.lastpos(); + } + cur.setCurrentFont(); + dr.screenUpdate(Update::Force); + break; + } + + + 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: { @@ -1782,22 +1986,22 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr) FuncRequest const fr = lyxaction.lookupFunc(commandstr); // an arbitrary number to limit number of iterations - const int max_iter = 10000; + 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 * 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; @@ -1807,11 +2011,21 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr) break; insname = insname.substr(0, i); } - cur.forwardInset(); + // if we did not delete the inset, skip it + if (!curs.nextInset() || curs.nextInset() == ins) + curs.forwardInset(); } - cur.endUndoGroup(); - 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) + + * 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(); dr.screenUpdate(Update::Force); dr.forceBufferUpdate(); @@ -1837,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; } @@ -1870,7 +2079,7 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr) if (decodeInsetParam(name, data, buffer_)) lyx::dispatch(FuncRequest(LFUN_DIALOG_SHOW, name + " " + data)); else - lyxerr << "Inset type '" << name << + lyxerr << "Inset type '" << name << "' not recognized in LFUN_DIALOG_SHOW_NEW_INSET" << endl; break; } @@ -1890,10 +2099,29 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr) arg = token(argument, '|', 0); opt1 = token(argument, '|', 1); } + + // if our cursor is directly in front of or behind a citation inset, + // we will instead add the new key to it. + Inset * inset = cur.nextInset(); + if (!inset || inset->lyxCode() != CITE_CODE) + inset = cur.prevInset(); + if (inset && inset->lyxCode() == CITE_CODE) { + InsetCitation * icite = static_cast(inset); + if (icite->addKey(arg)) { + dr.forceBufferUpdate(); + dr.screenUpdate(Update::FitCursor | Update::SinglePar); + if (!opt1.empty()) + LYXERR0("Discarding optional argument to citation-insert."); + } + dispatched = true; + break; + } InsetCommandParams icp(CITE_CODE); 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); @@ -1932,7 +2160,7 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr) if (!newL || oldL == newL) break; if (oldL->rightToLeft() == newL->rightToLeft()) { - cur.recordUndoFullDocument(); + cur.recordUndoFullBuffer(); buffer_.changeLanguage(oldL, newL); cur.setCurrentFont(); dr.forceBufferUpdate(); @@ -1940,38 +2168,14 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr) break; } - // FIXME We do not really want this here, but it has to be at present - // because we need a cursor for the recordUndoFullDocument call. What - // we would really like is a recordUndoBufferParams call that did not - // need a cursor, but we do not have that yet. - // So, if this does get fixed, this code can be moved back to Buffer.cpp, - // and the corresponding code in getStatus() should be moved back, too. - case LFUN_BRANCH_ACTIVATE: - case LFUN_BRANCH_DEACTIVATE: { - BranchList & branch_list = buffer().params().branchlist(); - docstring const branch_name = cmd.argument(); - // the case without a branch name is handled elsewhere - if (branch_name.empty()) { - dispatched = false; - break; - } - Branch * branch = branch_list.find(branch_name); - if (!branch) { - LYXERR0("Branch " << branch_name << " does not exist."); - dr.setError(true); - docstring const msg = - bformat(_("Branch \"%1$s\" does not exist."), branch_name); - dr.setMessage(msg); - break; - } - bool activate = cmd.action() == LFUN_BRANCH_ACTIVATE; - if (branch->isSelected() != activate) { - branch->setSelected(activate); - cur.recordUndoFullDocument(); - dr.setError(false); - dr.screenUpdate(Update::Force); - dr.forceBufferUpdate(); - } + case LFUN_FILE_INSERT_PLAINTEXT_PARA: + case LFUN_FILE_INSERT_PLAINTEXT: { + bool const as_paragraph = (act == LFUN_FILE_INSERT_PLAINTEXT_PARA); + string const fname = to_utf8(cmd.argument()); + if (!FileName::isAbsolute(fname)) + dr.setMessage(_("Absolute filename expected.")); + else + insertPlaintextFile(FileName(fname), as_paragraph); break; } @@ -1984,6 +2188,21 @@ void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr) buffer_.undo().endUndoGroup(); dr.dispatched(dispatched); + + // NOTE: The code below is copied from Cursor::dispatch. If you + // need to modify this, please update the other one too. + + // notify insets we just entered/left + if (cursor() != old) { + old.beginUndoGroup(); + old.fixIfBroken(); + bool badcursor = notifyCursorLeavesOrEnters(old, cursor()); + if (badcursor) { + cursor().fixIfBroken(); + resetInlineCompletionPos(); + } + old.endUndoGroup(); + } } @@ -2075,7 +2294,7 @@ void BufferView::updateHoveredInset() const int const y = d->mouse_position_cache_.y_; Inset const * covering_inset = getCoveringInset(buffer_.text(), x, y); - d->clickable_inset_ = covering_inset && covering_inset->clickable(x, y); + d->clickable_inset_ = covering_inset && covering_inset->clickable(*this, x, y); if (covering_inset == d->last_inset_) // Same inset, no need to do anything... @@ -2087,10 +2306,10 @@ void BufferView::updateHoveredInset() const need_redraw |= d->last_inset_->setMouseHover(this, false); d->last_inset_ = 0; } - + if (covering_inset && covering_inset->setMouseHover(this, true)) { need_redraw = true; - // Only the insets that accept the hover state, do + // Only the insets that accept the hover state, do // clear the last_inset_, so only set the last_inset_ // member if the hovered setting is accepted. d->last_inset_ = covering_inset; @@ -2098,9 +2317,9 @@ void BufferView::updateHoveredInset() const if (need_redraw) { LYXERR(Debug::PAINTING, "Mouse hover detected at: (" - << d->mouse_position_cache_.x_ << ", " + << d->mouse_position_cache_.x_ << ", " << d->mouse_position_cache_.y_ << ")"); - + d->update_strategy_ = DecorationUpdate; // This event (moving without mouse click) is not passed further. @@ -2114,7 +2333,7 @@ void BufferView::clearLastInset(Inset * inset) const { if (d->last_inset_ != inset) { LYXERR0("Wrong last_inset!"); - LASSERT(false, /**/); + LATTEST(false); } d->last_inset_ = 0; } @@ -2131,7 +2350,7 @@ void BufferView::mouseEventDispatch(FuncRequest const & cmd0) Cursor old = cursor(); Cursor cur(*this); cur.push(buffer_.inset()); - cur.setSelection(d->cursor_.selection()); + cur.selection(d->cursor_.selection()); // Either the inset under the cursor or the // surrounding Text will handle this event. @@ -2149,6 +2368,20 @@ void BufferView::mouseEventDispatch(FuncRequest const & cmd0) // Build temporary cursor. Inset * inset = d->text_metrics_[&buffer_.text()].editXY(cur, cmd.x(), cmd.y()); + if (inset) { + // If inset is not editable, cur.pos() might point behind the + // inset (depending on cmd.x(), cmd.y()). This is needed for + // editing to fix bug 9628, but e.g. the context menu needs a + // cursor in front of the inset. + if ((inset->hasSettings() || !inset->contextMenuName().empty() + || inset->lyxCode() == SEPARATOR_CODE) && + cur.nextInset() != inset && cur.prevInset() == inset) + cur.posBackward(); + } else if (cur.inTexted() && cur.pos() + && cur.paragraph().isEnvSeparator(cur.pos() - 1)) { + // Always place cursor in front of a separator inset. + cur.posBackward(); + } // Put anchor at the same position. cur.resetAnchor(); @@ -2167,16 +2400,16 @@ void BufferView::mouseEventDispatch(FuncRequest const & cmd0) if (!inset || !cur.result().dispatched()) cur.dispatch(cmd); - cur.endUndoGroup(); - // Notify left insets if (cur != old) { - old.fixIfBroken(); - bool badcursor = notifyCursorLeavesOrEnters(old, cur); + bool badcursor = old.fixIfBroken() | cur.fixIfBroken(); + badcursor |= notifyCursorLeavesOrEnters(old, cur); if (badcursor) cursor().fixIfBroken(); } - + + cur.endUndoGroup(); + // Do we have a selection? theSelection().haveSelection(cursor().selection()); @@ -2255,45 +2488,35 @@ int BufferView::scrollUp(int offset) } -void BufferView::setCursorFromRow(int row) +bool BufferView::setCursorFromRow(int row) { - int tmpid; - int tmppos; - pit_type newpit = 0; - pos_type newpos = 0; + 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); +} - buffer_.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 const dit = buffer_.getParFromID(tmpid); - if (dit == doc_iterator_end(&buffer_)) - posvalid = false; - 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; +bool BufferView::setCursorFromEntries(TexRow::TextEntry start, + TexRow::TextEntry end) +{ + 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_.setSelection(false); - d->cursor_.resetAnchor(); - recenter(); + return true; } @@ -2319,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 - Toc & toc = buf->tocBackend().toc("label"); - TocIterator toc_it = toc.begin(); - TocIterator 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); } @@ -2346,11 +2573,12 @@ TextMetrics const & BufferView::textMetrics(Text const * t) const TextMetrics & BufferView::textMetrics(Text const * t) { - LASSERT(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; } @@ -2377,7 +2605,8 @@ void BufferView::setCursor(DocIterator const & dit) dit[i].inset().edit(d->cursor_, true); d->cursor_.setCursor(dit); - d->cursor_.setSelection(false); + d->cursor_.selection(false); + d->cursor_.setCurrentFont(); // FIXME // It seems on general grounds as if this is probably needed, but // it is not yet clear. @@ -2386,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. @@ -2393,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) @@ -2404,15 +2645,18 @@ bool BufferView::checkDepm(Cursor & cur, Cursor & old) d->cursor_ = cur; - cur.forceBufferUpdate(); - cur.screenUpdateFlags(Update::Force); + // we would rather not do this here, but it needs to be done before + // the changed() signal is sent. + buffer_.updateBuffer(); + + buffer_.changed(true); return true; } -bool BufferView::mouseSetCursor(Cursor & cur, bool select) +bool BufferView::mouseSetCursor(Cursor & cur, bool const select) { - LASSERT(&cur.bv() == this, /**/); + LASSERT(&cur.bv() == this, return false); if (!select) // this event will clear selection so we save selection for @@ -2420,33 +2664,31 @@ bool BufferView::mouseSetCursor(Cursor & cur, bool select) cap::saveSelection(cursor()); d->cursor_.macroModeClose(); + // If a macro has been finalized, the cursor might have been broken + cur.fixIfBroken(); // Has the cursor just left the inset? bool const leftinset = (&d->cursor_.inset() != &cur.inset()); 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) @@ -2474,7 +2716,8 @@ void BufferView::putSelectionAt(DocIterator const & cur, bool BufferView::selectIfEmpty(DocIterator & cur) { - if (!cur.paragraph().empty()) + if ((cur.inTexted() && !cur.paragraph().empty()) + || (cur.inMathed() && !cur.cell().empty())) return false; pit_type const beg_pit = cur.pit(); @@ -2499,7 +2742,7 @@ bool BufferView::selectIfEmpty(DocIterator & cur) d->cursor_.setCursor(cur); d->cursor_.pit() = beg_pit; d->cursor_.pos() = 0; - d->cursor_.setSelection(false); + d->cursor_.selection(false); d->cursor_.resetAnchor(); d->cursor_.pit() = end_pit; d->cursor_.pos() = end_pos; @@ -2520,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(); @@ -2542,13 +2779,13 @@ bool BufferView::singleParUpdate() // (if this paragraph contains insets etc., rebreaking will // recursively descend) tm.redoParagraph(bottom_pit); - ParagraphMetrics const & pm = tm.parMetrics(bottom_pit); + ParagraphMetrics const & pm = tm.parMetrics(bottom_pit); if (pm.height() != old_height) // Paragraph height has changed so we cannot proceed to // 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() @@ -2559,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; @@ -2568,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 @@ -2579,7 +2824,7 @@ void BufferView::updateMetrics() // make sure inline completion pointer is ok if (d->inlineCompletionPos_.fixIfBroken()) d->inlineCompletionPos_ = DocIterator(); - + if (d->anchor_pit_ >= npit) // The anchor pit must have been deleted... d->anchor_pit_ = npit - 1; @@ -2587,20 +2832,21 @@ void BufferView::updateMetrics() // Rebreak anchor paragraph. tm.redoParagraph(d->anchor_pit_); ParagraphMetrics & anchor_pm = tm.par_metrics_[d->anchor_pit_]; - + // position anchor if (d->anchor_pit_ == 0) { int scrollRange = d->scrollbarParameters_.max - d->scrollbarParameters_.min; - + // 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_ @@ -2616,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(); } @@ -2629,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(); } @@ -2640,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"); @@ -2649,9 +2901,18 @@ 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(), /**/); + LASSERT(d->cursor_.inTexted(), return); // Get absolute path of file and add ".lyx" // to the filename if necessary @@ -2667,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 { @@ -2688,19 +2953,19 @@ Point BufferView::coordOffset(DocIterator const & dit) const int lastw = 0; // Addup contribution of nested insets, from inside to outside, - // keeping the outer paragraph for a special handling below + // keeping the outer paragraph for a special handling below for (size_t i = dit.depth() - 1; i >= 1; --i) { CursorSlice const & sl = dit[i]; int xx = 0; int yy = 0; - + // get relative position inside sl.inset() sl.inset().cursorPos(*this, sl, dit.boundary() && (i + 1 == dit.depth()), xx, yy); - + // Make relative position inside of the edited inset relative to sl.inset() x += xx; y += yy; - + // In case of an RTL inset, the edited inset will be positioned to the left // of xx:yy if (sl.text()) { @@ -2711,21 +2976,8 @@ 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 = parMetrics(dit[i - 1].text(), - dit[i - 1].pit()).insetDimension(&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; } @@ -2734,7 +2986,8 @@ Point BufferView::coordOffset(DocIterator const & dit) const CursorSlice const & sl = dit[0]; TextMetrics const & tm = textMetrics(sl.text()); ParagraphMetrics const & pm = tm.parMetrics(sl.pit()); - LASSERT(!pm.rows().empty(), /**/); + + LBUFERR(!pm.rows().empty()); y -= pm.rows()[0].ascent(); #if 1 // FIXME: document this mess @@ -2753,20 +3006,20 @@ Point BufferView::coordOffset(DocIterator const & dit) const for (size_t rit = 0; rit != rend; ++rit) y += pm.rows()[rit].height(); y += pm.rows()[rend].ascent(); - + TextMetrics const & bottom_tm = textMetrics(dit.bottom().text()); - + // Make relative position from the nested inset now bufferview absolute. int xx = bottom_tm.cursorX(dit.bottom(), dit.boundary() && dit.depth() == 1); x += xx; - - // In the RTL case place the nested inset at the left of the cursor in + + // In the RTL case place the nested inset at the left of the cursor in // the outer paragraph bool boundary_1 = dit.boundary() && 1 == dit.depth(); bool rtl = bottom_tm.isRTL(dit.bottom(), boundary_1); if (rtl) x -= lastw; - + return Point(x, y); } @@ -2780,7 +3033,7 @@ Point BufferView::getPos(DocIterator const & dit) const TextMetrics const & tm = textMetrics(bot.text()); // offset from outer paragraph - Point p = coordOffset(dit); + Point p = coordOffset(dit); p.y_ += tm.parMetrics(bot.pit()).position(); return p; } @@ -2795,56 +3048,182 @@ 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; } -void BufferView::draw(frontend::Painter & pain) +int BufferView::horizScrollOffset() const { - if (height_ == 0 || width_ == 0) + return d->horiz_scroll_offset_; +} + + +int BufferView::horizScrollOffset(Text const * text, + pit_type pit, pos_type pos) const +{ + // Is this a row that is currently scrolled? + if (!d->current_row_slice_.empty() + && &text->inset() == d->current_row_slice_.inset().asInsetText() + && pit == d->current_row_slice_.pit() + && pos == d->current_row_slice_.pos()) + return d->horiz_scroll_offset_; + return 0; +} + + +void BufferView::setCurrentRowSlice(CursorSlice const & rowSlice) +{ + // nothing to do if the cursor was already on this row + 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) { + // 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; + d->current_row_slice_ = rowSlice; +} + + +void BufferView::checkCursorScrollOffset() +{ + CursorSlice rowSlice = d->cursor_.bottom(); + TextMetrics const & tm = textMetrics(rowSlice.text()); + + // Stop if metrics have not been computed yet, since it means + // that there is nothing to do. + if (!tm.contains(rowSlice.pit())) return; - LYXERR(Debug::PAINTING, "\t\t*** START DRAWING ***"); + ParagraphMetrics const & pm = tm.parMetrics(rowSlice.pit()); + Row const & row = pm.getRow(rowSlice.pos(), + d->cursor_.boundary() && rowSlice == d->cursor_.top()); + rowSlice.pos() = row.pos(); + + // Set the row on which the cursor lives. + setCurrentRowSlice(rowSlice); + + // Current x position of the cursor in pixels + int cur_x = getPos(d->cursor_).x_; + + // Horizontal scroll offset of the cursor row in pixels + int offset = d->horiz_scroll_offset_; + int const MARGIN = 2 * theFontMetrics(d->cursor_.real_current_font).em() + + row.right_margin; + if (row.right_x() <= workWidth() - row.right_margin) { + // Row is narrower than the work area, no offset needed. + offset = 0; + } else { + if (cur_x - offset < MARGIN) { + // cursor would be too far right + offset = cur_x - MARGIN; + } else if (cur_x - offset > workWidth() - MARGIN) { + // cursor would be too far left + offset = cur_x - workWidth() + MARGIN; + } + // Correct the offset to make sure that we do not scroll too much + if (offset < 0) + offset = 0; + if (row.right_x() - offset < workWidth() - row.right_margin) + offset = row.right_x() - workWidth() + row.right_margin; + } + + //lyxerr << "cur_x=" << cur_x << ", offset=" << offset << ", row.wid=" << row.width() << ", margin=" << MARGIN << endl; + + 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; + } + + d->horiz_scroll_offset_ = offset; +} + +void BufferView::draw(frontend::Painter & pain, bool paint_caret) +{ + if (height_ == 0 || width_ == 0) + return; + 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(); PainterInfo pi(this, pain); + // Check whether the row where the cursor lives needs to be scrolled. + // Update the drawing strategy if needed. + 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. - pi.full_repaint = true; - pi.pain.setDrawingEnabled(false); - tm.draw(pi, 0, y); + // 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"); + 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: pi.full_repaint = false; + LYXERR(Debug::PAINTING, "Strategy: SingleParUpdate"); // In general, only the current row of the outermost paragraph // will be redrawn. Particular cases where selection spans // multiple paragraph are correctly detected in TextMetrics. - tm.draw(pi, 0, y); + tm.draw(pi, 0, y); break; case DecorationUpdate: @@ -2853,6 +3232,12 @@ void BufferView::draw(frontend::Painter & pain) // because of the single backing pixmap. case FullScreenUpdate: + + LYXERR(Debug::PAINTING, + ((d->update_strategy_ == FullScreenUpdate) + ? "Strategy: FullScreenUpdate" + : "Strategy: DecorationUpdate")); + // The whole screen, including insets, will be refreshed. pi.full_repaint = true; @@ -2866,15 +3251,16 @@ void BufferView::draw(frontend::Painter & pain) // and possibly grey out below pair lastpm = tm.last(); int const y2 = lastpm.second->position() + lastpm.second->descent(); - + if (y2 < height_) { - Color color = buffer().isInternal() + Color color = buffer().isInternal() ? Color_background : Color_bottomarea; pain.fillRectangle(0, y2, width_, height_ - y2, color); } 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(); @@ -2885,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); + } } @@ -3022,7 +3424,7 @@ bool samePar(DocIterator const & a, DocIterator const & b) } -void BufferView::setInlineCompletion(Cursor const & cur, DocIterator const & pos, +void BufferView::setInlineCompletion(Cursor const & cur, DocIterator const & pos, docstring const & completion, size_t uniqueChars) { uniqueChars = min(completion.size(), uniqueChars); @@ -3031,9 +3433,9 @@ void BufferView::setInlineCompletion(Cursor const & cur, DocIterator const & pos bool singlePar = true; d->inlineCompletion_ = completion; d->inlineCompletionUniqueChars_ = min(completion.size(), uniqueChars); - + //lyxerr << "setInlineCompletion pos=" << pos << " completion=" << completion << " uniqueChars=" << uniqueChars << std::endl; - + // at new position? DocIterator const & old = d->inlineCompletionPos_; if (old != pos) { @@ -3046,7 +3448,7 @@ void BufferView::setInlineCompletion(Cursor const & cur, DocIterator const & pos } d->inlineCompletionPos_ = pos; } - + // set update flags if (changed) { if (singlePar && !(cur.result().screenUpdate() & Update::Force)) @@ -3058,8 +3460,8 @@ void BufferView::setInlineCompletion(Cursor const & cur, DocIterator const & pos bool BufferView::clickableInset() const -{ - return d->clickable_inset_; +{ + return d->clickable_inset_; } } // namespace lyx