X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Flyxfunc.C;h=dbda91f6c8d513a28b6d636f8e9c8cf4dddacc09;hb=ec15dfd2a3049bbabcaf7d41de5709a5faf41cc0;hp=bfc4667d3fdaf16e17802ce2f40fb373880112ad;hpb=0d449056ef9ace3ef737e4b9aba8d3994615dc18;p=lyx.git

diff --git a/src/lyxfunc.C b/src/lyxfunc.C
index bfc4667d3f..dbda91f6c8 100644
--- a/src/lyxfunc.C
+++ b/src/lyxfunc.C
@@ -78,6 +78,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 +101,35 @@
 
 #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::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,8 +138,7 @@ 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;
 
 
@@ -147,7 +148,7 @@ 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.
@@ -223,14 +224,13 @@ void LyXFunc::setLyXView(LyXView * 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;
-	}
 
-	lyx_view_->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();
@@ -301,7 +301,7 @@ void LyXFunc::processKeySym(LyXKeySymPtr keysym, key_modifier::state state)
 	// num_bytes == 0? (Lgb)
 
 	if (keyseq->length() > 1) {
-		lyx_view_->message(lyx::from_utf8(keyseq->print()));
+		lyx_view_->message(from_utf8(keyseq->print()));
 	}
 
 
@@ -335,7 +335,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);
@@ -347,6 +347,25 @@ FuncStatus LyXFunc::getStatus(FuncRequest const & cmd) const
 {
 	//lyxerr << "LyXFunc::getStatus: cmd: " << cmd << endl;
 	FuncStatus flag;
+
+	if (cmd.action == LFUN_LYX_QUIT) {
+		flag.message(from_utf8(N_("Exiting")));
+		flag.enabled(true);
+		return flag;
+	} else if (cmd.action == LFUN_BOOKMARK_GOTO) {
+		// bookmarks can be valid even if there is no opened buffer
+		flag.enabled(LyX::ref().session().bookmarks().isValid(convert<unsigned int>(to_utf8(cmd.argument()))));
+		return flag;
+	} else if (cmd.action == LFUN_BOOKMARK_CLEAR) {
+		flag.enabled(LyX::ref().session().bookmarks().size() > 0);
+		return flag;
+	} else if (cmd.action == LFUN_TOOLBAR_TOGGLE_STATE) {
+		ToolbarBackend::Flags flags = lyx_view_->getToolbarState(to_utf8(cmd.argument()));
+		if (!(flags & ToolbarBackend::AUTO))
+			flag.setOnOff(flags & ToolbarBackend::ON);
+		return flag;
+	}
+
 	LCursor & cur = view()->cursor();
 
 	/* In LyX/Mac, when a dialog is open, the menus of the
@@ -358,13 +377,13 @@ FuncStatus LyXFunc::getStatus(FuncRequest const & cmd) const
 	   http://bugzilla.lyx.org/show_bug.cgi?id=1941#c4
 	*/
 	Buffer * buf;
-	if (cmd.origin == FuncRequest::UI && !lyx_view_->hasFocus())
+	if (cmd.origin == FuncRequest::MENU && !lyx_view_->hasFocus())
 		buf = 0;
 	else
 		buf = lyx_view_->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;
 	}
@@ -383,20 +402,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;
@@ -415,13 +434,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:
@@ -558,11 +577,12 @@ FuncStatus LyXFunc::getStatus(FuncRequest const & cmd) const
 		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);
@@ -581,7 +601,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:
@@ -619,12 +638,13 @@ 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:
 		// these are handled in our dispatch()
 		break;
 
 	default:
-
-		if (!::getStatus(cur, cmd, flag))
+		if (!getLocalStatus(cur, cmd, flag))
 			flag = view()->getStatus(cmd);
 	}
 
@@ -635,7 +655,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);
 	}
 
@@ -643,13 +663,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;
 }
@@ -689,7 +709,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) {
@@ -699,12 +719,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);
 	}
 }
