X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FBufferView.cpp;h=de2d71a1234aff48dbd5efd5ab33c5af8bd70616;hb=4b7f1b3c3918cd32070c72b6d8e95a888981c7a2;hp=e929f789f2e31ac43d21ebdc8650b18cdc94d8b8;hpb=f10a5043a94d5efb2de9ee96511b8669d705c246;p=lyx.git

diff --git a/src/BufferView.cpp b/src/BufferView.cpp
index e929f789f2..de2d71a123 100644
--- a/src/BufferView.cpp
+++ b/src/BufferView.cpp
@@ -37,6 +37,7 @@
 #include "LayoutFile.h"
 #include "Lexer.h"
 #include "LyX.h"
+#include "LyXAction.h"
 #include "lyxfind.h"
 #include "LyXFunc.h"
 #include "Layout.h"
@@ -275,6 +276,9 @@ struct BufferView::Private
 
 	/// Cache for Find Next
 	FuncRequest search_request_cache_;
+
+	///
+	map<string, Inset *> edited_insets_;
 };
 
 
@@ -420,7 +424,7 @@ void BufferView::processUpdateFlags(Update::flags flags)
 
 	if (flags == Update::Decoration) {
 		d->update_strategy_ = DecorationUpdate;
-		buffer_.changed();
+		buffer_.changed(false);
 		return;
 	}
 
@@ -433,7 +437,7 @@ void BufferView::processUpdateFlags(Update::flags flags)
 		}
 		if (flags & Update::Decoration) {
 			d->update_strategy_ = DecorationUpdate;
-			buffer_.changed();
+			buffer_.changed(false);
 			return;
 		}
 		// no screen update is needed.
@@ -449,13 +453,13 @@ void BufferView::processUpdateFlags(Update::flags flags)
 
 	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.
@@ -569,8 +573,7 @@ void BufferView::scrollDocView(int value)
 	// 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;
 	}
 
@@ -642,7 +645,7 @@ void BufferView::setCursorFromScrollbar()
 	// 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
@@ -761,7 +764,7 @@ bool BufferView::moveToPosition(pit_type bottom_pit, pos_type bottom_pos,
 		// 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();
 	}
@@ -807,7 +810,7 @@ void BufferView::showCursor()
 void BufferView::showCursor(DocIterator const & dit, bool recenter)
 {
 	if (scrollToCursor(dit, recenter))
-		buffer_.changed();
+		buffer_.changed(false);
 }
 
 
@@ -913,11 +916,52 @@ void BufferView::updateLayout(DocumentClass const * const oldlayout)
 	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
@@ -970,7 +1014,6 @@ bool BufferView::getStatus(FuncRequest const & cmd, FuncStatus & flag)
 	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:
@@ -982,8 +1025,8 @@ bool BufferView::getStatus(FuncRequest const & cmd, FuncStatus & flag)
 		break;
 
 	case LFUN_REGEXP_MODE:
-		// FIXME: Test if current WorkArea is the search WorkArea
-		flag.setEnabled(buffer().isInternal() && !cur.inRegexped());
+		flag.setEnabled(buffer().isInternal() && !cur.inRegexped()
+				&& cur.inset().lyxCode() != ERT_CODE);
 		break;
 
 	case LFUN_LABEL_COPY_AS_REF: {
@@ -995,18 +1038,6 @@ bool BufferView::getStatus(FuncRequest const & cmd, FuncStatus & flag)
 		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));
@@ -1045,6 +1076,7 @@ bool BufferView::getStatus(FuncRequest const & cmd, FuncStatus & flag)
 	case LFUN_SCROLL:
 	case LFUN_SCREEN_UP_SELECT:
 	case LFUN_SCREEN_DOWN_SELECT:
+	case LFUN_INSET_FORALL:
 		flag.setEnabled(true);
 		break;
 
