X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Flyxfunc.C;h=f6e54aa3faf682d4d37af6ac964aedb5cdc7c024;hb=3c851f1f7951f3a24b57826f3e580e4318b5e6c4;hp=cb4485b5873dda3b11305b3ab0743825021e9443;hpb=25bafa277251eaf01e3068921442b1584ce77975;p=lyx.git

diff --git a/src/lyxfunc.C b/src/lyxfunc.C
index cb4485b587..f6e54aa3fa 100644
--- a/src/lyxfunc.C
+++ b/src/lyxfunc.C
@@ -28,26 +28,32 @@
 #include "bufferparams.h"
 #include "BufferView.h"
 #include "cursor.h"
+#include "CutAndPaste.h"
 #include "debug.h"
 #include "dispatchresult.h"
 #include "encoding.h"
+#include "errorlist.h"
 #include "exporter.h"
 #include "format.h"
 #include "funcrequest.h"
 #include "gettext.h"
 #include "importer.h"
+#include "insetiterator.h"
 #include "intl.h"
-#include "iterators.h"
 #include "kbmap.h"
+#include "language.h"
 #include "LColor.h"
 #include "lyx_cb.h"
 #include "LyXAction.h"
 #include "lyxfind.h"
+#include "lyxlex.h"
 #include "lyxrc.h"
 #include "lyxrow.h"
 #include "lyxserver.h"
+#include "lyxtextclasslist.h"
 #include "lyxvc.h"
 #include "paragraph.h"
+#include "pariterator.h"
 #include "ParagraphParameters.h"
 #include "undo.h"
 
@@ -63,8 +69,6 @@
 #include "insets/insetvspace.h"
 #include "insets/insetwrap.h"
 
-#include "mathed/math_cursor.h"
-
 #include "frontends/Alert.h"
 #include "frontends/Dialogs.h"
 #include "frontends/FileDialog.h"
@@ -72,30 +76,33 @@
 #include "frontends/LyXKeySym.h"
 #include "frontends/LyXView.h"
 #include "frontends/Menubar.h"
-#include "frontends/Toolbar.h"
+#include "frontends/Toolbars.h"
 
-#include "support/FileInfo.h"
+#include "support/environment.h"
+#include "support/filefilterlist.h"
 #include "support/filetools.h"
 #include "support/forkedcontr.h"
-#include "support/globbing.h"
+#include "support/fs_extras.h"
+#include "support/lstrings.h"
 #include "support/path.h"
-#include "support/path_defines.h"
-#include "support/tostr.h"
-#include "support/std_sstream.h"
+#include "support/package.h"
+#include "support/systemcall.h"
+#include "support/convert.h"
 #include "support/os.h"
 
-using bv_funcs::changeDepth;
-using bv_funcs::currentState;
-using bv_funcs::DEC_DEPTH;
+#include <boost/filesystem/operations.hpp>
+
+#include <sstream>
+
 using bv_funcs::freefont2string;
-using bv_funcs::INC_DEPTH;
 
+using lyx::support::AbsolutePath;
 using lyx::support::AddName;
 using lyx::support::AddPath;
 using lyx::support::bformat;
 using lyx::support::ChangeExtension;
+using lyx::support::contains;
 using lyx::support::FileFilterList;
-using lyx::support::FileInfo;
 using lyx::support::FileSearch;
 using lyx::support::ForkedcallsController;
 using lyx::support::i18nLibFileSearch;
@@ -104,17 +111,16 @@ using lyx::support::IsFileReadable;
 using lyx::support::isStrInt;
 using lyx::support::MakeAbsPath;
 using lyx::support::MakeDisplayPath;
+using lyx::support::package;
 using lyx::support::Path;
+using lyx::support::QuoteName;
 using lyx::support::rtrim;
 using lyx::support::split;
-using lyx::support::strToInt;
-using lyx::support::strToUnsignedInt;
-using lyx::support::system_lyxdir;
+using lyx::support::subst;
+using lyx::support::Systemcall;
 using lyx::support::token;
 using lyx::support::trim;
-using lyx::support::user_lyxdir;
 using lyx::support::prefixIs;
-using lyx::support::os::getTmpDir;
 
 using std::endl;
 using std::make_pair;
@@ -122,10 +128,12 @@ using std::pair;
 using std::string;
 using std::istringstream;
 
+namespace biblio = lyx::biblio;
+namespace fs = boost::filesystem;
+
 
 extern BufferList bufferlist;
 extern LyXServer * lyxserver;
-extern bool selection_possible;
 
 extern boost::scoped_ptr<kb_keymap> toplevel_keymap;
 
@@ -133,6 +141,47 @@ extern boost::scoped_ptr<kb_keymap> toplevel_keymap;
 extern tex_accent_struct get_accent(kb_action action);
 
 
+namespace {
+
+bool getStatus(LCursor 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)
+	//LCursor safe = *this;
+	bool res = false;
+	for ( ; cursor.depth(); cursor.pop()) {
+		//lyxerr << "\nLCursor::getStatus: cmd: " << cmd << endl << *this << endl;
+		DocIterator::idx_type & idx = cursor.idx();
+		DocIterator::idx_type const lastidx = cursor.lastidx();
+		BOOST_ASSERT(idx <= lastidx);
+
+		DocIterator::pit_type & pit = cursor.pit();
+		DocIterator::pit_type const lastpit = cursor.lastpit();
+		BOOST_ASSERT(pit <= lastpit);
+
+		DocIterator::pos_type & pos = cursor.pos();
+		DocIterator::pos_type const lastpos = cursor.lastpos();
+		BOOST_ASSERT(pos <= 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;
+}
+
+}
+
 LyXFunc::LyXFunc(LyXView * lv)
 	: owner(lv),
 	encoded_last_key(0),
@@ -157,21 +206,14 @@ void LyXFunc::handleKeyFunc(kb_action action)
 	// actions
 	keyseq.clear();
 	// copied verbatim from do_accent_char
-	view()->resetAnchor();
+	view()->cursor().resetAnchor();
 	view()->update();
 }
 
 
