X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Flyx_main.C;h=7b4b8ce795c6bcff9aa1f72a2aee920498bdfba6;hb=1fa0fb5c67656cacbe3cfe6e8b08dd98cada1f73;hp=d95b6a9842535f740b60bab71e673078095fda9a;hpb=a45afb24a48241fa2dbdb20770eead62796f4214;p=lyx.git

diff --git a/src/lyx_main.C b/src/lyx_main.C
index d95b6a9842..7b4b8ce795 100644
--- a/src/lyx_main.C
+++ b/src/lyx_main.C
@@ -1,213 +1,309 @@
-/* This file is part of
- * ====================================================== 
- * 
- *           LyX, The Document Processor
- * 	 
- *           Copyright 1995 Matthias Ettrich
- *           Copyright 1995-2001 The LyX Team.
+/**
+ * \file lyx_main.C
+ * This file is part of LyX, the document processor.
+ * Licence details can be found in the file COPYING.
  *
- * ====================================================== */
+ * \author Alfredo Braunstein
+ * \author Lars Gullik Bjønnes
+ * \author Jean-Marc Lasgouttes
+ * \author John Levon
+ * \author André Pönitz
+ *
+ * Full author contact details are available in file CREDITS.
+ */
 
 #include <config.h>
-
-#include <cstdlib>
-#include <csignal>
-
-#ifdef __GNUG__
-#pragma implementation
-#endif
-
 #include <version.h>
+
 #include "lyx_main.h"
-#include "lyx_gui.h"
-#include "LyXView.h"
-#include "lyxfunc.h"
-#include "frontends/Alert.h"
-#include "frontends/GUIRunTime.h"
-#include "lyxrc.h"
-#include "support/path.h"
-#include "support/filetools.h"
+
 #include "buffer.h"
+#include "buffer_funcs.h"
 #include "bufferlist.h"
+#include "converter.h"
 #include "debug.h"
-#include "support/FileInfo.h"
-#include "lastfiles.h"
-#include "intl.h"
-#include "lyxserver.h"
-#include "layout.h"
+#include "encoding.h"
+#include "errorlist.h"
+#include "format.h"
 #include "gettext.h"
 #include "kbmap.h"
-#include "MenuBackend.h"
-#include "ToolbarDefaults.h"
-#include "lyxlex.h"
-#include "encoding.h"
-#include "converter.h"
 #include "language.h"
+#include "lastfiles.h"
+#include "LColor.h"
+#include "lyxfunc.h"
+#include "lyxlex.h"
+#include "lyxrc.h"
+#include "lyxtextclasslist.h"
+#include "lyxserver.h"
+#include "MenuBackend.h"
+#include "ToolbarBackend.h"
+
+#include "mathed/math_inset.h"
+
+#include "frontends/Alert.h"
+#include "frontends/lyx_gui.h"
+#include "frontends/LyXView.h"
+
+#include "support/FileInfo.h"
+#include "support/filetools.h"
+#include "support/lyxlib.h"
 #include "support/os.h"
+#include "support/path.h"
+#include "support/path_defines.h"
+
+#include <boost/bind.hpp>
+
+#include <iostream>
+#include <csignal>
+
+using lyx::support::AddName;
+using lyx::support::AddPath;
+using lyx::support::bformat;
+using lyx::support::createDirectory;
+using lyx::support::createLyXTmpDir;
+using lyx::support::FileInfo;
+using lyx::support::FileSearch;
+using lyx::support::GetEnv;
+using lyx::support::GetEnvPath;
+using lyx::support::i18nLibFileSearch;
+using lyx::support::LibFileSearch;
+using lyx::support::Path;
+using lyx::support::rtrim;
+using lyx::support::setLyxPaths;
+using lyx::support::system_lyxdir;
+using lyx::support::user_lyxdir;
+
+using lyx::support::os::getTmpDir;
+using lyx::support::os::setTmpDir;
 
 using std::endl;
+using std::string;
+using std::vector;
 
 #ifndef CXX_GLOBAL_CSTD
+using std::exit;
 using std::signal;
+using std::system;
 #endif
 
-extern void LoadLyXFile(string const &);
-extern void QuitLyX();
-
-string system_lyxdir;
-string build_lyxdir;
-string system_tempdir;
-string user_lyxdir;	// Default $HOME/.lyx
 
-// Should this be kept global? Asger says Yes.
-DebugStream lyxerr;
+extern void QuitLyX();
 
-boost::scoped_ptr<LastFiles> lastfiles;
+extern LyXServer * lyxserver;
 
 // This is the global bufferlist object
 BufferList bufferlist;
 
-LyXServer * lyxserver = 0;
-// this should be static, but I need it in buffer.C
-bool finished = false;	// flag, that we are quitting the program
-
 // convenient to have it here.
 boost::scoped_ptr<kb_keymap> toplevel_keymap;
 
+namespace {
+
+void showFileError(string const & error)
+{
+	Alert::warning(_("Could not read configuration file"),
+		   bformat(_("Error while reading the configuration file\n%1$s.\n"
+		     "Please check your installation."), error));
+	exit(EXIT_FAILURE);
+}
+
+} // namespace anon
+
+
+boost::scoped_ptr<LyX> LyX::singleton_;
+
+void LyX::exec(int & argc, char * argv[])
+{
+	BOOST_ASSERT(!singleton_.get());
+	// We must return from this before launching the gui so that
+	// other parts of the code can access singleton_ through
+	// LyX::ref and LyX::cref.
+	singleton_.reset(new LyX);
+	// Start the real execution loop.
+	singleton_->priv_exec(argc, argv);
+}
+
+
+LyX & LyX::ref()
+{
+	BOOST_ASSERT(singleton_.get());
+	return *singleton_.get();
+}
+
+
+LyX const & LyX::cref()
+{
+	BOOST_ASSERT(singleton_.get());
+	return *singleton_.get();
+}
+
+
+LyX::LyX()
+	: first_start(false)
+{}
+
+
+LastFiles & LyX::lastfiles()
+{
+	BOOST_ASSERT(lastfiles_.get());
+	return *lastfiles_.get();
+}
+
+
+LastFiles const & LyX::lastfiles() const
+{
+	BOOST_ASSERT(lastfiles_.get());
+	return *lastfiles_.get();
+}
+
+
+void LyX::addLyXView(boost::shared_ptr<LyXView> const & lyxview)
+{
+	views_.push_back(lyxview);
+}
+
+
+Buffer const * const LyX::updateInset(InsetBase const * inset) const
+{
+	if (!inset)
+		return 0;
+
+	Buffer const * buffer_ptr = 0;
+	ViewList::const_iterator it = views_.begin();
+	ViewList::const_iterator const end = views_.end();
+	for (; it != end; ++it) {
+		Buffer const * ptr = (*it)->updateInset(inset);
+		if (ptr)
+			buffer_ptr = ptr;
+	}
+	return buffer_ptr;
+}
 