@@ -1069,6 +1101,31 @@ bool BufferView::getStatus(FuncRequest const & cmd, FuncStatus & flag)
 		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;
@@ -1078,7 +1135,20 @@ bool BufferView::getStatus(FuncRequest const & cmd, FuncStatus & flag)
 }
 
 
-bool BufferView::dispatch(FuncRequest const & cmd)
+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;
+}
+
+
+void BufferView::dispatch(FuncRequest const & cmd, DispatchResult & dr)
 {
 	//lyxerr << [ cmd = " << cmd << "]" << endl;
 
@@ -1092,6 +1162,15 @@ bool BufferView::dispatch(FuncRequest const & cmd)
 	string const argument = to_utf8(cmd.argument());
 	Cursor & cur = d->cursor_;
 
+	// Don't dispatch function that does not apply to internal buffers.
+	if (buffer_.isInternal() 
+	    && 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) {
 
 	case LFUN_BUFFER_PARAMS_APPLY: {
@@ -1111,7 +1190,7 @@ bool BufferView::dispatch(FuncRequest const & cmd)
 		// 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;
 	}
 		
@@ -1122,7 +1201,7 @@ bool BufferView::dispatch(FuncRequest const & cmd)
 		buffer_.params().clearLayoutModules();
 		buffer_.params().makeDocumentClass();
 		updateLayout(oldClass);
-		processUpdateFlags(Update::Force | Update::FitCursor);
+		dr.update(Update::Force | Update::FitCursor);
 		break;
 	}
 
@@ -1139,7 +1218,7 @@ bool BufferView::dispatch(FuncRequest const & cmd)
 		buffer_.params().addLayoutModule(argument);
 		buffer_.params().makeDocumentClass();
 		updateLayout(oldClass);
-		processUpdateFlags(Update::Force | Update::FitCursor);
+		dr.update(Update::Force | Update::FitCursor);
 		break;
 	}
 
@@ -1162,7 +1241,7 @@ bool BufferView::dispatch(FuncRequest const & cmd)
 		buffer_.params().setBaseClass(argument);
 		buffer_.params().makeDocumentClass();
 		updateLayout(oldDocClass);
-		processUpdateFlags(Update::Force | Update::FitCursor);
+		dr.update(Update::Force | Update::FitCursor);
 		break;
 	}
 
@@ -1178,30 +1257,30 @@ bool BufferView::dispatch(FuncRequest const & cmd)
 		buffer_.params().setBaseClass(bc);
 		buffer_.params().makeDocumentClass();
 		updateLayout(oldClass);
-		processUpdateFlags(Update::Force | Update::FitCursor);
+		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:
@@ -1264,7 +1343,7 @@ bool BufferView::dispatch(FuncRequest const & cmd)
 				// 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(
@@ -1318,43 +1397,43 @@ bool BufferView::dispatch(FuncRequest const & cmd)
 	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;
 
 	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
 		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:
 		// 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
 		// 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:
@@ -1402,7 +1481,8 @@ bool BufferView::dispatch(FuncRequest const & cmd)
 			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;
 				}
 			}
@@ -1411,29 +1491,36 @@ bool BufferView::dispatch(FuncRequest const & cmd)
 		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;
@@ -1527,32 +1614,7 @@ bool BufferView::dispatch(FuncRequest const & cmd)
 			// 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;
 	}
 
@@ -1574,16 +1636,15 @@ bool BufferView::dispatch(FuncRequest const & cmd)
 			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()?
 		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;
 	}
 
@@ -1604,7 +1665,7 @@ bool BufferView::dispatch(FuncRequest const & cmd)
 			y = getPos(cur, cur.boundary()).y_;
 
 		cur.finishUndo();
-		processUpdateFlags(Update::SinglePar | Update::FitCursor);
+		dr.update(Update::SinglePar | Update::FitCursor);
 		break;
 	}
 
@@ -1621,22 +1682,60 @@ bool BufferView::dispatch(FuncRequest const & cmd)
 			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;