-void LyXFunc::processKeySym(LyXKeySymPtr keysym,
-			    key_modifier::state state)
+void LyXFunc::processKeySym(LyXKeySymPtr keysym, key_modifier::state state)
 {
-	string argument;
-
-	if (lyxerr.debugging(Debug::KEY)) {
-		lyxerr << "KeySym is "
-		       << keysym->getSymbolName()
-		       << endl;
-	}
+	lyxerr[Debug::KEY] << "KeySym is " << keysym->getSymbolName() << endl;
 
 	// Do nothing if we have nothing (JMarc)
 	if (!keysym->isOK()) {
@@ -185,7 +227,7 @@ void LyXFunc::processKeySym(LyXKeySymPtr keysym,
 		return;
 	}
 
-	Encoding const * encoding = view()->getEncoding();
+	Encoding const * encoding = view()->cursor().getEncoding();
 
 	encoded_last_key = keysym->getISOEncoded(encoding ? encoding->Name() : "");
 
@@ -194,7 +236,9 @@ void LyXFunc::processKeySym(LyXKeySymPtr keysym,
 	cancel_meta_seq.reset();
 
 	FuncRequest func = cancel_meta_seq.addkey(keysym, state);
-	lyxerr[Debug::KEY] << "action first set to [" << func.action << ']' << endl;
+	lyxerr[Debug::KEY] << BOOST_CURRENT_FUNCTION
+			   << " action first set to [" << func.action << ']'
+			   << endl;
 
 	// When not cancel or meta-fake, do the normal lookup.
 	// Note how the meta_fake Mod1 bit is OR-ed in and reset afterwards.
@@ -202,20 +246,22 @@ void LyXFunc::processKeySym(LyXKeySymPtr keysym,
 	if ((func.action != LFUN_CANCEL) && (func.action != LFUN_META_FAKE)) {
 		// remove Caps Lock and Mod2 as a modifiers
 		func = keyseq.addkey(keysym, (state | meta_fake_bit));
-		lyxerr[Debug::KEY] << "action now set to ["
-			<< func.action << ']' << endl;
+		lyxerr[Debug::KEY] << BOOST_CURRENT_FUNCTION
+				   << "action now set to ["
+				   << func.action << ']' << endl;
 	}
 
 	// Dont remove this unless you know what you are doing.
 	meta_fake_bit = key_modifier::none;
 
-	// can this happen now ?
+	// Can this happen now ?
 	if (func.action == LFUN_NOACTION) {
 		func = FuncRequest(LFUN_PREFIX);
 	}
 
 	if (lyxerr.debugging(Debug::KEY)) {
-		lyxerr << "Key [action="
+		lyxerr << BOOST_CURRENT_FUNCTION
+		       << " Key [action="
 		       << func.action << "]["
 		       << keyseq.print() << ']'
 		       << endl;
@@ -255,13 +301,10 @@ void LyXFunc::processKeySym(LyXKeySymPtr keysym,
 
 	if (func.action == LFUN_SELFINSERT) {
 		if (encoded_last_key != 0) {
-			string arg;
-			arg += encoded_last_key;
-
-			dispatch(FuncRequest(view(), LFUN_SELFINSERT, arg));
-
-			lyxerr[Debug::KEY] << "SelfInsert arg[`"
-				   << argument << "']" << endl;
+			string const arg(1, encoded_last_key);
+			dispatch(FuncRequest(LFUN_SELFINSERT, arg));
+			lyxerr[Debug::KEY]
+				<< "SelfInsert arg[`" << arg << "']" << endl;
 		}
 	} else {
 		dispatch(func);
@@ -269,240 +312,156 @@ void LyXFunc::processKeySym(LyXKeySymPtr keysym,
 }
 
 
-FuncStatus LyXFunc::getStatus(FuncRequest const & ev) const
+FuncStatus LyXFunc::getStatus(FuncRequest const & cmd) const
 {
+	//lyxerr << "LyXFunc::getStatus: cmd: " << cmd << endl;
 	FuncStatus flag;
-	Buffer * buf = owner->buffer();
-
-	if (ev.action == LFUN_NOACTION) {
-		setStatusMessage(N_("Nothing to do"));
-		flag.disabled(true);
+	LCursor & cur = view()->cursor();
+
+	/* In LyX/Mac, when a dialog is open, the menus of the
+	   application can still be accessed without giving focus to
+	   the main window. In this case, we want to disable the menu
+	   entries that are buffer-related.
+	*/
+	Buffer * buf;
+	if (cmd.origin == FuncRequest::UI && !owner->hasFocus())
+		buf = 0;
+	else
+		buf = owner->buffer();
+
+	if (cmd.action == LFUN_NOACTION) {
+		flag.message(N_("Nothing to do"));
+		flag.enabled(false);
 		return flag;
 	}
 
-	switch (ev.action) {
+	switch (cmd.action) {
 	case LFUN_UNKNOWN_ACTION:
 #ifndef HAVE_LIBAIKSAURUS
 	case LFUN_THESAURUS_ENTRY:
 #endif
 		flag.unknown(true);
-		flag.disabled(true);
+		flag.enabled(false);
 		break;
 	default:
-		flag |= lyx_gui::getStatus(ev);
+		flag |= lyx_gui::getStatus(cmd);
 	}
 
 	if (flag.unknown()) {
-		setStatusMessage(N_("Unknown action"));
+		flag.message(N_("Unknown action"));
 		return flag;
 	}
 
-	// the default error message if we disable the command
-	setStatusMessage(N_("Command disabled"));
+	if (!flag.enabled()) {
+		if (flag.message().empty())
+			flag.message(N_("Command disabled"));
+		return flag;
+	}
 
 	// Check whether we need a buffer
-	if (!lyxaction.funcHasFlag(ev.action, LyXAction::NoBuffer)) {
-		// Yes we need a buffer, do we have one?
-		if (buf) {
-			// yes
-			// Can we use a readonly buffer?
-			if (buf->isReadonly() &&
-			    !lyxaction.funcHasFlag(ev.action,
-						   LyXAction::ReadOnly)) {
-				// no
-				setStatusMessage(N_("Document is read-only"));
-				flag.disabled(true);
-			}
-		} else {
-			// no
-			setStatusMessage(N_("Command not allowed with"
-					    "out any document open"));
-			flag.disabled(true);
-			return flag;
-		}
+	if (!lyxaction.funcHasFlag(cmd.action, LyXAction::NoBuffer) && !buf) {
+		// no, exit directly
+		flag.message(N_("Command not allowed with"
+				    "out any document open"));
+		flag.enabled(false);
+		return flag;
 	}
 
-	UpdatableInset * tli = view()->fullCursor().innerInset();
-	InsetTabular * tab = view()->fullCursor().innerInsetTabular();
-
 	// I would really like to avoid having this switch and rather try to
 	// encode this in the function itself.
-	bool disable = false;
-	switch (ev.action) {
-	case LFUN_EXPORT:
-		disable = ev.argument != "custom"
-			&& !Exporter::IsExportable(*buf, ev.argument);
+	// -- And I'd rather let an inset decide which LFUNs it is willing
+	// to handle (Andre')
+	bool enable = true;
+	switch (cmd.action) {
+	case LFUN_TOOLTIPS_TOGGLE:
+		flag.setOnOff(owner->getDialogs().tooltipsEnabled());
 		break;
-	case LFUN_UNDO:
-		disable = buf->undostack().empty();
+
+	case LFUN_READ_ONLY_TOGGLE:
+		flag.setOnOff(buf->isReadonly());
+		break;
+
+	case LFUN_SWITCHBUFFER:
+		// toggle on the current buffer, but do not toggle off
+		// the other ones (is that a good idea?)
+		if (cmd.argument == buf->fileName())
+			flag.setOnOff(true);
 		break;
-	case LFUN_REDO:
-		disable = buf->redostack().empty();
+
+	case LFUN_EXPORT:
+		enable = cmd.argument == "custom"
+			|| Exporter::IsExportable(*buf, cmd.argument);
 		break;
 	case LFUN_CUT:
 	case LFUN_COPY:
-		if (tab && tab->hasSelection())
-			disable = false;
-		else
-			disable = !mathcursor && !view()->getLyXText()->selection.set();
+		enable = cur.selection();
 		break;
 
 	case LFUN_RUNCHKTEX:
-		disable = !buf->isLatex() || lyxrc.chktex_command == "none";
+		enable = buf->isLatex() && lyxrc.chktex_command != "none";
 		break;
 
 	case LFUN_BUILDPROG:
-		disable = !Exporter::IsExportable(*buf, "program");
+		enable = Exporter::IsExportable(*buf, "program");
 		break;
 
 	case LFUN_LAYOUT_TABULAR:
-		disable = !view()->fullCursor().innerInsetTabular();
-		break;
-
-	case LFUN_DEPTH_MIN:
-		disable = !changeDepthAllowed(view(), view()->getLyXText(), DEC_DEPTH);
-		break;
-
-	case LFUN_DEPTH_PLUS:
-		disable = !changeDepthAllowed(view(), view()->getLyXText(), INC_DEPTH);
+		enable = cur.innerInsetOfType(InsetBase::TABULAR_CODE);
 		break;
 
 	case LFUN_LAYOUT:
-	case LFUN_LAYOUT_PARAGRAPH: {
-		InsetOld * inset = view()->getLyXText()->cursorPar()->inInset();
-		disable = inset && inset->forceDefaultParagraphs(inset);
-		break;
-	}
-
-	case LFUN_INSET_OPTARG:
-		disable = (view()->getLyXText()->cursorPar()->layout()->optionalargs == 0);
-		break;
-
-	case LFUN_TABULAR_FEATURE:
-#if 0
-		if (mathcursor) {
-			// FIXME: check temporarily disabled
-			// valign code
-			char align = mathcursor->valign();
-			if (align == '\0') {
-				disable = true;
-				break;
-			}
-			if (ev.argument.empty()) {
-				flag.clear();
-				break;
-			}
-			if (!contains("tcb", ev.argument[0])) {
-				disable = true;
-				break;
-			}
-			flag.setOnOff(ev.argument[0] == align);
-		} else {
-			disable = true;
-
-			char align = mathcursor->halign();
-			if (align == '\0') {
-				disable = true;
-				break;
-			}
-			if (ev.argument.empty()) {
-				flag.clear();
-				break;
-			}
-			if (!contains("lcr", ev.argument[0])) {
-				disable = true;
-				break;
-			}
-			flag.setOnOff(ev.argument[0] == align);
-
-			disable = !mathcursor->halign();
-			break;
-		}
-
-		if (tli) {
-			FuncStatus ret;
-			//ret.disabled(true);
-			InsetTabular * tab = view()->cursor().innerInsetTabular();
-			if (tab) {
-				ret = tab->getStatus(ev.argument);
-				flag |= ret;
-				disable = false;
-			} else {
-				disable = true;
-			}
-		} else {
-			static InsetTabular inset(*buf, 1, 1);
-			disable = true;
-			FuncStatus ret = inset.getStatus(ev.argument);
-			if (ret.onoff(true) || ret.onoff(false))
-				flag.setOnOff(false);
-		}
-#endif
+	case LFUN_LAYOUT_PARAGRAPH:
+		enable = !cur.inset().forceDefaultParagraphs(&cur.inset());
 		break;
 
 	case LFUN_VC_REGISTER:
-		disable = buf->lyxvc().inUse();
+		enable = !buf->lyxvc().inUse();
 		break;
 	case LFUN_VC_CHECKIN:
-		disable = !buf->lyxvc().inUse() || buf->isReadonly();
+		enable = buf->lyxvc().inUse() && !buf->isReadonly();
 		break;
 	case LFUN_VC_CHECKOUT:
-		disable = !buf->lyxvc().inUse() || !buf->isReadonly();
+		enable = buf->lyxvc().inUse() && buf->isReadonly();
 		break;
 	case LFUN_VC_REVERT:
 	case LFUN_VC_UNDO:
-		disable = !buf->lyxvc().inUse();
+		enable = buf->lyxvc().inUse();
 		break;
 	case LFUN_MENURELOAD:
-		disable = buf->isUnnamed() || buf->isClean();
-		break;
-	case LFUN_BOOKMARK_GOTO:
-		disable = !view()->
-			isSavedPosition(strToUnsignedInt(ev.argument));
-		break;
-
-	case LFUN_MERGE_CHANGES:
-	case LFUN_ACCEPT_CHANGE:
-	case LFUN_REJECT_CHANGE:
-	case LFUN_ACCEPT_ALL_CHANGES:
-	case LFUN_REJECT_ALL_CHANGES:
-		disable = !buf->params().tracking_changes;
+		enable = !buf->isUnnamed() && !buf->isClean();
 		break;
 
 	case LFUN_INSET_SETTINGS: {
-		disable = true;
-		UpdatableInset * inset = view()->fullCursor().innerInset();
-
+		enable = false;
+		if (!cur)
+			break;
+		UpdatableInset * inset = cur.inset().asUpdatableInset();
+		lyxerr << "inset: " << inset << endl;
 		if (!inset)
 			break;
 
-		// jump back to owner if an InsetText, so
-		// we get back to the InsetTabular or whatever
-		if (inset->lyxCode() == InsetOld::TEXT_CODE)
-			inset = inset->owner();
-
-		InsetOld::Code code = inset->lyxCode();
+		InsetBase::Code code = inset->lyxCode();
 		switch (code) {
-			case InsetOld::TABULAR_CODE:
-				disable = ev.argument != "tabular";
+			case InsetBase::TABULAR_CODE:
+				enable = cmd.argument == "tabular";
 				break;
-			case InsetOld::ERT_CODE:
-				disable = ev.argument != "ert";
+			case InsetBase::ERT_CODE:
+				enable = cmd.argument == "ert";
 				break;
-			case InsetOld::FLOAT_CODE:
-				disable = ev.argument != "float";
+			case InsetBase::FLOAT_CODE:
+				enable = cmd.argument == "float";
 				break;
-			case InsetOld::WRAP_CODE:
-				disable = ev.argument != "wrap";
+			case InsetBase::WRAP_CODE:
+				enable = cmd.argument == "wrap";
 				break;
-			case InsetOld::NOTE_CODE:
-				disable = ev.argument != "note";
+			case InsetBase::NOTE_CODE:
+				enable = cmd.argument == "note";
 				break;
-			case InsetOld::BRANCH_CODE:
-				disable = ev.argument != "branch";
+			case InsetBase::BRANCH_CODE:
+				enable = cmd.argument == "branch";
 				break;
-			case InsetOld::BOX_CODE:
-				disable = ev.argument != "box";
+			case InsetBase::BOX_CODE:
+				enable = cmd.argument == "box";
 				break;
 			default:
 				break;
@@ -510,294 +469,124 @@ FuncStatus LyXFunc::getStatus(FuncRequest const & ev) const
 		break;
 	}
 
-	case LFUN_MATH_MUTATE:
-		if (mathcursor)
-			//flag.setOnOff(mathcursor->formula()->hullType() == ev.argument);
-			flag.setOnOff(false);
-		else
-			disable = true;
-		break;
-
-	// we just need to be in math mode to enable that
-	case LFUN_MATH_SIZE:
-	case LFUN_MATH_SPACE:
-	case LFUN_MATH_LIMITS:
-	case LFUN_MATH_NONUMBER:
-	case LFUN_MATH_NUMBER:
-	case LFUN_MATH_EXTERN:
-		disable = !mathcursor;
-		break;
-
 	case LFUN_DIALOG_SHOW: {
-		string const name = ev.getArg(0);
-		if (!buf) {
-			disable = !(name == "aboutlyx" ||
-				    name == "file" ||
-				    name == "forks" ||
-				    name == "preferences" ||
-				    name == "texinfo");
-			break;
-		}
-
-		if (name == "print") {
-			disable = !Exporter::IsExportable(*buf, "dvi") ||
-				lyxrc.print_command == "none";
-		} else if (name == "character") {
-			UpdatableInset * tli = view()->fullCursor().innerInset();
-			disable = tli && tli->lyxCode() == InsetOld::ERT_CODE;
-		} else if (name == "vclog") {
-			disable = !buf->lyxvc().inUse();
-		} else if (name == "latexlog") {
-			disable = !IsFileReadable(buf->getLogName().second);
-		}
+		string const name = cmd.getArg(0);
+		if (!buf)
+			enable = name == "aboutlyx"
+				|| name == "file"
+				|| name == "forks"
+				|| name == "prefs"
+				|| name == "texinfo";
+		else if (name == "print")
+			enable = Exporter::IsExportable(*buf, "dvi")
+				&& lyxrc.print_command != "none";
+		else if (name == "character" || name == "mathpanel")
+			enable = cur.inset().lyxCode() != InsetBase::ERT_CODE;
+		else if (name == "vclog")
+			enable = buf->lyxvc().inUse();
+		else if (name == "latexlog")
+			enable = IsFileReadable(buf->getLogName().second);
 		break;
 	}
 
-	default:
-		break;
-	}
-
-	// the functions which insert insets
-	InsetOld::Code code = InsetOld::NO_CODE;
-	switch (ev.action) {
 	case LFUN_DIALOG_SHOW_NEW_INSET:
-		if (ev.argument == "bibitem")
-			code = InsetOld::BIBITEM_CODE;
-		else if (ev.argument == "bibtex")
-			code = InsetOld::BIBTEX_CODE;
-		else if (ev.argument == "box")
-			code = InsetOld::BOX_CODE;
-		else if (ev.argument == "branch")
-			code = InsetOld::BRANCH_CODE;
-		else if (ev.argument == "citation")
-			code = InsetOld::CITE_CODE;
-		else if (ev.argument == "ert")
-			code = InsetOld::ERT_CODE;
-		else if (ev.argument == "external")
-			code = InsetOld::EXTERNAL_CODE;
-		else if (ev.argument == "float")
-			code = InsetOld::FLOAT_CODE;
-		else if (ev.argument == "graphics")
-			code = InsetOld::GRAPHICS_CODE;
-		else if (ev.argument == "include")
-			code = InsetOld::INCLUDE_CODE;
-		else if (ev.argument == "index")
-			code = InsetOld::INDEX_CODE;
-		else if (ev.argument == "label")
-			code = InsetOld::LABEL_CODE;
-		else if (ev.argument == "note")
-			code = InsetOld::NOTE_CODE;
-		else if (ev.argument == "ref")
-			code = InsetOld::REF_CODE;
-		else if (ev.argument == "toc")
-			code = InsetOld::TOC_CODE;
-		else if (ev.argument == "url")
-			code = InsetOld::URL_CODE;
-		else if (ev.argument == "vspace")
-			code = InsetOld::VSPACE_CODE;
-		else if (ev.argument == "wrap")
-			code = InsetOld::WRAP_CODE;
+		enable = cur.inset().lyxCode() != InsetBase::ERT_CODE;
 		break;
 
-	case LFUN_INSET_ERT:
-		code = InsetOld::ERT_CODE;
-		break;
-	case LFUN_INSET_FOOTNOTE:
-		code = InsetOld::FOOT_CODE;
-		break;
-	case LFUN_TABULAR_INSERT:
-		code = InsetOld::TABULAR_CODE;
-		break;
-	case LFUN_INSET_MARGINAL:
-		code = InsetOld::MARGIN_CODE;
-		break;
-	case LFUN_INSET_FLOAT:
-	case LFUN_INSET_WIDE_FLOAT:
-		code = InsetOld::FLOAT_CODE;
-		break;
-	case LFUN_INSET_WRAP:
-		code = InsetOld::WRAP_CODE;
-		break;
-	case LFUN_FLOAT_LIST:
-		code = InsetOld::FLOAT_LIST_CODE;
-		break;
-#if 0
-	case LFUN_INSET_LIST:
-		code = InsetOld::LIST_CODE;
-		break;
-	case LFUN_INSET_THEOREM:
-		code = InsetOld::THEOREM_CODE;
-		break;
-#endif
-	case LFUN_INSET_CAPTION:
-		code = InsetOld::CAPTION_CODE;
-		break;
-	case LFUN_INSERT_NOTE:
-		code = InsetOld::NOTE_CODE;
-		break;
-	case LFUN_INSERT_CHARSTYLE:
-		code = InsetOld::CHARSTYLE_CODE;
-		if (buf->params().getLyXTextClass().charstyles().empty())
-			disable = true;
-		break;
-	case LFUN_INSERT_BOX:
-		code = InsetOld::BOX_CODE;
-		break;
-	case LFUN_INSERT_BRANCH:
-		code = InsetOld::BRANCH_CODE;
-		if (buf->params().branchlist().empty())
-			disable = true;
-		break;
-	case LFUN_INSERT_LABEL:
-		code = InsetOld::LABEL_CODE;
-		break;
-	case LFUN_INSET_OPTARG:
-		code = InsetOld::OPTARG_CODE;
-		break;
-	case LFUN_ENVIRONMENT_INSERT:
-		code = InsetOld::BOX_CODE;
-		break;
-	case LFUN_INDEX_INSERT:
-		code = InsetOld::INDEX_CODE;
-		break;
-	case LFUN_INDEX_PRINT:
-		code = InsetOld::INDEX_PRINT_CODE;
-		break;
-	case LFUN_TOC_INSERT:
-		code = InsetOld::TOC_CODE;
-		break;
-	case LFUN_HTMLURL:
-	case LFUN_URL:
-		code = InsetOld::URL_CODE;
-		break;
-	case LFUN_QUOTE:
-		// always allow this, since we will inset a raw quote
-		// if an inset is not allowed.
-		break;
-	case LFUN_HYPHENATION:
-	case LFUN_LIGATURE_BREAK:
-	case LFUN_HFILL:
-	case LFUN_MENU_SEPARATOR:
-	case LFUN_LDOTS:
-	case LFUN_END_OF_SENTENCE:
-		code = InsetOld::SPECIALCHAR_CODE;
-		break;
-	case LFUN_SPACE_INSERT:
-		// slight hack: we know this is allowed in math mode
-		if (!mathcursor)
-			code = InsetOld::SPACE_CODE;
-		break;
-	case LFUN_INSET_DIALOG_SHOW: {
-		InsetOld * inset = view()->getLyXText()->getInset();
-		disable = !inset;
-		if (!disable) {
-			code = inset->lyxCode();
-			if (!(code == InsetOld::INCLUDE_CODE
-				|| code == InsetOld::BIBTEX_CODE
-				|| code == InsetOld::FLOAT_LIST_CODE
-				|| code == InsetOld::TOC_CODE))
-				disable = true;
-		}
-		break;
-	}
-	default:
+	case LFUN_DIALOG_UPDATE: {
+		string const name = cmd.getArg(0);
+		if (!buf)
+			enable = name == "prefs";
 		break;
 	}
-	if (code != InsetOld::NO_CODE && tli && !tli->insetAllowed(code))
-		disable = true;
 
-	if (disable)
-		flag.disabled(true);
+	// this one is difficult to get right. As a half-baked
+	// solution, we consider only the first action of the sequence
+	case LFUN_SEQUENCE: {
+		// argument contains ';'-terminated commands
+		string const firstcmd = token(cmd.argument, ';', 0);
+		FuncRequest func(lyxaction.lookupFunc(firstcmd));
+		func.origin = cmd.origin;
+		flag = getStatus(func);
+	}
 
-	// A few general toggles
-	switch (ev.action) {
-	case LFUN_TOOLTIPS_TOGGLE:
-		flag.setOnOff(owner->getDialogs().tooltipsEnabled());
+	case LFUN_MENUNEW:
+	case LFUN_MENUNEWTMPLT:
+	case LFUN_WORDFINDFORWARD:
+	case LFUN_WORDFINDBACKWARD:
+	case LFUN_PREFIX:
+	case LFUN_EXEC_COMMAND:
+	case LFUN_CANCEL:
+	case LFUN_META_FAKE:
+	case LFUN_CLOSEBUFFER:
+	case LFUN_MENUWRITE:
+	case LFUN_WRITEAS:
+	case LFUN_UPDATE:
+	case LFUN_PREVIEW:
+	case LFUN_IMPORT:
+	case LFUN_QUIT:
+	case LFUN_TOCVIEW:
+	case LFUN_AUTOSAVE:
+	case LFUN_RECONFIGURE:
+	case LFUN_HELP_OPEN:
+	case LFUN_FILE_NEW:
+	case LFUN_FILE_OPEN:
+	case LFUN_DROP_LAYOUTS_CHOICE:
+	case LFUN_MENU_OPEN_BY_NAME:
+	case LFUN_GETNAME:
+	case LFUN_NOTIFY:
+	case LFUN_GOTOFILEROW:
+	case LFUN_DIALOG_SHOW_NEXT_INSET:
+	case LFUN_DIALOG_HIDE:
+	case LFUN_DIALOG_DISCONNECT_INSET:
+	case LFUN_CHILDOPEN:
+	case LFUN_TOGGLECURSORFOLLOW:
+	case LFUN_KMAP_OFF:
+	case LFUN_KMAP_PRIM:
+	case LFUN_KMAP_SEC:
+	case LFUN_KMAP_TOGGLE:
+	case LFUN_REPEAT:
+	case LFUN_EXPORT_CUSTOM:
+	case LFUN_PRINT:
+	case LFUN_SAVEPREFERENCES:
+	case LFUN_SCREEN_FONT_UPDATE:
+	case LFUN_SET_COLOR:
+	case LFUN_MESSAGE:
+	case LFUN_EXTERNAL_EDIT:
+	case LFUN_GRAPHICS_EDIT:
+	case LFUN_ALL_INSETS_TOGGLE:
+	case LFUN_LANGUAGE_BUFFER:
+	case LFUN_TEXTCLASS_APPLY:
+	case LFUN_TEXTCLASS_LOAD:
+	case LFUN_SAVE_AS_DEFAULT:
+	case LFUN_BUFFERPARAMS_APPLY:
+	case LFUN_LYXRC_APPLY:
+	case LFUN_NEXTBUFFER:
+	case LFUN_PREVIOUSBUFFER:
+		// these are handled in our dispatch()
 		break;
 
-	case LFUN_READ_ONLY_TOGGLE:
-		flag.setOnOff(buf->isReadonly());
-		break;
-	case LFUN_APPENDIX:
-		flag.setOnOff(view()->getLyXText()->cursorPar()->params().startOfAppendix());
-		break;
-	case LFUN_SWITCHBUFFER:
-		// toggle on the current buffer, but do not toggle off
-		// the other ones (is that a good idea?)
-		if (ev.argument == buf->fileName())
-			flag.setOnOff(true);
-		break;
-	case LFUN_TRACK_CHANGES:
-		flag.setOnOff(buf->params().tracking_changes);
-		break;
 	default:
-		break;
-	}
 
-#ifdef LOCK
-	// the font related toggles
-	if (!mathcursor) {
-		LyXFont const & font = view()->getLyXText()->real_current_font;
-		switch (ev.action) {
-		case LFUN_EMPH:
-			flag.setOnOff(font.emph() == LyXFont::ON);
-			break;
-		case LFUN_NOUN:
-			flag.setOnOff(font.noun() == LyXFont::ON);
-			break;
-		case LFUN_BOLD:
-			flag.setOnOff(font.series() == LyXFont::BOLD_SERIES);
-			break;
-		case LFUN_SANS:
-			flag.setOnOff(font.family() == LyXFont::SANS_FAMILY);
-			break;
-		case LFUN_ROMAN:
-			flag.setOnOff(font.family() == LyXFont::ROMAN_FAMILY);
-			break;
-		case LFUN_CODE:
-			flag.setOnOff(font.family() == LyXFont::TYPEWRITER_FAMILY);
-			break;
-		default:
-			break;
-		}
-	} else {
-		string tc = mathcursor->getLastCode();
-		switch (ev.action) {
-		case LFUN_BOLD:
-			flag.setOnOff(tc == "mathbf");
-			break;
-		case LFUN_SANS:
-			flag.setOnOff(tc == "mathsf");
-			break;
-		case LFUN_EMPH:
-			flag.setOnOff(tc == "mathcal");
-			break;
-		case LFUN_ROMAN:
-			flag.setOnOff(tc == "mathrm");
-			break;
-		case LFUN_CODE:
-			flag.setOnOff(tc == "mathtt");
-			break;
-		case LFUN_NOUN:
-			flag.setOnOff(tc == "mathbb");
-			break;
-		case LFUN_DEFAULT:
-			flag.setOnOff(tc == "mathnormal");
-			break;
-		default:
-			break;
-		}
+		if (!::getStatus(cur, cmd, flag))
+			flag = view()->getStatus(cmd);
 	}
-#endif
 
-	// this one is difficult to get right. As a half-baked
-	// solution, we consider only the first action of the sequence
-	if (ev.action == LFUN_SEQUENCE) {
-		// argument contains ';'-terminated commands
-#warning LyXAction arguments not handled here.
-		flag = getStatus(FuncRequest(lyxaction.lookupFunc(token(ev.argument, ';', 0))));
+	if (!enable)
+		flag.enabled(false);
+
+	// Can we use a readonly buffer?
+	if (buf && buf->isReadonly()
+	    && !lyxaction.funcHasFlag(cmd.action, LyXAction::ReadOnly)
+	    && !lyxaction.funcHasFlag(cmd.action, LyXAction::NoBuffer)) {
+		flag.message(N_("Document is read-only"));
+		flag.enabled(false);
 	}
 
+	// the default error message if we disable the command
+	if (!flag.enabled() && flag.message().empty())
+		flag.message(N_("Command disabled"));
+
 	return flag;
 }
 
@@ -824,38 +613,67 @@ bool ensureBufferClean(BufferView * bv)
 	return buf.isClean();
 }
 
+
+void showPrintError(string const & name)
+{
+	string str = bformat(_("Could not print the document %1$s.\n"
+			       "Check that your printer is set up correctly."),
+			     MakeDisplayPath(name, 50));
+	Alert::error(_("Print document failed"), str);
+}
+
+
+void loadTextclass(string const & name)
+{
+	std::pair<bool, lyx::textclass_type> const tc_pair =
+		textclasslist.NumberOfClass(name);
+
+	if (!tc_pair.first) {
+		lyxerr << "Document class \"" << name
+		       << "\" does not exist."
+		       << std::endl;
+		return;
+	}
+
+	lyx::textclass_type const tc = tc_pair.second;
+
+	if (!textclasslist[tc].load()) {
+		string s = bformat(_("The document could not be converted\n"
+				     "into the document class %1$s."),
+				   textclasslist[tc].name());
+		Alert::error(_("Could not change class"), s);
+	}
+}
+
+
+void actOnUpdatedPrefs(LyXRC const & lyxrc_orig, LyXRC const & lyxrc_new);
+
 } //namespace anon
 
 
-void LyXFunc::dispatch(FuncRequest const & func, bool verbose)
+void LyXFunc::dispatch(FuncRequest const & cmd)
 {
-	string argument = func.argument;
-	kb_action action = func.action;
+	BOOST_ASSERT(view());
+	string const argument = cmd.argument;
+	kb_action const action = cmd.action;
 
-	//lyxerr[Debug::ACTION] << "LyXFunc::dispatch: cmd: " << func << endl;
-	lyxerr << "LyXFunc::dispatch: cmd: " << func << endl;
+	lyxerr[Debug::ACTION] << "LyXFunc::dispatch: cmd: " << cmd << endl;
+	//lyxerr << "LyXFunc::dispatch: cmd: " << cmd << endl;
 
 	// we have not done anything wrong yet.
 	errorstat = false;
 	dispatch_buffer.erase();
 
-#ifdef NEW_DISPATCHER
-	// We try do call the most specific dispatcher first:
-	//  1. the lockinginset's dispatch
-	//  2. the bufferview's dispatch
-	//  3. the lyxview's dispatch
-#endif
-
-	selection_possible = false;
+	bool update = false;
 
-	// We cannot use this function here
-	if (getStatus(func).disabled()) {
+	FuncStatus const flag = getStatus(cmd);
+	if (!flag.enabled()) {
+		// We cannot use this function here
 		lyxerr[Debug::ACTION] << "LyXFunc::dispatch: "
 		       << lyxaction.getActionName(action)
 		       << " [" << action << "] is disabled at this location"
 		       << endl;
-		setErrorMessage(getStatusMessage());
-
+		setErrorMessage(flag.message());
 	} else {
 
 		if (view()->available())
@@ -863,15 +681,6 @@ void LyXFunc::dispatch(FuncRequest const & func, bool verbose)
 
 		switch (action) {
 
-		case LFUN_ESCAPE: {
-			if (!view()->available())
-				break;
-			view()->fullCursor().pop();
-			// Tell the paragraph dialog that we changed paragraph
-			dispatch(FuncRequest(LFUN_PARAGRAPH_UPDATE));
-			break;
-		}
-
 		case LFUN_WORDFINDFORWARD:
 		case LFUN_WORDFINDBACKWARD: {
 			static string last_search;
@@ -880,18 +689,17 @@ void LyXFunc::dispatch(FuncRequest const & func, bool verbose)
 			if (!argument.empty()) {
 				last_search = argument;
 				searched_string = argument;
-			} else
+			} else {
 				searched_string = last_search;
+			}
 
 			if (searched_string.empty())
 				break;
 
 			bool const fw = action == LFUN_WORDFINDFORWARD;
 			string const data =
-				lyx::find::find2string(searched_string,
-						       true, false, fw);
-			FuncRequest const fr(view(), LFUN_WORD_FIND, data);
-			view()->dispatch(fr);
+				lyx::find::find2string(searched_string, true, false, fw);
+			lyx::find::find(view(), FuncRequest(LFUN_WORD_FIND, data));
 			break;
 		}
 
@@ -900,6 +708,7 @@ void LyXFunc::dispatch(FuncRequest const & func, bool verbose)
 			break;
 
 		case LFUN_EXEC_COMMAND:
+			owner->getToolbars().display("minibuffer", true);
 			owner->focus_command_buffer();
 			break;
 
@@ -925,10 +734,6 @@ void LyXFunc::dispatch(FuncRequest const & func, bool verbose)
 					!owner->buffer()->isReadonly());
 			break;
 
-		case LFUN_CENTER: // this is center and redraw.
-			view()->center();
-			break;
-
 		// --- Menus -----------------------------------------------
 		case LFUN_MENUNEW:
 			menuNew(argument, false);
@@ -991,13 +796,147 @@ void LyXFunc::dispatch(FuncRequest const & func, bool verbose)
 
 		case LFUN_EXPORT:
 			if (argument == "custom")
-				owner->getDialogs().showSendto();
+				owner->getDialogs().show("sendto");
 			else {
 				Exporter::Export(owner->buffer(), argument, false);
 				view()->showErrorList(BufferFormat(*owner->buffer()));
 			}
 			break;
 
+		case LFUN_EXPORT_CUSTOM: {
+			string format_name;
+			string command = split(argument, format_name, ' ');
+			Format const * format = formats.getFormat(format_name);
+			if (!format) {
+				lyxerr << "Format \"" << format_name
+				       << "\" not recognized!"
+				       << std::endl;
+				break;
+			}
+
+			Buffer * buffer = owner->buffer();
+
+			// The name of the file created by the conversion process
+			string filename;
+
+			// Output to filename
+			if (format->name() == "lyx") {
+				string const latexname =
+					buffer->getLatexName(false);
+				filename = ChangeExtension(latexname,
+							   format->extension());
+				filename = AddName(buffer->temppath(), filename);
+
+				if (!buffer->writeFile(filename))
+					break;
+
+			} else {
+				Exporter::Export(buffer, format_name, true,
+						 filename);
+			}
+
+			// Substitute $$FName for filename
+			if (!contains(command, "$$FName"))
+				command = "( " + command + " ) < $$FName";
+			command = subst(command, "$$FName", filename);
+
+			// Execute the command in the background
+			Systemcall call;
+			call.startscript(Systemcall::DontWait, command);
+			break;
+		}
+
+		case LFUN_PRINT: {
+			string target;
+			string target_name;
+			string command = split(split(argument, target, ' '),
+					       target_name, ' ');
+
+			if (target.empty()
+			    || target_name.empty()
+			    || command.empty()) {
+				lyxerr << "Unable to parse \""
+				       << argument << '"' << std::endl;
+				break;
+			}
+			if (target != "printer" && target != "file") {
+				lyxerr << "Unrecognized target \""
+				       << target << '"' << std::endl;
+				break;
+			}
+
+			Buffer * buffer = owner->buffer();
+
+			if (!Exporter::Export(buffer, "dvi", true)) {
+				showPrintError(buffer->fileName());
+				break;
+			}
+
+			// Push directory path.
+			string const path = buffer->temppath();
+			Path p(path);
+
+			// there are three cases here:
+			// 1. we print to a file
+			// 2. we print directly to a printer
+			// 3. we print using a spool command (print to file first)
+			Systemcall one;
+			int res = 0;
+			string const dviname =
+				ChangeExtension(buffer->getLatexName(true),
+						"dvi");
+
+			if (target == "printer") {
+				if (!lyxrc.print_spool_command.empty()) {
+					// case 3: print using a spool
+					string const psname =
+						ChangeExtension(dviname,".ps");
+					command += lyxrc.print_to_file
+						+ QuoteName(psname)
+						+ ' '
+						+ QuoteName(dviname);
+
+					string command2 =
+						lyxrc.print_spool_command +' ';
+					if (target_name != "default") {
+						command2 += lyxrc.print_spool_printerprefix
+							+ target_name
+							+ ' ';
+					}
+					command2 += QuoteName(psname);
+					// First run dvips.
+					// If successful, then spool command
+					res = one.startscript(
+						Systemcall::Wait,
+						command);
+
+					if (res == 0)
+						res = one.startscript(
+							Systemcall::DontWait,
+							command2);
+				} else {
+					// case 2: print directly to a printer
+					res = one.startscript(
+						Systemcall::DontWait,
+						command + QuoteName(dviname));
+				}
+
+			} else {
+				// case 1: print to a file
+				command += lyxrc.print_to_file
+					+ QuoteName(MakeAbsPath(target_name,
+								path))
+					+ ' '
+					+ QuoteName(dviname);
+				res = one.startscript(Systemcall::DontWait,
+						      command);
+			}
+
+			if (res != 0)
+				showPrintError(buffer->fileName());
+			break;
+		}
+
 		case LFUN_IMPORT:
 			doImport(argument);
 			break;
@@ -1017,14 +956,6 @@ void LyXFunc::dispatch(FuncRequest const & func, bool verbose)
 			AutoSave(view());
 			break;
 
-		case LFUN_UNDO:
-			view()->undo();
-			break;
-
-		case LFUN_REDO:
-			view()->redo();
-			break;
-
 		case LFUN_RECONFIGURE:
 			Reconfigure(view());
 			break;
@@ -1089,7 +1020,15 @@ void LyXFunc::dispatch(FuncRequest const & func, bool verbose)
 
 		// --- buffers ----------------------------------------
 		case LFUN_SWITCHBUFFER:
-			view()->buffer(bufferlist.getBuffer(argument));
+			view()->setBuffer(bufferlist.getBuffer(argument));
+			break;
+
+		case LFUN_NEXTBUFFER:
+			view()->setBuffer(bufferlist.next(view()->buffer()));
+			break;
+
+		case LFUN_PREVIOUSBUFFER:
+			view()->setBuffer(bufferlist.previous(view()->buffer()));
 			break;
 
 		case LFUN_FILE_NEW:
@@ -1100,13 +1039,8 @@ void LyXFunc::dispatch(FuncRequest const & func, bool verbose)
 			open(argument);
 			break;
 
-		case LFUN_LAYOUT_TABULAR:
-			if (InsetTabular * tab = view()->fullCursor().innerInsetTabular())
-				tab->openLayoutDialog(view());
-			break;
-
 		case LFUN_DROP_LAYOUTS_CHOICE:
-			owner->getToolbar().openLayoutList();
+			owner->getToolbars().openLayoutList();
 			break;
 
 		case LFUN_MENU_OPEN_BY_NAME:
@@ -1131,17 +1065,17 @@ void LyXFunc::dispatch(FuncRequest const & func, bool verbose)
 			int row;
 			istringstream is(argument);
 			is >> file_name >> row;
-			if (prefixIs(file_name, getTmpDir())) {
+			if (prefixIs(file_name, package().temp_dir())) {
 				// Needed by inverse dvi search. If it is a file
 				// in tmpdir, call the apropriated function
-				view()->buffer(bufferlist.getBufferFromTmp(file_name));
+				view()->setBuffer(bufferlist.getBufferFromTmp(file_name));
 			} else {
 				// Must replace extension of the file to be .lyx
 				// and get full path
 				string const s = ChangeExtension(file_name, ".lyx");
 				// Either change buffer or load the file
 				if (bufferlist.exists(s)) {
-					view()->buffer(bufferlist.getBuffer(s));
+					view()->setBuffer(bufferlist.getBuffer(s));
 				} else {
 					view()->loadLyXFile(s);
 				}
@@ -1155,65 +1089,15 @@ void LyXFunc::dispatch(FuncRequest const & func, bool verbose)
 			break;
 		}
 
-		case LFUN_GOTO_PARAGRAPH: {
-			istringstream is(argument);
-			int id;
-			is >> id;
-			ParIterator par = owner->buffer()->getParFromID(id);
-			if (par == owner->buffer()->par_iterator_end()) {
-				lyxerr[Debug::INFO] << "No matching paragraph found! ["
-								<< id << ']' << endl;
-				break;
-			} else {
-				lyxerr[Debug::INFO] << "Paragraph " << par->id()
-								<< " found." << endl;
-			}
-
-			par.lockPath(view());
-			LyXText * lt = par.text(*view()->buffer());
-
-			// Set the cursor
-			lt->setCursor(par.pit(), 0);
-			view()->switchKeyMap();
-			owner->view_state_changed();
-
-			view()->center();
-			// see BufferView_pimpl::center()
-			view()->updateScrollbar();
-			break;
-		}
-
-		// ---  Mathed stuff. If we are here, there is no locked inset yet.
-		case LFUN_MATH_EXTERN:
-		case LFUN_MATH_NUMBER:
-		case LFUN_MATH_NONUMBER:
-		case LFUN_MATH_LIMITS:
-			setErrorMessage(N_("This is only allowed in math mode!"));
-			break;
-
 		case LFUN_DIALOG_SHOW: {
-			string const name = func.getArg(0);
-			string data = trim(func.argument.substr(name.size()));
+			string const name = cmd.getArg(0);
+			string data = trim(cmd.argument.substr(name.size()));
 
 			if (name == "character") {
 				data = freefont2string();
 				if (!data.empty())
 					owner->getDialogs().show("character", data);
 			}
-			else if (name == "document")
-				owner->getDialogs().showDocument();
-			else if (name == "findreplace")
-				owner->getDialogs().showSearch();
-			else if (name == "forks")
-				owner->getDialogs().showForks();
-			else if (name == "preamble")
-				owner->getDialogs().showPreamble();
-			else if (name == "preferences")
-				owner->getDialogs().showPreferences();
-			else if (name == "print")
-				owner->getDialogs().showPrint();
-			else if (name == "spellchecker")
-				owner->getDialogs().showSpellchecker();
 
 			else if (name == "latexlog") {
 				pair<Buffer::LogType, string> const logfile =
@@ -1240,8 +1124,8 @@ void LyXFunc::dispatch(FuncRequest const & func, bool verbose)
 		}
 
 		case LFUN_DIALOG_SHOW_NEW_INSET: {
-			string const name = func.getArg(0);
-			string data = trim(func.argument.substr(name.size()));
+			string const name = cmd.getArg(0);
+			string data = trim(cmd.argument.substr(name.size()));
 			if (name == "bibitem" ||
 			    name == "bibtex" ||
 			    name == "include" ||
@@ -1292,23 +1176,17 @@ void LyXFunc::dispatch(FuncRequest const & func, bool verbose)
 		case LFUN_DIALOG_SHOW_NEXT_INSET:
 			break;
 
-		case LFUN_INSET_DIALOG_SHOW: {
-			InsetOld * inset = view()->getLyXText()->getInset();
-			if (inset)
-				inset->dispatch(FuncRequest(view(), LFUN_INSET_DIALOG_SHOW));
-			break;
-		}
-
 		case LFUN_DIALOG_UPDATE: {
 			string const & name = argument;
 			// Can only update a dialog connected to an existing inset
 			InsetBase * inset = owner->getDialogs().getOpenInset(name);
 			if (inset) {
-				FuncRequest fr(view(), LFUN_INSET_DIALOG_UPDATE,
-								 func.argument);
-				inset->dispatch(fr);
+				FuncRequest fr(LFUN_INSET_DIALOG_UPDATE, cmd.argument);
+				inset->dispatch(view()->cursor(), fr);
 			} else if (name == "paragraph") {
 				dispatch(FuncRequest(LFUN_PARAGRAPH_UPDATE));
+			} else if (name == "prefs") {
+				owner->getDialogs().update(name, string());
 			}
 			break;
 		}
@@ -1329,7 +1207,7 @@ void LyXFunc::dispatch(FuncRequest const & func, bool verbose)
 			view()->savePosition(0);
 			string const parentfilename = owner->buffer()->fileName();
 			if (bufferlist.exists(filename))
-				view()->buffer(bufferlist.getBuffer(filename));
+				view()->setBuffer(bufferlist.getBuffer(filename));
 			else
 				view()->loadLyXFile(filename);
 			// Set the parent name of the child document.
@@ -1362,28 +1240,32 @@ void LyXFunc::dispatch(FuncRequest const & func, bool verbose)
 		case LFUN_REPEAT: {
 			// repeat command
 			string countstr;
-			argument = split(argument, countstr, ' ');
+			string rest = split(argument, countstr, ' ');
 			istringstream is(countstr);
 			int count = 0;
 			is >> count;
-			lyxerr << "repeat: count: " << count << " cmd: " << argument << endl;
+			lyxerr << "repeat: count: " << count << " cmd: " << rest << endl;
 			for (int i = 0; i < count; ++i)
-				dispatch(lyxaction.lookupFunc(argument));
+				dispatch(lyxaction.lookupFunc(rest));
 			break;
 		}
 
-		case LFUN_SEQUENCE:
+		case LFUN_SEQUENCE: {
 			// argument contains ';'-terminated commands
-			while (!argument.empty()) {
+			string arg = argument;
+			while (!arg.empty()) {
 				string first;
-				argument = split(argument, first, ';');
-				dispatch(lyxaction.lookupFunc(first));
+				arg = split(arg, first, ';');
+				FuncRequest func(lyxaction.lookupFunc(first));
+				func.origin = cmd.origin;
+				dispatch(func);
 			}
 			break;
+		}
 
 		case LFUN_SAVEPREFERENCES: {
-			Path p(user_lyxdir());
-			lyxrc.write("preferences");
+			Path p(package().user_support());
+			lyxrc.write("preferences", false);
 			break;
 		}
 
@@ -1408,8 +1290,7 @@ void LyXFunc::dispatch(FuncRequest const & func, bool verbose)
 				(lyx_name == lcolor.getLyXName(LColor::graphicsbg) &&
 				 x11_name != lcolor.getX11Name(LColor::graphicsbg));
 
-			LColor::color col = lcolor.getFromLyXName(lyx_name);
-			if (!lcolor.setColor(col, x11_name)) {
+			if (!lcolor.setColor(lyx_name, x11_name)) {
 				setErrorMessage(
 					bformat(_("Set-color \"%1$s\" failed "
 								"- color is undefined or "
@@ -1434,55 +1315,206 @@ void LyXFunc::dispatch(FuncRequest const & func, bool verbose)
 			owner->message(argument);
 			break;
 
-		case LFUN_FORKS_KILL:
-			if (isStrInt(argument))
-				ForkedcallsController::get().kill(strToInt(argument));
-			break;
-
 		case LFUN_TOOLTIPS_TOGGLE:
 			owner->getDialogs().toggleTooltips();
 			break;
 
-		case LFUN_EXTERNAL_EDIT:
-			InsetExternal().dispatch(FuncRequest(view(), action, argument));
+		case LFUN_EXTERNAL_EDIT: {
+			FuncRequest fr(action, argument);
+			InsetExternal().dispatch(view()->cursor(), fr);
 			break;
+		}
 
-		default: {
-				DispatchResult result =
-					view()->fullCursor().dispatch(FuncRequest(func, view()));
-				if (result.dispatched())
-					lyxerr << "dispatched by Cursor::dispatch()" << endl;
-				else
-					lyxerr << "### NOT DISPATCHED BY Cursor::dispatch() ###" << endl;
+		case LFUN_GRAPHICS_EDIT: {
+			FuncRequest fr(action, argument);
+			InsetGraphics().dispatch(view()->cursor(), fr);
+			break;
+		}
+
+		case LFUN_ALL_INSETS_TOGGLE: {
+			string action;
+			string const name = split(argument, action, ' ');
+			InsetBase::Code const inset_code =
+				InsetBase::translate(name);
+
+			LCursor & cur = view()->cursor();
+			FuncRequest fr(LFUN_INSET_TOGGLE, action);
+
+			InsetBase & inset = owner->buffer()->inset();
+			InsetIterator it  = inset_iterator_begin(inset);
+			InsetIterator const end = inset_iterator_end(inset);
+			for (; it != end; ++it) {
+				if (inset_code == InsetBase::NO_CODE
+				    || inset_code == it->lyxCode())
+					it->dispatch(cur, fr);
+			}
+			break;
+		}
+
+		case LFUN_LANGUAGE_BUFFER: {
+			Buffer & buffer = *owner->buffer();
+			Language const * oldL = buffer.params().language;
+			Language const * newL = languages.getLanguage(argument);
+			if (!newL || oldL == newL)
 				break;
+
+			if (oldL->RightToLeft() == newL->RightToLeft()
+			    && !buffer.isMultiLingual())
+				buffer.changeLanguage(oldL, newL);
+			else
+				buffer.updateDocLang(newL);
+			break;
+		}
+
+		case LFUN_SAVE_AS_DEFAULT: {
+			string const fname =
+				AddName(AddPath(package().user_support(), "templates/"),
+					"defaults.lyx");
+			Buffer defaults(fname);
+
+			istringstream ss(argument);
+			LyXLex lex(0,0);
+			lex.setStream(ss);
+			int const unknown_tokens = defaults.readHeader(lex);
+
+			if (unknown_tokens != 0) {
+				lyxerr << "Warning in LFUN_SAVE_AS_DEFAULT!\n"
+				       << unknown_tokens << " unknown token"
+				       << (unknown_tokens == 1 ? "" : "s")
+				       << endl;
+			}
+
+			if (defaults.writeFile(defaults.fileName()))
+				setMessage(_("Document defaults saved in ")
+					   + MakeDisplayPath(fname));
+			else
+				setErrorMessage(_("Unable to save document defaults"));
+			break;
+		}
+
+		case LFUN_BUFFERPARAMS_APPLY: {
+			biblio::CiteEngine const engine =
+				owner->buffer()->params().cite_engine;
+
+			istringstream ss(argument);
+			LyXLex lex(0,0);
+			lex.setStream(ss);
+			int const unknown_tokens =
+				owner->buffer()->readHeader(lex);
+
+			if (unknown_tokens != 0) {
+				lyxerr << "Warning in LFUN_BUFFERPARAMS_APPLY!\n"
+				       << unknown_tokens << " unknown token"
+				       << (unknown_tokens == 1 ? "" : "s")
+				       << endl;
 			}
+			if (engine == owner->buffer()->params().cite_engine)
+				break;
+
+			LCursor & cur = view()->cursor();
+			FuncRequest fr(LFUN_INSET_REFRESH);
+
+			InsetBase & inset = owner->buffer()->inset();
+			InsetIterator it  = inset_iterator_begin(inset);
+			InsetIterator const end = inset_iterator_end(inset);
+			for (; it != end; ++it)
+				if (it->lyxCode() == InsetBase::CITE_CODE)
+					it->dispatch(cur, fr);
+			break;
 		}
-	}
 
-	view()->owner()->updateLayoutChoice();
+		case LFUN_TEXTCLASS_APPLY: {
+			Buffer * buffer = owner->buffer();
 
-	if (view()->available()) {
-		view()->fitCursor();
-		view()->update();
-		view()->fullCursor().updatePos();
-		// if we executed a mutating lfun, mark the buffer as dirty
-		if (!getStatus(func).disabled()
-		    && !lyxaction.funcHasFlag(func.action, LyXAction::NoBuffer)
-		    && !lyxaction.funcHasFlag(func.action, LyXAction::ReadOnly))
-			view()->buffer()->markDirty();
-	}
+			lyx::textclass_type const old_class =
+				buffer->params().textclass;
+
+			loadTextclass(argument);
+
+			std::pair<bool, lyx::textclass_type> const tc_pair =
+				textclasslist.NumberOfClass(argument);
+
+			if (!tc_pair.first)
+				break;
+
+			lyx::textclass_type const new_class = tc_pair.second;
+			if (old_class == new_class)
+				// nothing to do
+				break;
+
+			owner->message(_("Converting document to new document class..."));
+			ErrorList el;
+			lyx::cap::SwitchLayoutsBetweenClasses(
+				old_class, new_class,
+				buffer->paragraphs(), el);
+
+			bufferErrors(*buffer, el);
+			view()->showErrorList(_("Class switch"));
+			break;
+		}
 
-	sendDispatchMessage(getMessage(), func, verbose);
+		case LFUN_TEXTCLASS_LOAD:
+			loadTextclass(argument);
+			break;
+
+		case LFUN_LYXRC_APPLY: {
+			LyXRC const lyxrc_orig = lyxrc;
+
+			istringstream ss(argument);
+			bool const success = lyxrc.read(ss) == 0;
+
+			if (!success) {
+				lyxerr << "Warning in LFUN_LYXRC_APPLY!\n"
+				       << "Unable to read lyxrc data"
+				       << endl;
+				break;
+			}
+
+			actOnUpdatedPrefs(lyxrc_orig, lyxrc);
+			break;
+		}
+
+		default: {
+			view()->cursor().dispatch(cmd);
+			update |= view()->cursor().result().update();
+			if (!view()->cursor().result().dispatched()) {
+				update |= view()->dispatch(cmd);
+			}
+
+			break;
+		}
+		}
+
+		if (view()->available()) {
+			// Redraw screen unless explicitly told otherwise.
+			// This also initializes the position cache for all insets
+			// in (at least partially) visible top-level paragraphs.
+			view()->update(true, update);
+
+			// if we executed a mutating lfun, mark the buffer as dirty
+			if (getStatus(cmd).enabled()
+					&& !lyxaction.funcHasFlag(cmd.action, LyXAction::NoBuffer)
+					&& !lyxaction.funcHasFlag(cmd.action, LyXAction::ReadOnly))
+				view()->buffer()->markDirty();
+		}
+
+		if (view()->cursor().inTexted()) {
+			view()->owner()->updateLayoutChoice();
+		}
+	}
+	sendDispatchMessage(getMessage(), cmd);
 }
 
 
-void LyXFunc::sendDispatchMessage(string const & msg,
-				  FuncRequest const & func, bool verbose)
+void LyXFunc::sendDispatchMessage(string const & msg, FuncRequest const & cmd)
 {
 	owner->updateMenubar();
-	owner->updateToolbar();
+	owner->updateToolbars();
+
+	const bool verbose = (cmd.origin == FuncRequest::UI
+			      || cmd.origin == FuncRequest::COMMANDBUFFER);
 
-	if (func.action == LFUN_SELFINSERT || !verbose) {
+	if (cmd.action == LFUN_SELFINSERT || !verbose) {
 		lyxerr[Debug::ACTION] << "dispatch msg is " << msg << endl;
 		if (!msg.empty())
 			owner->message(msg);
@@ -1493,23 +1525,23 @@ void LyXFunc::sendDispatchMessage(string const & msg,
 	if (!dispatch_msg.empty())
 		dispatch_msg += ' ';
 
-	string comname = lyxaction.getActionName(func.action);
+	string comname = lyxaction.getActionName(cmd.action);
 
 	bool argsadded = false;
 
-	if (!func.argument.empty()) {
-		if (func.action != LFUN_UNKNOWN_ACTION) {
-			comname += ' ' + func.argument;
+	if (!cmd.argument.empty()) {
+		if (cmd.action != LFUN_UNKNOWN_ACTION) {
+			comname += ' ' + cmd.argument;
 			argsadded = true;
 		}
 	}
 
-	string const shortcuts = toplevel_keymap->findbinding(func);
+	string const shortcuts = toplevel_keymap->printbindings(cmd);
 
 	if (!shortcuts.empty()) {
 		comname += ": " + shortcuts;
-	} else if (!argsadded && !func.argument.empty()) {
-		comname += ' ' + func.argument;
+	} else if (!argsadded && !cmd.argument.empty()) {
+		comname += ' ' + cmd.argument;
 	}
 
 	if (!comname.empty()) {
@@ -1548,14 +1580,12 @@ void LyXFunc::menuNew(string const & name, bool fromTemplate)
 
 	if (filename.empty()) {
 		filename = AddName(lyxrc.document_path,
-			    "newfile" + tostr(++newfile_number) + ".lyx");
-		FileInfo fi(filename);
-		while (bufferlist.exists(filename) || fi.readable()) {
+			    "newfile" + convert<string>(++newfile_number) + ".lyx");
+		while (bufferlist.exists(filename) || fs::is_readable(filename)) {
 			++newfile_number;
 			filename = AddName(lyxrc.document_path,
-				    "newfile" +	tostr(newfile_number) +
+					   "newfile" +	convert<string>(newfile_number) +
 				    ".lyx");
-			fi.newFile(filename);
 		}
 	}
 
@@ -1604,7 +1634,7 @@ void LyXFunc::open(string const & fname)
 			make_pair(string(_("Documents|#o#O")),
 				  string(lyxrc.document_path)),
 			make_pair(string(_("Examples|#E#e")),
-				  string(AddPath(system_lyxdir(), "examples"))));
+				  string(AddPath(package().system_support(), "examples"))));
 
 		FileDialog::Result result =
 			fileDlg.open(initpath,
@@ -1634,8 +1664,7 @@ void LyXFunc::open(string const & fname)
 	string const disp_fn(MakeDisplayPath(filename));
 
 	// if the file doesn't exist, let the user create one
-	FileInfo const f(filename, true);
-	if (!f.exist()) {
+	if (!fs::exists(filename)) {
 		// the user specifically chose this name. Believe them.
 		view()->newFile(filename, "", true);
 		return;
@@ -1680,7 +1709,7 @@ void LyXFunc::doImport(string const & argument)
 			make_pair(string(_("Documents|#o#O")),
 				  string(lyxrc.document_path)),
 			make_pair(string(_("Examples|#E#e")),
-				  string(AddPath(system_lyxdir(), "examples"))));
+				  string(AddPath(package().system_support(), "examples"))));
 
 		string const filter = formats.prettyName(format)
 			+ " (*." + formats.extension(format) + ')';
@@ -1718,7 +1747,7 @@ void LyXFunc::doImport(string const & argument)
 
 	// if the file exists already, and we didn't do
 	// -i lyx thefile.lyx, warn
-	if (FileInfo(lyxfile, true).exist() && filename != lyxfile) {
+	if (fs::exists(lyxfile) && filename != lyxfile) {
 		string const file = MakeDisplayPath(lyxfile, 30);
 
 		string text = bformat(_("The document %1$s already exists.\n\n"
@@ -1745,7 +1774,7 @@ void LyXFunc::closeBuffer()
 			// since there's no current buffer
 			owner->getDialogs().hideBufferDependent();
 		} else {
-			view()->buffer(bufferlist.first());
+			view()->setBuffer(bufferlist.first());
 		}
 	}
 }
@@ -1754,7 +1783,7 @@ void LyXFunc::closeBuffer()
 // Each "owner" should have it's own message method. lyxview and
 // the minibuffer would use the minibuffer, but lyxserver would
 // send an ERROR signal to its client.  Alejandro 970603
-// This func is bit problematic when it comes to NLS, to make the
+// This function is bit problematic when it comes to NLS, to make the
 // lyx servers client be language indepenent we must not translate
 // strings sent to this func.
 void LyXFunc::setErrorMessage(string const & m) const
@@ -1770,29 +1799,21 @@ void LyXFunc::setMessage(string const & m) const
 }
 
 
-void LyXFunc::setStatusMessage(string const & m) const
-{
-	status_buffer = m;
-}
-
-
-string const LyXFunc::view_status_message()
+string const LyXFunc::viewStatusMessage()
 {
 	// When meta-fake key is pressed, show the key sequence so far + "M-".
-	if (wasMetaKey()) {
+	if (wasMetaKey())
 		return keyseq.print() + "M-";
-	}
 
 	// Else, when a non-complete key sequence is pressed,
 	// show the available options.
-	if (keyseq.length() > 0 && !keyseq.deleted()) {
+	if (keyseq.length() > 0 && !keyseq.deleted())
 		return keyseq.printOptions();
-	}
 
 	if (!view()->available())
 		return _("Welcome to LyX!");
 
-	return currentState(view());
+	return view()->cursor().currentState();
 }
 
 
@@ -1807,3 +1828,139 @@ bool LyXFunc::wasMetaKey() const
 {
 	return (meta_fake_bit != key_modifier::none);
 }
+
+
+namespace {
+
+void actOnUpdatedPrefs(LyXRC const & lyxrc_orig, LyXRC const & lyxrc_new)
+{
+	// Why the switch you might ask. It is a trick to ensure that all
+	// the elements in the LyXRCTags enum is handled. As you can see
+	// there are no breaks at all. So it is just a huge fall-through.
+	// The nice thing is that we will get a warning from the compiler
+	// if we forget an element.
+	LyXRC::LyXRCTags tag = LyXRC::RC_LAST;
+	switch (tag) {
+	case LyXRC::RC_ACCEPT_COMPOUND:
+	case LyXRC::RC_ALT_LANG:
+	case LyXRC::RC_ASCIIROFF_COMMAND:
+	case LyXRC::RC_ASCII_LINELEN:
+	case LyXRC::RC_AUTOREGIONDELETE:
+	case LyXRC::RC_AUTORESET_OPTIONS:
+	case LyXRC::RC_AUTOSAVE:
+	case LyXRC::RC_AUTO_NUMBER:
+	case LyXRC::RC_BACKUPDIR_PATH:
+	case LyXRC::RC_BIBTEX_COMMAND:
+	case LyXRC::RC_BINDFILE:
+	case LyXRC::RC_CHECKLASTFILES:
+	case LyXRC::RC_CHKTEX_COMMAND:
+	case LyXRC::RC_CONVERTER:
+	case LyXRC::RC_COPIER:
+	case LyXRC::RC_CURSOR_FOLLOWS_SCROLLBAR:
+	case LyXRC::RC_CUSTOM_EXPORT_COMMAND:
+	case LyXRC::RC_CUSTOM_EXPORT_FORMAT:
+	case LyXRC::RC_CYGWIN_PATH_FIX:
+		if (lyxrc_orig.cygwin_path_fix != lyxrc_new.cygwin_path_fix) {
+			namespace os = lyx::support::os;
+			os::cygwin_path_fix(lyxrc_new.cygwin_path_fix);
+		}
+	case LyXRC::RC_DATE_INSERT_FORMAT:
+	case LyXRC::RC_DEFAULT_LANGUAGE:
+	case LyXRC::RC_DEFAULT_PAPERSIZE:
+	case LyXRC::RC_DIALOGS_ICONIFY_WITH_MAIN:
+	case LyXRC::RC_DISPLAY_GRAPHICS:
+	case LyXRC::RC_DOCUMENTPATH:
+		if (lyxrc_orig.document_path != lyxrc_new.document_path) {
+			if (fs::exists(lyxrc_new.document_path) &&
+			    fs::is_directory(lyxrc_new.document_path)) {
+				using lyx::support::package;
+				package().document_dir() = lyxrc.document_path;
+			}
+		}
+	case LyXRC::RC_ESC_CHARS:
+	case LyXRC::RC_FONT_ENCODING:
+	case LyXRC::RC_FORMAT:
+	case LyXRC::RC_INDEX_COMMAND:
+	case LyXRC::RC_INPUT:
+	case LyXRC::RC_KBMAP:
+	case LyXRC::RC_KBMAP_PRIMARY:
+	case LyXRC::RC_KBMAP_SECONDARY:
+	case LyXRC::RC_LABEL_INIT_LENGTH:
+	case LyXRC::RC_LANGUAGE_AUTO_BEGIN:
+	case LyXRC::RC_LANGUAGE_AUTO_END:
+	case LyXRC::RC_LANGUAGE_COMMAND_BEGIN:
+	case LyXRC::RC_LANGUAGE_COMMAND_END:
+	case LyXRC::RC_LANGUAGE_COMMAND_LOCAL:
+	case LyXRC::RC_LANGUAGE_GLOBAL_OPTIONS:
+	case LyXRC::RC_LANGUAGE_PACKAGE:
+	case LyXRC::RC_LANGUAGE_USE_BABEL:
+	case LyXRC::RC_LASTFILES:
+	case LyXRC::RC_MAKE_BACKUP:
+	case LyXRC::RC_MARK_FOREIGN_LANGUAGE:
+	case LyXRC::RC_NUMLASTFILES:
+	case LyXRC::RC_PATH_PREFIX:
+		if (lyxrc_orig.path_prefix != lyxrc_new.path_prefix) {
+			using lyx::support::prependEnvPath;
+			prependEnvPath("PATH", lyxrc.path_prefix);
+		}
+	case LyXRC::RC_PERS_DICT:
+	case LyXRC::RC_POPUP_BOLD_FONT:
+	case LyXRC::RC_POPUP_FONT_ENCODING:
+	case LyXRC::RC_POPUP_NORMAL_FONT:
+	case LyXRC::RC_PREVIEW:
+	case LyXRC::RC_PREVIEW_HASHED_LABELS:
+	case LyXRC::RC_PREVIEW_SCALE_FACTOR:
+	case LyXRC::RC_PRINTCOLLCOPIESFLAG:
+	case LyXRC::RC_PRINTCOPIESFLAG:
+	case LyXRC::RC_PRINTER:
+	case LyXRC::RC_PRINTEVENPAGEFLAG:
+	case LyXRC::RC_PRINTEXSTRAOPTIONS:
+	case LyXRC::RC_PRINTFILEEXTENSION:
+	case LyXRC::RC_PRINTLANDSCAPEFLAG:
+	case LyXRC::RC_PRINTODDPAGEFLAG:
+	case LyXRC::RC_PRINTPAGERANGEFLAG:
+	case LyXRC::RC_PRINTPAPERDIMENSIONFLAG:
+	case LyXRC::RC_PRINTPAPERFLAG:
+	case LyXRC::RC_PRINTREVERSEFLAG:
+	case LyXRC::RC_PRINTSPOOL_COMMAND:
+	case LyXRC::RC_PRINTSPOOL_PRINTERPREFIX:
+	case LyXRC::RC_PRINTTOFILE:
+	case LyXRC::RC_PRINTTOPRINTER:
+	case LyXRC::RC_PRINT_ADAPTOUTPUT:
+	case LyXRC::RC_PRINT_COMMAND:
+	case LyXRC::RC_RTL_SUPPORT:
+	case LyXRC::RC_SCREEN_DPI:
+	case LyXRC::RC_SCREEN_FONT_ENCODING:
+	case LyXRC::RC_SCREEN_FONT_ROMAN:
+	case LyXRC::RC_SCREEN_FONT_ROMAN_FOUNDRY:
+	case LyXRC::RC_SCREEN_FONT_SANS:
+	case LyXRC::RC_SCREEN_FONT_SANS_FOUNDRY:
+	case LyXRC::RC_SCREEN_FONT_SCALABLE:
+	case LyXRC::RC_SCREEN_FONT_SIZES:
+	case LyXRC::RC_SCREEN_FONT_TYPEWRITER:
+	case LyXRC::RC_SCREEN_FONT_TYPEWRITER_FOUNDRY:
+	case LyXRC::RC_SCREEN_ZOOM:
+	case LyXRC::RC_SERVERPIPE:
+	case LyXRC::RC_SET_COLOR:
+	case LyXRC::RC_SHOW_BANNER:
+	case LyXRC::RC_SPELL_COMMAND:
+	case LyXRC::RC_TEMPDIRPATH:
+	case LyXRC::RC_TEMPLATEPATH:
+	case LyXRC::RC_UIFILE:
+	case LyXRC::RC_USER_EMAIL:
+	case LyXRC::RC_USER_NAME:
+	case LyXRC::RC_USETEMPDIR:
+	case LyXRC::RC_USE_ALT_LANG:
+	case LyXRC::RC_USE_ESC_CHARS:
+	case LyXRC::RC_USE_INP_ENC:
+	case LyXRC::RC_USE_PERS_DICT:
+	case LyXRC::RC_USE_SPELL_LIB:
+	case LyXRC::RC_VIEWDVI_PAPEROPTION:
+	case LyXRC::RC_VIEWER:
+	case LyXRC::RC_WHEEL_JUMP:
+	case LyXRC::RC_LAST:
+		break;
+	}
+}
+
+} // namespace anon