/// Cache for Find Next
FuncRequest search_request_cache_;
+
+ ///
+ map<string, Inset *> edited_insets_;
};
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.
// 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);
return;
}
// 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
// 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();
+ buffer_.changed(false);
}
buffer_.updateLabels();
}
+/** Return the change status at cursor position, taking in account the
+ * status at each level of the document iterator (a table in a deleted
+ * footnote is deleted).
+ * When \param outer is true, the top slice is not looked at.
+ */
+static Change::Type lookupChangeType(DocIterator const & dit, bool outer = false)
+{
+ size_t const depth = dit.depth() - (outer ? 1 : 0);
+
+ for (size_t i = 0 ; i < depth ; ++i) {
+ CursorSlice const & slice = dit[i];
+ if (!slice.inset().inMathed()
+ && slice.pos() < slice.paragraph().size()) {
+ Change::Type const ch = slice.paragraph().lookupChange(slice.pos()).type;
+ if (ch != Change::UNCHANGED)
+ return ch;
+ }
+ }
+ return Change::UNCHANGED;
+}
+
bool BufferView::getStatus(FuncRequest const & cmd, FuncStatus & flag)
{
+ // Can we use a readonly buffer?
+ if (buffer_.isReadonly()
+ && !lyxaction.funcHasFlag(cmd.action, LyXAction::ReadOnly)
+ && !lyxaction.funcHasFlag(cmd.action, 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)) {
+ flag.message(from_utf8(N_("This portion of the document is deleted.")));
+ flag.setEnabled(false);
+ return true;
+ }
+
Cursor & cur = d->cursor_;
+ if (cur.getStatus(cmd, flag))
+ return true;
+
switch (cmd.action) {
// FIXME: This is a bit problematic because we don't check is this is a
case LFUN_SCROLL:
case LFUN_SCREEN_UP_SELECT:
case LFUN_SCREEN_DOWN_SELECT:
+ case LFUN_INSET_FORALL:
flag.setEnabled(true);
break;
flag.setEnabled(!cur.inset().getLayout().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());
+ FuncStatus fs;
+ if (!inset->getStatus(cur, fr, fs)) {
+ // Every inset is supposed to handle this
+ LASSERT(false, break);
+ }
+ flag |= fs;
+ } else {
+ FuncRequest fr(LFUN_INSET_INSERT, cmd.argument());
+ flag |= lyx::getStatus(fr);
+ }
+ break;
+ }
+
default:
flag.setEnabled(false);
return false;
}
+Inset * BufferView::editedInset(string const & name) const
+{
+ map<string, Inset *>::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;
+}
+
+
bool BufferView::dispatch(FuncRequest const & cmd)
{
//lyxerr << [ cmd = " << cmd << "]" << endl;
Cursor & cur = d->cursor_;
// Don't dispatch function that does not apply to internal buffers.
- if (buffer_.isInternal() && lyxaction.funcHasFlag(cmd.action, LyXAction::NoInternal))
+ if (buffer_.isInternal()
+ && lyxaction.funcHasFlag(cmd.action, LyXAction::NoInternal))
return false;
+ // We'll set this back to false if need be.
+ bool dispatched = true;
+ buffer_.undo().beginUndoGroup();
+
switch (cmd.action) {
case LFUN_BUFFER_PARAMS_APPLY: {
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
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
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();
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);
d->text_metrics_[&buffer_.text()].editXY(cur, p.x_, p.y_,
true, cmd.action == LFUN_SCREEN_UP);
//FIXME: what to do with cur.x_target()?
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 = 1000;
+ int iterations = 0;
+ Cursor & cur = d->cursor_;
+ 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);
+ ++iterations;
+ break;
+ }
+ size_t const i = insname.rfind(':');
+ if (i == string::npos)
+ break;
+ insname = insname.substr(0, i);
+ }
+ cur.forwardInset();
+ }
+ cur.endUndoGroup();
+ cur.reset();
+ processUpdateFlags(Update::Force);
+
+ if (iterations >= max_iter)
+ cur.errorMessage(bformat(_("`inset-forall' interrupted because number of actions is larger than %1$d"), max_iter));
+ else
+ cur.message(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, ' ');
Alert::warning(_("Branch already exists"), drtmp.message());
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));
break;
}
getIntl().toggleKeyMap();
break;
+ case LFUN_DIALOG_SHOW_NEW_INSET: {
+ string const name = cmd.getArg(0);
+ string data = trim(to_utf8(cmd.argument()).substr(name.size()));
+ if (decodeInsetParam(name, data, buffer_))
+ lyx::dispatch(FuncRequest(LFUN_DIALOG_SHOW, name + " " + data));
+ else
+ lyxerr << "Inset type '" << name <<
+ "' not recognized in LFUN_DIALOG_SHOW_NEW_INSET" << endl;
+ 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 <key>|<text_before>
+ // 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("citation", 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);
+ processUpdateFlags(Update::SinglePar | Update::FitCursor);
+ break;
+ }
+
default:
- return false;
+ dispatched = false;
+ break;
}
- return true;
+ buffer_.undo().endUndoGroup();
+ return dispatched;
}
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);
}
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;
// This event (moving without mouse click) is not passed further.
// This should be changed if it is further utilized.
- buffer_.changed();
+ buffer_.changed(false);
return;
}
if (scroll_value)
scroll(scroll_step * scroll_value);
}
- updateMetrics();
- buffer_.changed();
+ buffer_.changed(true);
}
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
buffer_.text().setCursor(d->cursor_, buffer_.getParFromID(tmpid).pit(), tmppos);
+ recenter();
}
// 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();
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);
d->cursor_ = cur;
buffer_.updateLabels();
-
- updateMetrics();
- buffer_.changed();
+ buffer_.changed(true);
return true;
}
// persistent selection
cap::saveSelection(cursor());
+ d->cursor_.macroModeClose();
+
// Has the cursor just left the inset?
bool leftinset = (&d->cursor_.inset() != &cur.inset());
if (leftinset)
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)
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);
}