+	}
+
+
+	// 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 = 10000;
+		int iterations = 0;
+		Cursor & cur = d->cursor_;
+		Cursor const savecur = cur;
+		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 = savecur;
+		cur.fixIfBroken();
+		dr.update(Update::Force);
+
+		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, ' ');
@@ -1656,7 +1755,7 @@ bool BufferView::dispatch(FuncRequest const & cmd)
 				it->dispatch(tmpcur, fr);
 			}
 		}
-		processUpdateFlags(Update::Force | Update::FitCursor);
+		dr.update(Update::Force | Update::FitCursor);
 		break;
 	}
 
@@ -1673,11 +1772,6 @@ bool BufferView::dispatch(FuncRequest const & cmd)
 			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;
 	}
@@ -1698,11 +1792,69 @@ bool BufferView::dispatch(FuncRequest const & cmd)
 		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);
+		dr.update(Update::SinglePar | Update::FitCursor);
+		break;
+	}
+
 	default:
-		return false;
+		dispatched = false;
+		break;
 	}
 
-	return true;
+	buffer_.undo().endUndoGroup();
+	dr.dispatched(dispatched);
+	return;
 }
 
 
@@ -1740,7 +1892,7 @@ void BufferView::clearSelection()
 	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);
 }
 
 
@@ -1765,7 +1917,7 @@ Inset const * BufferView::getCoveringInset(Text const & text,
 	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;
@@ -1835,7 +1987,7 @@ void BufferView::mouseEventDispatch(FuncRequest const & cmd0)
 
 		// 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;
 	}
 
@@ -1896,8 +2048,7 @@ void BufferView::lfunScroll(FuncRequest const & cmd)
 		if (scroll_value)
 			scroll(scroll_step * scroll_value);
 	}
-	updateMetrics();
-	buffer_.changed();
+	buffer_.changed(true);
 }
 
 
@@ -1972,11 +2123,12 @@ void BufferView::setCursorFromRow(int row)
 
 	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();
 }
 
 
@@ -1988,7 +2140,7 @@ bool BufferView::setCursorFromInset(Inset const * inset)
 
 	// 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();
 
@@ -2013,7 +2165,7 @@ void BufferView::gotoLabel(docstring const & label)
 		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;
 			}
 		}
@@ -2053,7 +2205,7 @@ int BufferView::workHeight() const
 
 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);
@@ -2082,9 +2234,7 @@ bool BufferView::checkDepm(Cursor & cur, Cursor & old)
 	d->cursor_ = cur;
 
 	buffer_.updateLabels();
-
-	updateMetrics();
-	buffer_.changed();
+	buffer_.changed(true);
 	return true;
 }
 
@@ -2098,6 +2248,8 @@ bool BufferView::mouseSetCursor(Cursor & cur, bool select)
 		// persistent selection
 		cap::saveSelection(cursor());
 
+	d->cursor_.macroModeClose();
+
 	// Has the cursor just left the inset?
 	bool leftinset = (&d->cursor_.inset() != &cur.inset());
 	if (leftinset)
@@ -2113,9 +2265,9 @@ bool BufferView::mouseSetCursor(Cursor & cur, bool select)
 	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)
@@ -2316,8 +2468,7 @@ void BufferView::insertLyXFile(FileName const & fname)
 		res = _("Could not insert document %1$s");
 	}
 
-	updateMetrics();
-	buffer_.changed();
+	buffer_.changed(true);
 	// emit message signal.
 	message(bformat(res, disp_fn));
 	buffer_.errors("Parse");
@@ -2624,8 +2775,7 @@ void BufferView::insertPlaintextFile(FileName const & f, bool asParagraph)
 	else
 		cur.innerText()->insertStringAsLines(cur, tmpstr, cur.current_font);
 
-	updateMetrics();
-	buffer_.changed();
+	buffer_.changed(true);
 }