X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FBufferView.cpp;h=ac22a4e618996a53145199735e6c0df51b551425;hb=e6f46dd08c0e1ea040f7d085344d4fd568674cec;hp=cce0932f98b1ca65de36864cd0f899e39cf2d01f;hpb=09f96833bf5b17aae9a650313db4fce688ced0e9;p=lyx.git diff --git a/src/BufferView.cpp b/src/BufferView.cpp index cce0932f98..ac22a4e618 100644 --- a/src/BufferView.cpp +++ b/src/BufferView.cpp @@ -39,7 +39,6 @@ #include "LyX.h" #include "LyXAction.h" #include "lyxfind.h" -#include "LyXFunc.h" #include "Layout.h" #include "LyXRC.h" #include "MetricsInfo.h" @@ -59,9 +58,9 @@ #include "insets/InsetCommand.h" // ChangeRefs #include "insets/InsetExternal.h" #include "insets/InsetGraphics.h" +#include "insets/InsetNote.h" #include "insets/InsetRef.h" #include "insets/InsetText.h" -#include "insets/InsetNote.h" #include "frontends/alert.h" #include "frontends/Application.h" @@ -108,10 +107,7 @@ T * getInsetByCode(Cursor const & cur, InsetCode code) return 0; } - -bool findInset(DocIterator & dit, vector const & codes, - bool same_content); - +/// Note that comparing contents can only be used for InsetCommand bool findNextInset(DocIterator & dit, vector const & codes, docstring const & contents) { @@ -119,12 +115,17 @@ bool findNextInset(DocIterator & dit, vector const & codes, while (tmpdit) { Inset const * inset = tmpdit.nextInset(); - if (inset - && std::find(codes.begin(), codes.end(), inset->lyxCode()) != codes.end() - && (contents.empty() || - static_cast(inset)->getFirstNonOptParam() == contents)) { - dit = tmpdit; - return true; + if (inset) { + 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; + } } tmpdit.forwardInset(); } @@ -134,6 +135,7 @@ bool findNextInset(DocIterator & dit, vector const & codes, /// Looks for next inset with one of the given codes. +/// Note that same_content can only be used for InsetCommand bool findInset(DocIterator & dit, vector const & codes, bool same_content) { @@ -143,11 +145,14 @@ bool findInset(DocIterator & dit, vector const & codes, if (!tmpdit) return false; - if (same_content) { - Inset const * inset = tmpdit.nextInset(); - if (inset - && std::find(codes.begin(), codes.end(), inset->lyxCode()) != codes.end()) { - contents = static_cast(inset)->getFirstNonOptParam(); + Inset const * inset = tmpdit.nextInset(); + if (same_content && inset) { + InsetCommand const * ic = inset->asInsetCommand(); + if (ic) { + bool const valid_code = std::find(codes.begin(), codes.end(), + ic->lyxCode()) != codes.end(); + if (valid_code) + contents = ic->getFirstNonOptParam(); } } @@ -221,7 +226,9 @@ struct BufferView::Private Private(BufferView & bv): wh_(0), cursor_(bv), anchor_pit_(0), anchor_ypos_(0), inlineCompletionUniqueChars_(0), - last_inset_(0), bookmark_edit_position_(0), gui_(0) + last_inset_(0), clickable_inset_(false), + mouse_position_cache_(), + bookmark_edit_position_(-1), gui_(0) {} /// @@ -262,7 +269,14 @@ struct BufferView::Private /** kept to send setMouseHover(false). * Not owned, so don't delete. */ - Inset * last_inset_; + Inset const * last_inset_; + /// are we hovering something that we can click + bool clickable_inset_; + + /// position of the mouse at the time of the last mouse move + /// This is used to update the hovering status of inset in + /// cases where the buffer is scrolled, but the mouse didn't move. + Point mouse_position_cache_; // cache for id of the paragraph which was edited the last time int bookmark_edit_position_; @@ -276,6 +290,9 @@ struct BufferView::Private /// Cache for Find Next FuncRequest search_request_cache_; + + /// + map edited_insets_; }; @@ -291,8 +308,7 @@ BufferView::BufferView(Buffer & buf) d->cursor_.resetAnchor(); d->cursor_.setCurrentFont(); - if (graphics::Previews::status() != LyXRC::PREVIEW_OFF) - thePreviews().generateBufferPreviews(buffer_); + buffer_.updatePreviews(); } @@ -307,6 +323,9 @@ BufferView::~BufferView() fp.pit = d->cursor_.bottom().pit(); fp.pos = d->cursor_.bottom().pos(); theSession().lastFilePos().save(buffer_.fileName(), fp); + + if (d->last_inset_) + d->last_inset_->setMouseHover(this, false); delete d; } @@ -385,7 +404,7 @@ bool BufferView::fitCursor() theFontMetrics(d->cursor_.getFont().fontInfo()); int const asc = fm.maxAscent(); int const des = fm.maxDescent(); - Point const p = getPos(d->cursor_, d->cursor_.boundary()); + Point const p = getPos(d->cursor_); if (p.y_ - asc >= 0 && p.y_ + des < height_) return false; } @@ -395,10 +414,6 @@ bool BufferView::fitCursor() void BufferView::processUpdateFlags(Update::flags flags) { - // last_inset_ points to the last visited inset. This pointer may become - // invalid because of keyboard editing. Since all such operations - // causes screen update(), I reset last_inset_ to avoid such a problem. - d->last_inset_ = 0; // This is close to a hot-path. LYXERR(Debug::DEBUG, "BufferView::processUpdateFlags()" << "[fitcursor = " << (flags & Update::FitCursor) @@ -406,6 +421,8 @@ void BufferView::processUpdateFlags(Update::flags flags) << ", singlepar = " << (flags & Update::SinglePar) << "] buffer: " << &buffer_); + // 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 @@ -421,7 +438,7 @@ void BufferView::processUpdateFlags(Update::flags flags) if (flags == Update::Decoration) { d->update_strategy_ = DecorationUpdate; - buffer_.changed(); + buffer_.changed(false); return; } @@ -434,7 +451,7 @@ void BufferView::processUpdateFlags(Update::flags flags) } if (flags & Update::Decoration) { d->update_strategy_ = DecorationUpdate; - buffer_.changed(); + buffer_.changed(false); return; } // no screen update is needed. @@ -450,19 +467,21 @@ void BufferView::processUpdateFlags(Update::flags flags) if (!(flags & Update::FitCursor)) { // Nothing to do anymore. Trigger a redraw and return - buffer_.changed(); + buffer_.changed(false); return; } // updateMetrics() does not update paragraph position // This is done at draw() time. So we need a redraw! - buffer_.changed(); + buffer_.changed(false); if (fitCursor()) { // The cursor is off screen so ensure it is visible. // refresh it: showCursor(); } + + updateHoveredInset(); } @@ -559,7 +578,7 @@ docstring BufferView::contextMenu(int x, int y) const } -void BufferView::scrollDocView(int value) +void BufferView::scrollDocView(int value, bool update) { int const offset = value - d->scrollbarParameters_.position; @@ -570,15 +589,15 @@ void BufferView::scrollDocView(int value) // If the offset is less than 2 screen height, prefer to scroll instead. if (abs(offset) <= 2 * height_) { d->anchor_ypos_ -= offset; - updateMetrics(); - buffer_.changed(); + buffer_.changed(true); + updateHoveredInset(); return; } // cut off at the top if (value <= d->scrollbarParameters_.min) { DocIterator dit = doc_iterator_begin(&buffer_); - showCursor(dit); + showCursor(dit, false, update); LYXERR(Debug::SCROLLING, "scroll to top"); return; } @@ -587,7 +606,7 @@ void BufferView::scrollDocView(int value) if (value >= d->scrollbarParameters_.max) { DocIterator dit = doc_iterator_end(&buffer_); dit.backwardPos(); - showCursor(dit); + showCursor(dit, false, update); LYXERR(Debug::SCROLLING, "scroll to bottom"); return; } @@ -605,14 +624,14 @@ void BufferView::scrollDocView(int value) // It seems we didn't find the correct pit so stay on the safe side and // scroll to bottom. LYXERR0("scrolling position not found!"); - scrollDocView(d->scrollbarParameters_.max); + scrollDocView(d->scrollbarParameters_.max, update); return; } DocIterator dit = doc_iterator_begin(&buffer_); dit.pit() = i; LYXERR(Debug::SCROLLING, "value = " << value << " -> scroll to pit " << i); - showCursor(dit); + showCursor(dit, false, update); } @@ -635,7 +654,7 @@ void BufferView::setCursorFromScrollbar() newy = last; break; case CUR_INSIDE: - int const y = getPos(oldcur, oldcur.boundary()).y_; + int const y = getPos(oldcur).y_; newy = min(last, max(y, first)); if (y == newy) return; @@ -643,7 +662,7 @@ void BufferView::setCursorFromScrollbar() // We reset the cursor because cursorStatus() does not // work when the cursor is within mathed. Cursor cur(*this); - cur.reset(buffer_.inset()); + cur.reset(); tm.setCursorFromCoordinates(cur, 0, newy); // update the bufferview cursor and notify insets @@ -670,7 +689,7 @@ Change const BufferView::getCurrentChange() const // FIXME: This does not work within mathed! CursorStatus BufferView::cursorStatus(DocIterator const & dit) const { - Point const p = getPos(dit, dit.boundary()); + Point const p = getPos(dit); if (p.y_ < 0) return CUR_ABOVE; if (p.y_ > workHeight()) @@ -681,6 +700,7 @@ CursorStatus BufferView::cursorStatus(DocIterator const & dit) const void BufferView::bookmarkEditPosition() { + d->cursor_.markEditPosition(); // Don't eat cpu time for each keystroke if (d->cursor_.paragraph().id() == d->bookmark_edit_position_) return; @@ -695,17 +715,19 @@ void BufferView::saveBookmark(unsigned int idx) // acturately locate a bookmark in a 'live' lyx session. // pit and pos will be updated with bottom level pit/pos // when lyx exits. - theSession().bookmarks().save( - buffer_.fileName(), - d->cursor_.bottom().pit(), - d->cursor_.bottom().pos(), - d->cursor_.paragraph().id(), - d->cursor_.pos(), - idx - ); - if (idx) - // emit message signal. - message(_("Save bookmark")); + if (!buffer_.isInternal()) { + theSession().bookmarks().save( + buffer_.fileName(), + d->cursor_.bottom().pit(), + d->cursor_.bottom().pos(), + d->cursor_.paragraph().id(), + d->cursor_.pos(), + idx + ); + if (idx) + // emit message signal. + message(_("Save bookmark")); + } } @@ -762,7 +784,7 @@ bool BufferView::moveToPosition(pit_type bottom_pit, pos_type bottom_pos, // 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(); + buffer_.changed(false); if (fitCursor()) showCursor(); } @@ -795,26 +817,32 @@ int BufferView::workWidth() const void BufferView::recenter() { - showCursor(d->cursor_, true); + showCursor(d->cursor_, true, true); } void BufferView::showCursor() { - showCursor(d->cursor_, false); + showCursor(d->cursor_, false, true); } -void BufferView::showCursor(DocIterator const & dit, bool recenter) +void BufferView::showCursor(DocIterator const & dit, + bool recenter, bool update) { - if (scrollToCursor(dit, recenter)) - buffer_.changed(); + if (scrollToCursor(dit, recenter) && update) { + buffer_.changed(true); + updateHoveredInset(); + } } void BufferView::scrollToCursor() { - scrollToCursor(d->cursor_, false); + if (scrollToCursor(d->cursor_, false)) { + buffer_.changed(true); + updateHoveredInset(); + } } @@ -849,24 +877,32 @@ bool BufferView::scrollToCursor(DocIterator const & dit, bool recenter) LASSERT(!pm.rows().empty(), /**/); // FIXME: smooth scrolling doesn't work in mathed. CursorSlice const & cs = dit.innerTextSlice(); - int offset = coordOffset(dit, dit.boundary()).y_; + int offset = coordOffset(dit).y_; int ypos = pm.position() + offset; Dimension const & row_dim = pm.getRow(cs.pos(), dit.boundary()).dimension(); int scrolled = 0; if (recenter) scrolled = scroll(ypos - height_/2); + + // If the top part of the row falls of the screen, we scroll + // up to align the top of the row with the top of the screen. else if (ypos - row_dim.ascent() < 0) - scrolled = scrollUp(- ypos + row_dim.ascent()); - else if (ypos + row_dim.descent() > height_) - scrolled = scrollDown(ypos - height_ + defaultRowHeight() ); + scrolled = scrollUp(-ypos + row_dim.ascent()); + + // If the bottom of the row falls of the screen, we scroll down. + // However, we have to be careful not to scroll that much that + // the top falls of the screen. + else if (ypos + row_dim.descent() > height_) { + int ynew = height_ - row_dim.descent(); + if (ynew < row_dim.ascent()) + ynew = row_dim.ascent(); + int const scroll = ypos - ynew; + scrolled = scrollDown(scroll); + } // else, nothing to do, the cursor is already visible so we just return. - if (scrolled != 0) { - updateMetrics(); - return true; - } - return false; + return scrolled != 0; } // fix inline completion position @@ -875,7 +911,7 @@ bool BufferView::scrollToCursor(DocIterator const & dit, bool recenter) tm.redoParagraph(bot_pit); ParagraphMetrics const & pm = tm.parMetrics(bot_pit); - int offset = coordOffset(dit, dit.boundary()).y_; + int offset = coordOffset(dit).y_; d->anchor_pit_ = bot_pit; CursorSlice const & cs = dit.innerTextSlice(); @@ -893,25 +929,23 @@ bool BufferView::scrollToCursor(DocIterator const & dit, bool recenter) else d->anchor_ypos_ = defaultRowHeight() * 2; - updateMetrics(); return true; } -void BufferView::updateLayout(DocumentClass const * const oldlayout) +void BufferView::updateDocumentClass(DocumentClass const * const olddc) { message(_("Converting document to new document class...")); StableDocIterator backcur(d->cursor_); ErrorList & el = buffer_.errorList("Class Switch"); cap::switchBetweenClasses( - oldlayout, buffer_.params().documentClassPtr(), + olddc, buffer_.params().documentClassPtr(), static_cast(buffer_.inset()), el); setCursor(backcur.asDocIterator(&buffer_)); buffer_.errors("Class Switch"); - buffer_.updateLabels(); } /** Return the change status at cursor position, taking in account the @@ -936,49 +970,23 @@ static Change::Type lookupChangeType(DocIterator const & dit, bool outer = false } -static bool getLocalStatus(Cursor cursor, FuncRequest const & cmd, FuncStatus & status) -{ - // Try to fix cursor in case it is broken. - cursor.fixIfBroken(); - - // This is, of course, a mess. Better create a new doc iterator and use - // this in Inset::getStatus. This might require an additional - // BufferView * arg, though (which should be avoided) - //Cursor safe = *this; - bool res = false; - for ( ; cursor.depth(); cursor.pop()) { - //lyxerr << "\nCursor::getStatus: cmd: " << cmd << endl << *this << endl; - LASSERT(cursor.idx() <= cursor.lastidx(), /**/); - LASSERT(cursor.pit() <= cursor.lastpit(), /**/); - LASSERT(cursor.pos() <= cursor.lastpos(), /**/); - - // The inset's getStatus() will return 'true' if it made - // a definitive decision on whether it want to handle the - // request or not. The result of this decision is put into - // the 'status' parameter. - if (cursor.inset().getStatus(cursor, cmd, status)) { - res = true; - break; - } - } - return res; -} - - bool BufferView::getStatus(FuncRequest const & cmd, FuncStatus & flag) { + FuncCode const act = cmd.action(); + // Can we use a readonly buffer? if (buffer_.isReadonly() - && !lyxaction.funcHasFlag(cmd.action, LyXAction::ReadOnly) - && !lyxaction.funcHasFlag(cmd.action, LyXAction::NoBuffer)) { + && !lyxaction.funcHasFlag(act, LyXAction::ReadOnly) + && !lyxaction.funcHasFlag(act, LyXAction::NoBuffer)) { flag.message(from_utf8(N_("Document is read-only"))); flag.setEnabled(false); return true; } + // Are we in a DELETED change-tracking region? if (lookupChangeType(d->cursor_, true) == Change::DELETED - && !lyxaction.funcHasFlag(cmd.action, LyXAction::ReadOnly) - && !lyxaction.funcHasFlag(cmd.action, LyXAction::NoBuffer)) { + && !lyxaction.funcHasFlag(act, LyXAction::ReadOnly) + && !lyxaction.funcHasFlag(act, LyXAction::NoBuffer)) { flag.message(from_utf8(N_("This portion of the document is deleted."))); flag.setEnabled(false); return true; @@ -986,22 +994,16 @@ bool BufferView::getStatus(FuncRequest const & cmd, FuncStatus & flag) Cursor & cur = d->cursor_; - // Is this a function that acts on inset at point? - Inset * inset = cur.nextInset(); - if (lyxaction.funcHasFlag(cmd.action, LyXAction::AtPoint) - && inset && inset->getStatus(cur, cmd, flag)) - return true; - - if (getLocalStatus(cur, cmd, flag)) + if (cur.getStatus(cmd, flag)) return true; - switch (cmd.action) { + switch (act) { - // FIXME: This is a bit problematic because we don't check is this is a - // document BufferView or not for these LFUNs. We probably have to + // FIXME: This is a bit problematic because we don't check if this is + // a document BufferView or not for these LFUNs. We probably have to // dispatch both to currentBufferView() and, if that fails, - // to documentBufferView(); same as we do know for current Buffer and - // document Buffer. Ideally those LFUN should go to Buffer as they* + // to documentBufferView(); same as we do now for current Buffer and + // document Buffer. Ideally those LFUN should go to Buffer as they // operate on the full Buffer and the cursor is only needed either for // an Undo record or to restore a cursor position. But we don't know // how to do that inside Buffer of course. @@ -1015,10 +1017,14 @@ bool BufferView::getStatus(FuncRequest const & cmd, FuncStatus & flag) break; case LFUN_UNDO: - flag.setEnabled(buffer_.undo().hasUndoStack()); + // We do not use the LyXAction flag for readonly because Undo sets the + // buffer clean/dirty status by itself. + flag.setEnabled(!buffer_.isReadonly() && buffer_.undo().hasUndoStack()); break; case LFUN_REDO: - flag.setEnabled(buffer_.undo().hasRedoStack()); + // We do not use the LyXAction flag for readonly because Redo sets the + // buffer clean/dirty status by itself. + flag.setEnabled(!buffer_.isReadonly() && buffer_.undo().hasRedoStack()); break; case LFUN_FILE_INSERT: case LFUN_FILE_INSERT_PLAINTEXT_PARA: @@ -1031,7 +1037,6 @@ bool BufferView::getStatus(FuncRequest const & cmd, FuncStatus & flag) case LFUN_FONT_STATE: case LFUN_LABEL_INSERT: case LFUN_INFO_INSERT: - case LFUN_INSET_EDIT: case LFUN_PARAGRAPH_GOTO: case LFUN_NOTE_NEXT: case LFUN_REFERENCE_NEXT: @@ -1047,8 +1052,6 @@ bool BufferView::getStatus(FuncRequest const & cmd, FuncStatus & flag) case LFUN_SCREEN_SHOW_CURSOR: case LFUN_BIBTEX_DATABASE_ADD: case LFUN_BIBTEX_DATABASE_DEL: - case LFUN_NOTES_MUTATE: - case LFUN_ALL_INSETS_TOGGLE: case LFUN_STATISTICS: case LFUN_BRANCH_ADD_INSERT: case LFUN_KEYMAP_OFF: @@ -1058,32 +1061,6 @@ bool BufferView::getStatus(FuncRequest const & cmd, FuncStatus & flag) flag.setEnabled(true); break; - case LFUN_REGEXP_MODE: - // FIXME: Test if current WorkArea is the search WorkArea - flag.setEnabled(buffer().isInternal() && !cur.inRegexped()); - break; - - case LFUN_LABEL_COPY_AS_REF: { - // if there is an inset at cursor, see whether it - // handles the lfun - Inset * inset = cur.nextInset(); - if (!inset || !inset->getStatus(cur, cmd, flag)) - flag.setEnabled(false); - break; - } - - case LFUN_NEXT_INSET_MODIFY: { - // this is the real function we want to invoke - FuncRequest tmpcmd = cmd; - tmpcmd.action = LFUN_INSET_MODIFY; - // if there is an inset at cursor, see whether it - // handles the lfun, other start from scratch - Inset * inset = cur.nextInset(); - if (!inset || !inset->getStatus(cur, tmpcmd, flag)) - flag = lyx::getStatus(tmpcmd); - break; - } - case LFUN_LABEL_GOTO: { flag.setEnabled(!cmd.argument().empty() || getInsetByCode(cur, REF_CODE)); @@ -1116,12 +1093,18 @@ bool BufferView::getStatus(FuncRequest const & cmd, FuncStatus & flag) 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: case LFUN_SCREEN_UP_SELECT: case LFUN_SCREEN_DOWN_SELECT: + case LFUN_INSET_FORALL: flag.setEnabled(true); break; @@ -1143,11 +1126,33 @@ bool BufferView::getStatus(FuncRequest const & cmd, FuncStatus & flag) if (cur.inset().lyxCode() == CAPTION_CODE) return cur.inset().getStatus(cur, cmd, flag); // FIXME we should consider passthru paragraphs too. - flag.setEnabled(!cur.inset().getLayout().isPassThru()); + flag.setEnabled(!(cur.inTexted() && cur.paragraph().isPassThru())); break; + case LFUN_CITATION_INSERT: { + FuncRequest fr(LFUN_INSET_INSERT, "citation"); + // FIXME: This could turn in a recursive hell. + // Shouldn't we use Buffer::getStatus() instead? + flag.setEnabled(lyx::getStatus(fr).enabled()); + break; + } + case LFUN_INSET_APPLY: { + string const name = cmd.getArg(0); + Inset * inset = editedInset(name); + if (inset) { + FuncRequest fr(LFUN_INSET_MODIFY, cmd.argument()); + if (!inset->getStatus(cur, fr, flag)) { + // Every inset is supposed to handle this + LASSERT(false, break); + } + } else { + FuncRequest fr(LFUN_INSET_INSERT, cmd.argument()); + flag = lyx::getStatus(fr); + } + break; + } + default: - flag.setEnabled(false); return false; } @@ -1155,25 +1160,44 @@ bool BufferView::getStatus(FuncRequest const & cmd, FuncStatus & flag) } -bool BufferView::dispatch(FuncRequest const & cmd) +Inset * BufferView::editedInset(string const & name) const +{ + map::const_iterator it = d->edited_insets_.find(name); + return it == d->edited_insets_.end() ? 0 : it->second; +} + + +void BufferView::editInset(string const & name, Inset * inset) +{ + d->edited_insets_[name] = inset; +} + + +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 << ']' + LYXERR(Debug::ACTION, " action[" << cmd.action() << ']' << " arg[" << to_utf8(cmd.argument()) << ']' - << " x[" << cmd.x << ']' - << " y[" << cmd.y << ']' + << " x[" << cmd.x() << ']' + << " y[" << cmd.y() << ']' << " button[" << cmd.button() << ']'); string const argument = to_utf8(cmd.argument()); Cursor & cur = d->cursor_; // Don't dispatch function that does not apply to internal buffers. - if (buffer_.isInternal() && lyxaction.funcHasFlag(cmd.action, LyXAction::NoInternal)) - return false; + if (buffer_.isInternal() + && lyxaction.funcHasFlag(cmd.action(), LyXAction::NoInternal)) + return; + + // We'll set this back to false if need be. + bool dispatched = true; + buffer_.undo().beginUndoGroup(); - switch (cmd.action) { + FuncCode const act = cmd.action(); + switch (act) { case LFUN_BUFFER_PARAMS_APPLY: { DocumentClass const * const oldClass = buffer_.params().documentClassPtr(); @@ -1187,12 +1211,13 @@ bool BufferView::dispatch(FuncRequest const & cmd) << unknown_tokens << " unknown token" << (unknown_tokens == 1 ? "" : "s")); } - updateLayout(oldClass); + updateDocumentClass(oldClass); // 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. - processUpdateFlags(Update::Force | Update::FitCursor); + dr.screenUpdate(Update::Force | Update::FitCursor); + dr.forceBufferUpdate(); break; } @@ -1202,8 +1227,9 @@ bool BufferView::dispatch(FuncRequest const & cmd) cur.recordUndoFullDocument(); buffer_.params().clearLayoutModules(); buffer_.params().makeDocumentClass(); - updateLayout(oldClass); - processUpdateFlags(Update::Force | Update::FitCursor); + updateDocumentClass(oldClass); + dr.screenUpdate(Update::Force); + dr.forceBufferUpdate(); break; } @@ -1219,15 +1245,24 @@ bool BufferView::dispatch(FuncRequest const & cmd) cur.recordUndoFullDocument(); buffer_.params().addLayoutModule(argument); buffer_.params().makeDocumentClass(); - updateLayout(oldClass); - processUpdateFlags(Update::Force | Update::FitCursor); + updateDocumentClass(oldClass); + dr.screenUpdate(Update::Force); + dr.forceBufferUpdate(); break; } case LFUN_TEXTCLASS_APPLY: { - if (!LayoutFileList::get().load(argument, buffer_.temppath()) && - !LayoutFileList::get().load(argument, buffer_.filePath())) + // since this shortcircuits, the second call is made only if + // the first fails + bool const success = + LayoutFileList::get().load(argument, buffer_.temppath()) || + LayoutFileList::get().load(argument, buffer_.filePath()); + 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); break; + } LayoutFile const * old_layout = buffer_.params().baseClass(); LayoutFile const * new_layout = &(LayoutFileList::get()[argument]); @@ -1236,53 +1271,66 @@ bool BufferView::dispatch(FuncRequest const & cmd) // nothing to do break; - //Save the old, possibly modular, layout for use in conversion. + // 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(); - updateLayout(oldDocClass); - processUpdateFlags(Update::Force | Update::FitCursor); + updateDocumentClass(oldDocClass); + dr.screenUpdate(Update::Force); + dr.forceBufferUpdate(); + break; + } + + case LFUN_TEXTCLASS_LOAD: { + // since this shortcircuits, the second call is made only if + // the first fails + bool const success = + LayoutFileList::get().load(argument, buffer_.temppath()) || + LayoutFileList::get().load(argument, buffer_.filePath()); + 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); + } break; } - case LFUN_TEXTCLASS_LOAD: - LayoutFileList::get().load(argument, buffer_.temppath()) || - LayoutFileList::get().load(argument, buffer_.filePath()); - break; - 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(); - updateLayout(oldClass); - processUpdateFlags(Update::Force | Update::FitCursor); + updateDocumentClass(oldClass); + dr.screenUpdate(Update::Force); + dr.forceBufferUpdate(); break; } case LFUN_UNDO: - cur.message(_("Undo")); + dr.setMessage(_("Undo")); cur.clearSelection(); if (!cur.textUndo()) - cur.message(_("No further undo information")); + dr.setMessage(_("No further undo information")); else - processUpdateFlags(Update::Force | Update::FitCursor); + dr.screenUpdate(Update::Force | Update::FitCursor); + dr.forceBufferUpdate(); break; case LFUN_REDO: - cur.message(_("Redo")); + dr.setMessage(_("Redo")); cur.clearSelection(); if (!cur.textRedo()) - cur.message(_("No further redo information")); + dr.setMessage(_("No further redo information")); else - processUpdateFlags(Update::Force | Update::FitCursor); + dr.screenUpdate(Update::Force | Update::FitCursor); + dr.forceBufferUpdate(); break; case LFUN_FONT_STATE: - cur.message(cur.currentState()); + dr.setMessage(cur.currentState()); break; case LFUN_BOOKMARK_SAVE: @@ -1300,30 +1348,16 @@ bool BufferView::dispatch(FuncRequest const & cmd) saveBookmark(0); } } - if (!label.empty()) + if (!label.empty()) { gotoLabel(label); + // at the moment, this is redundant, since gotoLabel will + // eventually call LFUN_PARAGRAPH_GOTO, but it seems best + // to have it here. + dr.screenUpdate(Update::Force | Update::FitCursor); + } break; } - case LFUN_INSET_EDIT: { - FuncRequest fr(cmd); - // if there is an inset at cursor, see whether it - // can be modified. - Inset * inset = cur.nextInset(); - if (inset) - inset->dispatch(cur, fr); - // if it did not work, try the underlying inset. - if (!inset || !cur.result().dispatched()) - cur.dispatch(cmd); - - // FIXME I'm adding the last break to solve a crash, - // but that is obviously not right. - if (!cur.result().dispatched()) - // It did not work too; no action needed. - break; - break; - } - case LFUN_PARAGRAPH_GOTO: { int const id = convert(cmd.getArg(0)); int const pos = convert(cmd.getArg(1)); @@ -1345,12 +1379,12 @@ bool BufferView::dispatch(FuncRequest const & cmd) // Set the cursor dit.pos() = pos; setCursor(dit); - processUpdateFlags(Update::Force | Update::FitCursor); + dr.screenUpdate(Update::Force | Update::FitCursor); } else { // Switch to other buffer view and resend cmd - theLyXFunc().dispatch(FuncRequest( + lyx::dispatch(FuncRequest( LFUN_BUFFER_SWITCH, b->absFileName())); - theLyXFunc().dispatch(cmd); + lyx::dispatch(cmd); } break; } @@ -1399,43 +1433,46 @@ bool BufferView::dispatch(FuncRequest const & cmd) case LFUN_CHANGE_NEXT: findNextChange(this); // FIXME: Move this LFUN to Buffer so that we don't have to do this: - processUpdateFlags(Update::Force | Update::FitCursor); + dr.screenUpdate(Update::Force | Update::FitCursor); break; case LFUN_CHANGE_PREVIOUS: findPreviousChange(this); // FIXME: Move this LFUN to Buffer so that we don't have to do this: - processUpdateFlags(Update::Force | Update::FitCursor); + dr.screenUpdate(Update::Force | Update::FitCursor); break; case LFUN_CHANGES_MERGE: if (findNextChange(this) || findPreviousChange(this)) { - processUpdateFlags(Update::Force | Update::FitCursor); + dr.screenUpdate(Update::Force | Update::FitCursor); + dr.forceBufferUpdate(); showDialog("changes"); } break; case LFUN_ALL_CHANGES_ACCEPT: // select complete document - cur.reset(buffer_.inset()); + cur.reset(); cur.selHandle(true); buffer_.text().cursorBottom(cur); // accept everything in a single step to support atomic undo buffer_.text().acceptOrRejectChanges(cur, Text::ACCEPT); // FIXME: Move this LFUN to Buffer so that we don't have to do this: - processUpdateFlags(Update::Force | Update::FitCursor); + dr.screenUpdate(Update::Force | Update::FitCursor); + dr.forceBufferUpdate(); break; case LFUN_ALL_CHANGES_REJECT: // select complete document - cur.reset(buffer_.inset()); + 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 buffer_.text().acceptOrRejectChanges(cur, Text::REJECT); // FIXME: Move this LFUN to Buffer so that we don't have to do this: - processUpdateFlags(Update::Force | Update::FitCursor); + dr.screenUpdate(Update::Force | Update::FitCursor); + dr.forceBufferUpdate(); break; case LFUN_WORD_FIND_FORWARD: @@ -1453,10 +1490,12 @@ bool BufferView::dispatch(FuncRequest const & cmd) if (searched_string.empty()) break; - bool const fw = cmd.action == LFUN_WORD_FIND_FORWARD; + bool const fw = act == LFUN_WORD_FIND_FORWARD; docstring const data = find2string(searched_string, true, false, fw); - find(this, FuncRequest(LFUN_WORD_FIND, data)); + bool found = lyxfind(this, FuncRequest(LFUN_WORD_FIND, data)); + if (found) + dr.screenUpdate(Update::Force | Update::FitCursor); break; } @@ -1465,11 +1504,11 @@ bool BufferView::dispatch(FuncRequest const & cmd) if (cmd.argument().empty() && !d->search_request_cache_.argument().empty()) req = d->search_request_cache_; if (req.argument().empty()) { - theLyXFunc().dispatch(FuncRequest(LFUN_DIALOG_SHOW, "findreplace")); + lyx::dispatch(FuncRequest(LFUN_DIALOG_SHOW, "findreplace")); break; } - if (find(this, req)) - showCursor(); + if (lyxfind(this, req)) + dr.screenUpdate(Update::Force | Update::FitCursor); else message(_("String not found!")); d->search_request_cache_ = req; @@ -1483,38 +1522,54 @@ bool BufferView::dispatch(FuncRequest const & cmd) DocIterator end = cur.selectionEnd(); if (beg.pit() == end.pit()) { for (pos_type p = beg.pos() ; p < end.pos() ; ++p) { - if (cur.paragraph().isDeleted(p)) + if (!cur.inMathed() && cur.paragraph().isDeleted(p)) { has_deleted = true; + break; + } } } } - replace(this, cmd, has_deleted); + if (lyxreplace(this, cmd, has_deleted)) { + dr.forceBufferUpdate(); + dr.screenUpdate(Update::Force | Update::FitCursor); + } break; } - case LFUN_WORD_FINDADV: - findAdv(this, cmd); + case LFUN_WORD_FINDADV: { + FindAndReplaceOptions opt; + istringstream iss(to_utf8(cmd.argument())); + iss >> opt; + if (findAdv(this, opt)) { + dr.screenUpdate(Update::Force | Update::FitCursor); + cur.dispatched(); + dispatched = true; + } else { + cur.undispatched(); + dispatched = false; + } break; + } case LFUN_MARK_OFF: cur.clearSelection(); - cur.message(from_utf8(N_("Mark off"))); + dr.setMessage(from_utf8(N_("Mark off"))); break; case LFUN_MARK_ON: cur.clearSelection(); cur.setMark(true); - cur.message(from_utf8(N_("Mark on"))); + dr.setMessage(from_utf8(N_("Mark on"))); break; case LFUN_MARK_TOGGLE: cur.setSelection(false); if (cur.mark()) { cur.setMark(false); - cur.message(from_utf8(N_("Mark removed"))); + dr.setMessage(from_utf8(N_("Mark removed"))); } else { cur.setMark(true); - cur.message(from_utf8(N_("Mark set"))); + dr.setMessage(from_utf8(N_("Mark set"))); } cur.resetAnchor(); break; @@ -1533,8 +1588,10 @@ bool BufferView::dispatch(FuncRequest const & cmd) InsetBibtex * inset = getInsetByCode(tmpcur, BIBTEX_CODE); if (inset) { - if (inset->addDatabase(cmd.argument())) - buffer_.updateBibfilesCache(); + if (inset->addDatabase(cmd.argument())) { + buffer_.invalidateBibfileCache(); + dr.forceBufferUpdate(); + } } break; } @@ -1545,8 +1602,10 @@ bool BufferView::dispatch(FuncRequest const & cmd) InsetBibtex * inset = getInsetByCode(tmpcur, BIBTEX_CODE); if (inset) { - if (inset->delDatabase(cmd.argument())) - buffer_.updateBibfilesCache(); + if (inset->delDatabase(cmd.argument())) { + buffer_.invalidateBibfileCache(); + dr.forceBufferUpdate(); + } } break; } @@ -1595,81 +1654,47 @@ bool BufferView::dispatch(FuncRequest const & cmd) buffer_.params().compressed = !buffer_.params().compressed; break; - case LFUN_LABEL_COPY_AS_REF: { - // if there is an inset at cursor, try to copy it - Inset * inset = &cur.inset(); - if (!inset || !inset->asInsetMath()) - inset = cur.nextInset(); - if (inset) { - FuncRequest tmpcmd = cmd; - inset->dispatch(cur, tmpcmd); - } - if (!cur.result().dispatched()) - // It did not work too; no action needed. - break; - cur.clearSelection(); - processUpdateFlags(Update::SinglePar | Update::FitCursor); - break; - } - - case LFUN_NEXT_INSET_MODIFY: { - // create the the real function we want to invoke - FuncRequest tmpcmd = cmd; - tmpcmd.action = LFUN_INSET_MODIFY; - // if there is an inset at cursor, see whether it - // can be modified. - Inset * inset = cur.nextInset(); - if (inset) { - cur.recordUndo(); - inset->dispatch(cur, tmpcmd); - } - // if it did not work, try the underlying inset. - if (!inset || !cur.result().dispatched()) { - cur.recordUndo(); - cur.dispatch(tmpcmd); - } - - if (!cur.result().dispatched()) - // It did not work too; no action needed. - break; - cur.clearSelection(); - processUpdateFlags(Update::Force | Update::FitCursor); + 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, cur.boundary()); + Point p = getPos(cur); // This code has been commented out to enable to scroll down a // document, even if there are large insets in it (see bug #5465). /*if (p.y_ < 0 || p.y_ > height_) { // The cursor is off-screen so recenter before proceeding. showCursor(); - p = getPos(cur, cur.boundary()); + p = getPos(cur); }*/ - int const scrolled = scroll(cmd.action == LFUN_SCREEN_UP + int const scrolled = scroll(act == LFUN_SCREEN_UP ? -height_ : height_); - if (cmd.action == LFUN_SCREEN_UP && scrolled > -height_) + if (act == LFUN_SCREEN_UP && scrolled > -height_) p = Point(0, 0); - if (cmd.action == LFUN_SCREEN_DOWN && scrolled < height_) + if (act == LFUN_SCREEN_DOWN && scrolled < height_) p = Point(width_, height_); Cursor old = cur; bool const in_texted = cur.inTexted(); - cur.reset(buffer_.inset()); - updateMetrics(); - buffer_.changed(); + cur.reset(); + buffer_.changed(true); + updateHoveredInset(); + d->text_metrics_[&buffer_.text()].editXY(cur, p.x_, p.y_, - true, cmd.action == 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) - processUpdateFlags(Update::Force | Update::FitCursor); + if (update) { + dr.screenUpdate(Update::Force | Update::FitCursor); + dr.forceBufferUpdate(); + } break; } case LFUN_SCROLL: lfunScroll(cmd); + dr.forceBufferUpdate(); break; case LFUN_SCREEN_UP_SELECT: { @@ -1679,13 +1704,13 @@ bool BufferView::dispatch(FuncRequest const & cmd) cur.finishUndo(); break; } - int y = getPos(cur, cur.boundary()).y_; + int y = getPos(cur).y_; int const ymin = y - height_ + defaultRowHeight(); while (y > ymin && cur.up()) - y = getPos(cur, cur.boundary()).y_; + y = getPos(cur).y_; cur.finishUndo(); - processUpdateFlags(Update::SinglePar | Update::FitCursor); + dr.screenUpdate(Update::SinglePar | Update::FitCursor); break; } @@ -1696,51 +1721,67 @@ bool BufferView::dispatch(FuncRequest const & cmd) cur.finishUndo(); break; } - int y = getPos(cur, cur.boundary()).y_; + int y = getPos(cur).y_; int const ymax = y + height_ - defaultRowHeight(); while (y < ymax && cur.down()) - y = getPos(cur, cur.boundary()).y_; + y = getPos(cur).y_; cur.finishUndo(); - processUpdateFlags(Update::SinglePar | Update::FitCursor); - break; - } - - // This could be rewriten using some command like forall - // once the insets refactoring is done. - case LFUN_NOTES_MUTATE: { - if (cmd.argument().empty()) - break; - - if (mutateNotes(cur, cmd.getArg(0), cmd.getArg(1))) { - processUpdateFlags(Update::Force); - } - break; - } - - case LFUN_ALL_INSETS_TOGGLE: { - string action; - string const name = split(to_utf8(cmd.argument()), action, ' '); - InsetCode const inset_code = insetCode(name); - - FuncRequest fr(LFUN_INSET_TOGGLE, action); - - Inset & inset = cur.buffer()->inset(); - InsetIterator it = inset_iterator_begin(inset); - InsetIterator const end = inset_iterator_end(inset); - for (; it != end; ++it) { - if (it->asInsetCollapsable() - && (inset_code == NO_CODE - || inset_code == it->lyxCode())) { - Cursor tmpcur = cur; - tmpcur.pushBackward(*it); - it->dispatch(tmpcur, fr); + dr.screenUpdate(Update::SinglePar | Update::FitCursor); + break; + } + + + // This would be in Buffer class if only Cursor did not + // require a bufferview + case LFUN_INSET_FORALL: { + docstring const name = from_utf8(cmd.getArg(0)); + string const commandstr = cmd.getLongArg(1); + FuncRequest const fr = lyxaction.lookupFunc(commandstr); + + // an arbitrary number to limit number of iterations + const int max_iter = 10000; + 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(); + if (!ins) + break; + docstring insname = ins->name(); + while (!insname.empty()) { + if (insname == name || name == from_utf8("*")) { + cur.recordUndo(); + lyx::dispatch(fr, dr); + ++iterations; + break; + } + size_t const i = insname.rfind(':'); + if (i == string::npos) + break; + insname = insname.substr(0, i); } + cur.forwardInset(); } - processUpdateFlags(Update::Force | Update::FitCursor); + cur.endUndoGroup(); + cur = savecur; + cur.fixIfBroken(); + dr.screenUpdate(Update::Force); + dr.forceBufferUpdate(); + + if (iterations >= max_iter) { + dr.setError(true); + dr.setMessage(bformat(_("`inset-forall' interrupted because number of actions is larger than %1$d"), max_iter)); + } else + dr.setMessage(bformat(_("Applied \"%1$s\" to %2$d insets"), from_utf8(commandstr), iterations)); break; } + case LFUN_BRANCH_ADD_INSERT: { docstring branch_name = from_utf8(cmd.getArg(0)); if (branch_name.empty()) @@ -1755,11 +1796,13 @@ bool BufferView::dispatch(FuncRequest const & cmd) break; } BranchList & branch_list = buffer_.params().branchlist(); - Branch const * branch = branch_list.find(branch_name); - string const x11hexname = X11hexname(branch->color()); - docstring const str = branch_name + ' ' + from_ascii(x11hexname); - lyx::dispatch(FuncRequest(LFUN_SET_COLOR, str)); - lyx::dispatch(FuncRequest(LFUN_BRANCH_INSERT, branch_name)); + 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)); + } break; } @@ -1790,11 +1833,61 @@ bool BufferView::dispatch(FuncRequest const & cmd) break; } + case LFUN_CITATION_INSERT: { + if (argument.empty()) { + lyx::dispatch(FuncRequest(LFUN_DIALOG_SHOW_NEW_INSET, "citation")); + break; + } + // we can have one optional argument, delimited by '|' + // citation-insert | + // this should be enhanced to also support text_after + // and citation style + string arg = argument; + string opt1; + if (contains(argument, "|")) { + arg = token(argument, '|', 0); + opt1 = token(argument, '|', 1); + } + InsetCommandParams icp(CITE_CODE); + icp["key"] = from_utf8(arg); + if (!opt1.empty()) + icp["before"] = from_utf8(opt1); + string icstr = InsetCommand::params2string(icp); + FuncRequest fr(LFUN_INSET_INSERT, icstr); + lyx::dispatch(fr); + break; + } + + case LFUN_INSET_APPLY: { + string const name = cmd.getArg(0); + Inset * inset = editedInset(name); + if (!inset) { + FuncRequest fr(LFUN_INSET_INSERT, cmd.argument()); + lyx::dispatch(fr); + break; + } + // put cursor in front of inset. + if (!setCursorFromInset(inset)) { + LASSERT(false, break); + } + cur.recordUndo(); + FuncRequest fr(LFUN_INSET_MODIFY, cmd.argument()); + inset->dispatch(cur, fr); + dr.screenUpdate(cur.result().screenUpdate()); + if (cur.result().needBufferUpdate()) + dr.forceBufferUpdate(); + break; + } + default: - return false; + // OK, so try the Buffer itself... + buffer_.dispatch(cmd, dr); + dispatched = dr.dispatched(); + break; } - return true; + buffer_.undo().endUndoGroup(); + dr.dispatched(dispatched); } @@ -1811,10 +1904,10 @@ docstring const BufferView::requestSelection() LYXERR(Debug::SELECTION, "requestSelection: xsel_cache.set: " << d->xsel_cache_.set); if (!d->xsel_cache_.set || cur.top() != d->xsel_cache_.cursor || - cur.anchor_.top() != d->xsel_cache_.anchor) + cur.realAnchor().top() != d->xsel_cache_.anchor) { d->xsel_cache_.cursor = cur.top(); - d->xsel_cache_.anchor = cur.anchor_.top(); + d->xsel_cache_.anchor = cur.realAnchor().top(); d->xsel_cache_.set = cur.selection(); return cur.selectionAsString(false); } @@ -1832,7 +1925,7 @@ void BufferView::clearSelection() d->xsel_cache_.set = false; // The buffer did not really change, but this causes the // redraw we need because we cleared the selection above. - buffer_.changed(); + buffer_.changed(false); } @@ -1857,7 +1950,7 @@ Inset const * BufferView::getCoveringInset(Text const & text, if (!inset) return 0; - if (!inset->descendable()) + if (!inset->descendable(*this)) // No need to go further down if the inset is not // descendable. return inset; @@ -1879,6 +1972,58 @@ Inset const * BufferView::getCoveringInset(Text const & text, } +void BufferView::updateHoveredInset() const +{ + // Get inset under mouse, if there is one. + int const x = d->mouse_position_cache_.x_; + int const y = d->mouse_position_cache_.y_; + Inset const * covering_inset = getCoveringInset(buffer_.text(), x, y); + + d->clickable_inset_ = covering_inset && covering_inset->clickable(x, y); + + if (covering_inset == d->last_inset_) + // Same inset, no need to do anything... + return; + + bool need_redraw = false; + if (d->last_inset_) { + // Remove the hint on the last hovered inset (if any). + 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 + // clear the last_inset_, so only set the last_inset_ + // member if the hovered setting is accepted. + d->last_inset_ = covering_inset; + } + + if (need_redraw) { + LYXERR(Debug::PAINTING, "Mouse hover detected at: (" + << d->mouse_position_cache_.x_ << ", " + << d->mouse_position_cache_.y_ << ")"); + + d->update_strategy_ = DecorationUpdate; + + // This event (moving without mouse click) is not passed further. + // This should be changed if it is further utilized. + buffer_.changed(false); + } +} + + +void BufferView::clearLastInset(Inset * inset) const +{ + if (d->last_inset_ != inset) { + LYXERR0("Wrong last_inset!"); + LASSERT(false, /**/); + } + d->last_inset_ = 0; +} + + void BufferView::mouseEventDispatch(FuncRequest const & cmd0) { //lyxerr << "[ cmd0 " << cmd0 << "]" << endl; @@ -1896,43 +2041,18 @@ void BufferView::mouseEventDispatch(FuncRequest const & cmd0) // surrounding Text will handle this event. // make sure we stay within the screen... - cmd.y = min(max(cmd.y, -1), height_); - - if (cmd.action == LFUN_MOUSE_MOTION && cmd.button() == mouse_button::none) { - - // Get inset under mouse, if there is one. - Inset const * covering_inset = - getCoveringInset(buffer_.text(), cmd.x, cmd.y); - if (covering_inset == d->last_inset_) - // Same inset, no need to do anything... - return; + cmd.set_y(min(max(cmd.y(), -1), height_)); - bool need_redraw = false; - // const_cast because of setMouseHover(). - Inset * inset = const_cast(covering_inset); - if (d->last_inset_) - // Remove the hint on the last hovered inset (if any). - need_redraw |= d->last_inset_->setMouseHover(false); - if (inset) - // Highlighted the newly hovered inset (if any). - need_redraw |= inset->setMouseHover(true); - d->last_inset_ = inset; - if (!need_redraw) - return; - - LYXERR(Debug::PAINTING, "Mouse hover detected at: (" - << cmd.x << ", " << cmd.y << ")"); + d->mouse_position_cache_.x_ = cmd.x(); + d->mouse_position_cache_.y_ = cmd.y(); - d->update_strategy_ = DecorationUpdate; - - // This event (moving without mouse click) is not passed further. - // This should be changed if it is further utilized. - buffer_.changed(); + if (cmd.action() == LFUN_MOUSE_MOTION && cmd.button() == mouse_button::none) { + updateHoveredInset(); return; } // Build temporary cursor. - Inset * inset = d->text_metrics_[&buffer_.text()].editXY(cur, cmd.x, cmd.y); + Inset * inset = d->text_metrics_[&buffer_.text()].editXY(cur, cmd.x(), cmd.y()); // Put anchor at the same position. cur.resetAnchor(); @@ -1965,18 +2085,20 @@ void BufferView::mouseEventDispatch(FuncRequest const & cmd0) theSelection().haveSelection(cursor().selection()); // If the command has been dispatched, - if (cur.result().dispatched() || cur.result().update()) - processUpdateFlags(cur.result().update()); + if (cur.result().dispatched() || cur.result().screenUpdate()) + processUpdateFlags(cur.result().screenUpdate()); } void BufferView::lfunScroll(FuncRequest const & cmd) { string const scroll_type = cmd.getArg(0); - int const scroll_step = - (scroll_type == "line") ? d->scrollbarParameters_.single_step - : (scroll_type == "page") ? d->scrollbarParameters_.page_step : 0; - if (scroll_step == 0) + int scroll_step = 0; + if (scroll_type == "line") + scroll_step = d->scrollbarParameters_.single_step; + else if (scroll_type == "page") + scroll_step = d->scrollbarParameters_.page_step; + else return; string const scroll_quantity = cmd.getArg(1); if (scroll_quantity == "up") @@ -1988,8 +2110,8 @@ void BufferView::lfunScroll(FuncRequest const & cmd) if (scroll_value) scroll(scroll_step * scroll_value); } - updateMetrics(); - buffer_.changed(); + buffer_.changed(true); + updateHoveredInset(); } @@ -2064,7 +2186,7 @@ void BufferView::setCursorFromRow(int row) buffer_.texrow().getIdFromRow(row, tmpid, tmppos); - d->cursor_.reset(buffer_.inset()); + d->cursor_.reset(); if (tmpid == -1) buffer_.text().setCursor(d->cursor_, 0, 0); else @@ -2081,7 +2203,7 @@ bool BufferView::setCursorFromInset(Inset const * inset) // Inset is not at cursor position. Find it in the document. Cursor cur(*this); - cur.reset(buffer().inset()); + cur.reset(); while (cur && cur.nextInset() != inset) cur.forwardInset(); @@ -2095,8 +2217,8 @@ bool BufferView::setCursorFromInset(Inset const * inset) void BufferView::gotoLabel(docstring const & label) { - std::vector bufs = buffer().allRelatives(); - std::vector::iterator it = bufs.begin(); + ListOfBuffers bufs = buffer().allRelatives(); + ListOfBuffers::iterator it = bufs.begin(); for (; it != bufs.end(); ++it) { Buffer const * buf = *it; @@ -2106,7 +2228,7 @@ void BufferView::gotoLabel(docstring const & label) TocIterator end = toc.end(); for (; toc_it != end; ++toc_it) { if (label == toc_it->str()) { - dispatch(toc_it->action()); + lyx::dispatch(toc_it->action()); return; } } @@ -2122,6 +2244,7 @@ TextMetrics const & BufferView::textMetrics(Text const * t) const TextMetrics & BufferView::textMetrics(Text const * t) { + LASSERT(t, /**/); TextMetricsCache::iterator tmc_it = d->text_metrics_.find(t); if (tmc_it == d->text_metrics_.end()) { tmc_it = d->text_metrics_.insert( @@ -2146,7 +2269,7 @@ int BufferView::workHeight() const void BufferView::setCursor(DocIterator const & dit) { - d->cursor_.reset(buffer().inset()); + d->cursor_.reset(); size_t const n = dit.depth(); for (size_t i = 0; i < n; ++i) dit[i].inset().edit(d->cursor_, true); @@ -2174,10 +2297,8 @@ bool BufferView::checkDepm(Cursor & cur, Cursor & old) d->cursor_ = cur; - buffer_.updateLabels(); - - updateMetrics(); - buffer_.changed(); + cur.forceBufferUpdate(); + buffer_.changed(true); return true; } @@ -2191,13 +2312,15 @@ bool BufferView::mouseSetCursor(Cursor & cur, bool select) // persistent selection cap::saveSelection(cursor()); + d->cursor_.macroModeClose(); + // Has the cursor just left the inset? bool leftinset = (&d->cursor_.inset() != &cur.inset()); if (leftinset) d->cursor_.fixIfBroken(); // FIXME: shift-mouse selection doesn't work well across insets. - bool do_selection = select && &d->cursor_.anchor().inset() == &cur.inset(); + bool do_selection = select && &d->cursor_.normalAnchor().inset() == &cur.inset(); // do the dEPM magic if needed // FIXME: (1) move this to InsetText::notifyCursorLeaves? @@ -2206,9 +2329,9 @@ bool BufferView::mouseSetCursor(Cursor & cur, bool select) bool update = leftinset; if (!do_selection && d->cursor_.inTexted()) update |= checkDepm(cur, d->cursor_); - d->cursor_.macroModeClose(); - d->cursor_.resetAnchor(); + if (!do_selection) + d->cursor_.resetAnchor(); d->cursor_.setCursor(cur); d->cursor_.boundary(cur.boundary()); if (do_selection) @@ -2218,6 +2341,8 @@ bool BufferView::mouseSetCursor(Cursor & cur, bool select) d->cursor_.finishUndo(); d->cursor_.setCurrentFont(); + if (update) + cur.forceBufferUpdate(); return update; } @@ -2236,9 +2361,42 @@ void BufferView::putSelectionAt(DocIterator const & cur, } else d->cursor_.setSelection(d->cursor_, length); } - // Ensure a redraw happens in any case because the new selection could - // possibly be on the same screen as the previous selection. - processUpdateFlags(Update::Force | Update::FitCursor); +} + + +bool BufferView::selectIfEmpty(DocIterator & cur) +{ + if (!cur.paragraph().empty()) + return false; + + pit_type const beg_pit = cur.pit(); + if (beg_pit > 0) { + // The paragraph associated to this item isn't + // the first one, so it can be selected + cur.backwardPos(); + } else { + // We have to resort to select the space between the + // end of this item and the begin of the next one + cur.forwardPos(); + } + if (cur.empty()) { + // If it is the only item in the document, + // nothing can be selected + return false; + } + pit_type const end_pit = cur.pit(); + pos_type const end_pos = cur.pos(); + d->cursor_.clearSelection(); + d->cursor_.reset(); + d->cursor_.setCursor(cur); + d->cursor_.pit() = beg_pit; + d->cursor_.pos() = 0; + d->cursor_.setSelection(false); + d->cursor_.resetAnchor(); + d->cursor_.pit() = end_pit; + d->cursor_.pos() = end_pos; + d->cursor_.setSelection(); + return true; } @@ -2389,15 +2547,15 @@ void BufferView::insertLyXFile(FileName const & fname) // Get absolute path of file and add ".lyx" // to the filename if necessary - FileName filename = fileSearch(string(), fname.absFilename(), "lyx"); + FileName filename = fileSearch(string(), fname.absFileName(), "lyx"); - docstring const disp_fn = makeDisplayPath(filename.absFilename()); + docstring const disp_fn = makeDisplayPath(filename.absFileName()); // emit message signal. message(bformat(_("Inserting document %1$s..."), disp_fn)); docstring res; - Buffer buf("", false); - if (buf.loadLyXFile(filename)) { + Buffer buf(filename.absFileName(), false); + if (buf.loadLyXFile() == Buffer::ReadSuccess) { ErrorList & el = buffer_.errorList("Parse"); // Copy the inserted document error list into the current buffer one. el = buf.errorList("Parse"); @@ -2409,15 +2567,13 @@ void BufferView::insertLyXFile(FileName const & fname) res = _("Could not insert document %1$s"); } - updateMetrics(); - buffer_.changed(); + buffer_.changed(true); // emit message signal. message(bformat(res, disp_fn)); - buffer_.errors("Parse"); } -Point BufferView::coordOffset(DocIterator const & dit, bool boundary) const +Point BufferView::coordOffset(DocIterator const & dit) const { int x = 0; int y = 0; @@ -2431,7 +2587,7 @@ Point BufferView::coordOffset(DocIterator const & dit, bool boundary) const int yy = 0; // get relative position inside sl.inset() - sl.inset().cursorPos(*this, sl, boundary && (i + 1 == dit.depth()), xx, yy); + 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; @@ -2440,7 +2596,7 @@ Point BufferView::coordOffset(DocIterator const & dit, bool boundary) const // In case of an RTL inset, the edited inset will be positioned to the left // of xx:yy if (sl.text()) { - bool boundary_i = boundary && i + 1 == dit.depth(); + bool boundary_i = dit.boundary() && i + 1 == dit.depth(); bool rtl = textMetrics(sl.text()).isRTL(sl, boundary_i); if (rtl) x -= lastw; @@ -2477,9 +2633,9 @@ Point BufferView::coordOffset(DocIterator const & dit, bool boundary) const size_t rend; if (sl.pos() > 0 && dit.depth() == 1) { int pos = sl.pos(); - if (pos && boundary) + if (pos && dit.boundary()) --pos; -// lyxerr << "coordOffset: boundary:" << boundary << " depth:" << dit.depth() << " pos:" << pos << " sl.pos:" << sl.pos() << endl; +// lyxerr << "coordOffset: boundary:" << dit.boundary() << " depth:" << dit.depth() << " pos:" << pos << " sl.pos:" << sl.pos() << endl; rend = pm.pos2row(pos); } else rend = pm.pos2row(sl.pos()); @@ -2493,12 +2649,12 @@ Point BufferView::coordOffset(DocIterator const & dit, bool boundary) const 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(), boundary && dit.depth() == 1); + 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 // the outer paragraph - bool boundary_1 = boundary && 1 == dit.depth(); + bool boundary_1 = dit.boundary() && 1 == dit.depth(); bool rtl = bottom_tm.isRTL(dit.bottom(), boundary_1); if (rtl) x -= lastw; @@ -2507,7 +2663,7 @@ Point BufferView::coordOffset(DocIterator const & dit, bool boundary) const } -Point BufferView::getPos(DocIterator const & dit, bool boundary) const +Point BufferView::getPos(DocIterator const & dit) const { if (!paragraphVisible(dit)) return Point(-1, -1); @@ -2515,7 +2671,8 @@ Point BufferView::getPos(DocIterator const & dit, bool boundary) const CursorSlice const & bot = dit.bottom(); TextMetrics const & tm = textMetrics(bot.text()); - Point p = coordOffset(dit, boundary); // offset from outer paragraph + // offset from outer paragraph + Point p = coordOffset(dit); p.y_ += tm.parMetrics(bot.pit()).position(); return p; } @@ -2538,7 +2695,7 @@ void BufferView::cursorPosAndHeight(Point & p, int & h) const int const asc = fm.maxAscent(); int const des = fm.maxDescent(); h = asc + des; - p = getPos(cur, cur.boundary()); + p = getPos(cur); p.y_ -= asc; } @@ -2670,7 +2827,7 @@ docstring BufferView::contentsOfPlaintextFile(FileName const & fname) { if (!fname.isReadableFile()) { docstring const error = from_ascii(strerror(errno)); - docstring const file = makeDisplayPath(fname.absFilename(), 50); + docstring const file = makeDisplayPath(fname.absFileName(), 50); docstring const text = bformat(_("Could not read the specified document\n" "%1$s\ndue to the error: %2$s"), file, error); @@ -2679,7 +2836,7 @@ docstring BufferView::contentsOfPlaintextFile(FileName const & fname) } if (!fname.isReadableFile()) { - docstring const file = makeDisplayPath(fname.absFilename(), 50); + docstring const file = makeDisplayPath(fname.absFileName(), 50); docstring const text = bformat(_("%1$s\n is not readable."), file); Alert::error(_("Could not open file"), text); @@ -2717,8 +2874,7 @@ void BufferView::insertPlaintextFile(FileName const & f, bool asParagraph) else cur.innerText()->insertStringAsLines(cur, tmpstr, cur.current_font); - updateMetrics(); - buffer_.changed(); + buffer_.changed(true); } @@ -2740,6 +2896,12 @@ DocIterator const & BufferView::inlineCompletionPos() const } +void BufferView::resetInlineCompletionPos() +{ + d->inlineCompletionPos_ = DocIterator(); +} + + bool samePar(DocIterator const & a, DocIterator const & b) { if (a.empty() && b.empty()) @@ -2779,11 +2941,17 @@ void BufferView::setInlineCompletion(Cursor & cur, DocIterator const & pos, // set update flags if (changed) { - if (singlePar && !(cur.disp_.update() & Update::Force)) - cur.updateFlags(cur.disp_.update() | Update::SinglePar); + if (singlePar && !(cur.result().screenUpdate() & Update::Force)) + cur.screenUpdateFlags(cur.result().screenUpdate() | Update::SinglePar); else - cur.updateFlags(cur.disp_.update() | Update::Force); + cur.screenUpdateFlags(cur.result().screenUpdate() | Update::Force); } } + +bool BufferView::clickableInset() const +{ + return d->clickable_inset_; +} + } // namespace lyx