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)
// refresh it:
showCursor();
}
+
+ updateHoveredInset();
}
if (abs(offset) <= 2 * height_) {
d->anchor_ypos_ -= offset;
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"));
+ }
}
void BufferView::showCursor(DocIterator const & dit, bool recenter)
{
- if (scrollToCursor(dit, recenter))
- buffer_.changed(false);
+ 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;
}
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_ALL_INSETS_TOGGLE:
case LFUN_STATISTICS:
case LFUN_BRANCH_ADD_INSERT:
case LFUN_KEYMAP_OFF:
//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))
+ && 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();
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));
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();
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();
while (!insname.empty()) {
if (insname == name || name == from_utf8("*")) {
cur.recordUndo();
- lyx::dispatch(fr);
+ lyx::dispatch(fr, dr);
++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);
- }
- }
- dr.update(Update::Force | Update::FitCursor);
- break;
- }
-
case LFUN_BRANCH_ADD_INSERT: {
docstring branch_name = from_utf8(cmd.getArg(0));
if (branch_name.empty())
}
+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_);
-
- 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;
-
- 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;
+ cmd.set_y(min(max(cmd.y(), -1), height_));
- LYXERR(Debug::PAINTING, "Mouse hover detected at: ("
- << cmd.x << ", " << cmd.y << ")");
-
- d->update_strategy_ = DecorationUpdate;
+ d->mouse_position_cache_.x_ = cmd.x();
+ d->mouse_position_cache_.y_ = cmd.y();
- // This event (moving without mouse click) is not passed further.
- // This should be changed if it is further utilized.
- buffer_.changed(false);
+ 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")
scroll(scroll_step * scroll_value);
}
buffer_.changed(true);
+ updateHoveredInset();
}
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?
// 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);
}
}
projects / features.git / blobdiff