-LyX::LyX(int * argc, char * argv[])
+
+void LyX::priv_exec(int & argc, char * argv[])
 {
 	// Here we need to parse the command line. At least
 	// we need to parse for "-dbg" and "-help"
-	bool gui = easyParse(argc, argv);
-
-	// Global bindings (this must be done as early as possible.) (Lgb)
-	toplevel_keymap.reset(new kb_keymap);
-	defaultKeyBindings(toplevel_keymap.get());
-	
-	// Make the GUI object, and let it take care of the
-	// command line arguments that concerns it.
-	lyxerr[Debug::INIT] << "Initializing LyXGUI..." << endl;
-	lyxGUI.reset(new LyXGUI(this, argc, argv, gui));
-	lyxerr[Debug::INIT] << "Initializing LyXGUI...done" << endl;
-
-	// Now the GUI and LyX have taken care of their arguments, so
-	// the only thing left on the command line should be
-	// filenames. Let's check anyway.
-	for (int argi = 1; argi < *argc ; ++argi) {
+	bool const want_gui = easyParse(argc, argv);
+
+	if (want_gui)
+		lyx_gui::parse_init(argc, argv);
+
+	// check for any spurious extra arguments
+	// other than documents
+	for (int argi = 1; argi < argc ; ++argi) {
 		if (argv[argi][0] == '-') {
-			lyxerr << _("Wrong command line option `")
-			       << argv[argi]
-			       << _("'. Exiting.") << endl;
-			exit(0);
+			lyxerr << bformat(_("Wrong command line option `%1$s'. Exiting."),
+				argv[argi]) << endl;
+			exit(1);
 		}
 	}
-	
+
 	// Initialization of LyX (reads lyxrc and more)
 	lyxerr[Debug::INIT] << "Initializing LyX::init..." << endl;
-	init(gui);
+	init(want_gui);
 	lyxerr[Debug::INIT] << "Initializing LyX::init...done" << endl;
 
-	lyxGUI->init();
+	if (want_gui)
+		lyx_gui::parse_lyxrc();
 
-	// Load the files specified in the command line.
-	if ((*argc) == 2) 
-		lyxerr[Debug::INFO] << "Opening document..." << endl;
-	else if ((*argc) > 2)
-		lyxerr[Debug::INFO] << "Opening documents..." << endl;
+	initMath();
 
-	Buffer * last_loaded = 0;
+	vector<string> files;
 
-	for (int argi = (*argc) - 1; argi >= 1; --argi) {
-		Buffer * loadb = bufferlist.loadLyXFile(argv[argi]);
-		if (loadb != 0) {
-			last_loaded = loadb;
-		}
-	}
-
-	if (first_start) {
-		string const splash =
-			i18nLibFileSearch("examples", "splash.lyx");
-		lyxerr[Debug::INIT] << "Opening splash document "
-			       << splash << "..." << endl;
-		Buffer * loadb = bufferlist.loadLyXFile(splash);
-		if (loadb != 0) {
-			last_loaded = loadb;
-		}
-	}
+	for (int argi = argc - 1; argi >= 1; --argi)
+		files.push_back(argv[argi]);
 
-	if (last_loaded != 0) {
-		lyxerr[Debug::INIT] << "Yes we loaded some files." << endl;
-		if (lyxrc.use_gui)
-			lyxGUI->regBuf(last_loaded);
-	}
+	if (first_start)
+		files.push_back(i18nLibFileSearch("examples", "splash.lyx"));
 
 	// Execute batch commands if available
 	if (!batch_command.empty()) {
-		lyxerr << "About to handle -x '"
-		       << batch_command << "'" << endl;
 
-		// no buffer loaded, create one
-		if (!last_loaded)
-			last_loaded = bufferlist.newFile("tmpfile", string());
+		lyxerr[Debug::INIT] << "About to handle -x '"
+		       << batch_command << '\'' << endl;
 
-		// try to dispatch to last loaded buffer first
-		bool dispatched	= last_loaded->dispatch(batch_command);
+		Buffer * last_loaded = 0;
 
-		// if this was successful, return. 
-		// Maybe we could do something more clever than aborting...
-		if (dispatched) {
-			lyxerr << "We are done!" << endl;
-			QuitLyX();
-			return;
-		}
+		vector<string>::const_iterator it = files.begin();
+		vector<string>::const_iterator end = files.end();
 
-		// otherwise, let the GUI handle the batch command
-		lyxGUI->regBuf(last_loaded);
-		lyxGUI->getLyXView()->getLyXFunc()->dispatch(batch_command);
+		for (; it != end; ++it) {
+			// get absolute path of file and add ".lyx" to
+			// the filename if necessary
+			string s = FileSearch(string(), *it, "lyx");
+			if (s.empty()) {
+				last_loaded = newFile(*it, string(), true);
+			} else {
+				Buffer * buf = bufferlist.newBuffer(s, false);
+				buf->error.connect(boost::bind(&LyX::printError, this, _1));
+				if (loadLyXFile(buf, s))
+					last_loaded = buf;
+				else
+					bufferlist.release(buf);
+			}
+		}
 
-		// fall through...
+		// try to dispatch to last loaded buffer first
+		if (last_loaded) {
+			bool success = false;
+			if (last_loaded->dispatch(batch_command, &success)) {
+				QuitLyX();
+				exit(!success);
+			}
+		}
+		files.clear(); // the files are already loaded
 	}
-	
-	// Let the ball begin...
-	lyxGUI->runTime();
-}
-
 
-// A destructor is always necessary  (asierra-970604)
-LyX::~LyX()
-{
+	lyx_gui::start(batch_command, files);
 }
 
 
 extern "C" {
-	
-static
-void error_handler(int err_sig)
+
+static void error_handler(int err_sig)
 {
+	// Throw away any signals other than the first one received.
+	static sig_atomic_t handling_error = false;
+	if (handling_error)
+		return;
+	handling_error = true;
+
+	// We have received a signal indicating a fatal error, so
+	// try and save the data ASAP.
+	LyX::cref().emergencyCleanup();
+
+	// These lyxerr calls may or may not work:
+
+	// Signals are asynchronous, so the main program may be in a very
+	// fragile state when a signal is processed and thus while a signal
+	// handler function executes.
+	// In general, therefore, we should avoid performing any
+	// I/O operations or calling most library and system functions from
+	// signal handlers.
+
+	// This shouldn't matter here, however, as we've already invoked
+	// emergencyCleanup.
 	switch (err_sig) {
 	case SIGHUP:
-		lyxerr << "\nlyx: SIGHUP signal caught" << endl;
-		break;
-	case SIGINT:
-		// no comments
+		lyxerr << "\nlyx: SIGHUP signal caught\nBye." << endl;
 		break;
 	case SIGFPE:
-		lyxerr << "\nlyx: SIGFPE signal caught" << endl;
+		lyxerr << "\nlyx: SIGFPE signal caught\nBye." << endl;
 		break;
 	case SIGSEGV:
-		lyxerr << "\nlyx: SIGSEGV signal caught" << endl;
-		lyxerr <<
-			"Sorry, you have found a bug in LyX. "
-			"Please read the bug-reporting instructions " 
-			"in Help->Introduction and send us a bug report, "
-			"if necessary. Thanks !" << endl;
+		lyxerr << "\nlyx: SIGSEGV signal caught\n"
+		          "Sorry, you have found a bug in LyX. "
+		          "Please read the bug-reporting instructions "
+		          "in Help->Introduction and send us a bug report, "
+		          "if necessary. Thanks !\nBye." << endl;
 		break;
+	case SIGINT:
 	case SIGTERM:
 		// no comments
 		break;
 	}
-   
+
 	// Deinstall the signal handlers
 	signal(SIGHUP, SIG_DFL);
 	signal(SIGINT, SIG_DFL);
@@ -215,190 +311,33 @@ void error_handler(int err_sig)
 	signal(SIGSEGV, SIG_DFL);
 	signal(SIGTERM, SIG_DFL);
 
-	LyX::emergencyCleanup();
-
-	lyxerr << "Bye." << endl;
-	if (err_sig!= SIGHUP && 
-	   (!GetEnv("LYXDEBUG").empty() || err_sig == SIGSEGV))
-		lyx::abort();
+	if (err_sig == SIGSEGV ||
+	    (err_sig != SIGHUP && !GetEnv("LYXDEBUG").empty()))
+		lyx::support::abort();
 	exit(0);
 }
 
 }
 
 
+void LyX::printError(ErrorItem const & ei)
+{
+	std::cerr << _("LyX: ") << ei.error
+		  << ':' << ei.description << std::endl;
+
+}
+
+
 void LyX::init(bool gui)
 {
-	// Install the signal handlers
 	signal(SIGHUP, error_handler);
 	signal(SIGFPE, error_handler);
 	signal(SIGSEGV, error_handler);
 	signal(SIGINT, error_handler);
 	signal(SIGTERM, error_handler);
+	// SIGPIPE can be safely ignored.
 
-	//
-	// Determine path of binary
-	//
-
-	string fullbinpath;
-	string binpath = os::binpath();
-	string binname = os::binname();
-	fullbinpath = binpath;
-
-	if (binpath.empty()) {
-		lyxerr << _("Warning: could not determine path of binary.")
-		       << "\n"
-		       << _("If you have problems, try starting LyX with an absolute path.")
-		       << endl;
-	}
-	lyxerr[Debug::INIT] << "Path of binary: " << binpath << endl;
-
-	//
-	// Determine system directory.
-	//
-
-	// Directories are searched in this order:
-	// 1) -sysdir command line parameter
-	// 2) LYX_DIR_11x environment variable
-	// 3) Maybe <path of binary>/TOP_SRCDIR/lib
-	// 4) <path of binary>/../share/<name of binary>/
-	// 4a) repeat 4 after following the Symlink if <path of
-	//     binary> is a symbolic link.
-	// 5) hardcoded lyx_dir
-	// The directory is checked for the presence of the file
-	// "chkconfig.ltx", and if that is present, the directory
-	// is accepted as the system directory.
-	// If no chkconfig.ltx file is found, a warning is given,
-	// and the hardcoded lyx_dir is used.
-
-	// If we had a command line switch, system_lyxdir is already set
-	string searchpath;
-	if (!system_lyxdir.empty())
-		searchpath= MakeAbsPath(system_lyxdir) + ';';
-
-	// LYX_DIR_11x environment variable
-	string const lyxdir = GetEnvPath("LYX_DIR_11x");
-	
-	if (!lyxdir.empty()) {
-		lyxerr[Debug::INIT] << "LYX_DIR_11x: " << lyxdir << endl;
-		searchpath += lyxdir + ';';
-	}
-
-	// <path of binary>/TOP_SRCDIR/lib
-	build_lyxdir = MakeAbsPath("../lib", binpath);
-	if (!FileSearch(build_lyxdir, "lyxrc.defaults").empty()) {
-		searchpath += MakeAbsPath(AddPath(TOP_SRCDIR, "lib"),
-					  binpath) + ';';
-		lyxerr[Debug::INIT] << "Checking whether LyX is run in "
-			"place... yes" << endl;
-	} else {
-		lyxerr[Debug::INIT]
-			<< "Checking whether LyX is run in place... no"
-			<< endl;
-		build_lyxdir.erase();
-	}
-
-        bool followlink;
-	do {
-	  // Path of binary/../share/name of binary/
-		searchpath += NormalizePath(AddPath(binpath, "../share/") + 
-		      OnlyFilename(binname)) + ';';
-
-	  // Follow Symlinks
-		FileInfo file(fullbinpath, true);
-		followlink = file.isLink();
-		if (followlink) {
-			string link;
-			if (LyXReadLink(fullbinpath, link)) {
-				fullbinpath = link;
-				binpath = MakeAbsPath(OnlyPath(fullbinpath));
-			}
-			else {
-				followlink = false;
-			}
-		}
-	} while (followlink);
-
-	// Hardcoded dir
-	searchpath += LYX_DIR;
-
-	// If debugging, show complete search path
-	lyxerr[Debug::INIT] << "System directory search path: "
-			    << searchpath << endl;
-
-	string const filename = "chkconfig.ltx";
-	string const temp = FileOpenSearch(searchpath, filename, string());
-	system_lyxdir = OnlyPath(temp);
-
-	// Reduce "path/../path" stuff out of system directory
-	system_lyxdir = NormalizePath(system_lyxdir);
-
-	bool path_shown = false;
-
-	// Warn if environment variable is set, but unusable
-	if (!lyxdir.empty()) {
-		if (system_lyxdir != NormalizePath(lyxdir)) {
-			lyxerr <<_("LYX_DIR_11x environment variable no good.")
-			       << '\n'
-			       << _("System directory set to: ") 
-			       << system_lyxdir << endl;
-			path_shown = true;
-		}
-	}
-
-	// Warn the user if we couldn't find "chkconfig.ltx"
-	if (system_lyxdir == "./") {
-		lyxerr <<_("LyX Warning! Couldn't determine system directory. ")
-		       <<_("Try the '-sysdir' command line parameter or ")
-		       <<_("set the environment variable LYX_DIR_11x to the "
-			   "LyX system directory ")
-		       << _("containing the file `chkconfig.ltx'.") << endl;
-		if (!path_shown) {
-			FileInfo fi(LYX_DIR);
-			if (!fi.exist()) {
-				lyxerr << "Couldn't even find the default LYX_DIR." << endl
-					<< "Giving up." << endl;
-				exit(1);
-			}
-			lyxerr << _("Using built-in default ") 
-			       << LYX_DIR << _(" but expect problems.")
-			       << endl;
-		} else {
-			lyxerr << _("Expect problems.") << endl;
-		}
-		system_lyxdir = LYX_DIR;
-		path_shown = true;
-	}
-	// Report the system directory if debugging is on
-	if (!path_shown)
-		lyxerr[Debug::INIT] << "System directory: '"
-				    << system_lyxdir << '\'' << endl; 
-
-	//
-	// Determine user lyx-dir
-	//
-	
-	// Directories are searched in this order:
-	// 1) -userdir command line parameter
-	// 2) LYX_USERDIR_11x environment variable
-	// 3) $HOME/.<name of binary>
-
-	// If we had a command line switch, user_lyxdir is already set
-	bool explicit_userdir = true;
-	if (user_lyxdir.empty()) {
-
-		// LYX_USERDIR_11x environment variable
-		user_lyxdir = GetEnvPath("LYX_USERDIR_11x");
-
-		// default behaviour
-		if (user_lyxdir.empty())
-			user_lyxdir = AddPath(GetEnvPath("HOME"),
-							string(".") + PACKAGE);
-			explicit_userdir = false;
-	}
-
-	lyxerr[Debug::INIT] << "User LyX directory: '" 
-			    <<  user_lyxdir << '\'' << endl;
+	bool const explicit_userdir = setLyxPaths();
 
 	// Check that user LyX directory is ok. We don't do that if
 	// running in batch mode.
@@ -407,34 +346,25 @@ void LyX::init(bool gui)
 	} else {
 		first_start = false;
 	}
-	
-	//
-	// Shine up lyxrc defaults
-	//
 
-	// Default template path: system_dir/templates
-	if (lyxrc.template_path.empty()){
-		lyxrc.template_path = AddPath(system_lyxdir, "templates");
-	}
-   
-	// Default lastfiles file: $HOME/.lyx/lastfiles
-	if (lyxrc.lastfiles.empty()){
-		lyxrc.lastfiles = AddName(user_lyxdir, "lastfiles");
+	// Disable gui when easyparse says so
+	lyx_gui::use_gui = gui;
+
+	if (lyxrc.template_path.empty()) {
+		lyxrc.template_path = AddPath(system_lyxdir(), "templates");
 	}
 
-	// Disable gui when either lyxrc or easyparse says so
-	if (!gui)
-		lyxrc.use_gui = false;
- 
-        // Calculate screen dpi as average of x-DPI and y-DPI:
-	if (lyxrc.use_gui) {
-		lyxrc.dpi = GUIRunTime::getScreenDPI();
-		lyxerr[Debug::INIT] << "DPI setting detected to be "
-                                                << lyxrc.dpi + 0.5 << endl;
-	} else {
-		lyxrc.dpi = 1; // I hope this is safe
+	if (lyxrc.lastfiles.empty()) {
+		lyxrc.lastfiles = AddName(user_lyxdir(), "lastfiles");
 	}
 
+	if (lyxrc.roman_font_name.empty())
+		lyxrc.roman_font_name = lyx_gui::roman_font_name();
+	if (lyxrc.sans_font_name.empty())
+		lyxrc.sans_font_name = lyx_gui::sans_font_name();
+	if (lyxrc.typewriter_font_name.empty())
+		lyxrc.typewriter_font_name = lyx_gui::typewriter_font_name();
+
 	//
 	// Read configuration files
 	//
@@ -445,222 +375,209 @@ void LyX::init(bool gui)
 	system_converters = converters;
 	system_lcolor = lcolor;
 
-	// If there is a preferences file we read that instead
-	// of the old lyxrc file.
-	if (!readRcFile("preferences"))
-	    readRcFile("lyxrc");
+	string prefsfile = "preferences";
+	// back compatibility to lyxs < 1.1.6
+	if (LibFileSearch(string(), prefsfile).empty())
+		prefsfile = "lyxrc";
+	if (!LibFileSearch(string(), prefsfile).empty())
+		readRcFile(prefsfile);
 
-	// Read encodings
 	readEncodingsFile("encodings");
-	// Read languages
 	readLanguagesFile("languages");
 
 	// Load the layouts
 	lyxerr[Debug::INIT] << "Reading layouts..." << endl;
 	LyXSetStyle();
 
-	// Ensure that we have really read a bind file, so that LyX is
-	// usable.
-	lyxrc.readBindFileIfNeeded();
-
-	// Read menus
-	readUIFile(lyxrc.ui_file);
+	if (gui) {
+		// Set up bindings
+		toplevel_keymap.reset(new kb_keymap);
+		defaultKeyBindings(toplevel_keymap.get());
+		toplevel_keymap->read(lyxrc.bind_file);
 
-	// Bind the X dead keys to the corresponding LyX functions if
-	// necessary. 
-	if (lyxrc.override_x_deadkeys)
-		deadKeyBindings(toplevel_keymap.get());
+		// Read menus
+		readUIFile(lyxrc.ui_file);
+	}
 
-	if (lyxerr.debugging(Debug::LYXRC)) {
+	if (lyxerr.debugging(Debug::LYXRC))
 		lyxrc.print();
+
+	setTmpDir(createLyXTmpDir(lyxrc.tempdir_path));
+	if (getTmpDir().empty()) {
+		Alert::error(_("Could not create temporary directory"),
+		             bformat(_("Could not create a temporary directory in\n"
+		                       "%1$s. Make sure that this\n"
+		                       "path exists and is writable and try again."),
+		                     lyxrc.tempdir_path));
+		// createLyXTmpDir() tries sufficiently hard to create a
+		// usable temp dir, so the probability to come here is
+		// close to zero. We therefore don't try to overcome this
+		// problem with e.g. asking the user for a new path and
+		// trying again but simply exit.
+		exit(EXIT_FAILURE);
 	}
 
-	// Create temp directory	
-	os::setTmpDir(CreateLyXTmpDir(lyxrc.tempdir_path));
-	system_tempdir = os::getTmpDir();
 	if (lyxerr.debugging(Debug::INIT)) {
-		lyxerr << "LyX tmp dir: `" << system_tempdir << '\'' << endl;
+		lyxerr << "LyX tmp dir: `" << getTmpDir() << '\'' << endl;
 	}
 
-	// load the lastfiles mini-database
 	lyxerr[Debug::INIT] << "Reading lastfiles `"
-			    << lyxrc.lastfiles << "'..." << endl; 
-	lastfiles.reset(new LastFiles(lyxrc.lastfiles, 
-				      lyxrc.check_lastfiles,
-				      lyxrc.num_lastfiles));
-
-	// start up the lyxserver. (is this a bit early?) (Lgb)
-	// 0.12 this will be way to early, we need the GUI to be initialized
-	// first, so move it for now.
-	// lyxserver = new LyXServer;
+			    << lyxrc.lastfiles << "'..." << endl;
+	lastfiles_.reset(new LastFiles(lyxrc.lastfiles,
+				       lyxrc.check_lastfiles,
+				       lyxrc.num_lastfiles));
 }
 
 
-// These are the default bindings known to LyX
 void LyX::defaultKeyBindings(kb_keymap  * kbmap)
 {
-	kbmap->bind("Right", LFUN_RIGHT);
-	kbmap->bind("Left", LFUN_LEFT);
-	kbmap->bind("Up", LFUN_UP);
-	kbmap->bind("Down", LFUN_DOWN);
-	
-	kbmap->bind("Tab", LFUN_TAB);
-	kbmap->bind("ISO_Left_Tab", LFUN_TAB); // jbl 2001-23-02
-	
-	kbmap->bind("Home", LFUN_HOME);
-	kbmap->bind("End", LFUN_END);
-	kbmap->bind("Prior", LFUN_PRIOR);
-	kbmap->bind("Next", LFUN_NEXT);
-	
-	kbmap->bind("Return", LFUN_BREAKPARAGRAPH);
-	//kbmap->bind("~C-~S-~M-nobreakspace", LFUN_PROTECTEDSPACE);
-	
-	kbmap->bind("Delete", LFUN_DELETE);
-	kbmap->bind("BackSpace", LFUN_BACKSPACE);
-
-	// sub- and superscript -MV
-	kbmap->bind("~S-underscore", LFUN_SUBSCRIPT);
-	kbmap->bind("~S-asciicircum", LFUN_SUPERSCRIPT);
-	
+	kbmap->bind("Right", FuncRequest(LFUN_RIGHT));
+	kbmap->bind("Left", FuncRequest(LFUN_LEFT));
+	kbmap->bind("Up", FuncRequest(LFUN_UP));
+	kbmap->bind("Down", FuncRequest(LFUN_DOWN));
+
+	kbmap->bind("Tab", FuncRequest(LFUN_CELL_FORWARD));
+	kbmap->bind("ISO_Left_Tab", FuncRequest(LFUN_CELL_FORWARD));
+
+	kbmap->bind("Home", FuncRequest(LFUN_HOME));
+	kbmap->bind("End", FuncRequest(LFUN_END));
+	kbmap->bind("Prior", FuncRequest(LFUN_PRIOR));
+	kbmap->bind("Next", FuncRequest(LFUN_NEXT));
+
+	kbmap->bind("Return", FuncRequest(LFUN_BREAKPARAGRAPH));
+	//kbmap->bind("~C-~S-~M-nobreakspace", FuncRequest(LFUN_PROTECTEDSPACE));
+
+	kbmap->bind("Delete", FuncRequest(LFUN_DELETE));
+	kbmap->bind("BackSpace", FuncRequest(LFUN_BACKSPACE));
+
 	// kbmap->bindings to enable the use of the numeric keypad
 	// e.g. Num Lock set
-	//kbmap->bind("KP_0", LFUN_SELFINSERT);
-	//kbmap->bind("KP_Decimal", LFUN_SELFINSERT);
-	kbmap->bind("KP_Enter", LFUN_BREAKPARAGRAPH);
-	//kbmap->bind("KP_1", LFUN_SELFINSERT);
-	//kbmap->bind("KP_2", LFUN_SELFINSERT);
-	//kbmap->bind("KP_3", LFUN_SELFINSERT);
-	//kbmap->bind("KP_4", LFUN_SELFINSERT);
-	//kbmap->bind("KP_5", LFUN_SELFINSERT);
-	//kbmap->bind("KP_6", LFUN_SELFINSERT);
-	//kbmap->bind("KP_Add", LFUN_SELFINSERT);
-	//kbmap->bind("KP_7", LFUN_SELFINSERT);
-	//kbmap->bind("KP_8", LFUN_SELFINSERT);
-	//kbmap->bind("KP_9", LFUN_SELFINSERT);
-	//kbmap->bind("KP_Divide", LFUN_SELFINSERT);
-	//kbmap->bind("KP_Multiply", LFUN_SELFINSERT);
-	//kbmap->bind("KP_Subtract", LFUN_SELFINSERT);
-	kbmap->bind("KP_Right", LFUN_RIGHT);
-	kbmap->bind("KP_Left", LFUN_LEFT);
-	kbmap->bind("KP_Up", LFUN_UP);
-	kbmap->bind("KP_Down", LFUN_DOWN);
-	kbmap->bind("KP_Home", LFUN_HOME);
-	kbmap->bind("KP_End", LFUN_END);
-	kbmap->bind("KP_Prior", LFUN_PRIOR);
-	kbmap->bind("KP_Next", LFUN_NEXT);
-	
-        kbmap->bind("C-Tab", LFUN_TABINSERT);  // ale970515
-	kbmap->bind("S-Tab", LFUN_SHIFT_TAB);  // jug20000522
-	kbmap->bind("S-ISO_Left_Tab", LFUN_SHIFT_TAB); // jbl 2001-23-02
+	//kbmap->bind("KP_0", FuncRequest(LFUN_SELFINSERT));
+	//kbmap->bind("KP_Decimal", FuncRequest(LFUN_SELFINSERT));
+	kbmap->bind("KP_Enter", FuncRequest(LFUN_BREAKPARAGRAPH));
+	//kbmap->bind("KP_1", FuncRequest(LFUN_SELFINSERT));
+	//kbmap->bind("KP_2", FuncRequest(LFUN_SELFINSERT));
+	//kbmap->bind("KP_3", FuncRequest(LFUN_SELFINSERT));
+	//kbmap->bind("KP_4", FuncRequest(LFUN_SELFINSERT));
+	//kbmap->bind("KP_5", FuncRequest(LFUN_SELFINSERT));
+	//kbmap->bind("KP_6", FuncRequest(LFUN_SELFINSERT));
+	//kbmap->bind("KP_Add", FuncRequest(LFUN_SELFINSERT));
+	//kbmap->bind("KP_7", FuncRequest(LFUN_SELFINSERT));
+	//kbmap->bind("KP_8", FuncRequest(LFUN_SELFINSERT));
+	//kbmap->bind("KP_9", FuncRequest(LFUN_SELFINSERT));
+	//kbmap->bind("KP_Divide", FuncRequest(LFUN_SELFINSERT));
+	//kbmap->bind("KP_Multiply", FuncRequest(LFUN_SELFINSERT));
+	//kbmap->bind("KP_Subtract", FuncRequest(LFUN_SELFINSERT));
+	kbmap->bind("KP_Right", FuncRequest(LFUN_RIGHT));
+	kbmap->bind("KP_Left", FuncRequest(LFUN_LEFT));
+	kbmap->bind("KP_Up", FuncRequest(LFUN_UP));
+	kbmap->bind("KP_Down", FuncRequest(LFUN_DOWN));
+	kbmap->bind("KP_Home", FuncRequest(LFUN_HOME));
+	kbmap->bind("KP_End", FuncRequest(LFUN_END));
+	kbmap->bind("KP_Prior", FuncRequest(LFUN_PRIOR));
+	kbmap->bind("KP_Next", FuncRequest(LFUN_NEXT));
+
+	kbmap->bind("C-Tab", FuncRequest(LFUN_CELL_SPLIT));
+	kbmap->bind("S-Tab", FuncRequest(LFUN_CELL_BACKWARD));
+	kbmap->bind("S-ISO_Left_Tab", FuncRequest(LFUN_CELL_BACKWARD));
 }
 
 
-void LyX::emergencyCleanup()
+void LyX::emergencyCleanup() const
 {
 	// what to do about tmpfiles is non-obvious. we would
 	// like to delete any we find, but our lyxdir might
 	// contain documents etc. which might be helpful on
 	// a crash
- 
+
 	bufferlist.emergencyWriteAll();
 	if (lyxserver)
 		lyxserver->emergencyCleanup();
 }
 
- 
-// LyX can optionally take over the handling of deadkeys
+
 void LyX::deadKeyBindings(kb_keymap * kbmap)
 {
 	// bindKeyings for transparent handling of deadkeys
 	// The keysyms are gotten from XFree86 X11R6
-	kbmap->bind("~C-~S-~M-dead_acute", LFUN_ACUTE);
-	kbmap->bind("~C-~S-~M-dead_breve", LFUN_BREVE);
-	kbmap->bind("~C-~S-~M-dead_caron", LFUN_CARON);
-	kbmap->bind("~C-~S-~M-dead_cedilla", LFUN_CEDILLA);
-	kbmap->bind("~C-~S-~M-dead_abovering", LFUN_CIRCLE);
-	kbmap->bind("~C-~S-~M-dead_circumflex", LFUN_CIRCUMFLEX);
-	kbmap->bind("~C-~S-~M-dead_abovedot", LFUN_DOT);
-	kbmap->bind("~C-~S-~M-dead_grave", LFUN_GRAVE);
-	kbmap->bind("~C-~S-~M-dead_doubleacute", LFUN_HUNG_UMLAUT);
-	kbmap->bind("~C-~S-~M-dead_macron", LFUN_MACRON);
+	kbmap->bind("~C-~S-~M-dead_acute", FuncRequest(LFUN_ACUTE));
+	kbmap->bind("~C-~S-~M-dead_breve", FuncRequest(LFUN_BREVE));
+	kbmap->bind("~C-~S-~M-dead_caron", FuncRequest(LFUN_CARON));
+	kbmap->bind("~C-~S-~M-dead_cedilla", FuncRequest(LFUN_CEDILLA));
+	kbmap->bind("~C-~S-~M-dead_abovering", FuncRequest(LFUN_CIRCLE));
+	kbmap->bind("~C-~S-~M-dead_circumflex", FuncRequest(LFUN_CIRCUMFLEX));
+	kbmap->bind("~C-~S-~M-dead_abovedot", FuncRequest(LFUN_DOT));
+	kbmap->bind("~C-~S-~M-dead_grave", FuncRequest(LFUN_GRAVE));
+	kbmap->bind("~C-~S-~M-dead_doubleacute", FuncRequest(LFUN_HUNG_UMLAUT));
+	kbmap->bind("~C-~S-~M-dead_macron", FuncRequest(LFUN_MACRON));
 	// nothing with this name
 	// kbmap->bind("~C-~S-~M-dead_special_caron", LFUN_SPECIAL_CARON);
-	kbmap->bind("~C-~S-~M-dead_tilde", LFUN_TILDE);
-	kbmap->bind("~C-~S-~M-dead_diaeresis", LFUN_UMLAUT);
+	kbmap->bind("~C-~S-~M-dead_tilde", FuncRequest(LFUN_TILDE));
+	kbmap->bind("~C-~S-~M-dead_diaeresis", FuncRequest(LFUN_UMLAUT));
 	// nothing with this name either...
-	//kbmap->bind("~C-~S-~M-dead_underbar", LFUN_UNDERBAR);
-	kbmap->bind("~C-~S-~M-dead_belowdot", LFUN_UNDERDOT);
-	kbmap->bind("~C-~S-~M-dead_tie", LFUN_TIE);
-	kbmap->bind("~C-~S-~M-dead_ogonek", LFUN_OGONEK);
+	//kbmap->bind("~C-~S-~M-dead_underbar", FuncRequest(LFUN_UNDERBAR));
+	kbmap->bind("~C-~S-~M-dead_belowdot", FuncRequest(LFUN_UNDERDOT));
+	kbmap->bind("~C-~S-~M-dead_tie", FuncRequest(LFUN_TIE));
+	kbmap->bind("~C-~S-~M-dead_ogonek",FuncRequest(LFUN_OGONEK));
 }
 
 
-// This one is not allowed to use anything on the main form, since that
-// one does not exist yet. (Asger)
 void LyX::queryUserLyXDir(bool explicit_userdir)
 {
+	string const configure_script = AddName(system_lyxdir(), "configure");
+
 	// Does user directory exist?
-	FileInfo fileInfo(user_lyxdir);
+	FileInfo fileInfo(user_lyxdir());
 	if (fileInfo.isOK() && fileInfo.isDir()) {
 		first_start = false;
-		return;
-	} else {
-		first_start = !explicit_userdir;
-	}
-	
-	// If the user specified explicitely a directory, ask whether
-	// to create it (otherwise, always create it)
-	if (explicit_userdir &&
-	    !Alert::askQuestion(_("You have specified an invalid LyX directory."),
-			 _("It is needed to keep your own configuration."),
-			 _("Should I try to set it up for you (recommended)?"))) {
-		lyxerr << _("Running without personal LyX directory.") << endl;
-		// No, let's use $HOME instead.
-		user_lyxdir = GetEnvPath("HOME");
+		FileInfo script(configure_script);
+		FileInfo defaults(AddName(user_lyxdir(), "lyxrc.defaults"));
+		if (defaults.isOK() && script.isOK()
+		    && defaults.getModificationTime() < script.getModificationTime()) {
+			lyxerr << _("LyX: reconfiguring user directory")
+			       << endl;
+			Path p(user_lyxdir());
+			::system(configure_script.c_str());
+			lyxerr << "LyX: " << _("Done!") << endl;
+		}
 		return;
 	}
 
-	// Tell the user what is going on
-	lyxerr << _("LyX: Creating directory ") << user_lyxdir
-	       << _(" and running configure...") << endl;
+	first_start = !explicit_userdir;
+
+	lyxerr << bformat(_("LyX: Creating directory %1$s"
+				  " and running configure..."), user_lyxdir()) << endl;
 
-	// Create directory structure
-	if (!createDirectory(user_lyxdir, 0755)) {
+	if (!createDirectory(user_lyxdir(), 0755)) {
 		// Failed, let's use $HOME instead.
-		user_lyxdir = GetEnvPath("HOME");
-		lyxerr << _("Failed. Will use ") << user_lyxdir
-		       << _(" instead.") << endl;
+		user_lyxdir(GetEnvPath("HOME"));
+		lyxerr << bformat(_("Failed. Will use %1$s instead."),
+			user_lyxdir()) << endl;
 		return;
 	}
 
 	// Run configure in user lyx directory
-	Path p(user_lyxdir);
-	::system(AddName(system_lyxdir, "configure").c_str());
+	Path p(user_lyxdir());
+	::system(configure_script.c_str());
 	lyxerr << "LyX: " << _("Done!") << endl;
 }
 
 
-// Read the rc file `name'
-bool LyX::readRcFile(string const & name)
+void LyX::readRcFile(string const & name)
 {
 	lyxerr[Debug::INIT] << "About to read " << name << "..." << endl;
-	
+
 	string const lyxrc_path = LibFileSearch(string(), name);
-	if (!lyxrc_path.empty()){
-	        lyxerr[Debug::INIT] << "Found " << name
+	if (!lyxrc_path.empty()) {
+
+		lyxerr[Debug::INIT] << "Found " << name
 				    << " in " << lyxrc_path << endl;
-		if (lyxrc.read(lyxrc_path) < 0) { 
-		        Alert::alert(_("LyX Warning!"), 
-				   _("Error while reading ") + lyxrc_path + ".",
-				   _("Using built-in defaults."));
-			return false;
-		}
-		return true;
-	} else {
-	  	lyxerr[Debug::INIT] << "Could not find " << name << endl;
+
+		if (lyxrc.read(lyxrc_path) >= 0)
+			return;
 	}
-	
-	return false;
+
+	showFileError(name);
 }
 
 
@@ -670,24 +587,42 @@ void LyX::readUIFile(string const & name)
 	enum Uitags {
 		ui_menuset = 1,
 		ui_toolbar,
+		ui_toolbars,
+		ui_include,
 		ui_last
 	};
 
-	struct keyword_item uitags[ui_last-1] = {
+	struct keyword_item uitags[ui_last - 1] = {
+		{ "include", ui_include },
 		{ "menuset", ui_menuset },
-		{ "toolbar", ui_toolbar }
+		{ "toolbar", ui_toolbar },
+		{ "toolbars", ui_toolbars }
 	};
 
+	// Ensure that a file is read only once (prevents include loops)
+	static std::list<string> uifiles;
+	std::list<string>::const_iterator it  = uifiles.begin();
+	std::list<string>::const_iterator end = uifiles.end();
+	it = std::find(it, end, name);
+	if (it != end) {
+		lyxerr[Debug::INIT] << "UI file '" << name
+				    << "' has been read already. "
+				    << "Is this an include loop?"
+				    << endl;
+		return;
+	}
+
 	lyxerr[Debug::INIT] << "About to read " << name << "..." << endl;
-	
+
 	string const ui_path = LibFileSearch("ui", name, "ui");
 
 	if (ui_path.empty()) {
-	  	lyxerr[Debug::INIT] << "Could not find " << name << endl;
-		menubackend.defaults();
+		lyxerr[Debug::INIT] << "Could not find " << name << endl;
+		showFileError(name);
 		return;
 	}
-	
+	uifiles.push_back(name);
+
 	lyxerr[Debug::INIT] << "Found " << name
 			    << " in " << ui_path << endl;
 	LyXLex lex(uitags, ui_last - 1);
@@ -696,22 +631,32 @@ void LyX::readUIFile(string const & name)
 		lyxerr << "Unable to set LyXLeX for ui file: " << ui_path
 		       << endl;
 	}
-	
+
 	if (lyxerr.debugging(Debug::PARSER))
 		lex.printTable(lyxerr);
 
 	while (lex.isOK()) {
 		switch (lex.lex()) {
-		case ui_menuset: 
+		case ui_include: {
+			lex.next(true);
+			string const file = lex.getString();
+			readUIFile(file);
+			break;
+		}
+		case ui_menuset:
 			menubackend.read(lex);
 			break;
 
 		case ui_toolbar:
-			toolbardefaults.read(lex);
+			toolbarbackend.read(lex);
+			break;
+
+		case ui_toolbars:
+			toolbarbackend.readToolbars(lex);
 			break;
 
 		default:
-			if(!strip(lex.getString()).empty())
+			if (!rtrim(lex.getString()).empty())
 				lex.printError("LyX::ReadUIFile: "
 					       "Unknown menu tag: `$$Token'");
 			break;
@@ -727,8 +672,7 @@ void LyX::readLanguagesFile(string const & name)
 
 	string const lang_path = LibFileSearch(string(), name);
 	if (lang_path.empty()) {
-		lyxerr[Debug::INIT] << "Could not find " << name << endl;
-		languages.setDefaults();
+		showFileError(name);
 		return;
 	}
 	languages.read(lang_path);
@@ -742,7 +686,7 @@ void LyX::readEncodingsFile(string const & name)
 
 	string const enc_path = LibFileSearch(string(), name);
 	if (enc_path.empty()) {
-		lyxerr[Debug::INIT] << "Could not find " << name << endl;
+		showFileError(name);
 		return;
 	}
 	encodings.read(enc_path);
@@ -751,17 +695,28 @@ void LyX::readEncodingsFile(string const & name)
 
 namespace {
 
-// Set debugging level and report result to user
-void setDebuggingLevel(string const & dbgLevel)
+bool is_gui = true;
+string batch;
+
+/// return the the number of arguments consumed
+typedef boost::function<int(string const &, string const &)> cmd_helper;
+
+int parse_dbg(string const & arg, string const &)
 {
-	lyxerr << _("Setting debug level to ") <<  dbgLevel << endl;
-	lyxerr.level(Debug::value(dbgLevel));
+	if (arg.empty()) {
+		lyxerr << _("List of supported debug flags:") << endl;
+		Debug::showTags(lyxerr);
+		exit(0);
+	}
+	lyxerr << bformat(_("Setting debug level to %1$s"), arg) << endl;
+
+	lyxerr.level(Debug::value(arg));
 	Debug::showLevel(lyxerr, lyxerr.level());
+	return 1;
 }
 
 
-// Give command line help
-void commandLineHelp()
+int parse_help(string const &, string const &)
 {
 	lyxerr <<
 		_("Usage: lyx [ command line switches ] [ name.lyx ... ]\n"
@@ -770,9 +725,9 @@ void commandLineHelp()
 		  "\t-userdir dir       try to set user directory to dir\n"
 		  "\t-sysdir dir        try to set system directory to dir\n"
 		  "\t-geometry WxH+X+Y  set geometry of the main window\n"
-                  "\t-dbg feature[,feature]...\n"
-                  "                  select the features to debug.\n"
-                  "                  Type `lyx -dbg' to see the list of features\n"
+		  "\t-dbg feature[,feature]...\n"
+		  "                  select the features to debug.\n"
+		  "                  Type `lyx -dbg' to see the list of features\n"
 		  "\t-x [--execute] command\n"
 		  "                  where command is a lyx command.\n"
 		  "\t-e [--export] fmt\n"
@@ -782,130 +737,125 @@ void commandLineHelp()
 		  "                  and file.xxx is the file to be imported.\n"
 		  "\t-version        summarize version and build info\n"
 		  "Check the LyX man page for more details.") << endl;
+	exit(0);
+	return 0;
 }
 
-// Give command line version information
-void commandLineVersionInfo()
+int parse_version(string const &, string const &)
 {
 	lyxerr << "LyX " << lyx_version
 	       << " of " << lyx_release_date << endl;
 	lyxerr << "Built on " << __DATE__ << ", " << __TIME__ << endl;
 
 	lyxerr << lyx_version_info << endl;
+	exit(0);
+	return 0;
 }
 
+int parse_sysdir(string const & arg, string const &)
+{
+	if (arg.empty()) {
+		lyxerr << _("Missing directory for -sysdir switch") << endl;
+		exit(1);
+	}
+	system_lyxdir(arg);
+	return 1;
+}
 
-} // namespace anon
+int parse_userdir(string const & arg, string const &)
+{
+	if (arg.empty()) {
+		lyxerr << _("Missing directory for -userdir switch") << endl;
+		exit(1);
+	}
+	user_lyxdir(arg);
+	return 1;
+}
 
+int parse_execute(string const & arg, string const &)
+{
+	if (arg.empty()) {
+		lyxerr << _("Missing command string after --execute switch") << endl;
+		exit(1);
+	}
+	batch = arg;
+	// Argh. Setting gui to false segfaults..
+	// FIXME: when ? how ?
+	// is_gui = false;
+	return 1;
+}
 
-bool LyX::easyParse(int * argc, char * argv[])
+int parse_export(string const & type, string const &)
 {
-	bool gui = true;
-	int removeargs = 0; // used when options are read
-	for (int i = 1; i < *argc; ++i) {
-		string arg = argv[i];
-
-		// Check for -dbg int
-		if (arg == "-dbg") {
-			if (i + 1 < *argc) {
-				setDebuggingLevel(argv[i + 1]);
-				removeargs = 2;
-			} else {
-				lyxerr << _("List of supported debug flags:")
-				       << endl;
-				Debug::showTags(lyxerr);
-				exit(0);
-			}
-		} 
-		// Check for "-sysdir"
-		else if (arg == "-sysdir") {
-			if (i + 1 < *argc) {
-				system_lyxdir = argv[i + 1];
-				removeargs = 2;
-			} else {
-				lyxerr << _("Missing directory for -sysdir switch!") 
-				       << endl;
-				exit(0);
-			}
-		}
-		// Check for "-userdir"
-		else if (arg == "-userdir") {
-			if (i + 1 < *argc) {
-				user_lyxdir = argv[i + 1];
-				removeargs = 2;
-			} else {
-				lyxerr << _("Missing directory for -userdir switch!")
-				       << endl;
-				exit(0);
-			}
-		}
-		// Check for --help or -help
-		else if (arg == "--help" || arg == "-help") {
-			commandLineHelp();
-			exit(0);
-		} 
-		// Check for --version or -version
-		else if (arg == "--version" || arg == "-version") {
-			commandLineVersionInfo();
-			exit(0);
-		}
-		// Check for "-nw": No XWindows as for emacs this should
-		// give a LyX that could be used in a terminal window.
-		//else if (arg == "-nw") {
-		//	gui = false;
-		//}
-
-		// Check for "-x": Execute commands
-		else if (arg == "-x" || arg == "--execute") {
-			if (i + 1 < *argc) {
-				batch_command = string(argv[i + 1]);
-				removeargs = 2;
-			}
-			else
-				lyxerr << _("Missing command string after  -x switch!") << endl;
+	if (type.empty()) {
+		lyxerr << _("Missing file type [eg latex, ps...] after "
+			"--export switch") << endl;
+		exit(1);
+	}
+	batch = "buffer-export " + type;
+	is_gui = false;
+	return 1;
+}
 
-			// Argh. Setting gui to false segfaults..
-			//gui = false;
-		}
+int parse_import(string const & type, string const & file)
+{
+	if (type.empty()) {
+		lyxerr << _("Missing file type [eg latex, ps...] after "
+			"--import switch") << endl;
+		exit(1);
+	}
+	if (file.empty()) {
+		lyxerr << _("Missing filename for --import") << endl;
+		exit(1);
+	}
 
-		else if (arg == "-e" || arg == "--export") {
-			if (i + 1 < *argc) {
-				string type(argv[i+1]);
-				removeargs = 2;
-				batch_command = "buffer-export " + type;
-				gui = false;
-			} else
-				lyxerr << _("Missing file type [eg latex, "
-					    "ps...] after ")
-				       << arg << _(" switch!") << endl;
-		}
-		else if (arg == "-i" || arg == "--import") {
-			if (i + 1 < *argc) {
-				string const type(argv[i+1]);
-				string const file(argv[i+2]);
-				removeargs = 3;
-	
-				batch_command = "buffer-import " + type + " " + file;
-				lyxerr << "batch_command: "
-				       << batch_command << endl;
-
-			} else
-				lyxerr << _("Missing type [eg latex, "
-					    "ps...] after ")
-				       << arg << _(" switch!") << endl;
-		}
+	batch = "buffer-import " + type + ' ' + file;
+	return 2;
+}
 
-		if (removeargs > 0) {
-			// Now, remove used arguments by shifting
-			// the following ones removeargs places down.
-			(*argc) -= removeargs;
-			for (int j = i; j < (*argc); ++j)
-				argv[j] = argv[j + removeargs];
-			--i; // After shift, check this number again.
-			removeargs = 0;
-		}
+} // namespace anon
 
+
+bool LyX::easyParse(int & argc, char * argv[])
+{
+	std::map<string, cmd_helper> cmdmap;
+
+	cmdmap["-dbg"] = parse_dbg;
+	cmdmap["-help"] = parse_help;
+	cmdmap["--help"] = parse_help;
+	cmdmap["-version"] = parse_version;
+	cmdmap["--version"] = parse_version;
+	cmdmap["-sysdir"] = parse_sysdir;
+	cmdmap["-userdir"] = parse_userdir;
+	cmdmap["-x"] = parse_execute;
+	cmdmap["--execute"] = parse_execute;
+	cmdmap["-e"] = parse_export;
+	cmdmap["--export"] = parse_export;
+	cmdmap["-i"] = parse_import;
+	cmdmap["--import"] = parse_import;
+
+	for (int i = 1; i < argc; ++i) {
+		std::map<string, cmd_helper>::const_iterator it
+			= cmdmap.find(argv[i]);
+
+		// don't complain if not found - may be parsed later
+		if (it == cmdmap.end())
+			continue;
+
+		string arg((i + 1 < argc) ? argv[i + 1] : "");
+		string arg2((i + 2 < argc) ? argv[i + 2] : "");
+
+		int const remove = 1 + it->second(arg, arg2);
+
+		// Now, remove used arguments by shifting
+		// the following ones remove places down.
+		argc -= remove;
+		for (int j = i; j < argc; ++j)
+			argv[j] = argv[j + remove];
+		--i;
 	}
 
-	return gui;
+	batch_command = batch;
+
+	return is_gui;
 }