X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Flyxfunc.C;h=4570bfba8f511ab85c6e4ac5f501e9d105ff67ce;hb=969ab85d985485f503790cb13f98a582d4e1cdb5;hp=a3cb9723871bfd435516b06a09bc671044b6aac7;hpb=fb1ffecd0c3b07939dcb8af50af71ef3ba0b1d02;p=lyx.git

diff --git a/src/lyxfunc.C b/src/lyxfunc.C
index a3cb972387..4570bfba8f 100644
--- a/src/lyxfunc.C
+++ b/src/lyxfunc.C
@@ -27,6 +27,7 @@
 #include "bufferlist.h"
 #include "bufferparams.h"
 #include "BufferView.h"
+#include "bufferview_funcs.h"
 #include "cursor.h"
 #include "CutAndPaste.h"
 #include "debug.h"
@@ -78,6 +79,7 @@
 #include "frontends/Dialogs.h"
 #include "frontends/FileDialog.h"
 #include "frontends/FontLoader.h"
+#include "frontends/Gui.h"
 #include "frontends/LyXKeySym.h"
 #include "frontends/LyXView.h"
 #include "frontends/Menubar.h"
@@ -100,34 +102,36 @@
 
 #include <sstream>
 
+
+namespace lyx {
+
 using bv_funcs::freefont2string;
 
-using lyx::docstring;
-
-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::fileSearch;
-using lyx::support::ForkedcallsController;
-using lyx::support::i18nLibFileSearch;
-using lyx::support::isDirWriteable;
-using lyx::support::isFileReadable;
-using lyx::support::isStrInt;
-using lyx::support::makeAbsPath;
-using lyx::support::makeDisplayPath;
-using lyx::support::package;
-using lyx::support::quoteName;
-using lyx::support::rtrim;
-using lyx::support::split;
-using lyx::support::subst;
-using lyx::support::Systemcall;
-using lyx::support::token;
-using lyx::support::trim;
-using lyx::support::prefixIs;
+using support::absolutePath;
+using support::addName;
+using support::addPath;
+using support::bformat;
+using support::changeExtension;
+using support::contains;
+using support::FileFilterList;
+using support::FileName;
+using support::fileSearch;
+using support::ForkedcallsController;
+using support::i18nLibFileSearch;
+using support::isDirWriteable;
+using support::isFileReadable;
+using support::isStrInt;
+using support::makeAbsPath;
+using support::makeDisplayPath;
+using support::package;
+using support::quoteName;
+using support::rtrim;
+using support::split;
+using support::subst;
+using support::Systemcall;
+using support::token;
+using support::trim;
+using support::prefixIs;
 
 using std::endl;
 using std::make_pair;
@@ -136,20 +140,17 @@ using std::string;
 using std::istringstream;
 using std::ostringstream;
 
-namespace Alert = lyx::frontend::Alert;
-namespace biblio = lyx::biblio;
+namespace Alert = frontend::Alert;
 namespace fs = boost::filesystem;
 
 
-extern boost::scoped_ptr<kb_keymap> toplevel_keymap;
-
 // (alkis)
 extern tex_accent_struct get_accent(kb_action action);
 
 
 namespace {
 
-bool getStatus(LCursor cursor,
+bool getLocalStatus(LCursor cursor,
 	       FuncRequest const & cmd, FuncStatus & status)
 {
 	// Try to fix cursor in case it is broken.
@@ -202,40 +203,81 @@ Change::Type lookupChangeType(DocIterator const & dit, bool outer = false)
 
 }
 
-LyXFunc::LyXFunc(LyXView * lv)
-	: owner(lv),
+LyXFunc::LyXFunc()
+	: lyx_view_(0),
 	encoded_last_key(0),
-	keyseq(toplevel_keymap.get(), toplevel_keymap.get()),
-	cancel_meta_seq(toplevel_keymap.get(), toplevel_keymap.get()),
 	meta_fake_bit(key_modifier::none)
 {
 }
 
 
+void LyXFunc::initKeySequences(kb_keymap * kb)
+{
+	keyseq.reset(new kb_sequence(kb, kb));
+	cancel_meta_seq.reset(new kb_sequence(kb, kb));
+}
+
+
 void LyXFunc::setLyXView(LyXView * lv)
 {
-	owner = lv;
+	lyx_view_ = lv;
 }
 
+
 void LyXFunc::handleKeyFunc(kb_action action)
 {
-	char c = encoded_last_key;
+	char_type c = encoded_last_key;
 
-	if (keyseq.length()) {
+	if (keyseq->length())
 		c = 0;
-	}
 
-	owner->view()->getIntl().getTransManager()
-		.deadkey(c, get_accent(action).accent, view()->getLyXText());
+	lyx_view_->view()->getIntl().getTransManager().deadkey(
+		c, get_accent(action).accent, view()->getLyXText(), view()->cursor());
 	// Need to clear, in case the minibuffer calls these
 	// actions
-	keyseq.clear();
+	keyseq->clear();
 	// copied verbatim from do_accent_char
 	view()->cursor().resetAnchor();
 	view()->update();
 }
 
 
+void LyXFunc::gotoBookmark(unsigned int idx, bool openFile, bool switchToBuffer)
+{
+	BOOST_ASSERT(lyx_view_);
+	if (!LyX::ref().session().bookmarks().isValid(idx))
+		return;
+	BookmarksSection::Bookmark const & bm = LyX::ref().session().bookmarks().bookmark(idx);
+	BOOST_ASSERT(!bm.filename.empty());
+	string const file = bm.filename.absFilename();
+	// if the file is not opened, open it.
+	if (!theBufferList().exists(file)) {
+		if (openFile)
+			dispatch(FuncRequest(LFUN_FILE_OPEN, file));
+		else
+			return;
+	}
+	// open may fail, so we need to test it again
+	if (theBufferList().exists(file)) {
+		// if the current buffer is not that one, switch to it.
+		if (lyx_view_->buffer()->fileName() != file) {
+			if (switchToBuffer)
+				dispatch(FuncRequest(LFUN_BUFFER_SWITCH, file));
+			else
+				return;
+		}
+		// moveToPosition use par_id, and par_pit and return new par_id.
+		pit_type new_pit;
+		int new_id;
+		boost::tie(new_pit, new_id) = view()->moveToPosition(bm.par_pit, bm.par_id, bm.par_pos);
+		// if par_id or pit has been changed, reset par_pit and par_id
+		// see http://bugzilla.lyx.org/show_bug.cgi?id=3092
+		if (bm.par_pit != new_pit || bm.par_id != new_id)
+			const_cast<BookmarksSection::Bookmark &>(bm).setPos(new_pit, new_id);
+	} 
+}
+
+
 void LyXFunc::processKeySym(LyXKeySymPtr keysym, key_modifier::state state)
 {
 	lyxerr[Debug::KEY] << "KeySym is " << keysym->getSymbolName() << endl;
@@ -252,16 +294,17 @@ void LyXFunc::processKeySym(LyXKeySymPtr keysym, key_modifier::state state)
 		return;
 	}
 
-	Encoding const * encoding = view()->cursor().getEncoding();
-
+	//Encoding const * encoding = view()->cursor().getEncoding();
 	//encoded_last_key = keysym->getISOEncoded(encoding ? encoding->name() : "");
-	size_t encoded_last_key = keysym->getUCSEncoded();
+	// FIXME: encoded_last_key shadows the member variable of the same
+	// name. Is that intended?
+	char_type encoded_last_key = keysym->getUCSEncoded();
 
 	// Do a one-deep top-level lookup for
 	// cancel and meta-fake keys. RVDK_PATCH_5
-	cancel_meta_seq.reset();
+	cancel_meta_seq->reset();
 
-	FuncRequest func = cancel_meta_seq.addkey(keysym, state);
+	FuncRequest func = cancel_meta_seq->addkey(keysym, state);
 	lyxerr[Debug::KEY] << BOOST_CURRENT_FUNCTION
 			   << " action first set to [" << func.action << ']'
 			   << endl;
@@ -271,7 +314,7 @@ void LyXFunc::processKeySym(LyXKeySymPtr keysym, key_modifier::state state)
 	// Mostly, meta_fake_bit = key_modifier::none. RVDK_PATCH_5.
 	if ((func.action != LFUN_CANCEL) && (func.action != LFUN_META_PREFIX)) {
 		// remove Caps Lock and Mod2 as a modifiers
-		func = keyseq.addkey(keysym, (state | meta_fake_bit));
+		func = keyseq->addkey(keysym, (state | meta_fake_bit));
 		lyxerr[Debug::KEY] << BOOST_CURRENT_FUNCTION
 				   << "action now set to ["
 				   << func.action << ']' << endl;
@@ -289,7 +332,7 @@ void LyXFunc::processKeySym(LyXKeySymPtr keysym, key_modifier::state state)
 		lyxerr << BOOST_CURRENT_FUNCTION
 		       << " Key [action="
 		       << func.action << "]["
-		       << keyseq.print() << ']'
+		       << to_utf8(keyseq->print(false)) << ']'
 		       << endl;
 	}
 
@@ -297,8 +340,8 @@ void LyXFunc::processKeySym(LyXKeySymPtr keysym, key_modifier::state state)
 	// why not return already here if action == -1 and
 	// num_bytes == 0? (Lgb)
 
-	if (keyseq.length() > 1) {
-		owner->message(lyx::from_utf8(keyseq.print()));
+	if (keyseq->length() > 1) {
+		lyx_view_->message(keyseq->print(true));
 	}
 
 
@@ -307,7 +350,7 @@ void LyXFunc::processKeySym(LyXKeySymPtr keysym, key_modifier::state state)
 	if (func.action == LFUN_UNKNOWN_ACTION &&
 	    state == key_modifier::shift) {
 		lyxerr[Debug::KEY] << "Trying without shift" << endl;
-		func = keyseq.addkey(keysym, key_modifier::none);
+		func = keyseq->addkey(keysym, key_modifier::none);
 		lyxerr[Debug::KEY] << "Action now " << func.action << endl;
 	}
 
@@ -315,13 +358,13 @@ void LyXFunc::processKeySym(LyXKeySymPtr keysym, key_modifier::state state)
 		// Hmm, we didn't match any of the keysequences. See
 		// if it's normal insertable text not already covered
 		// by a binding
-		if (keysym->isText() && keyseq.length() == 1) {
+		if (keysym->isText() && keyseq->length() == 1) {
 			lyxerr[Debug::KEY] << "isText() is true, inserting." << endl;
 			func = FuncRequest(LFUN_SELF_INSERT,
 					   FuncRequest::KEYBOARD);
 		} else {
 			lyxerr[Debug::KEY] << "Unknown, !isText() - giving up" << endl;
-			owner->message(_("Unknown function."));
+			lyx_view_->message(_("Unknown function."));
 			return;
 		}
 	}
@@ -332,7 +375,7 @@ void LyXFunc::processKeySym(LyXKeySymPtr keysym, key_modifier::state state)
 			dispatch(FuncRequest(LFUN_SELF_INSERT, arg,
 					     FuncRequest::KEYBOARD));
 			lyxerr[Debug::KEY]
-				<< "SelfInsert arg[`" << lyx::to_utf8(arg) << "']" << endl;
+				<< "SelfInsert arg[`" << to_utf8(arg) << "']" << endl;
 		}
 	} else {
 		dispatch(func);
@@ -344,6 +387,7 @@ FuncStatus LyXFunc::getStatus(FuncRequest const & cmd) const
 {
 	//lyxerr << "LyXFunc::getStatus: cmd: " << cmd << endl;
 	FuncStatus flag;
+
 	LCursor & cur = view()->cursor();
 
 	/* In LyX/Mac, when a dialog is open, the menus of the
@@ -354,14 +398,12 @@ FuncStatus LyXFunc::getStatus(FuncRequest const & cmd) const
 	   Note that this code is not perfect, as bug 1941 attests:
 	   http://bugzilla.lyx.org/show_bug.cgi?id=1941#c4
 	*/
-	Buffer * buf;
-	if (cmd.origin == FuncRequest::UI && !owner->hasFocus())
+	Buffer * buf = lyx_view_? lyx_view_->buffer() : 0;
+	if (lyx_view_ && cmd.origin == FuncRequest::MENU && !lyx_view_->hasFocus())
 		buf = 0;
-	else
-		buf = owner->buffer();
 
 	if (cmd.action == LFUN_NOACTION) {
-		flag.message(lyx::from_utf8(N_("Nothing to do")));
+		flag.message(from_utf8(N_("Nothing to do")));
 		flag.enabled(false);
 		return flag;
 	}
@@ -380,20 +422,20 @@ FuncStatus LyXFunc::getStatus(FuncRequest const & cmd) const
 	}
 
 	if (flag.unknown()) {
-		flag.message(lyx::from_utf8(N_("Unknown action")));
+		flag.message(from_utf8(N_("Unknown action")));
 		return flag;
 	}
 
 	if (!flag.enabled()) {
 		if (flag.message().empty())
-			flag.message(lyx::from_utf8(N_("Command disabled")));
+			flag.message(from_utf8(N_("Command disabled")));
 		return flag;
 	}
 
 	// Check whether we need a buffer
 	if (!lyxaction.funcHasFlag(cmd.action, LyXAction::NoBuffer) && !buf) {
 		// no, exit directly
-		flag.message(lyx::from_utf8(N_("Command not allowed with"
+		flag.message(from_utf8(N_("Command not allowed with"
 				    "out any document open")));
 		flag.enabled(false);
 		return flag;
@@ -412,13 +454,13 @@ FuncStatus LyXFunc::getStatus(FuncRequest const & cmd) const
 	case LFUN_BUFFER_SWITCH:
 		// toggle on the current buffer, but do not toggle off
 		// the other ones (is that a good idea?)
-		if (lyx::to_utf8(cmd.argument()) == buf->fileName())
+		if (to_utf8(cmd.argument()) == buf->fileName())
 			flag.setOnOff(true);
 		break;
 
 	case LFUN_BUFFER_EXPORT:
 		enable = cmd.argument() == "custom"
-			|| Exporter::isExportable(*buf, lyx::to_utf8(cmd.argument()));
+			|| Exporter::isExportable(*buf, to_utf8(cmd.argument()));
 		break;
 
 	case LFUN_BUFFER_CHKTEX:
@@ -490,13 +532,14 @@ FuncStatus LyXFunc::getStatus(FuncRequest const & cmd) const
 
 	case LFUN_INSET_APPLY: {
 		string const name = cmd.getArg(0);
-		InsetBase * inset = owner->getDialogs().getOpenInset(name);
+		InsetBase * inset = lyx_view_->getDialogs().getOpenInset(name);
 		if (inset) {
 			FuncRequest fr(LFUN_INSET_MODIFY, cmd.argument());
 			FuncStatus fs;
-			bool const success = inset->getStatus(cur, fr, fs);
-			// Every inset is supposed to handle this
-			BOOST_ASSERT(success);
+			if (!inset->getStatus(cur, fr, fs)) {
+				// Every inset is supposed to handle this
+				BOOST_ASSERT(false);
+			}
 			flag |= fs;
 		} else {
 			FuncRequest fr(LFUN_INSET_INSERT, cmd.argument());
@@ -520,7 +563,7 @@ FuncStatus LyXFunc::getStatus(FuncRequest const & cmd) const
 		else if (name == "character" || name == "mathpanel")
 			enable = cur.inset().lyxCode() != InsetBase::ERT_CODE;
 		else if (name == "latexlog")
-			enable = isFileReadable(buf->getLogName().second);
+			enable = isFileReadable(FileName(buf->getLogName().second));
 #if !defined (USE_ASPELL) && !defined (USE_ISPELL) && !defined (USE_PSPELL)
 		else if (name == "spellchecker")
 			enable = false;
@@ -534,6 +577,11 @@ FuncStatus LyXFunc::getStatus(FuncRequest const & cmd) const
 
 	case LFUN_DIALOG_SHOW_NEW_INSET:
 		enable = cur.inset().lyxCode() != InsetBase::ERT_CODE;
+		if (cur.inset().lyxCode() == InsetBase::CAPTION_CODE) {
+			FuncStatus flag;
+			if (cur.inset().getStatus(cur, cmd, flag))
+				return flag;
+		}
 		break;
 
 	case LFUN_DIALOG_UPDATE: {
@@ -555,11 +603,28 @@ FuncStatus LyXFunc::getStatus(FuncRequest const & cmd) const
 		break;
 	}
 
+	case LFUN_BOOKMARK_GOTO: {
+		const unsigned int num = convert<unsigned int>(to_utf8(cmd.argument()));
+		enable = LyX::ref().session().bookmarks().isValid(num);
+		break;
+	}
+
+	case LFUN_BOOKMARK_CLEAR:
+		enable = LyX::ref().session().bookmarks().size() > 0;
+		break;
+
+	case LFUN_TOOLBAR_TOGGLE_STATE: {
+		ToolbarBackend::Flags flags = lyx_view_->getToolbarState(to_utf8(cmd.argument()));
+		if (!(flags & ToolbarBackend::AUTO))
+			flag.setOnOff(flags & ToolbarBackend::ON);
+		break;
+	}
+
 	// this one is difficult to get right. As a half-baked
 	// solution, we consider only the first action of the sequence
 	case LFUN_COMMAND_SEQUENCE: {
 		// argument contains ';'-terminated commands
-		string const firstcmd = token(lyx::to_utf8(cmd.argument()), ';', 0);
+		string const firstcmd = token(to_utf8(cmd.argument()), ';', 0);
 		FuncRequest func(lyxaction.lookupFunc(firstcmd));
 		func.origin = cmd.origin;
 		flag = getStatus(func);
@@ -578,7 +643,6 @@ FuncStatus LyXFunc::getStatus(FuncRequest const & cmd) const
 	case LFUN_BUFFER_UPDATE:
 	case LFUN_BUFFER_VIEW:
 	case LFUN_BUFFER_IMPORT:
-	case LFUN_LYX_QUIT:
 	case LFUN_TOC_VIEW:
 	case LFUN_BUFFER_AUTO_SAVE:
 	case LFUN_RECONFIGURE:
@@ -616,12 +680,14 @@ FuncStatus LyXFunc::getStatus(FuncRequest const & cmd) const
 	case LFUN_LYXRC_APPLY:
 	case LFUN_BUFFER_NEXT:
 	case LFUN_BUFFER_PREVIOUS:
+	case LFUN_WINDOW_NEW:
+	case LFUN_WINDOW_CLOSE:
+	case LFUN_LYX_QUIT:
 		// these are handled in our dispatch()
 		break;
 
 	default:
-
-		if (!::getStatus(cur, cmd, flag))
+		if (!getLocalStatus(cur, cmd, flag))
 			flag = view()->getStatus(cmd);
 	}
 
@@ -632,7 +698,7 @@ FuncStatus LyXFunc::getStatus(FuncRequest const & cmd) const
 	if (buf && buf->isReadonly()
 	    && !lyxaction.funcHasFlag(cmd.action, LyXAction::ReadOnly)
 	    && !lyxaction.funcHasFlag(cmd.action, LyXAction::NoBuffer)) {
-		flag.message(lyx::from_utf8(N_("Document is read-only")));
+		flag.message(from_utf8(N_("Document is read-only")));
 		flag.enabled(false);
 	}
 
@@ -640,13 +706,13 @@ FuncStatus LyXFunc::getStatus(FuncRequest const & cmd) const
 	if (buf && lookupChangeType(cur, true) == Change::DELETED
 	    && !lyxaction.funcHasFlag(cmd.action, LyXAction::ReadOnly)
 	    && !lyxaction.funcHasFlag(cmd.action, LyXAction::NoBuffer)) {
-		flag.message(lyx::from_utf8(N_("This portion of the document is deleted.")));
+		flag.message(from_utf8(N_("This portion of the document is deleted.")));
 		flag.enabled(false);
 	}
 
 	// the default error message if we disable the command
 	if (!flag.enabled() && flag.message().empty())
-		flag.message(lyx::from_utf8(N_("Command disabled")));
+		flag.message(from_utf8(N_("Command disabled")));
 
 	return flag;
 }
@@ -686,7 +752,7 @@ void showPrintError(string const & name)
 
 void loadTextclass(string const & name)
 {
-	std::pair<bool, lyx::textclass_type> const tc_pair =
+	std::pair<bool, textclass_type> const tc_pair =
 		textclasslist.numberOfClass(name);
 
 	if (!tc_pair.first) {
@@ -696,12 +762,12 @@ void loadTextclass(string const & name)
 		return;
 	}
 
-	lyx::textclass_type const tc = tc_pair.second;
+	textclass_type const tc = tc_pair.second;
 
 	if (!textclasslist[tc].load()) {
 		docstring s = bformat(_("The document could not be converted\n"
 						  "into the document class %1$s."),
-				   lyx::from_utf8(textclasslist[tc].name()));
+				   from_utf8(textclasslist[tc].name()));
 		Alert::error(_("Could not change class"), s);
 	}
 }
@@ -714,11 +780,10 @@ void actOnUpdatedPrefs(LyXRC const & lyxrc_orig, LyXRC const & lyxrc_new);
 
 void LyXFunc::dispatch(FuncRequest const & cmd)
 {
-	BOOST_ASSERT(view());
-	string const argument = lyx::to_utf8(cmd.argument());
+	string const argument = to_utf8(cmd.argument());
 	kb_action const action = cmd.action;
 
-	lyxerr[Debug::ACTION] << "LyXFunc::dispatch: cmd: " << cmd << endl;
+	lyxerr[Debug::ACTION] << endl << "LyXFunc::dispatch: cmd: " << cmd << endl;
 	//lyxerr << "LyXFunc::dispatch: cmd: " << cmd << endl;
 
 	// we have not done anything wrong yet.
@@ -727,9 +792,7 @@ void LyXFunc::dispatch(FuncRequest const & cmd)
 
 	// redraw the screen at the end (first of the two drawing steps).
 	//This is done unless explicitely requested otherwise
-	bool update = true;
-	// also do the second redrawing step. Only done if requested.
-	bool updateforce = false;
+	Update::flags updateFlags = Update::FitCursor;
 
 	FuncStatus const flag = getStatus(cmd);
 	if (!flag.enabled()) {
@@ -744,12 +807,13 @@ void LyXFunc::dispatch(FuncRequest const & cmd)
 
 		case LFUN_WORD_FIND_FORWARD:
 		case LFUN_WORD_FIND_BACKWARD: {
-			static string last_search;
-			string searched_string;
+			BOOST_ASSERT(lyx_view_ && lyx_view_->view());
+			static docstring last_search;
+			docstring searched_string;
 
-			if (!argument.empty()) {
-				last_search = argument;
-				searched_string = argument;
+			if (!cmd.argument().empty()) {
+				last_search = cmd.argument();
+				searched_string = cmd.argument();
 			} else {
 				searched_string = last_search;
 			}
@@ -758,23 +822,26 @@ void LyXFunc::dispatch(FuncRequest const & cmd)
 				break;
 
 			bool const fw = action == LFUN_WORD_FIND_FORWARD;
-			string const data =
-				lyx::find::find2string(searched_string, true, false, fw);
-			lyx::find::find(view(), FuncRequest(LFUN_WORD_FIND, data));
+			docstring const data =
+				find2string(searched_string, true, false, fw);
+			find(view(), FuncRequest(LFUN_WORD_FIND, data));
 			break;
 		}
 
 		case LFUN_COMMAND_PREFIX:
-			owner->message(lyx::from_utf8(keyseq.printOptions()));
+			BOOST_ASSERT(lyx_view_);
+			lyx_view_->message(keyseq->printOptions(true));
 			break;
 
 		case LFUN_COMMAND_EXECUTE:
-			owner->getToolbars().display("minibuffer", true);
-			owner->focus_command_buffer();
+			BOOST_ASSERT(lyx_view_);
+			lyx_view_->getToolbars().display("minibuffer", true);
+			lyx_view_->focus_command_buffer();
 			break;
 
 		case LFUN_CANCEL:
-			keyseq.reset();
+			BOOST_ASSERT(lyx_view_ && lyx_view_->view());
+			keyseq->reset();
 			meta_fake_bit = key_modifier::none;
 			if (view()->buffer())
 				// cancel any selection
@@ -784,15 +851,16 @@ void LyXFunc::dispatch(FuncRequest const & cmd)
 
 		case LFUN_META_PREFIX:
 			meta_fake_bit = key_modifier::alt;
-			setMessage(lyx::from_utf8(keyseq.print()));
+			setMessage(keyseq->print(true));
 			break;
 
 		case LFUN_BUFFER_TOGGLE_READ_ONLY:
-			if (owner->buffer()->lyxvc().inUse())
-				owner->buffer()->lyxvc().toggleReadOnly();
+			BOOST_ASSERT(lyx_view_ && lyx_view_->view() && lyx_view_->buffer());
+			if (lyx_view_->buffer()->lyxvc().inUse())
+				lyx_view_->buffer()->lyxvc().toggleReadOnly();
 			else
-				owner->buffer()->setReadonly(
-					!owner->buffer()->isReadonly());
+				lyx_view_->buffer()->setReadonly(
+					!lyx_view_->buffer()->isReadonly());
 			break;
 
 		// --- Menus -----------------------------------------------
@@ -806,26 +874,31 @@ void LyXFunc::dispatch(FuncRequest const & cmd)
 
 		case LFUN_BUFFER_CLOSE:
 			closeBuffer();
+			view()->update();
 			break;
 
 		case LFUN_BUFFER_WRITE:
-			if (!owner->buffer()->isUnnamed()) {
+			BOOST_ASSERT(lyx_view_ && lyx_view_->buffer());
+			if (!lyx_view_->buffer()->isUnnamed()) {
 				docstring const str = bformat(_("Saving document %1$s..."),
-					 makeDisplayPath(owner->buffer()->fileName()));
-				owner->message(str);
-				menuWrite(owner->buffer());
-				owner->message(str + _(" done."));
-			} else
-				writeAs(owner->buffer());
-			update = false;
+					 makeDisplayPath(lyx_view_->buffer()->fileName()));
+				lyx_view_->message(str);
+				menuWrite(lyx_view_->buffer());
+				lyx_view_->message(str + _(" done."));
+			} else {
+ 				writeAs(lyx_view_->buffer());
+			}
+			updateFlags = Update::None;
 			break;
 
 		case LFUN_BUFFER_WRITE_AS:
-			writeAs(owner->buffer(), argument);
-			update = false;
+			BOOST_ASSERT(lyx_view_ && lyx_view_->buffer());
+			writeAs(lyx_view_->buffer(), argument);
+			updateFlags = Update::None;
 			break;
 
 		case LFUN_BUFFER_RELOAD: {
+			BOOST_ASSERT(lyx_view_ && lyx_view_->buffer());
 			docstring const file = makeDisplayPath(view()->buffer()->fileName(), 20);
 			docstring text = bformat(_("Any changes will be lost. Are you sure "
 							     "you want to revert to the saved version of the document %1$s?"), file);
@@ -833,35 +906,41 @@ void LyXFunc::dispatch(FuncRequest const & cmd)
 				text, 0, 1, _("&Revert"), _("&Cancel"));
 
 			if (ret == 0)
-				view()->reload();
+				reloadBuffer();
 			break;
 		}
 
 		case LFUN_BUFFER_UPDATE:
-			Exporter::Export(owner->buffer(), argument, true);
+			BOOST_ASSERT(lyx_view_ && lyx_view_->buffer());
+			Exporter::Export(lyx_view_->buffer(), argument, true);
 			break;
 
 		case LFUN_BUFFER_VIEW:
-			Exporter::preview(owner->buffer(), argument);
+			BOOST_ASSERT(lyx_view_ && lyx_view_->buffer());
+			Exporter::preview(lyx_view_->buffer(), argument);
 			break;
 
 		case LFUN_BUILD_PROGRAM:
-			Exporter::Export(owner->buffer(), "program", true);
+			BOOST_ASSERT(lyx_view_ && lyx_view_->buffer());
+			Exporter::Export(lyx_view_->buffer(), "program", true);
 			break;
 
 		case LFUN_BUFFER_CHKTEX:
-			owner->buffer()->runChktex();
+			BOOST_ASSERT(lyx_view_ && lyx_view_->buffer());
+			lyx_view_->buffer()->runChktex();
 			break;
 
 		case LFUN_BUFFER_EXPORT:
+			BOOST_ASSERT(lyx_view_ && lyx_view_->buffer());
 			if (argument == "custom")
-				owner->getDialogs().show("sendto");
+				lyx_view_->getDialogs().show("sendto");
 			else {
-				Exporter::Export(owner->buffer(), argument, false);
+				Exporter::Export(lyx_view_->buffer(), argument, false);
 			}
 			break;
 
 		case LFUN_BUFFER_EXPORT_CUSTOM: {
+			BOOST_ASSERT(lyx_view_ && lyx_view_->buffer());
 			string format_name;
 			string command = split(argument, format_name, ' ');
 			Format const * format = formats.getFormat(format_name);
@@ -872,7 +951,7 @@ void LyXFunc::dispatch(FuncRequest const & cmd)
 				break;
 			}
 
-			Buffer * buffer = owner->buffer();
+			Buffer * buffer = lyx_view_->buffer();
 
 			// The name of the file created by the conversion process
 			string filename;
@@ -885,7 +964,7 @@ void LyXFunc::dispatch(FuncRequest const & cmd)
 							   format->extension());
 				filename = addName(buffer->temppath(), filename);
 
-				if (!buffer->writeFile(filename))
+				if (!buffer->writeFile(FileName(filename)))
 					break;
 
 			} else {
@@ -904,6 +983,7 @@ void LyXFunc::dispatch(FuncRequest const & cmd)
 		}
 
 		case LFUN_BUFFER_PRINT: {
+			BOOST_ASSERT(lyx_view_ && lyx_view_->buffer());
 			string target;
 			string target_name;
 			string command = split(split(argument, target, ' '),
@@ -922,7 +1002,7 @@ void LyXFunc::dispatch(FuncRequest const & cmd)
 				break;
 			}
 
-			Buffer * buffer = owner->buffer();
+			Buffer * buffer = lyx_view_->buffer();
 
 			if (!Exporter::Export(buffer, "dvi", true)) {
 				showPrintError(buffer->fileName());
@@ -931,7 +1011,7 @@ void LyXFunc::dispatch(FuncRequest const & cmd)
 
 			// Push directory path.
 			string const path = buffer->temppath();
-			lyx::support::Path p(path);
+			support::Path p(path);
 
 			// there are three cases here:
 			// 1. we print to a file
@@ -980,9 +1060,20 @@ void LyXFunc::dispatch(FuncRequest const & cmd)
 
 			} else {
 				// case 1: print to a file
+				FileName const filename(makeAbsPath(target_name, path));
+				if (fs::exists(filename.toFilesystemEncoding())) {
+					docstring text = bformat(
+						_("The file %1$s already exists.\n\n"
+						  "Do you want to over-write that file?"),
+						makeDisplayPath(filename.absFilename()));
+					if (Alert::prompt(_("Over-write file?"),
+					    text, 0, 1, _("&Over-write"), _("&Cancel")) != 0) {
+						showPrintError(buffer->fileName());
+						break;
+					}
+				}
 				command += lyxrc.print_to_file
-					+ quoteName(makeAbsPath(target_name,
-								path))
+					+ quoteName(filename.toFilesystemEncoding())
 					+ ' '
 					+ quoteName(dviname);
 				res = one.startscript(Systemcall::DontWait,
@@ -999,20 +1090,18 @@ void LyXFunc::dispatch(FuncRequest const & cmd)
 			break;
 
 		case LFUN_LYX_QUIT:
-			if (view()->buffer()) {
-				// save cursor Position for opened files to .lyx/session
-				LyX::ref().session().saveFilePosition(owner->buffer()->fileName(),
-					boost::tie(view()->cursor().pit(), view()->cursor().pos()) );
-				// save bookmarks to .lyx/session
-				view()->saveSavedPositions();
-			}			
-			LyX::ref().quit(argument == "force");
+			// quitting is triggered by the gui code
+			// (leaving the event loop).
+			lyx_view_->message(from_utf8(N_("Exiting.")));
+			if (theBufferList().quitWriteAll())
+				theApp()->gui().closeAllViews();
 			break;
 
 		case LFUN_TOC_VIEW: {
+			BOOST_ASSERT(lyx_view_);
 			InsetCommandParams p("tableofcontents");
 			string const data = InsetCommandMailer::params2string("toc", p);
-			owner->getDialogs().show("toc", data, 0);
+			lyx_view_->getDialogs().show("toc", data, 0);
 			break;
 		}
 
@@ -1021,110 +1110,127 @@ void LyXFunc::dispatch(FuncRequest const & cmd)
 			break;
 
 		case LFUN_RECONFIGURE:
-			reconfigure(view());
+			BOOST_ASSERT(lyx_view_);
+			reconfigure(*lyx_view_);
 			break;
 
 		case LFUN_HELP_OPEN: {
+			BOOST_ASSERT(lyx_view_);
 			string const arg = argument;
 			if (arg.empty()) {
 				setErrorMessage(_("Missing argument"));
 				break;
 			}
-			string const fname = i18nLibFileSearch("doc", arg, "lyx");
+			FileName const fname = i18nLibFileSearch("doc", arg, "lyx");
 			if (fname.empty()) {
 				lyxerr << "LyX: unable to find documentation file `"
 							 << arg << "'. Bad installation?" << endl;
 				break;
 			}
-			owner->message(bformat(_("Opening help file %1$s..."),
-				makeDisplayPath(fname)));
-			owner->loadLyXFile(fname, false);
+			lyx_view_->message(bformat(_("Opening help file %1$s..."),
+				makeDisplayPath(fname.absFilename())));
+			lyx_view_->loadLyXFile(fname, false);
 			break;
 		}
 
 		// --- version control -------------------------------
 		case LFUN_VC_REGISTER:
+			BOOST_ASSERT(lyx_view_ && lyx_view_->buffer());
 			if (!ensureBufferClean(view()))
 				break;
-			if (!owner->buffer()->lyxvc().inUse()) {
-				owner->buffer()->lyxvc().registrer();
-				view()->reload();
+			if (!lyx_view_->buffer()->lyxvc().inUse()) {
+				lyx_view_->buffer()->lyxvc().registrer();
+				reloadBuffer();
 			}
+			updateFlags = Update::Force;
 			break;
 
 		case LFUN_VC_CHECK_IN:
+			BOOST_ASSERT(lyx_view_ && lyx_view_->buffer());
 			if (!ensureBufferClean(view()))
 				break;
-			if (owner->buffer()->lyxvc().inUse()
-					&& !owner->buffer()->isReadonly()) {
-				owner->buffer()->lyxvc().checkIn();
-				view()->reload();
+			if (lyx_view_->buffer()->lyxvc().inUse()
+					&& !lyx_view_->buffer()->isReadonly()) {
+				lyx_view_->buffer()->lyxvc().checkIn();
+				reloadBuffer();
 			}
 			break;
 
 		case LFUN_VC_CHECK_OUT:
+			BOOST_ASSERT(lyx_view_ && lyx_view_->buffer());
 			if (!ensureBufferClean(view()))
 				break;
-			if (owner->buffer()->lyxvc().inUse()
-					&& owner->buffer()->isReadonly()) {
-				owner->buffer()->lyxvc().checkOut();
-				view()->reload();
+			if (lyx_view_->buffer()->lyxvc().inUse()
+					&& lyx_view_->buffer()->isReadonly()) {
+				lyx_view_->buffer()->lyxvc().checkOut();
+				reloadBuffer();
 			}
 			break;
 
 		case LFUN_VC_REVERT:
-			owner->buffer()->lyxvc().revert();
-			view()->reload();
+			BOOST_ASSERT(lyx_view_ && lyx_view_->buffer());
+			lyx_view_->buffer()->lyxvc().revert();
+			reloadBuffer();
 			break;
 
 		case LFUN_VC_UNDO_LAST:
-			owner->buffer()->lyxvc().undoLast();
-			view()->reload();
+			BOOST_ASSERT(lyx_view_ && lyx_view_->buffer());
+			lyx_view_->buffer()->lyxvc().undoLast();
+			reloadBuffer();
 			break;
 
 		// --- buffers ----------------------------------------
 		case LFUN_BUFFER_SWITCH:
-			owner->setBuffer(theBufferList().getBuffer(argument));
+			BOOST_ASSERT(lyx_view_);
+			lyx_view_->setBuffer(theBufferList().getBuffer(argument));
 			break;
 
 		case LFUN_BUFFER_NEXT:
-			owner->setBuffer(theBufferList().next(view()->buffer()));
+			BOOST_ASSERT(lyx_view_);
+			lyx_view_->setBuffer(theBufferList().next(view()->buffer()));
 			break;
 
 		case LFUN_BUFFER_PREVIOUS:
-			owner->setBuffer(theBufferList().previous(view()->buffer()));
+			BOOST_ASSERT(lyx_view_);
+			lyx_view_->setBuffer(theBufferList().previous(view()->buffer()));
 			break;
 
 		case LFUN_FILE_NEW:
+			BOOST_ASSERT(lyx_view_);
 			newFile(view(), argument);
 			break;
 
 		case LFUN_FILE_OPEN:
+			BOOST_ASSERT(lyx_view_);
 			open(argument);
 			break;
 
 		case LFUN_DROP_LAYOUTS_CHOICE:
-			owner->getToolbars().openLayoutList();
+			BOOST_ASSERT(lyx_view_);
+			lyx_view_->getToolbars().openLayoutList();
 			break;
 
 		case LFUN_MENU_OPEN:
-			owner->getMenubar().openByName(lyx::from_utf8(argument));
+			BOOST_ASSERT(lyx_view_);
+			lyx_view_->getMenubar().openByName(from_utf8(argument));
 			break;
 
 		// --- lyxserver commands ----------------------------
 		case LFUN_SERVER_GET_NAME:
-			setMessage(lyx::from_utf8(owner->buffer()->fileName()));
+			BOOST_ASSERT(lyx_view_ && lyx_view_->buffer());
+			setMessage(from_utf8(lyx_view_->buffer()->fileName()));
 			lyxerr[Debug::INFO] << "FNAME["
-							 << owner->buffer()->fileName()
+							 << lyx_view_->buffer()->fileName()
 							 << "] " << endl;
 			break;
 
 		case LFUN_SERVER_NOTIFY:
-			dispatch_buffer = lyx::from_utf8(keyseq.print());
-			theApp->server().notifyClient(lyx::to_utf8(dispatch_buffer));
+			dispatch_buffer = keyseq->print(false);
+			theLyXServer().notifyClient(to_utf8(dispatch_buffer));
 			break;
 
 		case LFUN_SERVER_GOTO_FILE_ROW: {
+			BOOST_ASSERT(lyx_view_);
 			string file_name;
 			int row;
 			istringstream is(argument);
@@ -1132,37 +1238,37 @@ void LyXFunc::dispatch(FuncRequest const & cmd)
 			if (prefixIs(file_name, package().temp_dir())) {
 				// Needed by inverse dvi search. If it is a file
 				// in tmpdir, call the apropriated function
-				owner->setBuffer(theBufferList().getBufferFromTmp(file_name));
+				lyx_view_->setBuffer(theBufferList().getBufferFromTmp(file_name));
 			} else {
 				// Must replace extension of the file to be .lyx
 				// and get full path
-				string const s = changeExtension(file_name, ".lyx");
+				FileName const s = fileSearch(string(), changeExtension(file_name, ".lyx"), "lyx");
 				// Either change buffer or load the file
-				if (theBufferList().exists(s)) {
-					owner->setBuffer(theBufferList().getBuffer(s));
+				if (theBufferList().exists(s.absFilename())) {
+					lyx_view_->setBuffer(theBufferList().getBuffer(s.absFilename()));
 				} else {
-					owner->loadLyXFile(s);
+					lyx_view_->loadLyXFile(s);
 				}
 			}
 
 			view()->setCursorFromRow(row);
 
-			view()->center();
-			// see BufferView::center()
+			updateFlags = Update::FitCursor;
 			break;
 		}
 
 		case LFUN_DIALOG_SHOW: {
+			BOOST_ASSERT(lyx_view_);
 			string const name = cmd.getArg(0);
-			string data = trim(lyx::to_utf8(cmd.argument()).substr(name.size()));
+			string data = trim(to_utf8(cmd.argument()).substr(name.size()));
 
 			if (name == "character") {
 				data = freefont2string();
 				if (!data.empty())
-					owner->getDialogs().show("character", data);
+					lyx_view_->getDialogs().show("character", data);
 			} else if (name == "latexlog") {
 				pair<Buffer::LogType, string> const logfile =
-					owner->buffer()->getLogName();
+					lyx_view_->buffer()->getLogName();
 				switch (logfile.first) {
 				case Buffer::latexlog:
 					data = "latex ";
@@ -1172,29 +1278,36 @@ void LyXFunc::dispatch(FuncRequest const & cmd)
 					break;
 				}
 				data += LyXLex::quoteString(logfile.second);
-				owner->getDialogs().show("log", data);
+				lyx_view_->getDialogs().show("log", data);
 			} else if (name == "vclog") {
 				string const data = "vc " +
-					LyXLex::quoteString(owner->buffer()->lyxvc().getLogFile());
-				owner->getDialogs().show("log", data);
+					LyXLex::quoteString(lyx_view_->buffer()->lyxvc().getLogFile());
+				lyx_view_->getDialogs().show("log", data);
 			} else
-				owner->getDialogs().show(name, data);
+				lyx_view_->getDialogs().show(name, data);
 			break;
 		}
 
 		case LFUN_DIALOG_SHOW_NEW_INSET: {
+			BOOST_ASSERT(lyx_view_);
 			string const name = cmd.getArg(0);
-			string data = trim(lyx::to_utf8(cmd.argument()).substr(name.size()));
+			string data = trim(to_utf8(cmd.argument()).substr(name.size()));
 			if (name == "bibitem" ||
 			    name == "bibtex" ||
 			    name == "index" ||
 			    name == "label" ||
+			    name == "nomenclature" ||
 			    name == "ref" ||
 			    name == "toc" ||
 			    name == "url") {
 				InsetCommandParams p(name);
 				data = InsetCommandMailer::params2string(name, p);
 			} else if (name == "include") {
+				// data is the include type: one of "include",
+				// "input", "verbatiminput" or "verbatiminput*"
+				if (data.empty())
+					// default type is requested
+					data = "include";
 				InsetCommandParams p(data);
 				data = InsetIncludeMailer::params2string(p);
 			} else if (name == "box") {
@@ -1211,14 +1324,14 @@ void LyXFunc::dispatch(FuncRequest const & cmd)
 				data = InsetERTMailer::params2string(InsetCollapsable::Open);
 			} else if (name == "external") {
 				InsetExternalParams p;
-				Buffer const & buffer = *owner->buffer();
+				Buffer const & buffer = *lyx_view_->buffer();
 				data = InsetExternalMailer::params2string(p, buffer);
 			} else if (name == "float") {
 				InsetFloatParams p;
 				data = InsetFloatMailer::params2string(p);
 			} else if (name == "graphics") {
 				InsetGraphicsParams p;
-				Buffer const & buffer = *owner->buffer();
+				Buffer const & buffer = *lyx_view_->buffer();
 				data = InsetGraphicsMailer::params2string(p, buffer);
 			} else if (name == "note") {
 				InsetNoteParams p;
@@ -1230,21 +1343,22 @@ void LyXFunc::dispatch(FuncRequest const & cmd)
 				InsetWrapParams p;
 				data = InsetWrapMailer::params2string(p);
 			}
-			owner->getDialogs().show(name, data, 0);
+			lyx_view_->getDialogs().show(name, data, 0);
 			break;
 		}
 
 		case LFUN_DIALOG_UPDATE: {
+			BOOST_ASSERT(lyx_view_);
 			string const & name = argument;
 			// Can only update a dialog connected to an existing inset
-			InsetBase * inset = owner->getDialogs().getOpenInset(name);
+			InsetBase * inset = lyx_view_->getDialogs().getOpenInset(name);
 			if (inset) {
 				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());
+				lyx_view_->getDialogs().update(name, string());
 			}
 			break;
 		}
@@ -1254,11 +1368,13 @@ void LyXFunc::dispatch(FuncRequest const & cmd)
 			break;
 
 		case LFUN_DIALOG_DISCONNECT_INSET:
-			owner->getDialogs().disconnect(argument);
+			BOOST_ASSERT(lyx_view_);
+			lyx_view_->getDialogs().disconnect(argument);
 			break;
 
 
 		case LFUN_CITATION_INSERT: {
+			BOOST_ASSERT(lyx_view_);
 			if (!argument.empty()) {
 				// we can have one optional argument, delimited by '|'
 				// citation-insert <key>|<text_before>
@@ -1282,42 +1398,48 @@ void LyXFunc::dispatch(FuncRequest const & cmd)
 		}
 
 		case LFUN_BUFFER_CHILD_OPEN: {
-			string const filename =
-				makeAbsPath(argument, owner->buffer()->filePath());
+			BOOST_ASSERT(lyx_view_);
+			FileName const filename =
+				makeAbsPath(argument, lyx_view_->buffer()->filePath());
 			// FIXME Should use bformat
 			setMessage(_("Opening child document ") +
-					 makeDisplayPath(filename) + "...");
-			view()->savePosition(0);
-			string const parentfilename = owner->buffer()->fileName();
-			if (theBufferList().exists(filename))
-				owner->setBuffer(theBufferList().getBuffer(filename));
+					 makeDisplayPath(filename.absFilename()) + "...");
+			view()->saveBookmark(false);
+			string const parentfilename = lyx_view_->buffer()->fileName();
+			if (theBufferList().exists(filename.absFilename()))
+				lyx_view_->setBuffer(theBufferList().getBuffer(filename.absFilename()));
 			else
-				owner->loadLyXFile(filename);
+				lyx_view_->loadLyXFile(filename);
 			// Set the parent name of the child document.
 			// This makes insertion of citations and references in the child work,
 			// when the target is in the parent or another child document.
-			owner->buffer()->setParentName(parentfilename);
+			lyx_view_->buffer()->setParentName(parentfilename);
 			break;
 		}
 
 		case LFUN_TOGGLE_CURSOR_FOLLOWS_SCROLLBAR:
+			BOOST_ASSERT(lyx_view_);
 			lyxrc.cursor_follows_scrollbar = !lyxrc.cursor_follows_scrollbar;
 			break;
 
 		case LFUN_KEYMAP_OFF:
-			owner->view()->getIntl().keyMapOn(false);
+			BOOST_ASSERT(lyx_view_);
+			lyx_view_->view()->getIntl().keyMapOn(false);
 			break;
 
 		case LFUN_KEYMAP_PRIMARY:
-			owner->view()->getIntl().keyMapPrim();
+			BOOST_ASSERT(lyx_view_);
+			lyx_view_->view()->getIntl().keyMapPrim();
 			break;
 
 		case LFUN_KEYMAP_SECONDARY:
-			owner->view()->getIntl().keyMapSec();
+			BOOST_ASSERT(lyx_view_);
+			lyx_view_->view()->getIntl().keyMapSec();
 			break;
 
 		case LFUN_KEYMAP_TOGGLE:
-			owner->view()->getIntl().toggleKeyMap();
+			BOOST_ASSERT(lyx_view_);
+			lyx_view_->view()->getIntl().toggleKeyMap();
 			break;
 
 		case LFUN_REPEAT: {
@@ -1347,17 +1469,20 @@ void LyXFunc::dispatch(FuncRequest const & cmd)
 		}
 
 		case LFUN_PREFERENCES_SAVE: {
-			lyx::support::Path p(package().user_support());
-			lyxrc.write("preferences", false);
+			lyxrc.write(makeAbsPath("preferences",
+			                        package().user_support()),
+			            false);
 			break;
 		}
 
 		case LFUN_SCREEN_FONT_UPDATE:
+			BOOST_ASSERT(lyx_view_);
 			// handle the screen font changes.
 			lyxrc.set_font_norm_type();
 			theFontLoader().update();
-			// All visible buffers will need resize
-			view()->resize();
+			/// FIXME: only the current view will be updated. the Gui
+			/// class is able to furnish the list of views.
+			updateFlags = Update::Force;
 			break;
 
 		case LFUN_SET_COLOR: {
@@ -1378,28 +1503,30 @@ void LyXFunc::dispatch(FuncRequest const & cmd)
 						bformat(_("Set-color \"%1$s\" failed "
 								       "- color is undefined or "
 								       "may not be redefined"),
-									   lyx::from_utf8(lyx_name)));
+									   from_utf8(lyx_name)));
 				break;
 			}
 
-			theApp->updateColor(lcolor.getFromLyXName(lyx_name));
+			theApp()->updateColor(lcolor.getFromLyXName(lyx_name));
 
 			if (graphicsbg_changed) {
 #ifdef WITH_WARNINGS
 #warning FIXME!! The graphics cache no longer has a changeDisplay method.
 #endif
 #if 0
-				lyx::graphics::GCache::get().changeDisplay(true);
+				graphics::GCache::get().changeDisplay(true);
 #endif
 			}
 			break;
 		}
 
 		case LFUN_MESSAGE:
-			owner->message(lyx::from_utf8(argument));
+			BOOST_ASSERT(lyx_view_);
+			lyx_view_->message(from_utf8(argument));
 			break;
 
 		case LFUN_EXTERNAL_EDIT: {
+			BOOST_ASSERT(lyx_view_);
 			FuncRequest fr(action, argument);
 			InsetExternal().dispatch(view()->cursor(), fr);
 			break;
@@ -1412,8 +1539,9 @@ void LyXFunc::dispatch(FuncRequest const & cmd)
 		}
 
 		case LFUN_INSET_APPLY: {
+			BOOST_ASSERT(lyx_view_);
 			string const name = cmd.getArg(0);
-			InsetBase * inset = owner->getDialogs().getOpenInset(name);
+			InsetBase * inset = lyx_view_->getDialogs().getOpenInset(name);
 			if (inset) {
 				FuncRequest fr(LFUN_INSET_MODIFY, argument);
 				inset->dispatch(view()->cursor(), fr);
@@ -1423,11 +1551,12 @@ void LyXFunc::dispatch(FuncRequest const & cmd)
 			}
 			// ideally, the update flag should be set by the insets,
 			// but this is not possible currently
-			updateforce = true;
+			updateFlags = Update::Force | Update::FitCursor;
 			break;
 		}
 
 		case LFUN_ALL_INSETS_TOGGLE: {
+			BOOST_ASSERT(lyx_view_);
 			string action;
 			string const name = split(argument, action, ' ');
 			InsetBase::Code const inset_code =
@@ -1436,7 +1565,7 @@ void LyXFunc::dispatch(FuncRequest const & cmd)
 			LCursor & cur = view()->cursor();
 			FuncRequest fr(LFUN_INSET_TOGGLE, action);
 
-			InsetBase & inset = owner->buffer()->inset();
+			InsetBase & inset = lyx_view_->buffer()->inset();
 			InsetIterator it  = inset_iterator_begin(inset);
 			InsetIterator const end = inset_iterator_end(inset);
 			for (; it != end; ++it) {
@@ -1447,12 +1576,13 @@ void LyXFunc::dispatch(FuncRequest const & cmd)
 					it->dispatch(tmpcur, fr);
 				}
 			}
-			updateforce = true;
+			updateFlags = Update::Force | Update::FitCursor;
 			break;
 		}
 
 		case LFUN_BUFFER_LANGUAGE: {
-			Buffer & buffer = *owner->buffer();
+			BOOST_ASSERT(lyx_view_);
+			Buffer & buffer = *lyx_view_->buffer();
 			Language const * oldL = buffer.params().language;
 			Language const * newL = languages.getLanguage(argument);
 			if (!newL || oldL == newL)
@@ -1484,7 +1614,7 @@ void LyXFunc::dispatch(FuncRequest const & cmd)
 				       << endl;
 			}
 
-			if (defaults.writeFile(defaults.fileName()))
+			if (defaults.writeFile(FileName(defaults.fileName())))
 				// FIXME Should use bformat
 				setMessage(_("Document defaults saved in ")
 					   + makeDisplayPath(fname));
@@ -1494,14 +1624,15 @@ void LyXFunc::dispatch(FuncRequest const & cmd)
 		}
 
 		case LFUN_BUFFER_PARAMS_APPLY: {
+			BOOST_ASSERT(lyx_view_);
 			biblio::CiteEngine const engine =
-				owner->buffer()->params().cite_engine;
+				lyx_view_->buffer()->params().cite_engine;
 
 			istringstream ss(argument);
 			LyXLex lex(0,0);
 			lex.setStream(ss);
 			int const unknown_tokens =
-				owner->buffer()->readHeader(lex);
+				lyx_view_->buffer()->readHeader(lex);
 
 			if (unknown_tokens != 0) {
 				lyxerr << "Warning in LFUN_BUFFER_PARAMS_APPLY!\n"
@@ -1509,13 +1640,13 @@ void LyXFunc::dispatch(FuncRequest const & cmd)
 				       << (unknown_tokens == 1 ? "" : "s")
 				       << endl;
 			}
-			if (engine == owner->buffer()->params().cite_engine)
+			if (engine == lyx_view_->buffer()->params().cite_engine)
 				break;
 
 			LCursor & cur = view()->cursor();
 			FuncRequest fr(LFUN_INSET_REFRESH);
 
-			InsetBase & inset = owner->buffer()->inset();
+			InsetBase & inset = lyx_view_->buffer()->inset();
 			InsetIterator it  = inset_iterator_begin(inset);
 			InsetIterator const end = inset_iterator_end(inset);
 			for (; it != end; ++it)
@@ -1525,30 +1656,31 @@ void LyXFunc::dispatch(FuncRequest const & cmd)
 		}
 
 		case LFUN_TEXTCLASS_APPLY: {
-			Buffer * buffer = owner->buffer();
+			BOOST_ASSERT(lyx_view_);
+			Buffer * buffer = lyx_view_->buffer();
 
-			lyx::textclass_type const old_class =
+			textclass_type const old_class =
 				buffer->params().textclass;
 
 			loadTextclass(argument);
 
-			std::pair<bool, lyx::textclass_type> const tc_pair =
+			std::pair<bool, textclass_type> const tc_pair =
 				textclasslist.numberOfClass(argument);
 
 			if (!tc_pair.first)
 				break;
 
-			lyx::textclass_type const new_class = tc_pair.second;
+			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..."));
+			lyx_view_->message(_("Converting document to new document class..."));
 			recordUndoFullDocument(view());
 			buffer->params().textclass = new_class;
 			StableDocIterator backcur(view()->cursor());
 			ErrorList & el = buffer->errorList("Class Switch");
-			lyx::cap::switchBetweenClasses(
+			cap::switchBetweenClasses(
 				old_class, new_class,
 				static_cast<InsetText &>(buffer->inset()), el);
 
@@ -1556,7 +1688,7 @@ void LyXFunc::dispatch(FuncRequest const & cmd)
 
 			buffer->errors("Class Switch");
 			updateLabels(*buffer);
-			updateforce = true;
+			updateFlags = Update::Force | Update::FitCursor;
 			break;
 		}
 
@@ -1578,66 +1710,97 @@ void LyXFunc::dispatch(FuncRequest const & cmd)
 			}
 
 			actOnUpdatedPrefs(lyxrc_orig, lyxrc);
+
+			/// We force the redraw in any case because there might be
+			/// some screen font changes.
+			/// FIXME: only the current view will be updated. the Gui
+			/// class is able to furnish the list of views.
+			updateFlags = Update::Force;
 			break;
 		}
 
+		case LFUN_WINDOW_NEW:
+			LyX::ref().newLyXView();
+			break;
+
+		case LFUN_WINDOW_CLOSE:
+			BOOST_ASSERT(lyx_view_);
+			BOOST_ASSERT(theApp());
+			// update bookmark pit of the current buffer before window close
+			for (size_t i = 0; i < LyX::ref().session().bookmarks().size(); ++i)
+				gotoBookmark(i+1, false, false);
+			// ask the user for saving changes or cancel quit
+			if (!theBufferList().quitWriteAll())
+				break;
+			lyx_view_->close();
+			return;
+
+		case LFUN_BOOKMARK_GOTO:
+			// go to bookmark, open unopened file and switch to buffer if necessary
+			gotoBookmark(convert<unsigned int>(to_utf8(cmd.argument())), true, true);
+			break;
+
+		case LFUN_BOOKMARK_CLEAR:
+			LyX::ref().session().bookmarks().clear();
+			break;
+
+		case LFUN_TOOLBAR_TOGGLE_STATE:
+			lyx_view_->toggleToolbarState(argument);
+			break;
+
 		default: {
+			BOOST_ASSERT(lyx_view_);
 			view()->cursor().dispatch(cmd);
-			updateforce |= view()->cursor().result().update();
+			updateFlags = view()->cursor().result().update();
 			if (!view()->cursor().result().dispatched())
-				updateforce |= view()->dispatch(cmd);
+				updateFlags = view()->dispatch(cmd);
 			break;
 		}
 		}
 
-		if (view()->buffer()) {
-			// Redraw screen unless explicitly told otherwise.
-			// This also initializes the position cache for all insets
-			// in (at least partially) visible top-level paragraphs.
-			if (updateforce)
-				view()->update(Update::FitCursor | Update::Force);
-			else if (update)
-				view()->update(Update::FitCursor);
+		if (lyx_view_ && view()->buffer()) {
+			// BufferView::update() updates the ViewMetricsInfo and
+			// also initializes the position cache for all insets in
+			// (at least partially) visible top-level paragraphs.
+			// We will redraw the screen only if needed.
+			if (view()->update(updateFlags)) {
+				// Buffer::changed() signals that a repaint is needed.
+				// The frontend (WorkArea) knows which area to repaint
+				// thanks to the ViewMetricsInfo updated above.
+				view()->buffer()->changed();
+			}
 
-			owner->redrawWorkArea();
+			lyx_view_->updateStatusBar();
 
 			// if we executed a mutating lfun, mark the buffer as dirty
 			if (flag.enabled()
-			    && !lyxaction.funcHasFlag(cmd.action, LyXAction::NoBuffer)
-			    && !lyxaction.funcHasFlag(cmd.action, LyXAction::ReadOnly))
+			    && !lyxaction.funcHasFlag(action, LyXAction::NoBuffer)
+			    && !lyxaction.funcHasFlag(action, LyXAction::ReadOnly))
 				view()->buffer()->markDirty();
 
 			if (view()->cursor().inTexted()) {
-				owner->updateLayoutChoice();
+				lyx_view_->updateLayoutChoice();
 			}
 		}
 	}
-	if (!quitting)
-		// FIXME UNICODE: _() does not support anything but ascii.
-		// Do we need a lyx::to_ascii() method?
+	if (!quitting) {
+		lyx_view_->updateMenubar();
+		lyx_view_->updateToolbars();
 		sendDispatchMessage(getMessage(), cmd);
+	}
 }
 
 
 void LyXFunc::sendDispatchMessage(docstring const & msg, FuncRequest const & cmd)
 {
-	/* When an action did not originate from the UI/kbd, it makes
-	 * sense to avoid updating the GUI. It turns out that this
-	 * fixes bug 1941, for reasons that are described here:
-	 * http://bugzilla.lyx.org/show_bug.cgi?id=1941#c4
-	 */
-	if (cmd.origin != FuncRequest::INTERNAL) {
-		owner->updateMenubar();
-		owner->updateToolbars();
-	}
-
-	const bool verbose = (cmd.origin == FuncRequest::UI
+	const bool verbose = (cmd.origin == FuncRequest::MENU
+			      || cmd.origin == FuncRequest::TOOLBAR
 			      || cmd.origin == FuncRequest::COMMANDBUFFER);
 
 	if (cmd.action == LFUN_SELF_INSERT || !verbose) {
-		lyxerr[Debug::ACTION] << "dispatch msg is " << lyx::to_utf8(msg) << endl;
+		lyxerr[Debug::ACTION] << "dispatch msg is " << to_utf8(msg) << endl;
 		if (!msg.empty())
-			owner->message(msg);
+			lyx_view_->message(msg);
 		return;
 	}
 
@@ -1645,54 +1808,46 @@ void LyXFunc::sendDispatchMessage(docstring const & msg, FuncRequest const & cmd
 	if (!dispatch_msg.empty())
 		dispatch_msg += ' ';
 
-	string comname = lyxaction.getActionName(cmd.action);
+	docstring comname = from_utf8(lyxaction.getActionName(cmd.action));
 
 	bool argsadded = false;
 
 	if (!cmd.argument().empty()) {
 		if (cmd.action != LFUN_UNKNOWN_ACTION) {
-			comname += ' ' + lyx::to_utf8(cmd.argument());
+			comname += ' ' + cmd.argument();
 			argsadded = true;
 		}
 	}
 
-	string const shortcuts = toplevel_keymap->printbindings(cmd);
+	docstring const shortcuts = theTopLevelKeymap().printbindings(cmd);
 
 	if (!shortcuts.empty())
 		comname += ": " + shortcuts;
 	else if (!argsadded && !cmd.argument().empty())
-		comname += ' ' + lyx::to_utf8(cmd.argument());
+		comname += ' ' + cmd.argument();
 
 	if (!comname.empty()) {
 		comname = rtrim(comname);
-		dispatch_msg += lyx::from_utf8('(' + rtrim(comname) + ')');
+		dispatch_msg += '(' + rtrim(comname) + ')';
 	}
 
 	lyxerr[Debug::ACTION] << "verbose dispatch msg "
-		<< lyx::to_utf8(dispatch_msg) << endl;
+		<< to_utf8(dispatch_msg) << endl;
 	if (!dispatch_msg.empty())
-		owner->message(dispatch_msg);
-}
-
-
-void LyXFunc::setupLocalKeymap()
-{
-	keyseq.stdmap = toplevel_keymap.get();
-	keyseq.curmap = toplevel_keymap.get();
-	cancel_meta_seq.stdmap = toplevel_keymap.get();
-	cancel_meta_seq.curmap = toplevel_keymap.get();
+		lyx_view_->message(dispatch_msg);
 }
 
 
 void LyXFunc::menuNew(string const & name, bool fromTemplate)
 {
+	// FIXME: initpath is not used. What to do?
 	string initpath = lyxrc.document_path;
 	string filename(name);
 
 	if (view()->buffer()) {
-		string const trypath = owner->buffer()->filePath();
+		string const trypath = lyx_view_->buffer()->filePath();
 		// If directory is writeable, use this as default.
-		if (isDirWriteable(trypath))
+		if (isDirWriteable(FileName(trypath)))
 			initpath = trypath;
 	}
 
@@ -1701,7 +1856,8 @@ void LyXFunc::menuNew(string const & name, bool fromTemplate)
 	if (filename.empty()) {
 		filename = addName(lyxrc.document_path,
 			    "newfile" + convert<string>(++newfile_number) + ".lyx");
-		while (theBufferList().exists(filename) || fs::is_readable(filename)) {
+		while (theBufferList().exists(filename) ||
+		       fs::is_readable(FileName(filename).toFilesystemEncoding())) {
 			++newfile_number;
 			filename = addName(lyxrc.document_path,
 					   "newfile" +	convert<string>(newfile_number) +
@@ -1714,11 +1870,11 @@ void LyXFunc::menuNew(string const & name, bool fromTemplate)
 	if (fromTemplate) {
 		FileDialog fileDlg(_("Select template file"),
 			LFUN_SELECT_FILE_SYNC,
-			make_pair(_("Documents|#o#O"), lyx::from_utf8(lyxrc.document_path)),
-			make_pair(_("Templates|#T#t"), lyx::from_utf8(lyxrc.template_path)));
+			make_pair(_("Documents|#o#O"), from_utf8(lyxrc.document_path)),
+			make_pair(_("Templates|#T#t"), from_utf8(lyxrc.template_path)));
 
 		FileDialog::Result result =
-			fileDlg.open(lyx::from_utf8(lyxrc.template_path),
+			fileDlg.open(from_utf8(lyxrc.template_path),
 				     FileFilterList(_("LyX Documents (*.lyx)")),
 				     docstring());
 
@@ -1726,12 +1882,12 @@ void LyXFunc::menuNew(string const & name, bool fromTemplate)
 			return;
 		if (result.second.empty())
 			return;
-		templname = lyx::to_utf8(result.second);
+		templname = to_utf8(result.second);
 	}
 
 	Buffer * const b = newFile(filename, templname, !name.empty());
 	if (b)
-		owner->setBuffer(b);
+		lyx_view_->setBuffer(b);
 }
 
 
@@ -1740,9 +1896,9 @@ void LyXFunc::open(string const & fname)
 	string initpath = lyxrc.document_path;
 
 	if (view()->buffer()) {
-		string const trypath = owner->buffer()->filePath();
+		string const trypath = lyx_view_->buffer()->filePath();
 		// If directory is writeable, use this as default.
-		if (isDirWriteable(trypath))
+		if (isDirWriteable(FileName(trypath)))
 			initpath = trypath;
 	}
 
@@ -1751,22 +1907,22 @@ void LyXFunc::open(string const & fname)
 	if (fname.empty()) {
 		FileDialog fileDlg(_("Select document to open"),
 			LFUN_FILE_OPEN,
-			make_pair(_("Documents|#o#O"), lyx::from_utf8(lyxrc.document_path)),
-			make_pair(_("Examples|#E#e"), lyx::from_utf8(addPath(package().system_support(), "examples"))));
+			make_pair(_("Documents|#o#O"), from_utf8(lyxrc.document_path)),
+			make_pair(_("Examples|#E#e"), from_utf8(addPath(package().system_support(), "examples"))));
 
 		FileDialog::Result result =
-			fileDlg.open(lyx::from_utf8(initpath),
+			fileDlg.open(from_utf8(initpath),
 				     FileFilterList(_("LyX Documents (*.lyx)")),
 				     docstring());
 
 		if (result.first == FileDialog::Later)
 			return;
 
-		filename = lyx::to_utf8(result.second);
+		filename = to_utf8(result.second);
 
 		// check selected filename
 		if (filename.empty()) {
-			owner->message(_("Canceled."));
+			lyx_view_->message(_("Canceled."));
 			return;
 		}
 	} else
@@ -1774,31 +1930,29 @@ void LyXFunc::open(string const & fname)
 
 	// get absolute path of file and add ".lyx" to the filename if
 	// necessary
-	string const fullpath = fileSearch(string(), filename, "lyx");
-	if (!fullpath.empty()) {
-		filename = fullpath;
-	}
-
-	docstring const disp_fn = makeDisplayPath(filename);
+	FileName const fullname = fileSearch(string(), filename, "lyx");
+	if (!fullname.empty())
+		filename = fullname.absFilename();
 
 	// if the file doesn't exist, let the user create one
-	if (!fs::exists(filename)) {
+	if (!fs::exists(fullname.toFilesystemEncoding())) {
 		// the user specifically chose this name. Believe him.
 		Buffer * const b = newFile(filename, string(), true);
 		if (b)
-			owner->setBuffer(b);
+			lyx_view_->setBuffer(b);
 		return;
 	}
 
-	owner->message(bformat(_("Opening document %1$s..."), disp_fn));
+	docstring const disp_fn = makeDisplayPath(filename);
+	lyx_view_->message(bformat(_("Opening document %1$s..."), disp_fn));
 
 	docstring str2;
-	if (owner->loadLyXFile(filename)) {
+	if (lyx_view_->loadLyXFile(fullname)) {
 		str2 = bformat(_("Document %1$s opened."), disp_fn);
 	} else {
 		str2 = bformat(_("Could not open document %1$s"), disp_fn);
 	}
-	owner->message(str2);
+	lyx_view_->message(str2);
 }
 
 
@@ -1815,9 +1969,9 @@ void LyXFunc::doImport(string const & argument)
 		string initpath = lyxrc.document_path;
 
 		if (view()->buffer()) {
-			string const trypath = owner->buffer()->filePath();
+			string const trypath = lyx_view_->buffer()->filePath();
 			// If directory is writeable, use this as default.
-			if (isDirWriteable(trypath))
+			if (isDirWriteable(FileName(trypath)))
 				initpath = trypath;
 		}
 
@@ -1826,51 +1980,51 @@ void LyXFunc::doImport(string const & argument)
 
 		FileDialog fileDlg(text,
 			LFUN_BUFFER_IMPORT,
-			make_pair(_("Documents|#o#O"), lyx::from_utf8(lyxrc.document_path)),
+			make_pair(_("Documents|#o#O"), from_utf8(lyxrc.document_path)),
 			make_pair(_("Examples|#E#e"),
-				  lyx::from_utf8(addPath(package().system_support(), "examples"))));
+				  from_utf8(addPath(package().system_support(), "examples"))));
 
 		docstring filter = formats.prettyName(format);
 		filter += " (*.";
 		// FIXME UNICODE
-		filter += lyx::from_utf8(formats.extension(format));
+		filter += from_utf8(formats.extension(format));
 		filter += ')';
 
 		FileDialog::Result result =
-			fileDlg.open(lyx::from_utf8(initpath),
+			fileDlg.open(from_utf8(initpath),
 				     FileFilterList(filter),
 				     docstring());
 
 		if (result.first == FileDialog::Later)
 			return;
 
-		filename = lyx::to_utf8(result.second);
+		filename = to_utf8(result.second);
 
 		// check selected filename
 		if (filename.empty())
-			owner->message(_("Canceled."));
+			lyx_view_->message(_("Canceled."));
 	}
 
 	if (filename.empty())
 		return;
 
 	// get absolute path of file
-	filename = makeAbsPath(filename);
+	FileName const fullname(makeAbsPath(filename));
 
-	string const lyxfile = changeExtension(filename, ".lyx");
+	FileName const lyxfile(changeExtension(fullname.absFilename(), ".lyx"));
 
 	// Check if the document already is open
-	if (lyx::use_gui && theBufferList().exists(lyxfile)) {
-		if (!theBufferList().close(theBufferList().getBuffer(lyxfile), true)) {
-			owner->message(_("Canceled."));
+	if (use_gui && theBufferList().exists(lyxfile.absFilename())) {
+		if (!theBufferList().close(theBufferList().getBuffer(lyxfile.absFilename()), true)) {
+			lyx_view_->message(_("Canceled."));
 			return;
 		}
 	}
 
 	// if the file exists already, and we didn't do
 	// -i lyx thefile.lyx, warn
-	if (fs::exists(lyxfile) && filename != lyxfile) {
-		docstring const file = makeDisplayPath(lyxfile, 30);
+	if (fs::exists(lyxfile.toFilesystemEncoding()) && fullname != lyxfile) {
+		docstring const file = makeDisplayPath(lyxfile.absFilename(), 30);
 
 		docstring text = bformat(_("The document %1$s already exists.\n\n"
 						     "Do you want to over-write that document?"), file);
@@ -1878,13 +2032,13 @@ void LyXFunc::doImport(string const & argument)
 			text, 0, 1, _("&Over-write"), _("&Cancel"));
 
 		if (ret == 1) {
-			owner->message(_("Canceled."));
+			lyx_view_->message(_("Canceled."));
 			return;
 		}
 	}
 
 	ErrorList errorList;
-	Importer::Import(owner, filename, format, errorList);
+	Importer::Import(lyx_view_, fullname, format, errorList);
 	// FIXME (Abdel 12/08/06): Is there a need to display the error list here?
 }
 
@@ -1892,22 +2046,32 @@ void LyXFunc::doImport(string const & argument)
 void LyXFunc::closeBuffer()
 {
 	// save current cursor position
-	LyX::ref().session().saveFilePosition(owner->buffer()->fileName(),
+	LyX::ref().session().lastFilePos().save(FileName(lyx_view_->buffer()->fileName()),
 		boost::tie(view()->cursor().pit(), view()->cursor().pos()) );
-	if (theBufferList().close(owner->buffer(), true) && !quitting) {
+	// goto bookmark to update bookmark pit.
+	for (size_t i = 0; i < LyX::ref().session().bookmarks().size(); ++i)
+		gotoBookmark(i+1, false, false);
+	if (theBufferList().close(lyx_view_->buffer(), true) && !quitting) {
 		if (theBufferList().empty()) {
 			// need this otherwise SEGV may occur while
 			// trying to set variables that don't exist
 			// since there's no current buffer
-			owner->getDialogs().hideBufferDependent();
+			lyx_view_->getDialogs().hideBufferDependent();
 		} else {
-			owner->setBuffer(theBufferList().first());
+			lyx_view_->setBuffer(theBufferList().first());
 		}
 	}
 }
 
 
-// Each "owner" should have it's own message method. lyxview and
+void LyXFunc::reloadBuffer()
+{
+	FileName filename(lyx_view_->buffer()->fileName());
+	closeBuffer();
+	lyx_view_->loadLyXFile(filename);
+}
+
+// Each "lyx_view_" 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 function is bit problematic when it comes to NLS, to make the
@@ -1926,19 +2090,19 @@ void LyXFunc::setMessage(docstring const & m) const
 }
 
 
-string const LyXFunc::viewStatusMessage()
+docstring const LyXFunc::viewStatusMessage()
 {
 	// When meta-fake key is pressed, show the key sequence so far + "M-".
 	if (wasMetaKey())
-		return keyseq.print() + "M-";
+		return keyseq->print(true) + "M-";
 
 	// Else, when a non-complete key sequence is pressed,
 	// show the available options.
-	if (keyseq.length() > 0 && !keyseq.deleted())
-		return keyseq.printOptions();
+	if (keyseq->length() > 0 && !keyseq->deleted())
+		return keyseq->printOptions(true);
 
 	if (!view()->buffer())
-		return lyx::to_utf8(_("Welcome to LyX!"));
+		return _("Welcome to LyX!");
 
 	return view()->cursor().currentState();
 }
@@ -1946,8 +2110,8 @@ string const LyXFunc::viewStatusMessage()
 
 BufferView * LyXFunc::view() const
 {
-	BOOST_ASSERT(owner);
-	return owner->view();
+	BOOST_ASSERT(lyx_view_);
+	return lyx_view_->view();
 }
 
 
@@ -1970,8 +2134,8 @@ void actOnUpdatedPrefs(LyXRC const & lyxrc_orig, LyXRC const & lyxrc_new)
 	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_PLAINTEXT_ROFF_COMMAND:
+	case LyXRC::RC_PLAINTEXT_LINELEN:
 	case LyXRC::RC_AUTOREGIONDELETE:
 	case LyXRC::RC_AUTORESET_OPTIONS:
 	case LyXRC::RC_AUTOSAVE:
@@ -1984,6 +2148,7 @@ void actOnUpdatedPrefs(LyXRC const & lyxrc_orig, LyXRC const & lyxrc_new)
 	case LyXRC::RC_LOADSESSION:
 	case LyXRC::RC_CHKTEX_COMMAND:
 	case LyXRC::RC_CONVERTER:
+	case LyXRC::RC_CONVERTER_CACHE_MAXAGE:
 	case LyXRC::RC_COPIER:
 	case LyXRC::RC_CURSOR_FOLLOWS_SCROLLBAR:
 	case LyXRC::RC_CUSTOM_EXPORT_COMMAND:
@@ -1995,11 +2160,10 @@ void actOnUpdatedPrefs(LyXRC const & lyxrc_orig, LyXRC const & lyxrc_new)
 	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;
-			}
+			string const encoded = FileName(
+				lyxrc_new.document_path).toFilesystemEncoding();
+			if (fs::exists(encoded) && fs::is_directory(encoded))
+				support::package().document_dir() = lyxrc.document_path;
 		}
 	case LyXRC::RC_ESC_CHARS:
 	case LyXRC::RC_FONT_ENCODING:
@@ -2023,8 +2187,7 @@ void actOnUpdatedPrefs(LyXRC const & lyxrc_orig, LyXRC const & lyxrc_new)
 	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);
+			support::prependEnvPath("PATH", lyxrc.path_prefix);
 		}
 	case LyXRC::RC_PERS_DICT:
 	case LyXRC::RC_POPUP_BOLD_FONT:
@@ -2075,14 +2238,14 @@ void actOnUpdatedPrefs(LyXRC const & lyxrc_orig, LyXRC const & lyxrc_new)
 	case LyXRC::RC_TEX_ALLOWS_SPACES:
 	case LyXRC::RC_TEX_EXPECTS_WINDOWS_PATHS:
 		if (lyxrc_orig.windows_style_tex_paths != lyxrc_new.windows_style_tex_paths) {
-			namespace os = lyx::support::os;
-			os::windows_style_tex_paths(lyxrc_new.windows_style_tex_paths);
+			support::os::windows_style_tex_paths(lyxrc_new.windows_style_tex_paths);
 		}
 	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_CONVERTER_CACHE:
 	case LyXRC::RC_USE_ESC_CHARS:
 	case LyXRC::RC_USE_INP_ENC:
 	case LyXRC::RC_USE_PERS_DICT:
@@ -2095,3 +2258,6 @@ void actOnUpdatedPrefs(LyXRC const & lyxrc_orig, LyXRC const & lyxrc_new)
 }
 
 } // namespace anon
+
+
+} // namespace lyx