/// Cache for Find Next
FuncRequest search_request_cache_;
+
+ ///
+ map<string, Inset *> edited_insets_;
};
// 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
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
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
p = Point(width_, height_);
Cursor old = cur;
bool const in_texted = cur.inTexted();
- cur.reset(buffer_.inset());
+ cur.reset();
updateMetrics();
buffer_.changed();
d->text_metrics_[&buffer_.text()].editXY(cur, p.x_, p.y_,
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;
}
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;
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);
// 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)
projects / lyx.git / blobdiff