X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Flyxfunc.C;h=244a858dbca70488982b1fd23ae0c899a75d5db6;hb=de3c8e5b80effa940c92980032389c868f377d6b;hp=6d86ec4da276c64f4090270488325ca66e4b3740;hpb=1b3f5ee46ff2924c4b374f52ad6317b5fd7ac9a5;p=lyx.git

diff --git a/src/lyxfunc.C b/src/lyxfunc.C
index 6d86ec4da2..244a858dbc 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"
 
@@ -76,20 +82,21 @@
 #include "support/filetools.h"
 #include "support/forkedcontr.h"
 #include "support/globbing.h"
+#include "support/lstrings.h"
 #include "support/path.h"
 #include "support/path_defines.h"
+#include "support/systemcall.h"
 #include "support/tostr.h"
 #include "support/std_sstream.h"
 #include "support/os.h"
 
-using bv_funcs::DEC_DEPTH;
 using bv_funcs::freefont2string;
-using bv_funcs::INC_DEPTH;
 
 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;
@@ -101,11 +108,14 @@ using lyx::support::isStrInt;
 using lyx::support::MakeAbsPath;
 using lyx::support::MakeDisplayPath;
 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::subst;
 using lyx::support::system_lyxdir;
+using lyx::support::Systemcall;
 using lyx::support::token;
 using lyx::support::trim;
 using lyx::support::user_lyxdir;