@@ -717,11 +737,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.
@@ -730,9 +749,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()) {
@@ -747,6 +764,7 @@ void LyXFunc::dispatch(FuncRequest const & cmd)
 
 		case LFUN_WORD_FIND_FORWARD:
 		case LFUN_WORD_FIND_BACKWARD: {
+			BOOST_ASSERT(lyx_view_ && lyx_view_->view());
 			static string last_search;
 			string searched_string;
 
@@ -762,21 +780,24 @@ void LyXFunc::dispatch(FuncRequest const & cmd)
 
 			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));
+				find2string(searched_string, true, false, fw);
+			find(view(), FuncRequest(LFUN_WORD_FIND, data));
 			break;
 		}
 
 		case LFUN_COMMAND_PREFIX:
-			lyx_view_->message(lyx::from_utf8(keyseq->printOptions()));
+			BOOST_ASSERT(lyx_view_);
+			lyx_view_->message(from_utf8(keyseq->printOptions()));
 			break;
 
 		case LFUN_COMMAND_EXECUTE:
+			BOOST_ASSERT(lyx_view_);
 			lyx_view_->getToolbars().display("minibuffer", true);
 			lyx_view_->focus_command_buffer();
 			break;
 
 		case LFUN_CANCEL:
+			BOOST_ASSERT(lyx_view_ && lyx_view_->view());
 			keyseq->reset();
 			meta_fake_bit = key_modifier::none;
 			if (view()->buffer())
@@ -787,10 +808,11 @@ void LyXFunc::dispatch(FuncRequest const & cmd)
 
 		case LFUN_META_PREFIX:
 			meta_fake_bit = key_modifier::alt;
-			setMessage(lyx::from_utf8(keyseq->print()));
+			setMessage(from_utf8(keyseq->print()));
 			break;
 
 		case LFUN_BUFFER_TOGGLE_READ_ONLY:
+			BOOST_ASSERT(lyx_view_ && lyx_view_->view() && lyx_view_->buffer());
 			if (lyx_view_->buffer()->lyxvc().inUse())
 				lyx_view_->buffer()->lyxvc().toggleReadOnly();
 			else
@@ -809,9 +831,11 @@ void LyXFunc::dispatch(FuncRequest const & cmd)
 
 		case LFUN_BUFFER_CLOSE:
 			closeBuffer();
+			view()->update();
 			break;
 
 		case LFUN_BUFFER_WRITE:
+			BOOST_ASSERT(lyx_view_ && lyx_view_->buffer());
 			if (!lyx_view_->buffer()->isUnnamed()) {
 				docstring const str = bformat(_("Saving document %1$s..."),
 					 makeDisplayPath(lyx_view_->buffer()->fileName()));
@@ -820,15 +844,17 @@ void LyXFunc::dispatch(FuncRequest const & cmd)
 				lyx_view_->message(str + _(" done."));
 			} else
 				writeAs(lyx_view_->buffer());
-			update = false;
+			updateFlags = Update::None;
 			break;
 
 		case LFUN_BUFFER_WRITE_AS:
+			BOOST_ASSERT(lyx_view_ && lyx_view_->buffer());
 			writeAs(lyx_view_->buffer(), argument);
-			update = false;
+			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);
@@ -841,22 +867,27 @@ void LyXFunc::dispatch(FuncRequest const & cmd)
 		}
 
 		case LFUN_BUFFER_UPDATE:
+			BOOST_ASSERT(lyx_view_ && lyx_view_->buffer());
 			Exporter::Export(lyx_view_->buffer(), argument, true);
 			break;
 
 		case LFUN_BUFFER_VIEW:
+			BOOST_ASSERT(lyx_view_ && lyx_view_->buffer());
 			Exporter::preview(lyx_view_->buffer(), argument);
 			break;
 
 		case LFUN_BUILD_PROGRAM:
+			BOOST_ASSERT(lyx_view_ && lyx_view_->buffer());
 			Exporter::Export(lyx_view_->buffer(), "program", true);
 			break;
 
 		case LFUN_BUFFER_CHKTEX:
+			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")
 				lyx_view_->getDialogs().show("sendto");
 			else {
@@ -865,6 +896,7 @@ void LyXFunc::dispatch(FuncRequest const & cmd)
 			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);
