#include "LyX.h"
#include "LyXAction.h"
#include "lyxfind.h"
-#include "LyXFunc.h"
#include "Layout.h"
#include "LyXRC.h"
#include "MetricsInfo.h"
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), mouse_position_cache_(),
+ bookmark_edit_position_(0), gui_(0)
{}
///
*/
Inset * last_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_;
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;
+ // 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)
if (flags == Update::Decoration) {
d->update_strategy_ = DecorationUpdate;
- buffer_.changed();
+ buffer_.changed(false);
return;
}
}
if (flags & Update::Decoration) {
d->update_strategy_ = DecorationUpdate;
- buffer_.changed();
+ buffer_.changed(false);
return;
}
// no screen update is needed.
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();
}
// 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;
}
// 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"));
+ }
}
// 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();
}
void BufferView::showCursor(DocIterator const & dit, bool recenter)
{
- if (scrollToCursor(dit, recenter))
- buffer_.changed();
+ if (scrollToCursor(dit, recenter)) {
+ buffer_.changed(true);
+ updateHoveredInset();
+ }
}
void BufferView::scrollToCursor()
{
- scrollToCursor(d->cursor_, false);
+ if (scrollToCursor(d->cursor_, false)) {
+ buffer_.changed(true);
+ updateHoveredInset();
+ }
}
scrolled = scrollDown(ypos - height_ + defaultRowHeight() );
// 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
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<InsetText &>(buffer_.inset()), el);
setCursor(backcur.asDocIterator(&buffer_));
buffer_.errors("Class Switch");
- buffer_.updateLabels();
+ buffer_.updateBuffer();
}
/** Return the change status at cursor position, taking in account the
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;
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*
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:
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
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<InsetRef>(cur, REF_CODE));
}
-bool BufferView::dispatch(FuncRequest const & cmd)
+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());
// Don't dispatch function that does not apply to internal buffers.
if (buffer_.isInternal()
- && lyxaction.funcHasFlag(cmd.action, LyXAction::NoInternal))
- return false;
+ && 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();
<< 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.update(Update::Force | Update::FitCursor);
break;
}
cur.recordUndoFullDocument();
buffer_.params().clearLayoutModules();
buffer_.params().makeDocumentClass();
- updateLayout(oldClass);
- processUpdateFlags(Update::Force | Update::FitCursor);
+ updateDocumentClass(oldClass);
+ dr.update(Update::Force | Update::FitCursor);
break;
}
cur.recordUndoFullDocument();
buffer_.params().addLayoutModule(argument);
buffer_.params().makeDocumentClass();
- updateLayout(oldClass);
- processUpdateFlags(Update::Force | Update::FitCursor);
+ updateDocumentClass(oldClass);
+ dr.update(Update::Force | Update::FitCursor);
break;
}
cur.recordUndoFullDocument();
buffer_.params().setBaseClass(argument);
buffer_.params().makeDocumentClass();
- updateLayout(oldDocClass);
- processUpdateFlags(Update::Force | Update::FitCursor);
+ updateDocumentClass(oldDocClass);
+ dr.update(Update::Force | Update::FitCursor);
break;
}
LayoutFileList::get().reset(bc);
buffer_.params().setBaseClass(bc);
buffer_.params().makeDocumentClass();
- updateLayout(oldClass);
- processUpdateFlags(Update::Force | Update::FitCursor);
+ updateDocumentClass(oldClass);
+ dr.update(Update::Force | Update::FitCursor);
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.update(Update::Force | Update::FitCursor);
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.update(Update::Force | Update::FitCursor);
break;
case LFUN_FONT_STATE:
- cur.message(cur.currentState());
+ dr.setMessage(cur.currentState());
break;
case LFUN_BOOKMARK_SAVE:
// Set the cursor
dit.pos() = pos;
setCursor(dit);
- processUpdateFlags(Update::Force | Update::FitCursor);
+ dr.update(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;
}
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.update(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.update(Update::Force | Update::FitCursor);
break;
case LFUN_CHANGES_MERGE:
if (findNextChange(this) || findPreviousChange(this)) {
- processUpdateFlags(Update::Force | Update::FitCursor);
+ dr.update(Update::Force | Update::FitCursor);
showDialog("changes");
}
break;
// 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.update(Update::Force | Update::FitCursor);
break;
case LFUN_ALL_CHANGES_REJECT:
// 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.update(Update::Force | Update::FitCursor);
break;
case LFUN_WORD_FIND_FORWARD:
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));
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))
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;
}
- 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))
+ cur.dispatched();
+ else
+ cur.undispatched();
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;
// 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);
+ dr.update(Update::SinglePar | Update::FitCursor);
break;
}
showCursor();
p = getPos(cur, cur.boundary());
}*/
- 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();
- updateMetrics();
- buffer_.changed();
+ 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);
+ dr.update(Update::Force | Update::FitCursor);
break;
}
y = getPos(cur, cur.boundary()).y_;
cur.finishUndo();
- processUpdateFlags(Update::SinglePar | Update::FitCursor);
+ dr.update(Update::SinglePar | Update::FitCursor);
break;
}
y = getPos(cur, cur.boundary()).y_;
cur.finishUndo();
- processUpdateFlags(Update::SinglePar | Update::FitCursor);
- break;
- }
-
- // This could be rewriten using some command like forall <insetname> <command>
- // 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);
- }
+ dr.update(Update::SinglePar | Update::FitCursor);
break;
}
FuncRequest const fr = lyxaction.lookupFunc(commandstr);
// an arbitrary number to limit number of iterations
- const int max_iter = 1000;
+ const int max_iter = 10000;
int iterations = 0;
Cursor & cur = d->cursor_;
+ Cursor const savecur = cur;
cur.reset();
if (!cur.nextInset())
cur.forwardInset();
while (!insname.empty()) {
if (insname == name || name == from_utf8("*")) {
cur.recordUndo();
- lyx::dispatch(fr);
+ lyx::dispatch(fr, dr);
++iterations;
break;
}
cur.forwardInset();
}
cur.endUndoGroup();
- cur.reset();
- processUpdateFlags(Update::Force);
+ cur = savecur;
+ cur.fixIfBroken();
+ dr.update(Update::Force);
- if (iterations >= max_iter)
- cur.errorMessage(bformat(_("inset-forall interrupted because number of actions is larger than %1$s"), max_iter));
- else
- cur.message(bformat(_("Applied \"%1$s\" to %2$d insets"), from_utf8(commandstr), iterations));
+ 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_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);
- }
- }
- processUpdateFlags(Update::Force | Update::FitCursor);
- break;
- }
-
case LFUN_BRANCH_ADD_INSERT: {
docstring branch_name = from_utf8(cmd.getArg(0));
if (branch_name.empty())
cur.recordUndo();
FuncRequest fr(LFUN_INSET_MODIFY, cmd.argument());
inset->dispatch(cur, fr);
- processUpdateFlags(Update::SinglePar | Update::FitCursor);
+ dr.update(Update::SinglePar | Update::FitCursor);
break;
}
}
buffer_.undo().endUndoGroup();
- return dispatched;
+ dr.dispatched(dispatched);
+ return;
}
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);
}
}
+void BufferView::updateHoveredInset() const
+{
+ // Get inset under mouse, if there is one.
+ Inset const * covering_inset = getCoveringInset(buffer_.text(),
+ d->mouse_position_cache_.x_, d->mouse_position_cache_.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(false);
+
+ // const_cast because of setMouseHover().
+ Inset * inset = const_cast<Inset *>(covering_inset);
+ if (inset)
+ // Highlight the newly hovered inset (if any).
+ need_redraw |= inset->setMouseHover(true);
+
+ d->last_inset_ = 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::mouseEventDispatch(FuncRequest const & cmd0)
{
//lyxerr << "[ cmd0 " << cmd0 << "]" << endl;
// surrounding Text will handle this event.
// make sure we stay within the screen...
- cmd.y = min(max(cmd.y, -1), height_);
+ cmd.set_y(min(max(cmd.y(), -1), height_));
- if (cmd.action == LFUN_MOUSE_MOTION && cmd.button() == mouse_button::none) {
+ d->mouse_position_cache_.x_ = cmd.x();
+ d->mouse_position_cache_.y_ = cmd.y();
- // 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;
-
- bool need_redraw = false;
- // const_cast because of setMouseHover().
- Inset * inset = const_cast<Inset *>(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->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();
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")
if (scroll_value)
scroll(scroll_step * scroll_value);
}
- updateMetrics();
- buffer_.changed();
+ buffer_.changed(true);
+ updateHoveredInset();
}
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;
}
}
d->cursor_ = cur;
- buffer_.updateLabels();
-
- updateMetrics();
- buffer_.changed();
+ buffer_.updateBuffer();
+ buffer_.changed(true);
return true;
}
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?
res = _("Could not insert document %1$s");
}
- updateMetrics();
- buffer_.changed();
+ buffer_.changed(true);
// emit message signal.
message(bformat(res, disp_fn));
buffer_.errors("Parse");
else
cur.innerText()->insertStringAsLines(cur, tmpstr, cur.current_font);
- updateMetrics();
- buffer_.changed();
+ buffer_.changed(true);
}
// set update flags
if (changed) {
- if (singlePar && !(cur.disp_.update() & Update::Force))
- cur.updateFlags(cur.disp_.update() | Update::SinglePar);
+ if (singlePar && !(cur.result().update() & Update::Force))
+ cur.updateFlags(cur.result().update() | Update::SinglePar);
else
- cur.updateFlags(cur.disp_.update() | Update::Force);
+ cur.updateFlags(cur.result().update() | Update::Force);
}
}