X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Flyx_main.C;h=97f71100ff10ece894cf3e99837d70daf1cdbd23;hb=27a777ccc624b19c5d1961a6279c0db97594c0fb;hp=cd9d079844952b4cd60ea288cb38fdadda7f8c72;hpb=3287c44f3322973eb6a31709dcdd7e0feb9f27a2;p=lyx.git diff --git a/src/lyx_main.C b/src/lyx_main.C index cd9d079844..97f71100ff 100644 --- a/src/lyx_main.C +++ b/src/lyx_main.C @@ -17,6 +17,7 @@ #include "lyx_main.h" +#include "ConverterCache.h" #include "buffer.h" #include "buffer_funcs.h" #include "bufferlist.h" @@ -31,56 +32,71 @@ #include "session.h" #include "LColor.h" #include "lyx_cb.h" +#include "LyXAction.h" #include "lyxfunc.h" #include "lyxlex.h" #include "lyxrc.h" -#include "lyxtextclasslist.h" #include "lyxserver.h" +#include "lyxsocket.h" +#include "lyxtextclasslist.h" #include "MenuBackend.h" +#include "messages.h" #include "mover.h" #include "ToolbarBackend.h" -#include "mathed/math_inset.h" - #include "frontends/Alert.h" -#include "frontends/lyx_gui.h" +#include "frontends/Application.h" +#include "frontends/Gui.h" #include "frontends/LyXView.h" #include "support/environment.h" #include "support/filetools.h" #include "support/lyxlib.h" #include "support/convert.h" +#include "support/ExceptionMessage.h" #include "support/os.h" #include "support/package.h" #include "support/path.h" #include "support/systemcall.h" +#include "support/unicode.h" #include #include #include #include - -using lyx::support::addName; -using lyx::support::addPath; -using lyx::support::bformat; -using lyx::support::createDirectory; -using lyx::support::createLyXTmpDir; -using lyx::support::fileSearch; -using lyx::support::getEnv; -using lyx::support::i18nLibFileSearch; -using lyx::support::libFileSearch; -using lyx::support::package; -using lyx::support::Path; -using lyx::support::prependEnvPath; -using lyx::support::quoteName; -using lyx::support::rtrim; -using lyx::support::Systemcall; - -namespace os = lyx::support::os; +#include +#include +#include + + +namespace lyx { + +using support::addName; +using support::addPath; +using support::bformat; +using support::changeExtension; +using support::createDirectory; +using support::createLyXTmpDir; +using support::destroyDir; +using support::FileName; +using support::fileSearch; +using support::getEnv; +using support::i18nLibFileSearch; +using support::libFileSearch; +using support::package; +using support::prependEnvPath; +using support::rtrim; +using support::Systemcall; + +namespace Alert = frontend::Alert; +namespace os = support::os; namespace fs = boost::filesystem; using std::endl; +using std::for_each; +using std::map; +using std::make_pair; using std::string; using std::vector; @@ -91,13 +107,12 @@ using std::system; #endif -extern LyXServer * lyxserver; - -// This is the global bufferlist object -BufferList bufferlist; +/// are we using the GUI at all? +/** +* We default to true and this is changed to false when the export feature is used. +*/ +bool use_gui = true; -// convenient to have it here. -boost::scoped_ptr toplevel_keymap; namespace { @@ -106,24 +121,15 @@ namespace { string cl_system_support; string cl_user_support; +std::string geometryArg; -void lyx_exit(int status) -{ - // FIXME: We should not directly call exit(), since it only - // guarantees a return to the system, no application cleanup. - // This may cause troubles with not executed destructors. - if (lyx_gui::use_gui) - lyx_gui::exit(status); - exit(status); -} - +LyX * singleton_ = 0; 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)); - lyx_exit(EXIT_FAILURE); + bformat(_("Error while reading the configuration file\n%1$s.\n" + "Please check your installation."), from_utf8(error))); } @@ -131,66 +137,237 @@ void reconfigureUserLyXDir() { string const configure_command = package().configure_command(); - lyxerr << _("LyX: reconfiguring user directory") << endl; - Path p(package().user_support()); + lyxerr << to_utf8(_("LyX: reconfiguring user directory")) << endl; + support::Path p(package().user_support()); Systemcall one; one.startscript(Systemcall::Wait, configure_command); - lyxerr << "LyX: " << _("Done!") << endl; + lyxerr << "LyX: " << to_utf8(_("Done!")) << endl; } } // namespace anon -boost::scoped_ptr LyX::singleton_; +/// The main application class private implementation. +struct LyX::Singletons +{ + Singletons(): iconv(ucs4_codeset, "UTF-8") + { + // Set the default User Interface language as soon as possible. + // The language used will be derived from the environment + // variables. + messages_["GUI"] = Messages(); + } + /// our function handler + LyXFunc lyxfunc_; + /// + BufferList buffer_list_; + /// + boost::scoped_ptr toplevel_keymap_; + /// + boost::scoped_ptr lyx_server_; + /// + boost::scoped_ptr lyx_socket_; + /// + boost::scoped_ptr application_; + /// lyx session, containing lastfiles, lastfilepos, and lastopened + boost::scoped_ptr session_; + + /// + IconvProcessor iconv; + + /// Files to load at start. + vector files_to_load_; + + /// The messages translators. + map messages_; + + /// The file converters. + Converters converters_; + + // The system converters copy after reading lyxrc.defaults. + Converters system_converters_; + + /// + Movers movers_; + + /// + Movers system_movers_; +}; + +/// +frontend::Application * theApp() +{ + if (singleton_) + return singleton_->pimpl_->application_.get(); + else + return 0; +} -void LyX::exec(int & argc, char * argv[]) + +LyX::~LyX() { - 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(); + BOOST_ASSERT(singleton_); + return *singleton_; } LyX const & LyX::cref() { - BOOST_ASSERT(singleton_.get()); - return *singleton_.get(); + BOOST_ASSERT(singleton_); + return *singleton_; } LyX::LyX() - : first_start(false), geometryOption_(false) -{} + : first_start(false) +{ + singleton_ = this; + pimpl_.reset(new Singletons); + geometryArg.clear(); +} + + +BufferList & LyX::bufferList() +{ + return pimpl_->buffer_list_; +} + + +BufferList const & LyX::bufferList() const +{ + return pimpl_->buffer_list_; +} + + +Session & LyX::session() +{ + BOOST_ASSERT(pimpl_->session_.get()); + return *pimpl_->session_.get(); +} + + +Session const & LyX::session() const +{ + BOOST_ASSERT(pimpl_->session_.get()); + return *pimpl_->session_.get(); +} -lyx::Session & LyX::session() +LyXFunc & LyX::lyxFunc() { - BOOST_ASSERT(session_.get()); - return *session_.get(); + return pimpl_->lyxfunc_; } -lyx::Session const & LyX::session() const +LyXFunc const & LyX::lyxFunc() const { - BOOST_ASSERT(session_.get()); - return *session_.get(); + return pimpl_->lyxfunc_; } -void LyX::addLyXView(LyXView * lyxview) +LyXServer & LyX::server() { - views_.push_back(lyxview); + BOOST_ASSERT(pimpl_->lyx_server_.get()); + return *pimpl_->lyx_server_.get(); +} + + +LyXServer const & LyX::server() const +{ + BOOST_ASSERT(pimpl_->lyx_server_.get()); + return *pimpl_->lyx_server_.get(); +} + + +LyXServerSocket & LyX::socket() +{ + BOOST_ASSERT(pimpl_->lyx_socket_.get()); + return *pimpl_->lyx_socket_.get(); +} + + +LyXServerSocket const & LyX::socket() const +{ + BOOST_ASSERT(pimpl_->lyx_socket_.get()); + return *pimpl_->lyx_socket_.get(); +} + + +frontend::Application & LyX::application() +{ + BOOST_ASSERT(pimpl_->application_.get()); + return *pimpl_->application_.get(); +} + + +frontend::Application const & LyX::application() const +{ + BOOST_ASSERT(pimpl_->application_.get()); + return *pimpl_->application_.get(); +} + + +kb_keymap & LyX::topLevelKeymap() +{ + BOOST_ASSERT(pimpl_->toplevel_keymap_.get()); + return *pimpl_->toplevel_keymap_.get(); +} + + +Converters & LyX::converters() +{ + return pimpl_->converters_; +} + + +Converters & LyX::systemConverters() +{ + return pimpl_->system_converters_; +} + + +IconvProcessor & LyX::iconvProcessor() +{ + return pimpl_->iconv; +} + + +kb_keymap const & LyX::topLevelKeymap() const +{ + BOOST_ASSERT(pimpl_->toplevel_keymap_.get()); + return *pimpl_->toplevel_keymap_.get(); +} + + +Messages & LyX::getMessages(std::string const & language) +{ + map::iterator it = pimpl_->messages_.find(language); + + if (it != pimpl_->messages_.end()) + return it->second; + + std::pair::iterator, bool> result = + pimpl_->messages_.insert(std::make_pair(language, Messages(language))); + + BOOST_ASSERT(result.second); + return result.first->second; +} + + +Messages & LyX::getGuiMessages() +{ + return pimpl_->messages_["GUI"]; +} + + +void LyX::setGuiLanguage(std::string const & language) +{ + pimpl_->messages_["GUI"] = Messages(language); } @@ -200,10 +377,12 @@ Buffer const * const LyX::updateInset(InsetBase const * inset) const return 0; Buffer const * buffer_ptr = 0; - ViewList::const_iterator it = views_.begin(); - ViewList::const_iterator const end = views_.end(); + vector const & view_ids = pimpl_->application_->gui().viewIds(); + vector::const_iterator it = view_ids.begin(); + vector::const_iterator const end = view_ids.end(); for (; it != end; ++it) { - Buffer const * ptr = (*it)->updateInset(inset); + Buffer const * ptr = + pimpl_->application_->gui().view(*it).updateInset(inset); if (ptr) buffer_ptr = ptr; } @@ -211,145 +390,305 @@ Buffer const * const LyX::updateInset(InsetBase const * inset) const } -void LyX::priv_exec(int & argc, char * argv[]) +int LyX::exec(int & argc, char * argv[]) { // Here we need to parse the command line. At least // we need to parse for "-dbg" and "-help" - lyx_gui::use_gui = easyParse(argc, argv); + easyParse(argc, argv); + + try { support::init_package(to_utf8(from_local8bit(argv[0])), + cl_system_support, cl_user_support, + support::top_build_dir_is_one_level_up); + } catch (support::ExceptionMessage const & message) { + if (message.type_ == support::ErrorException) { + Alert::error(message.title_, message.details_); + exit(1); + } else if (message.type_ == support::WarningException) { + Alert::warning(message.title_, message.details_); + } + } + + if (!use_gui) { + // FIXME: create a ConsoleApplication + int exit_status = init(argc, argv); + if (exit_status) { + prepareExit(); + return exit_status; + } + + loadFiles(); + + if (batch_command.empty() || pimpl_->buffer_list_.empty()) { + prepareExit(); + return EXIT_SUCCESS; + } + + BufferList::iterator begin = pimpl_->buffer_list_.begin(); + BufferList::iterator end = pimpl_->buffer_list_.end(); + + bool final_success = false; + for (BufferList::iterator I = begin; I != end; ++I) { + Buffer * buf = *I; + bool success = false; + buf->dispatch(batch_command, &success); + final_success |= success; + } + prepareExit(); + return !final_success; + } + + // Force adding of font path _before_ Application is initialized + support::os::addFontResources(); + + // Let the frontend parse and remove all arguments that it knows + pimpl_->application_.reset(createApplication(argc, argv)); - lyx::support::init_package(argv[0], cl_system_support, cl_user_support, - lyx::support::top_build_dir_is_one_level_up); + initGuiFont(); + + // Parse and remove all known arguments in the LyX singleton + // Give an error for all remaining ones. + int exit_status = init(argc, argv); + if (exit_status) { + // Kill the application object before exiting. + pimpl_->application_.reset(); + use_gui = false; + prepareExit(); + return exit_status; + } + + // FIXME + /* Create a CoreApplication class that will provide the main event loop + * and the socket callback registering. With Qt4, only QtCore + * library would be needed. + * When this is done, a server_mode could be created and the following two + * line would be moved out from here. + */ + // Note: socket callback must be registered after init(argc, argv) + // such that package().temp_dir() is properly initialized. + pimpl_->lyx_server_.reset(new LyXServer(&pimpl_->lyxfunc_, lyxrc.lyxpipes)); + pimpl_->lyx_socket_.reset(new LyXServerSocket(&pimpl_->lyxfunc_, + os::internal_path(package().temp_dir() + "/lyxsocket"))); // Start the real execution loop. - if (lyx_gui::use_gui) - lyx_gui::exec(argc, argv); - else - exec2(argc, argv); + exit_status = pimpl_->application_->exec(); + + prepareExit(); + + // Restore original font resources after Application is destroyed. + support::os::restoreFontResources(); + + return exit_status; +} + + +void LyX::prepareExit() +{ + // Set a flag that we do quitting from the program, + // so no refreshes are necessary. + quitting = true; + + // close buffers first + pimpl_->buffer_list_.closeAll(); + + // do any other cleanup procedures now + if (package().temp_dir() != package().system_temp_dir()) { + lyxerr[Debug::INFO] << "Deleting tmp dir " + << package().temp_dir() << endl; + + if (!destroyDir(FileName(package().temp_dir()))) { + docstring const msg = + bformat(_("Unable to remove the temporary directory %1$s"), + from_utf8(package().temp_dir())); + Alert::warning(_("Unable to remove temporary directory"), msg); + } + } + + if (use_gui) { + if (pimpl_->session_) + pimpl_->session_->writeFile(); + pimpl_->session_.reset(); + pimpl_->lyx_server_.reset(); + pimpl_->lyx_socket_.reset(); + } + + // Kill the application object before exiting. This avoids crashes + // when exiting on Linux. + if (pimpl_->application_) + pimpl_->application_.reset(); } -void LyX::exec2(int & argc, char * argv[]) +void LyX::earlyExit(int status) +{ + BOOST_ASSERT(pimpl_->application_.get()); + // LyX::pimpl_::application_ is not initialised at this + // point so it's safe to just exit after some cleanup. + prepareExit(); + exit(status); +} + + +int LyX::init(int & argc, char * argv[]) { // check for any spurious extra arguments // other than documents for (int argi = 1; argi < argc ; ++argi) { if (argv[argi][0] == '-') { - lyxerr << bformat(_("Wrong command line option `%1$s'. Exiting."), - argv[argi]) << endl; - exit(1); + lyxerr << to_utf8( + bformat(_("Wrong command line option `%1$s'. Exiting."), + from_utf8(argv[argi]))) << endl; + return EXIT_FAILURE; } } // Initialization of LyX (reads lyxrc and more) lyxerr[Debug::INIT] << "Initializing LyX::init..." << endl; - init(); + bool success = init(); lyxerr[Debug::INIT] << "Initializing LyX::init...done" << endl; + if (!success) + return EXIT_FAILURE; + + for (int argi = argc - 1; argi >= 1; --argi) { + // get absolute path of file and add ".lyx" to + // the filename if necessary + pimpl_->files_to_load_.push_back(fileSearch(string(), + os::internal_path(to_utf8(from_local8bit(argv[argi]))), + "lyx", support::allow_unreadable)); + } - if (lyx_gui::use_gui) - lyx_gui::parse_lyxrc(); + if (first_start) + pimpl_->files_to_load_.push_back(i18nLibFileSearch("examples", "splash.lyx")); - vector files; + return EXIT_SUCCESS; +} - for (int argi = argc - 1; argi >= 1; --argi) - files.push_back(os::internal_path(argv[argi])); - if (first_start) - files.push_back(i18nLibFileSearch("examples", "splash.lyx")); +void LyX::loadFiles() +{ + vector::const_iterator it = pimpl_->files_to_load_.begin(); + vector::const_iterator end = pimpl_->files_to_load_.end(); - // if a file is specified, I assume that user wants to edit *that* file - if (files.empty() && lyxrc.load_session) { - vector const & lastopened = session_->lastOpenedFiles(); - files.insert(files.end(), lastopened.begin(), lastopened.end() ); + for (; it != end; ++it) { + if (it->empty()) + continue; + + Buffer * buf = pimpl_->buffer_list_.newBuffer(it->absFilename(), false); + if (loadLyXFile(buf, *it)) { + ErrorList const & el = buf->errorList("Parse"); + if (!el.empty()) + for_each(el.begin(), el.end(), + boost::bind(&LyX::printError, this, _1)); + } + else + pimpl_->buffer_list_.release(buf); } - // clear this list to save a few bytes of RAM - session_->clearLastOpenedFiles(); +} + + +void LyX::execBatchCommands() +{ + // The advantage of doing this here is that the event loop + // is already started. So any need for interaction will be + // aknowledged. + restoreGuiSession(); // Execute batch commands if available - if (!batch_command.empty()) { - - lyxerr[Debug::INIT] << "About to handle -x '" - << batch_command << '\'' << endl; - - Buffer * last_loaded = 0; - - vector::const_iterator it = files.begin(); - vector::const_iterator end = files.end(); - - 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); - } - } + if (batch_command.empty()) + return; - // try to dispatch to last loaded buffer first - if (last_loaded) { - bool success = false; - if (last_loaded->dispatch(batch_command, &success)) { - quitLyX(false); - lyx_exit(!success); - } - } - files.clear(); // the files are already loaded + lyxerr[Debug::INIT] << "About to handle -x '" + << batch_command << '\'' << endl; + + pimpl_->lyxfunc_.dispatch(lyxaction.lookupFunc(batch_command)); +} + + +void LyX::restoreGuiSession() +{ + LyXView * view = newLyXView(); + + // if some files were specified at command-line we assume that the + // user wants to edit *these* files and not to restore the session. + if (!pimpl_->files_to_load_.empty()) { + for_each(pimpl_->files_to_load_.begin(), + pimpl_->files_to_load_.end(), + bind(&LyXView::loadLyXFile, view, _1, true)); + // clear this list to save a few bytes of RAM + pimpl_->files_to_load_.clear(); + pimpl_->session_->lastOpened().clear(); + return; } - if (lyx_gui::use_gui) { - // determine windows size and position, from lyxrc and/or session - // initial geometry - unsigned int width = 690; - unsigned int height = 510; - bool maximize = false; - // first try lyxrc - if (lyxrc.geometry_width != 0 && lyxrc.geometry_height != 0 ) { - width = lyxrc.geometry_width; - height = lyxrc.geometry_height; - } - // if lyxrc returns (0,0), then use session info - else { - string val = session().loadSessionInfo("WindowWidth"); - if (!val.empty()) - width = convert(val); - val = session().loadSessionInfo("WindowHeight"); - if (!val.empty()) - height = convert(val); - if (session().loadSessionInfo("WindowIsMaximized") == "yes") - maximize = true; - } - // if user wants to restore window position - int posx = -1; - int posy = -1; - if (lyxrc.geometry_xysaved) { - string val = session().loadSessionInfo("WindowPosX"); - if (!val.empty()) - posx = convert(val); - val = session().loadSessionInfo("WindowPosY"); - if (!val.empty()) - posy = convert(val); - } + if (!lyxrc.load_session) + return; - if (geometryOption_) { - width = -1; - height = -1; - } + vector const & lastopened = pimpl_->session_->lastOpened().getfiles(); + // do not add to the lastfile list since these files are restored from + // last session, and should be already there (regular files), or should + // not be added at all (help files). + for_each(lastopened.begin(), lastopened.end(), + bind(&LyXView::loadLyXFile, view, _1, false)); + + // clear this list to save a few bytes of RAM + pimpl_->session_->lastOpened().clear(); +} - lyx_gui::start(batch_command, files, width, height, posx, posy, maximize); - } else { - // Something went wrong above - quitLyX(false); - lyx_exit(EXIT_FAILURE); +LyXView * LyX::newLyXView() +{ + if (!lyx::use_gui) + return 0; + + // determine windows size and position, from lyxrc and/or session + // initial geometry + unsigned int width = 690; + unsigned int height = 510; + // default icon size, will be overwritten by stored session value + unsigned int iconSizeXY = 0; + bool maximize = false; + // first try lyxrc + if (lyxrc.geometry_width != 0 && lyxrc.geometry_height != 0 ) { + width = lyxrc.geometry_width; + height = lyxrc.geometry_height; + } + // if lyxrc returns (0,0), then use session info + else { + string val = session().sessionInfo().load("WindowWidth"); + if (!val.empty()) + width = convert(val); + val = session().sessionInfo().load("WindowHeight"); + if (!val.empty()) + height = convert(val); + if (session().sessionInfo().load("WindowIsMaximized") == "yes") + maximize = true; + val = session().sessionInfo().load("IconSizeXY"); + if (!val.empty()) + iconSizeXY = convert(val); + } + + // if user wants to restore window position + int posx = -1; + int posy = -1; + if (lyxrc.geometry_xysaved) { + string val = session().sessionInfo().load("WindowPosX"); + if (!val.empty()) + posx = convert(val); + val = session().sessionInfo().load("WindowPosY"); + if (!val.empty()) + posy = convert(val); + } + + if (!geometryArg.empty()) + { + width = 0; + height = 0; } -} + // create the main window + LyXView * view = &pimpl_->application_->createView(width, height, posx, posy, maximize, iconSizeXY, geometryArg); + + return view; +} /* Signals and Windows @@ -443,7 +782,7 @@ static void error_handler(int err_sig) #else if (err_sig == SIGSEGV || !getEnv("LYXDEBUG").empty()) #endif - lyx::support::abort(); + support::abort(); exit(0); } @@ -452,13 +791,27 @@ static void error_handler(int err_sig) void LyX::printError(ErrorItem const & ei) { - std::cerr << _("LyX: ") << ei.error - << ':' << ei.description << std::endl; + docstring tmp = _("LyX: ") + ei.error + char_type(':') + + ei.description; + std::cerr << to_utf8(tmp) << std::endl; +} + + +void LyX::initGuiFont() +{ + if (lyxrc.roman_font_name.empty()) + lyxrc.roman_font_name = pimpl_->application_->romanFontName(); + + if (lyxrc.sans_font_name.empty()) + lyxrc.sans_font_name = pimpl_->application_->sansFontName(); + if (lyxrc.typewriter_font_name.empty()) + lyxrc.typewriter_font_name + = pimpl_->application_->typewriterFontName(); } -void LyX::init() +bool LyX::init() { #ifdef SIGHUP signal(SIGHUP, error_handler); @@ -477,19 +830,16 @@ void LyX::init() "templates"); } - 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 // // This one may have been distributed along with LyX. - readRcFile("lyxrc.dist"); + if (!readRcFile("lyxrc.dist")) + return false; + + // Set the language defined by the distributor. + //setGuiLanguage(lyxrc.gui_language); // Set the PATH correctly. #if !defined (USE_POSIX_PACKAGING) @@ -501,71 +851,86 @@ void LyX::init() if (!lyxrc.path_prefix.empty()) prependEnvPath("PATH", lyxrc.path_prefix); - // Check that user LyX directory is ok. We don't do that if - // running in batch mode. - if (lyx_gui::use_gui) { - if (queryUserLyXDir(package().explicit_user_support())) - reconfigureUserLyXDir(); - } else { + // Check that user LyX directory is ok. + if (queryUserLyXDir(package().explicit_user_support())) + reconfigureUserLyXDir(); + + // no need for a splash when there is no GUI + if (!use_gui) { first_start = false; } // This one is generated in user_support directory by lib/configure.py. - readRcFile("lyxrc.defaults"); + if (!readRcFile("lyxrc.defaults")) + return false; // Query the OS to know what formats are viewed natively formats.setAutoOpen(); + // Read lyxrc.dist again to be able to override viewer auto-detection. + readRcFile("lyxrc.dist"); + system_lyxrc = lyxrc; system_formats = formats; - system_converters = converters; - system_movers = movers; + pimpl_->system_converters_ = pimpl_->converters_; + pimpl_->system_movers_ = pimpl_->movers_; system_lcolor = lcolor; // This one is edited through the preferences dialog. - readRcFile("preferences"); + if (!readRcFile("preferences")) + return false; - readEncodingsFile("encodings"); - readLanguagesFile("languages"); + if (!readEncodingsFile("encodings")) + return false; + if (!readLanguagesFile("languages")) + return false; // Load the layouts lyxerr[Debug::INIT] << "Reading layouts..." << endl; - LyXSetStyle(); + if (!LyXSetStyle()) + return false; + + if (use_gui) { + // Set the language defined by the user. + //setGuiLanguage(lyxrc.gui_language); - if (lyx_gui::use_gui) { // Set up bindings - toplevel_keymap.reset(new kb_keymap); - defaultKeyBindings(toplevel_keymap.get()); - toplevel_keymap->read(lyxrc.bind_file); + pimpl_->toplevel_keymap_.reset(new kb_keymap); + defaultKeyBindings(pimpl_->toplevel_keymap_.get()); + pimpl_->toplevel_keymap_->read(lyxrc.bind_file); + + pimpl_->lyxfunc_.initKeySequences(pimpl_->toplevel_keymap_.get()); // Read menus - readUIFile(lyxrc.ui_file); + if (!readUIFile(lyxrc.ui_file)) + return false; } if (lyxerr.debugging(Debug::LYXRC)) lyxrc.print(); - os::cygwin_path_fix(lyxrc.cygwin_path_fix); + os::windows_style_tex_paths(lyxrc.windows_style_tex_paths); if (!lyxrc.path_prefix.empty()) prependEnvPath("PATH", lyxrc.path_prefix); - if (fs::exists(lyxrc.document_path) && - fs::is_directory(lyxrc.document_path)) + FileName const document_path(lyxrc.document_path); + if (fs::exists(document_path.toFilesystemEncoding()) && + fs::is_directory(document_path.toFilesystemEncoding())) package().document_dir() = lyxrc.document_path; - package().temp_dir() = createLyXTmpDir(lyxrc.tempdir_path); + package().temp_dir() = createLyXTmpDir(FileName(lyxrc.tempdir_path)).absFilename(); if (package().temp_dir().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)); + "%1$s. Make sure that this\n" + "path exists and is writable and try again."), + from_utf8(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. - lyx_exit(EXIT_FAILURE); + return false; } if (lyxerr.debugging(Debug::INIT)) { @@ -573,7 +938,13 @@ void LyX::init() } lyxerr[Debug::INIT] << "Reading session information '.lyx/session'..." << endl; - session_.reset(new lyx::Session(lyxrc.num_lastfiles)); + pimpl_->session_.reset(new Session(lyxrc.num_lastfiles)); + + // This must happen after package initialization and after lyxrc is + // read, therefore it can't be done by a static object. + ConverterCache::init(); + + return true; } @@ -636,9 +1007,13 @@ void LyX::emergencyCleanup() const // contain documents etc. which might be helpful on // a crash - bufferlist.emergencyWriteAll(); - if (lyxserver) - lyxserver->emergencyCleanup(); + pimpl_->buffer_list_.emergencyWriteAll(); + if (use_gui) { + if (pimpl_->lyx_server_) + pimpl_->lyx_server_->emergencyCleanup(); + pimpl_->lyx_server_.reset(); + pimpl_->lyx_socket_.reset(); + } } @@ -673,13 +1048,21 @@ namespace { // return true if file does not exist or is older than configure.py. bool needsUpdate(string const & file) { - static string const configure_script = - addName(package().system_support(), "configure.py"); - string const absfile = - addName(package().user_support(), file); + // We cannot initialize configure_script directly because the package + // is not initialized yet when static objects are constructed. + static string configure_script; + static bool firstrun = true; + if (firstrun) { + configure_script = FileName(addName( + package().system_support(), + "configure.py")).toFilesystemEncoding(); + firstrun = false; + } + string const absfile = FileName(addName( + package().user_support(), file)).toFilesystemEncoding(); return (! fs::exists(absfile)) - || (fs::last_write_time(configure_script) + || (fs::last_write_time(configure_script) > fs::last_write_time(absfile)); } @@ -689,12 +1072,13 @@ bool needsUpdate(string const & file) bool LyX::queryUserLyXDir(bool explicit_userdir) { // Does user directory exist? - if (fs::exists(package().user_support()) && - fs::is_directory(package().user_support())) { + string const user_support = + FileName(package().user_support()).toFilesystemEncoding(); + if (fs::exists(user_support) && fs::is_directory(user_support)) { first_start = false; - - return needsUpdate("lyxrc.defaults") - || needsUpdate("textclass.lst") + + return needsUpdate("lyxrc.defaults") + || needsUpdate("textclass.lst") || needsUpdate("packages.lst"); } @@ -706,50 +1090,53 @@ bool LyX::queryUserLyXDir(bool explicit_userdir) Alert::prompt( _("Missing user LyX directory"), bformat(_("You have specified a non-existent user " - "LyX directory, %1$s.\n" - "It is needed to keep your own configuration."), - package().user_support()), + "LyX directory, %1$s.\n" + "It is needed to keep your own configuration."), + from_utf8(package().user_support())), 1, 0, _("&Create directory"), _("&Exit LyX"))) { - lyxerr << _("No user LyX directory. Exiting.") << endl; - lyx_exit(EXIT_FAILURE); + lyxerr << to_utf8(_("No user LyX directory. Exiting.")) << endl; + earlyExit(EXIT_FAILURE); } - lyxerr << bformat(_("LyX: Creating directory %1$s"), - package().user_support()) + lyxerr << to_utf8(bformat(_("LyX: Creating directory %1$s"), + from_utf8(package().user_support()))) << endl; if (!createDirectory(package().user_support(), 0755)) { // Failed, so let's exit. - lyxerr << _("Failed to create directory. Exiting.") + lyxerr << to_utf8(_("Failed to create directory. Exiting.")) << endl; - lyx_exit(EXIT_FAILURE); + earlyExit(EXIT_FAILURE); } return true; } -void LyX::readRcFile(string const & name) +bool LyX::readRcFile(string const & name) { lyxerr[Debug::INIT] << "About to read " << name << "... "; - string const lyxrc_path = libFileSearch(string(), name); + FileName const lyxrc_path = libFileSearch(string(), name); if (!lyxrc_path.empty()) { lyxerr[Debug::INIT] << "Found in " << lyxrc_path << endl; - if (lyxrc.read(lyxrc_path) < 0) + if (lyxrc.read(lyxrc_path) < 0) { showFileError(name); + return false; + } } else lyxerr[Debug::INIT] << "Not found." << lyxrc_path << endl; + return true; } // Read the ui file `name' -void LyX::readUIFile(string const & name) +bool LyX::readUIFile(string const & name, bool include) { enum Uitags { ui_menuset = 1, @@ -776,18 +1163,28 @@ void LyX::readUIFile(string const & name) << "' has been read already. " << "Is this an include loop?" << endl; - return; + return false; } lyxerr[Debug::INIT] << "About to read " << name << "..." << endl; - string const ui_path = libFileSearch("ui", name, "ui"); - + + FileName ui_path; + if (include) { + ui_path = libFileSearch("ui", name, "inc"); + if (ui_path.empty()) + ui_path = libFileSearch("ui", + changeExtension(name, "inc")); + } + else + ui_path = libFileSearch("ui", name, "ui"); + if (ui_path.empty()) { lyxerr[Debug::INIT] << "Could not find " << name << endl; showFileError(name); - return; + return false; } + uifiles.push_back(name); lyxerr[Debug::INIT] << "Found " << name @@ -807,7 +1204,8 @@ void LyX::readUIFile(string const & name) case ui_include: { lex.next(true); string const file = lex.getString(); - readUIFile(file); + if (!readUIFile(file, true)) + return false; break; } case ui_menuset: @@ -829,40 +1227,42 @@ void LyX::readUIFile(string const & name) break; } } + return true; } // Read the languages file `name' -void LyX::readLanguagesFile(string const & name) +bool LyX::readLanguagesFile(string const & name) { lyxerr[Debug::INIT] << "About to read " << name << "..." << endl; - string const lang_path = libFileSearch(string(), name); + FileName const lang_path = libFileSearch(string(), name); if (lang_path.empty()) { showFileError(name); - return; + return false; } languages.read(lang_path); + return true; } // Read the encodings file `name' -void LyX::readEncodingsFile(string const & name) +bool LyX::readEncodingsFile(string const & name) { lyxerr[Debug::INIT] << "About to read " << name << "..." << endl; - string const enc_path = libFileSearch(string(), name); + FileName const enc_path = libFileSearch(string(), name); if (enc_path.empty()) { showFileError(name); - return; + return false; } encodings.read(enc_path); + return true; } namespace { -bool is_gui = true; string batch; /// return the the number of arguments consumed @@ -871,11 +1271,11 @@ typedef boost::function cmd_helper; int parse_dbg(string const & arg, string const &) { if (arg.empty()) { - lyxerr << _("List of supported debug flags:") << endl; + lyxerr << to_utf8(_("List of supported debug flags:")) << endl; Debug::showTags(lyxerr); exit(0); } - lyxerr << bformat(_("Setting debug level to %1$s"), arg) << endl; + lyxerr << to_utf8(bformat(_("Setting debug level to %1$s"), from_utf8(arg))) << endl; lyxerr.level(Debug::value(arg)); Debug::showLevel(lyxerr, lyxerr.level()); @@ -886,7 +1286,7 @@ int parse_dbg(string const & arg, string const &) int parse_help(string const &, string const &) { lyxerr << - _("Usage: lyx [ command line switches ] [ name.lyx ... ]\n" + to_utf8(_("Usage: lyx [ command line switches ] [ name.lyx ... ]\n" "Command line switches (case sensitive):\n" "\t-help summarize LyX usage\n" "\t-userdir dir set user directory to dir\n" @@ -903,7 +1303,7 @@ int parse_help(string const &, string const &) " where fmt is the import format of choice\n" " 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; + "Check the LyX man page for more details.")) << endl; exit(0); return 0; } @@ -911,7 +1311,7 @@ int parse_help(string const &, string const &) int parse_version(string const &, string const &) { lyxerr << "LyX " << lyx_version - << " of " << lyx_release_date << endl; + << " (" << lyx_release_date << ")" << endl; lyxerr << "Built on " << __DATE__ << ", " << __TIME__ << endl; lyxerr << lyx_version_info << endl; @@ -922,7 +1322,8 @@ int parse_version(string const &, string const &) int parse_sysdir(string const & arg, string const &) { if (arg.empty()) { - lyxerr << _("Missing directory for -sysdir switch") << endl; + Alert::error(_("No system directory"), + _("Missing directory for -sysdir switch")); exit(1); } cl_system_support = arg; @@ -932,7 +1333,8 @@ int parse_sysdir(string const & arg, string const &) int parse_userdir(string const & arg, string const &) { if (arg.empty()) { - lyxerr << _("Missing directory for -userdir switch") << endl; + Alert::error(_("No user directory"), + _("Missing directory for -userdir switch")); exit(1); } cl_user_support = arg; @@ -942,7 +1344,8 @@ int parse_userdir(string const & arg, string const &) int parse_execute(string const & arg, string const &) { if (arg.empty()) { - lyxerr << _("Missing command string after --execute switch") << endl; + Alert::error(_("Incomplete command"), + _("Missing command string after --execute switch")); exit(1); } batch = arg; @@ -952,24 +1355,24 @@ int parse_execute(string const & arg, string const &) int parse_export(string const & type, string const &) { if (type.empty()) { - lyxerr << _("Missing file type [eg latex, ps...] after " - "--export switch") << endl; + lyxerr << to_utf8(_("Missing file type [eg latex, ps...] after " + "--export switch")) << endl; exit(1); } batch = "buffer-export " + type; - is_gui = false; + use_gui = false; return 1; } int parse_import(string const & type, string const & file) { if (type.empty()) { - lyxerr << _("Missing file type [eg latex, ps...] after " - "--import switch") << endl; + lyxerr << to_utf8(_("Missing file type [eg latex, ps...] after " + "--import switch")) << endl; exit(1); } if (file.empty()) { - lyxerr << _("Missing filename for --import") << endl; + lyxerr << to_utf8(_("Missing filename for --import")) << endl; exit(1); } @@ -977,10 +1380,23 @@ int parse_import(string const & type, string const & file) return 2; } +int parse_geometry(string const & arg1, string const &) +{ + geometryArg = arg1; +#if defined(_WIN32) || (defined(__CYGWIN__) && defined(X_DISPLAY_MISSING)) + // remove also the arg + return 1; +#else + // don't remove "-geometry" + return -1; +#endif +} + + } // namespace anon -bool LyX::easyParse(int & argc, char * argv[]) +void LyX::easyParse(int & argc, char * argv[]) { std::map cmdmap; @@ -997,33 +1413,133 @@ bool LyX::easyParse(int & argc, char * argv[]) cmdmap["--export"] = parse_export; cmdmap["-i"] = parse_import; cmdmap["--import"] = parse_import; + cmdmap["-geometry"] = parse_geometry; for (int i = 1; i < argc; ++i) { std::map::const_iterator it = cmdmap.find(argv[i]); - // check for X11 -geometry option - if (lyx::support::compare(argv[i], "-geometry") == 0) - geometryOption_ = true; - // 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] : ""); + string const arg((i + 1 < argc) ? to_utf8(from_local8bit(argv[i + 1])) : string()); + string const arg2((i + 2 < argc) ? to_utf8(from_local8bit(argv[i + 2])) : string()); 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; + if (remove > 0) { + argc -= remove; + for (int j = i; j < argc; ++j) + argv[j] = argv[j + remove]; + --i; + } } batch_command = batch; +} + + +FuncStatus getStatus(FuncRequest const & action) +{ + return LyX::ref().lyxFunc().getStatus(action); +} + + +void dispatch(FuncRequest const & action) +{ + LyX::ref().lyxFunc().dispatch(action); +} + + +BufferList & theBufferList() +{ + return LyX::ref().bufferList(); +} + + +LyXFunc & theLyXFunc() +{ + return LyX::ref().lyxFunc(); +} + + +LyXServer & theLyXServer() +{ + // FIXME: this should not be use_gui dependent + BOOST_ASSERT(use_gui); + return LyX::ref().server(); +} + + +LyXServerSocket & theLyXServerSocket() +{ + // FIXME: this should not be use_gui dependent + BOOST_ASSERT(use_gui); + return LyX::ref().socket(); +} + + +kb_keymap & theTopLevelKeymap() +{ + BOOST_ASSERT(use_gui); + return LyX::ref().topLevelKeymap(); +} - return is_gui; + +Converters & theConverters() +{ + return LyX::ref().converters(); +} + + +Converters & theSystemConverters() +{ + return LyX::ref().systemConverters(); +} + + +Movers & theMovers() +{ + return LyX::ref().pimpl_->movers_; +} + + +Mover const & getMover(std::string const & fmt) +{ + return LyX::ref().pimpl_->movers_(fmt); +} + + +void setMover(std::string const & fmt, std::string const & command) +{ + LyX::ref().pimpl_->movers_.set(fmt, command); } + + +Movers & theSystemMovers() +{ + return LyX::ref().pimpl_->system_movers_; +} + + +IconvProcessor & utf8ToUcs4() +{ + return LyX::ref().iconvProcessor(); +} + + +Messages & getMessages(std::string const & language) +{ + return LyX::ref().getMessages(language); +} + + +Messages & getGuiMessages() +{ + return LyX::ref().getGuiMessages(); +} + +} // namespace lyx