@@ -907,6 +939,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, ' '),
@@ -934,7 +967,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
@@ -1002,17 +1035,26 @@ void LyXFunc::dispatch(FuncRequest const & cmd)
 			break;
 
 		case LFUN_LYX_QUIT:
-			if (view()->buffer()) {
+			if (argument != "force") {
+				if (!theApp->gui().closeAll())
+					break;
+				lyx_view_ = 0;
+			}
+
+			// FIXME: this code needs to be transfered somewhere else
+			// as lyx_view_ will most certainly be null and a same buffer
+			// might be visible in more than one LyXView.
+			if (lyx_view_ && lyx_view_->view()->buffer()) {
 				// save cursor Position for opened files to .lyx/session
-				LyX::ref().session().saveFilePosition(lyx_view_->buffer()->fileName(),
+				LyX::ref().session().lastFilePos().save(lyx_view_->buffer()->fileName(),
 					boost::tie(view()->cursor().pit(), view()->cursor().pos()) );
-				// save bookmarks to .lyx/session
-				view()->saveSavedPositions();
-			}			
-			LyX::ref().quit(argument == "force");
+			}
+
+			LyX::ref().quit();
 			break;
 
 		case LFUN_TOC_VIEW: {
+			BOOST_ASSERT(lyx_view_);
 			InsetCommandParams p("tableofcontents");
 			string const data = InsetCommandMailer::params2string("toc", p);
 			lyx_view_->getDialogs().show("toc", data, 0);
@@ -1024,10 +1066,12 @@ 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"));
@@ -1047,6 +1091,7 @@ void LyXFunc::dispatch(FuncRequest const & cmd)
 
 		// --- version control -------------------------------
 		case LFUN_VC_REGISTER:
+			BOOST_ASSERT(lyx_view_ && lyx_view_->buffer());
 			if (!ensureBufferClean(view()))
 				break;
 			if (!lyx_view_->buffer()->lyxvc().inUse()) {
@@ -1056,6 +1101,7 @@ void LyXFunc::dispatch(FuncRequest const & cmd)
 			break;
 
 		case LFUN_VC_CHECK_IN:
+			BOOST_ASSERT(lyx_view_ && lyx_view_->buffer());
 			if (!ensureBufferClean(view()))
 				break;
 			if (lyx_view_->buffer()->lyxvc().inUse()
@@ -1066,6 +1112,7 @@ void LyXFunc::dispatch(FuncRequest const & cmd)
 			break;
 
 		case LFUN_VC_CHECK_OUT:
+			BOOST_ASSERT(lyx_view_ && lyx_view_->buffer());
 			if (!ensureBufferClean(view()))
 				break;
 			if (lyx_view_->buffer()->lyxvc().inUse()
@@ -1076,58 +1123,69 @@ void LyXFunc::dispatch(FuncRequest const & cmd)
 			break;
 
 		case LFUN_VC_REVERT:
+			BOOST_ASSERT(lyx_view_ && lyx_view_->buffer());
 			lyx_view_->buffer()->lyxvc().revert();
 			view()->reload();
 			break;
 
 		case LFUN_VC_UNDO_LAST:
+			BOOST_ASSERT(lyx_view_ && lyx_view_->buffer());
 			lyx_view_->buffer()->lyxvc().undoLast();
 			view()->reload();
 			break;
 
 		// --- buffers ----------------------------------------
 		case LFUN_BUFFER_SWITCH:
+			BOOST_ASSERT(lyx_view_);
 			lyx_view_->setBuffer(theBufferList().getBuffer(argument));
 			break;
 
 		case LFUN_BUFFER_NEXT:
+			BOOST_ASSERT(lyx_view_);
 			lyx_view_->setBuffer(theBufferList().next(view()->buffer()));
 			break;
 
 		case LFUN_BUFFER_PREVIOUS:
+			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:
+			BOOST_ASSERT(lyx_view_);
 			lyx_view_->getToolbars().openLayoutList();
 			break;
 
 		case LFUN_MENU_OPEN:
-			lyx_view_->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(lyx_view_->buffer()->fileName()));
+			BOOST_ASSERT(lyx_view_ && lyx_view_->buffer());
+			setMessage(from_utf8(lyx_view_->buffer()->fileName()));
 			lyxerr[Debug::INFO] << "FNAME["
 							 << lyx_view_->buffer()->fileName()
 							 << "] " << endl;
 			break;
 
 		case LFUN_SERVER_NOTIFY:
-			dispatch_buffer = lyx::from_utf8(keyseq->print());
-			theLyXServer().notifyClient(lyx::to_utf8(dispatch_buffer));
+			dispatch_buffer = from_utf8(keyseq->print());
+			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);
@@ -1156,8 +1214,9 @@ void LyXFunc::dispatch(FuncRequest const & cmd)
 		}
 
 		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();
@@ -1186,12 +1245,14 @@ void LyXFunc::dispatch(FuncRequest const & cmd)
 		}
 
 		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") {
@@ -1238,6 +1299,7 @@ void LyXFunc::dispatch(FuncRequest const & cmd)
 		}
 
 		case LFUN_DIALOG_UPDATE: {
+			BOOST_ASSERT(lyx_view_);
 			string const & name = argument;
 			// Can only update a dialog connected to an existing inset
 			InsetBase * inset = lyx_view_->getDialogs().getOpenInset(name);
@@ -1257,11 +1319,13 @@ void LyXFunc::dispatch(FuncRequest const & cmd)
 			break;
 
 		case LFUN_DIALOG_DISCONNECT_INSET:
+			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>
@@ -1285,12 +1349,13 @@ void LyXFunc::dispatch(FuncRequest const & cmd)
 		}
 
 		case LFUN_BUFFER_CHILD_OPEN: {
+			BOOST_ASSERT(lyx_view_);
 			string const filename =
 				makeAbsPath(argument, lyx_view_->buffer()->filePath());
 			// FIXME Should use bformat
 			setMessage(_("Opening child document ") +
 					 makeDisplayPath(filename) + "...");
-			view()->savePosition(0);
+			view()->saveBookmark(false);
 			string const parentfilename = lyx_view_->buffer()->fileName();
 			if (theBufferList().exists(filename))
 				lyx_view_->setBuffer(theBufferList().getBuffer(filename));
@@ -1304,22 +1369,27 @@ void LyXFunc::dispatch(FuncRequest const & cmd)
 		}
 
 		case LFUN_TOGGLE_CURSOR_FOLLOWS_SCROLLBAR:
+			BOOST_ASSERT(lyx_view_);
 			lyxrc.cursor_follows_scrollbar = !lyxrc.cursor_follows_scrollbar;
 			break;
 
 		case LFUN_KEYMAP_OFF:
+			BOOST_ASSERT(lyx_view_);
 			lyx_view_->view()->getIntl().keyMapOn(false);
 			break;
 
 		case LFUN_KEYMAP_PRIMARY:
+			BOOST_ASSERT(lyx_view_);
 			lyx_view_->view()->getIntl().keyMapPrim();
 			break;
 
 		case LFUN_KEYMAP_SECONDARY:
+			BOOST_ASSERT(lyx_view_);
 			lyx_view_->view()->getIntl().keyMapSec();
 			break;
 
 		case LFUN_KEYMAP_TOGGLE:
+			BOOST_ASSERT(lyx_view_);
 			lyx_view_->view()->getIntl().toggleKeyMap();
 			break;
 
@@ -1350,12 +1420,13 @@ void LyXFunc::dispatch(FuncRequest const & cmd)
 		}
 
 		case LFUN_PREFERENCES_SAVE: {
-			lyx::support::Path p(package().user_support());
+			support::Path p(package().user_support());
 			lyxrc.write("preferences", false);
 			break;
 		}
 
 		case LFUN_SCREEN_FONT_UPDATE:
+			BOOST_ASSERT(lyx_view_);
 			// handle the screen font changes.
 			lyxrc.set_font_norm_type();
 			theFontLoader().update();
@@ -1381,7 +1452,7 @@ 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;
 			}
 
@@ -1392,17 +1463,19 @@ void LyXFunc::dispatch(FuncRequest const & cmd)
 #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:
