/// 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
}
-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)
{
// Can we use a readonly buffer?
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) {
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;
}
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
// 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