@@ -257,13 +267,14 @@ void LyXFunc::processKeySym(LyXKeySymPtr keysym, key_modifier::state state)
 
 FuncStatus LyXFunc::getStatus(FuncRequest const & cmd) const
 {
+	//lyxerr << "LyXFunc::getStatus: cmd: " << cmd << endl;
 	FuncStatus flag;
 	Buffer * buf = owner->buffer();
 	LCursor & cur = view()->cursor();
 
 	if (cmd.action == LFUN_NOACTION) {
 		setStatusMessage(N_("Nothing to do"));
-		flag.disabled(true);
+		flag.enabled(false);
 		return flag;
 	}
 
@@ -273,7 +284,7 @@ FuncStatus LyXFunc::getStatus(FuncRequest const & cmd) const
 	case LFUN_THESAURUS_ENTRY:
 #endif
 		flag.unknown(true);
-		flag.disabled(true);
+		flag.enabled(false);
 		break;
 	default:
 		flag |= lyx_gui::getStatus(cmd);
@@ -288,201 +299,110 @@ FuncStatus LyXFunc::getStatus(FuncRequest const & cmd) const
 	setStatusMessage(N_("Command disabled"));
 
 	// Check whether we need a buffer
-	if (!lyxaction.funcHasFlag(cmd.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(cmd.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
+		setStatusMessage(N_("Command not allowed with"
+				    "out any document open"));
+		flag.enabled(false);
+		return flag;
 	}
 
 	// I would really like to avoid having this switch and rather try to
 	// encode this in the function itself.
-	bool disable = false;
+	// -- And I'd rather let an inset decide which LFUNs it is willing
+	// to handle (Andre')
+	bool enable = true;
 	switch (cmd.action) {
-	case LFUN_EXPORT:
-		disable = cmd.argument != "custom"
-			&& !Exporter::IsExportable(*buf, cmd.argument);
+	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:
-		disable = !cur.selection();
+		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 = !cur.innerInsetOfType(InsetBase::TABULAR_CODE);
-		break;
-
-	case LFUN_DEPTH_MIN:
-		disable = !changeDepthAllowed(cur, view()->getLyXText(), DEC_DEPTH);
-		break;
-
-	case LFUN_DEPTH_PLUS:
-		disable = !changeDepthAllowed(cur, view()->getLyXText(), INC_DEPTH);
+		enable = cur.innerInsetOfType(InsetBase::TABULAR_CODE);
 		break;
 
 	case LFUN_LAYOUT:
 	case LFUN_LAYOUT_PARAGRAPH:
-		disable = cur.inset().forceDefaultParagraphs(&cur.inset());
-		break;
-
-	case LFUN_INSET_OPTARG:
-		disable = cur.inMathed()
-			|| cur.paragraph().layout()->optionalargs == 0;
-		break;
-
-	case LFUN_TABULAR_FEATURE:
-#if 0
-		if (cur.inMathed()) {
-			// FIXME: check temporarily disabled
-			// valign code
-			char align = mathcursor::valign();
-			if (align == '\0') {
-				disable = true;
-				break;
-			}
-			if (cmd.argument.empty()) {
-				flag.clear();
-				break;
-			}
-			if (!contains("tcb", cmd.argument[0])) {
-				disable = true;
-				break;
-			}
-			flag.setOnOff(cmd.argument[0] == align);
-		} else {
-			disable = true;
-
-			char const align = mathcursor::halign();
-			if (align == '\0') {
-				disable = true;
-				break;
-			}
-			if (cmd.argument.empty()) {
-				flag.clear();
-				break;
-			}
-			if (!contains("lcr", cmd.argument[0])) {
-				disable = true;
-				break;
-			}
-			flag.setOnOff(cmd.argument[0] == align);
-
-			disable = !mathcursor::halign();
-			break;
-		}
-
-		if (!cur.empty() && cur.inset().asUpdatableInset()) {
-			FuncStatus ret;
-			//ret.disabled(true);
-			InsetTabular * tab = static_cast<InsetTabular *>
-				(cur.innerInsetOfType(InsetBase::TABULAR_CODE));
-			if (tab) {
-				ret = tab->getStatus(cmd.argument);
-				flag |= ret;
-				disable = false;
-			} else {
-				disable = true;
-			}
-		} else {
-			static InsetTabular inset(*buf, 1, 1);
-			disable = true;
-			FuncStatus ret = inset.getStatus(cmd.argument);
-			if (ret.onoff(true) || ret.onoff(false))
-				flag.setOnOff(false);
-		}
-#endif
+		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(cmd.argument));
+		enable = !buf->isUnnamed() && !buf->isClean();
 		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;
-		break;
 
 	case LFUN_INSET_SETTINGS: {
-		disable = true;
+		enable = false;
+		if (!cur.size())
+			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();
 		switch (code) {
 			case InsetOld::TABULAR_CODE:
-				disable = cmd.argument != "tabular";
+				enable = cmd.argument == "tabular";
 				break;
 			case InsetOld::ERT_CODE:
-				disable = cmd.argument != "ert";
+				enable = cmd.argument == "ert";
 				break;
 			case InsetOld::FLOAT_CODE:
-				disable = cmd.argument != "float";
+				enable = cmd.argument == "float";
 				break;
 			case InsetOld::WRAP_CODE:
-				disable = cmd.argument != "wrap";
+				enable = cmd.argument == "wrap";
 				break;
 			case InsetOld::NOTE_CODE:
-				disable = cmd.argument != "note";
+				enable = cmd.argument == "note";
 				break;
 			case InsetOld::BRANCH_CODE:
-				disable = cmd.argument != "branch";
+				enable = cmd.argument == "branch";
 				break;
 			case InsetOld::BOX_CODE:
-				disable = cmd.argument != "box";
+				enable = cmd.argument == "box";
 				break;
 			default:
 				break;
@@ -490,293 +410,109 @@ FuncStatus LyXFunc::getStatus(FuncRequest const & cmd) const
 		break;
 	}
 
-	case LFUN_MATH_MUTATE:
-		if (cur.inMathed())
-			//flag.setOnOff(mathcursor::formula()->hullType() == cmd.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 = cur.inTexted();
-		break;
-
 	case LFUN_DIALOG_SHOW: {
 		string const name = cmd.getArg(0);
 		if (!buf)
-			disable = !(name == "aboutlyx" ||
-				    name == "file" ||
-				    name == "forks" ||
-				    name == "preferences" ||
-				    name == "texinfo");
+			enable = name == "aboutlyx"
+				|| name == "file"
+				|| name == "forks"
+				|| name == "prefs"
+				|| name == "texinfo";
 		else if (name == "print")
-			disable = !Exporter::IsExportable(*buf, "dvi") ||
-				lyxrc.print_command == "none";
+			enable = Exporter::IsExportable(*buf, "dvi")
+				&& lyxrc.print_command != "none";
 		else if (name == "character")
-			disable = cur.inset().lyxCode() == InsetOld::ERT_CODE;
+			enable = cur.inset().lyxCode() != InsetOld::ERT_CODE;
 		else if (name == "vclog")
-			disable = !buf->lyxvc().inUse();
+			enable = buf->lyxvc().inUse();
 		else if (name == "latexlog")
-			disable = !IsFileReadable(buf->getLogName().second);
+			enable = IsFileReadable(buf->getLogName().second);
 		break;
 	}
 
-	default:
+	case LFUN_DIALOG_UPDATE: {
+		string const name = cmd.getArg(0);
+		if (!buf)
+			enable = name == "prefs";
 		break;
 	}
 
-	// the functions which insert insets
-	InsetOld::Code code = InsetOld::NO_CODE;
-	switch (cmd.action) {
+	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_GOTO_PARAGRAPH:
 	case LFUN_DIALOG_SHOW_NEW_INSET:
-		if (cmd.argument == "bibitem")
-			code = InsetOld::BIBITEM_CODE;
-		else if (cmd.argument == "bibtex")
-			code = InsetOld::BIBTEX_CODE;
-		else if (cmd.argument == "box")
-			code = InsetOld::BOX_CODE;
-		else if (cmd.argument == "branch")
-			code = InsetOld::BRANCH_CODE;
-		else if (cmd.argument == "citation")
-			code = InsetOld::CITE_CODE;
-		else if (cmd.argument == "ert")
-			code = InsetOld::ERT_CODE;
-		else if (cmd.argument == "external")
-			code = InsetOld::EXTERNAL_CODE;
-		else if (cmd.argument == "float")
-			code = InsetOld::FLOAT_CODE;
-		else if (cmd.argument == "graphics")
-			code = InsetOld::GRAPHICS_CODE;
-		else if (cmd.argument == "include")
-			code = InsetOld::INCLUDE_CODE;
-		else if (cmd.argument == "index")
-			code = InsetOld::INDEX_CODE;
-		else if (cmd.argument == "label")
-			code = InsetOld::LABEL_CODE;
-		else if (cmd.argument == "note")
-			code = InsetOld::NOTE_CODE;
-		else if (cmd.argument == "ref")
-			code = InsetOld::REF_CODE;
-		else if (cmd.argument == "toc")
-			code = InsetOld::TOC_CODE;
-		else if (cmd.argument == "url")
-			code = InsetOld::URL_CODE;
-		else if (cmd.argument == "vspace")
-			code = InsetOld::VSPACE_CODE;
-		else if (cmd.argument == "wrap")
-			code = InsetOld::WRAP_CODE;
+	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_SEQUENCE:
+	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:
+		// these are handled in our dispatch()
 		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 (cur.inTexted())
-			code = InsetOld::SPACE_CODE;
-		break;
-	case LFUN_INSET_DIALOG_SHOW: {
-		InsetBase * inset = cur.nextInset();
-		disable = !inset;
-		if (inset) {
-			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:
-		break;
-	}
-
-	if (code != InsetOld::NO_CODE
-			&& (cur.empty() || !cur.inset().insetAllowed(code)))
-		disable = true;
 
-	if (disable)
-		flag.disabled(true);
-
-	// A few general toggles
-	switch (cmd.action) {
-	case LFUN_TOOLTIPS_TOGGLE:
-		flag.setOnOff(owner->getDialogs().tooltipsEnabled());
-		break;
-
-	case LFUN_READ_ONLY_TOGGLE:
-		flag.setOnOff(buf->isReadonly());
-		break;
-	case LFUN_APPENDIX:
-		flag.setOnOff(cur.inTexted()
-			&& cur.paragraph().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 (cmd.argument == buf->fileName())
-			flag.setOnOff(true);
-		break;
-	case LFUN_TRACK_CHANGES:
-		flag.setOnOff(buf->params().tracking_changes);
-		break;
-	default:
-		break;
+		cur.getStatus(cmd, flag);
+		if (!flag.enabled())
+			flag = view()->getStatus(cmd);
 	}
 
-#ifdef LOCK
-	// the font related toggles
-	if (cur.inTexted()) {
-		LyXFont const & font = cur.text()->real_current_font;
-		switch (cmd.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 (cmd.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;
-		}
-	}
-#endif
+	if (!enable)
+		flag.enabled(false);
 
-	// this one is difficult to get right. As a half-baked
-	// solution, we consider only the first action of the sequence
-	if (cmd.action == LFUN_SEQUENCE) {
-		// argument contains ';'-terminated commands
-#warning LyXAction arguments not handled here.
-		flag = getStatus(FuncRequest(
-			lyxaction.lookupFunc(token(cmd.argument, ';', 0))));
+	// Can we use a readonly buffer?
+	if (buf && buf->isReadonly()
+	    && !lyxaction.funcHasFlag(cmd.action, LyXAction::ReadOnly)
+	    && !lyxaction.funcHasFlag(cmd.action, LyXAction::NoBuffer)) {
+		setStatusMessage(N_("Document is read-only"));
+		flag.enabled(false);
 	}
 
+	//lyxerr << "LyXFunc::getStatus: got: " << flag.enabled() << endl;
 	return flag;
 }
 
@@ -803,13 +539,45 @@ 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);
+	}
+}
+
 } //namespace anon
 
 
 void LyXFunc::dispatch(FuncRequest const & cmd, bool verbose)
 {
-	string argument = cmd.argument;
-	kb_action action = cmd.action;
+	string const argument = cmd.argument;
+	kb_action const action = cmd.action;
 
 	lyxerr[Debug::ACTION] << "LyXFunc::dispatch: cmd: " << cmd << endl;
 	//lyxerr << "LyXFunc::dispatch: cmd: " << cmd << endl;
@@ -819,8 +587,10 @@ void LyXFunc::dispatch(FuncRequest const & cmd, bool verbose)
 	dispatch_buffer.erase();
 	selection_possible = false;
 
+	bool update = true;
+
 	// We cannot use this function here
-	if (getStatus(cmd).disabled()) {
+	if (!getStatus(cmd).enabled()) {
 		lyxerr[Debug::ACTION] << "LyXFunc::dispatch: "
 		       << lyxaction.getActionName(action)
 		       << " [" << action << "] is disabled at this location"
@@ -842,8 +612,9 @@ void LyXFunc::dispatch(FuncRequest const & cmd, bool verbose)
 			if (!argument.empty()) {
 				last_search = argument;
 				searched_string = argument;
-			} else
+			} else {
 				searched_string = last_search;
+			}
 
 			if (searched_string.empty())
 				break;
@@ -851,7 +622,7 @@ void LyXFunc::dispatch(FuncRequest const & cmd, bool verbose)
 			bool const fw = action == LFUN_WORDFINDFORWARD;
 			string const data =
 				lyx::find::find2string(searched_string, true, false, fw);
-			view()->dispatch(FuncRequest(LFUN_WORD_FIND, data));
+			lyx::find::find(view(), FuncRequest(LFUN_WORD_FIND, data));
 			break;
 		}
 
@@ -860,6 +631,7 @@ void LyXFunc::dispatch(FuncRequest const & cmd, bool verbose)
 			break;
 
 		case LFUN_EXEC_COMMAND:
+			owner->getToolbar().display("minibuffer", true);
 			owner->focus_command_buffer();
 			break;
 
@@ -947,13 +719,147 @@ void LyXFunc::dispatch(FuncRequest const & cmd, 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;
@@ -1133,18 +1039,6 @@ void LyXFunc::dispatch(FuncRequest const & cmd, bool verbose)
 				if (!data.empty())
 					owner->getDialogs().show("character", data);
 			}
-			else if (name == "document")
-				owner->getDialogs().showDocument();
-			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 =
@@ -1223,13 +1117,6 @@ void LyXFunc::dispatch(FuncRequest const & cmd, bool verbose)
 		case LFUN_DIALOG_SHOW_NEXT_INSET:
 			break;
 
-		case LFUN_INSET_DIALOG_SHOW: {
-			InsetBase * inset = view()->cursor().nextInset();
-			if (inset)
-				inset->dispatch(view()->cursor(), FuncRequest(LFUN_INSET_DIALOG_SHOW));
-			break;
-		}
-
 		case LFUN_DIALOG_UPDATE: {
 			string const & name = argument;
 			// Can only update a dialog connected to an existing inset
@@ -1239,6 +1126,8 @@ void LyXFunc::dispatch(FuncRequest const & cmd, bool verbose)
 				inset->dispatch(view()->cursor(), fr);
 			} else if (name == "paragraph") {
 				dispatch(FuncRequest(LFUN_PARAGRAPH_UPDATE));
+			} else if (name == "prefs") {
+				owner->getDialogs().update(name, string());
 			}
 			break;
 		}
@@ -1292,13 +1181,13 @@ void LyXFunc::dispatch(FuncRequest const & cmd, 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;
 		}
 
@@ -1306,14 +1195,14 @@ void LyXFunc::dispatch(FuncRequest const & cmd, bool verbose)
 			// argument contains ';'-terminated commands
 			while (!argument.empty()) {
 				string first;
-				argument = split(argument, first, ';');
-				dispatch(lyxaction.lookupFunc(first));
+				string rest = split(argument, first, ';');
+				dispatch(lyxaction.lookupFunc(rest));
 			}
 			break;
 
 		case LFUN_SAVEPREFERENCES: {
 			Path p(user_lyxdir());
-			lyxrc.write("preferences");
+			lyxrc.write("preferences", false);
 			break;
 		}
 
@@ -1338,8 +1227,7 @@ void LyXFunc::dispatch(FuncRequest const & cmd, 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 "
@@ -1364,43 +1252,146 @@ void LyXFunc::dispatch(FuncRequest const & cmd, 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(view()->cursor(), FuncRequest(action, argument));
+		case LFUN_EXTERNAL_EDIT: {
+			FuncRequest fr(action, argument);
+			InsetExternal().dispatch(view()->cursor(), fr);
+			break;
+		}
+
+		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;
 
-		default:
+			if (oldL->RightToLeft() == newL->RightToLeft()
+			    && !buffer.isMultiLingual())
+				buffer.changeLanguage(oldL, newL);
+			else
+				buffer.updateDocLang(newL);
+			break;
+		}
+
+		case LFUN_BUFFERPARAMS_APPLY: {
+			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;
+			}
+			break;
+		}
+
+		case LFUN_TEXTCLASS_APPLY: {
+			Buffer * buffer = owner->buffer();
+
+			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;
+		}
+
+		case LFUN_TEXTCLASS_LOAD:
+			loadTextclass(argument);
+			break;
+
+		case LFUN_LYXRC_APPLY: {
+			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;
+		}
+
+		default: {
+			update = false;
 			DispatchResult res = view()->cursor().dispatch(cmd);
-			if (!res.dispatched());
-				view()->dispatch(cmd);
+			if (res.dispatched())
+				update |= res.update();
+			else
+				update |= view()->dispatch(cmd);
+
 			break;
 		}
-	}
+		}
 
-	if (view()->cursor().inTexted())
-		view()->owner()->updateLayoutChoice();
+		if (view()->available()) {
+			if (view()->fitCursor() || update)
+				view()->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()->available()) {
-		view()->fitCursor();
-		view()->update();
-		view()->cursor().updatePos();
-		// if we executed a mutating lfun, mark the buffer as dirty
-		if (!getStatus(cmd).disabled()
-		    && !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, verbose);
+		}
 	}
-
-	if (view()->cursor().inTexted())
-		sendDispatchMessage(getMessage(), cmd, verbose);
 }