-			lyx_view_->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;
@@ -1415,6 +1488,7 @@ void LyXFunc::dispatch(FuncRequest const & cmd)
 		}
 
 		case LFUN_INSET_APPLY: {
+			BOOST_ASSERT(lyx_view_);
 			string const name = cmd.getArg(0);
 			InsetBase * inset = lyx_view_->getDialogs().getOpenInset(name);
 			if (inset) {
@@ -1426,11 +1500,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 =
@@ -1450,11 +1525,12 @@ void LyXFunc::dispatch(FuncRequest const & cmd)
 					it->dispatch(tmpcur, fr);
 				}
 			}
-			updateforce = true;
+			updateFlags = Update::Force | Update::FitCursor;
 			break;
 		}
 
 		case LFUN_BUFFER_LANGUAGE: {
+			BOOST_ASSERT(lyx_view_);
 			Buffer & buffer = *lyx_view_->buffer();
 			Language const * oldL = buffer.params().language;
 			Language const * newL = languages.getLanguage(argument);
@@ -1497,6 +1573,7 @@ void LyXFunc::dispatch(FuncRequest const & cmd)
 		}
 
 		case LFUN_BUFFER_PARAMS_APPLY: {
+			BOOST_ASSERT(lyx_view_);
 			biblio::CiteEngine const engine =
 				lyx_view_->buffer()->params().cite_engine;
 
@@ -1528,20 +1605,21 @@ void LyXFunc::dispatch(FuncRequest const & cmd)
 		}
 
 		case LFUN_TEXTCLASS_APPLY: {
+			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;
@@ -1551,7 +1629,7 @@ void LyXFunc::dispatch(FuncRequest const & cmd)
 			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);
 
@@ -1559,7 +1637,7 @@ void LyXFunc::dispatch(FuncRequest const & cmd)
 
 			buffer->errors("Class Switch");
 			updateLabels(*buffer);
-			updateforce = true;
+			updateFlags = Update::Force | Update::FitCursor;
 			break;
 		}
 
@@ -1584,25 +1662,69 @@ void LyXFunc::dispatch(FuncRequest const & cmd)
 			break;
 		}
 
+		case LFUN_WINDOW_NEW:
+			LyX::ref().newLyXView();
+			break;
+
+		case LFUN_WINDOW_CLOSE:
+			BOOST_ASSERT(lyx_view_);
+			BOOST_ASSERT(theApp);
+			lyx_view_->close();
+			// We return here because lyx_view does not exists anymore.
+			return;
+
+		case LFUN_BOOKMARK_GOTO: {
+			BOOST_ASSERT(lyx_view_);
+			unsigned int idx = convert<unsigned int>(to_utf8(cmd.argument()));
+			BookmarksSection::Bookmark const bm = LyX::ref().session().bookmarks().bookmark(idx);
+			BOOST_ASSERT(!bm.filename.empty());
+			// if the file is not opened, open it.
+			if (!theBufferList().exists(bm.filename))
+				dispatch(FuncRequest(LFUN_FILE_OPEN, bm.filename));
+			// open may fail, so we need to test it again
+			if (theBufferList().exists(bm.filename)) {
+				// if the current buffer is not that one, switch to it.
+				if (lyx_view_->buffer()->fileName() != bm.filename)
+					dispatch(FuncRequest(LFUN_BUFFER_SWITCH, bm.filename));
+				// BOOST_ASSERT(lyx_view_->buffer()->fileName() != bm.filename);
+				view()->moveToPosition(bm.par_id, bm.par_pos);
+			} 
+			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);
+				if (view()->dispatch(cmd)) 
+					updateFlags = Update::Force | Update::FitCursor;
 			break;
 		}
 		}
 
-		if (view()->buffer()) {
+		if (lyx_view_ && 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);
+			bool needSecondUpdate = false;
+			if (updateFlags != Update::None)
+				view()->update(updateFlags);
+			else
+				needSecondUpdate = view()->fitCursor();
 
-			lyx_view_->redrawWorkArea();
+			if (needSecondUpdate || updateFlags != Update::None) {
+				view()->buffer()->changed(updateFlags & Update::SinglePar);
+			}
+			lyx_view_->updateStatusBar();
 
 			// if we executed a mutating lfun, mark the buffer as dirty
 			if (flag.enabled()
@@ -1615,30 +1737,22 @@ void LyXFunc::dispatch(FuncRequest const & cmd)
 			}
 		}
 	}
-	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) {
-		lyx_view_->updateMenubar();
-		lyx_view_->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())
 			lyx_view_->message(msg);
 		return;
@@ -1654,7 +1768,7 @@ void LyXFunc::sendDispatchMessage(docstring const & msg, FuncRequest const & cmd
 
 	if (!cmd.argument().empty()) {
 		if (cmd.action != LFUN_UNKNOWN_ACTION) {
-			comname += ' ' + lyx::to_utf8(cmd.argument());
+			comname += ' ' + to_utf8(cmd.argument());
 			argsadded = true;
 		}
 	}
@@ -1664,15 +1778,15 @@ void LyXFunc::sendDispatchMessage(docstring const & msg, FuncRequest const & cmd
 	if (!shortcuts.empty())
 		comname += ": " + shortcuts;
 	else if (!argsadded && !cmd.argument().empty())
-		comname += ' ' + lyx::to_utf8(cmd.argument());
+		comname += ' ' + to_utf8(cmd.argument());
 
 	if (!comname.empty()) {
 		comname = rtrim(comname);
-		dispatch_msg += lyx::from_utf8('(' + rtrim(comname) + ')');
+		dispatch_msg += from_utf8('(' + rtrim(comname) + ')');
 	}
 
 	lyxerr[Debug::ACTION] << "verbose dispatch msg "
-		<< lyx::to_utf8(dispatch_msg) << endl;
+		<< to_utf8(dispatch_msg) << endl;
 	if (!dispatch_msg.empty())
 		lyx_view_->message(dispatch_msg);
 }
@@ -1708,11 +1822,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());
 
@@ -1720,7 +1834,7 @@ 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());
@@ -1745,18 +1859,18 @@ 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()) {
@@ -1820,25 +1934,25 @@ 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())
@@ -1854,7 +1968,7 @@ void LyXFunc::doImport(string const & argument)
 	string const lyxfile = changeExtension(filename, ".lyx");
 
 	// Check if the document already is open
-	if (lyx::use_gui && theBufferList().exists(lyxfile)) {
+	if (use_gui && theBufferList().exists(lyxfile)) {
 		if (!theBufferList().close(theBufferList().getBuffer(lyxfile), true)) {
 			lyx_view_->message(_("Canceled."));
 			return;
@@ -1886,7 +2000,7 @@ void LyXFunc::doImport(string const & argument)
 void LyXFunc::closeBuffer()
 {
 	// save current cursor position
-	LyX::ref().session().saveFilePosition(lyx_view_->buffer()->fileName(),
+	LyX::ref().session().lastFilePos().save(lyx_view_->buffer()->fileName(),
 		boost::tie(view()->cursor().pit(), view()->cursor().pos()) );
 	if (theBufferList().close(lyx_view_->buffer(), true) && !quitting) {
 		if (theBufferList().empty()) {
@@ -1932,7 +2046,7 @@ string const LyXFunc::viewStatusMessage()
 		return keyseq->printOptions();
 
 	if (!view()->buffer())
-		return lyx::to_utf8(_("Welcome to LyX!"));
+		return to_utf8(_("Welcome to LyX!"));
 
 	return view()->cursor().currentState();
 }
@@ -1991,8 +2105,7 @@ void actOnUpdatedPrefs(LyXRC const & lyxrc_orig, LyXRC const & lyxrc_new)
 		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;
+				support::package().document_dir() = lyxrc.document_path;
 			}
 		}
 	case LyXRC::RC_ESC_CHARS:
@@ -2017,8 +2130,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:
@@ -2069,8 +2181,7 @@ 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:
@@ -2089,3 +2200,6 @@ void actOnUpdatedPrefs(LyXRC const & lyxrc_orig, LyXRC const & lyxrc_new)
 }
 
 } // namespace anon
+
+
+} // namespace lyx