src/LyX.cpp

   1 /**
   2  * \file LyX.cpp
   3  * This file is part of LyX, the document processor.
   4  * Licence details can be found in the file COPYING.
   5  *
   6  * \author Alfredo Braunstein
   7  * \author Lars Gullik Bjønnes
   8  * \author Jean-Marc Lasgouttes
   9  * \author John Levon
  10  * \author André Pönitz
  11  *
  12  * Full author contact details are available in file CREDITS.
  13  */
  14
  15 #include <config.h>
  16 #include <version.h>
  17
  18 #include "LyX.h"
  19
  20 #include "LayoutFile.h"
  21 #include "Buffer.h"
  22 #include "BufferList.h"
  23 #include "CmdDef.h"
  24 #include "ColorSet.h"
  25 #include "ConverterCache.h"
  26 #include "Converter.h"
  27 #include "CutAndPaste.h"
  28 #include "Encoding.h"
  29 #include "ErrorList.h"
  30 #include "Format.h"
  31 #include "FuncStatus.h"
  32 #include "KeyMap.h"
  33 #include "Language.h"
  34 #include "Lexer.h"
  35 #include "LyXAction.h"
  36 #include "LyXFunc.h"
  37 #include "LyXRC.h"
  38 #include "ModuleList.h"
  39 #include "Mover.h"
  40 #include "Server.h"
  41 #include "ServerSocket.h"
  42 #include "Session.h"
  43
  44 #include "frontends/alert.h"
  45 #include "frontends/Application.h"
  46
  47 #include "graphics/Previews.h"
  48
  49 #include "support/lassert.h"
  50 #include "support/debug.h"
  51 #include "support/environment.h"
  52 #include "support/ExceptionMessage.h"
  53 #include "support/filetools.h"
  54 #include "support/gettext.h"
  55 #include "support/lstrings.h"
  56 #include "support/Messages.h"
  57 #include "support/os.h"
  58 #include "support/Package.h"
  59 #include "support/Path.h"
  60 #include "support/Systemcall.h"
  61
  62 #include <boost/bind.hpp>
  63 #include <boost/scoped_ptr.hpp>
  64
  65 #include <algorithm>
  66 #include <iostream>
  67 #include <csignal>
  68 #include <map>
  69 #include <stdlib.h>
  70 #include <string>
  71 #include <vector>
  72
  73 using namespace std;
  74 using namespace lyx::support;
  75
  76 namespace lyx {
  77
  78 namespace Alert = frontend::Alert;
  79 namespace os = support::os;
  80
  81
  82
  83 // Are we using the GUI at all?  We default to true and this is changed
  84 // to false when the export feature is used.
  85
  86 bool use_gui = true;
  87
  88 namespace {
  89
  90 // Filled with the command line arguments "foo" of "-sysdir foo" or
  91 // "-userdir foo".
  92 string cl_system_support;
  93 string cl_user_support;
  94
  95 string geometryArg;
  96
  97 LyX * singleton_ = 0;
  98
  99 void showFileError(string const & error)
 100 {
 101         Alert::warning(_("Could not read configuration file"),
 102                        bformat(_("Error while reading the configuration file\n%1$s.\n"
 103                            "Please check your installation."), from_utf8(error)));
 104 }
 105
 106
 107 void reconfigureUserLyXDir()
 108 {
 109         string const configure_command = package().configure_command();
 110
 111         lyxerr << to_utf8(_("LyX: reconfiguring user directory")) << endl;
 112         PathChanger p(package().user_support());
 113         Systemcall one;
 114         one.startscript(Systemcall::Wait, configure_command);
 115         lyxerr << "LyX: " << to_utf8(_("Done!")) << endl;
 116 }
 117
 118 } // namespace anon
 119
 120
 121 /// The main application class private implementation.
 122 struct LyX::Impl
 123 {
 124         Impl()
 125         {
 126                 // Set the default User Interface language as soon as possible.
 127                 // The language used will be derived from the environment
 128                 // variables.
 129                 messages_["GUI"] = Messages();
 130         }
 131         /// our function handler
 132         LyXFunc lyxfunc_;
 133         ///
 134         BufferList buffer_list_;
 135         ///
 136         KeyMap toplevel_keymap_;
 137         ///
 138         CmdDef toplevel_cmddef_;
 139         ///
 140         boost::scoped_ptr<Server> lyx_server_;
 141         ///
 142         boost::scoped_ptr<ServerSocket> lyx_socket_;
 143         ///
 144         boost::scoped_ptr<frontend::Application> application_;
 145         /// lyx session, containing lastfiles, lastfilepos, and lastopened
 146         boost::scoped_ptr<Session> session_;
 147
 148         /// Files to load at start.
 149         vector<string> files_to_load_;
 150
 151         /// The messages translators.
 152         map<string, Messages> messages_;
 153
 154         /// The file converters.
 155         Converters converters_;
 156
 157         // The system converters copy after reading lyxrc.defaults.
 158         Converters system_converters_;
 159
 160         ///
 161         Movers movers_;
 162         ///
 163         Movers system_movers_;
 164
 165         /// has this user started lyx for the first time?
 166         bool first_start;
 167         /// the parsed command line batch command if any
 168         vector<string> batch_commands;
 169
 170         ///
 171         graphics::Previews preview_;
 172 };
 173
 174 ///
 175 frontend::Application * theApp()
 176 {
 177         if (singleton_)
 178                 return singleton_->pimpl_->application_.get();
 179         else
 180                 return 0;
 181 }
 182
 183
 184 LyX::~LyX()
 185 {
 186         singleton_ = 0;
 187         delete pimpl_;
 188 }
 189
 190
 191 void lyx_exit(int exit_code)
 192 {
 193         if (exit_code)
 194                 // Something wrong happened so better save everything, just in
 195                 // case.
 196                 emergencyCleanup();
 197
 198 #ifndef NDEBUG
 199         // Properly crash in debug mode in order to get a useful backtrace.
 200         abort();
 201 #endif
 202
 203         // In release mode, try to exit gracefully.
 204         if (theApp())
 205                 theApp()->exit(exit_code);
 206         else
 207                 exit(exit_code);
 208 }
 209
 210
 211 LyX::LyX()
 212         : first_start(false)
 213 {
 214         singleton_ = this;
 215         pimpl_ = new Impl;
 216 }
 217
 218
 219 Messages & LyX::messages(string const & language)
 220 {
 221         map<string, Messages>::iterator it = pimpl_->messages_.find(language);
 222
 223         if (it != pimpl_->messages_.end())
 224                 return it->second;
 225
 226         pair<map<string, Messages>::iterator, bool> result =
 227                         pimpl_->messages_.insert(make_pair(language, Messages(language)));
 228
 229         LASSERT(result.second, /**/);
 230         return result.first->second;
 231 }
 232
 233
 234 void setRcGuiLanguage()
 235 {
 236         LASSERT(singleton_, /**/);
 237         if (lyxrc.gui_language == "auto")
 238                 return;
 239         Language const * language = languages.getLanguage(lyxrc.gui_language);
 240         if (language) {
 241                 LYXERR(Debug::LOCALE, "Setting LANGUAGE to " << language->code());
 242                 if (!setEnv("LANGUAGE", language->code()))
 243                         LYXERR(Debug::LOCALE, "\t... failed!");
 244         }
 245         LYXERR(Debug::LOCALE, "Setting LC_ALL to en_US");
 246         if (!setEnv("LC_ALL", "en_US"))
 247                 LYXERR(Debug::LOCALE, "\t... failed!");
 248         Messages::init();
 249         singleton_->pimpl_->messages_["GUI"] = Messages();
 250 }
 251
 252
 253 int LyX::exec(int & argc, char * argv[])
 254 {
 255         // Here we need to parse the command line. At least
 256         // we need to parse for "-dbg" and "-help"
 257         easyParse(argc, argv);
 258
 259         try {
 260                 init_package(to_utf8(from_local8bit(argv[0])),
 261                               cl_system_support, cl_user_support,
 262                               top_build_dir_is_one_level_up);
 263         } catch (ExceptionMessage const & message) {
 264                 if (message.type_ == ErrorException) {
 265                         Alert::error(message.title_, message.details_);
 266                         lyx_exit(1);
 267                 } else if (message.type_ == WarningException) {
 268                         Alert::warning(message.title_, message.details_);
 269                 }
 270         }
 271
 272         // Reinit the messages machinery in case package() knows
 273         // something interesting about the locale directory.
 274         Messages::init();
 275
 276         if (!use_gui) {
 277                 // FIXME: create a ConsoleApplication
 278                 int exit_status = init(argc, argv);
 279                 if (exit_status) {
 280                         prepareExit();
 281                         return exit_status;
 282                 }
 283
 284                 // this is correct, since return values are inverted.
 285                 exit_status = !loadFiles();
 286
 287                 if (pimpl_->batch_commands.empty() || pimpl_->buffer_list_.empty()) {
 288                         prepareExit();
 289                         return exit_status;
 290                 }
 291
 292                 BufferList::iterator begin = pimpl_->buffer_list_.begin();
 293
 294                 bool final_success = false;
 295                 for (BufferList::iterator I = begin; I != pimpl_->buffer_list_.end(); ++I) {
 296                         Buffer * buf = *I;
 297                         if (buf != buf->masterBuffer())
 298                                 continue;
 299                         bool success = false;
 300                         vector<string>::const_iterator bcit  = pimpl_->batch_commands.begin();
 301                         vector<string>::const_iterator bcend = pimpl_->batch_commands.end();
 302                         for (; bcit != bcend; bcit++) {
 303                                 buf->dispatch(*bcit, &success);
 304                                 final_success |= success;
 305                         }
 306                 }
 307                 prepareExit();
 308                 return !final_success;
 309         }
 310
 311         // Let the frontend parse and remove all arguments that it knows
 312         pimpl_->application_.reset(createApplication(argc, argv));
 313
 314         // Reestablish our defaults, as Qt overwrites them
 315         // after createApplication()
 316         locale_init();
 317
 318         // Parse and remove all known arguments in the LyX singleton
 319         // Give an error for all remaining ones.
 320         int exit_status = init(argc, argv);
 321         if (exit_status) {
 322                 // Kill the application object before exiting.
 323                 pimpl_->application_.reset();
 324                 use_gui = false;
 325                 prepareExit();
 326                 return exit_status;
 327         }
 328
 329         // FIXME
 330         /* Create a CoreApplication class that will provide the main event loop
 331         * and the socket callback registering. With Qt4, only QtCore
 332         * library would be needed.
 333         * When this is done, a server_mode could be created and the following two
 334         * line would be moved out from here.
 335         */
 336         // Note: socket callback must be registered after init(argc, argv)
 337         // such that package().temp_dir() is properly initialized.
 338         pimpl_->lyx_server_.reset(new Server(&pimpl_->lyxfunc_, lyxrc.lyxpipes));
 339         pimpl_->lyx_socket_.reset(new ServerSocket(&pimpl_->lyxfunc_,
 340                         FileName(package().temp_dir().absFilename() + "/lyxsocket")));
 341
 342         // Start the real execution loop.
 343         exit_status = pimpl_->application_->exec();
 344
 345         prepareExit();
 346
 347         return exit_status;
 348 }
 349
 350
 351 void LyX::prepareExit()
 352 {
 353         // Clear the clipboard and selection stack:
 354         cap::clearCutStack();
 355         cap::clearSelection();
 356
 357         // close buffers first
 358         pimpl_->buffer_list_.closeAll();
 359
 360         // register session changes and shutdown server and socket
 361         if (use_gui) {
 362                 if (pimpl_->session_)
 363                         pimpl_->session_->writeFile();
 364                 pimpl_->session_.reset();
 365                 pimpl_->lyx_server_.reset();
 366                 pimpl_->lyx_socket_.reset();
 367         }
 368
 369         // do any other cleanup procedures now
 370         if (package().temp_dir() != package().system_temp_dir()) {
 371                 string const abs_tmpdir = package().temp_dir().absFilename();
 372                 if (!contains(package().temp_dir().absFilename(), "lyx_tmpdir")) {
 373                         docstring const msg =
 374                                 bformat(_("%1$s does not appear like a LyX created temporary directory."),
 375                                 from_utf8(abs_tmpdir));
 376                         Alert::warning(_("Cannot remove temporary directory"), msg);
 377                 } else {
 378                         LYXERR(Debug::INFO, "Deleting tmp dir "
 379                                 << package().temp_dir().absFilename());
 380                         if (!package().temp_dir().destroyDirectory()) {
 381                                 docstring const msg =
 382                                         bformat(_("Unable to remove the temporary directory %1$s"),
 383                                         from_utf8(package().temp_dir().absFilename()));
 384                                 Alert::warning(_("Unable to remove temporary directory"), msg);
 385                         }
 386                 }
 387         }
 388
 389         // Kill the application object before exiting. This avoids crashes
 390         // when exiting on Linux.
 391         if (pimpl_->application_)
 392                 pimpl_->application_.reset();
 393 }
 394
 395
 396 void LyX::earlyExit(int status)
 397 {
 398         LASSERT(pimpl_->application_.get(), /**/);
 399         // LyX::pimpl_::application_ is not initialised at this
 400         // point so it's safe to just exit after some cleanup.
 401         prepareExit();
 402         exit(status);
 403 }
 404
 405
 406 int LyX::init(int & argc, char * argv[])
 407 {
 408         // check for any spurious extra arguments
 409         // other than documents
 410         for (int argi = 1; argi < argc ; ++argi) {
 411                 if (argv[argi][0] == '-') {
 412                         lyxerr << to_utf8(
 413                                 bformat(_("Wrong command line option `%1$s'. Exiting."),
 414                                 from_utf8(argv[argi]))) << endl;
 415                         return EXIT_FAILURE;
 416                 }
 417         }
 418
 419         // Initialization of LyX (reads lyxrc and more)
 420         LYXERR(Debug::INIT, "Initializing LyX::init...");
 421         bool success = init();
 422         LYXERR(Debug::INIT, "Initializing LyX::init...done");
 423         if (!success)
 424                 return EXIT_FAILURE;
 425
 426         // Remaining arguments are assumed to be files to load.
 427         for (int argi = argc - 1; argi >= 1; --argi)
 428                 pimpl_->files_to_load_.push_back(to_utf8(from_local8bit(argv[argi])));
 429
 430         if (first_start) {
 431                 pimpl_->files_to_load_.push_back(
 432                         i18nLibFileSearch("examples", "splash.lyx").absFilename());
 433         }
 434
 435         return EXIT_SUCCESS;
 436 }
 437
 438
 439 bool LyX::loadFiles()
 440 {
 441         LASSERT(!use_gui, /**/);
 442         bool success = true;
 443         vector<string>::const_iterator it = pimpl_->files_to_load_.begin();
 444         vector<string>::const_iterator end = pimpl_->files_to_load_.end();
 445
 446         for (; it != end; ++it) {
 447                 // get absolute path of file and add ".lyx" to
 448                 // the filename if necessary
 449                 FileName fname = fileSearch(string(), os::internal_path(*it), "lyx",
 450                         may_not_exist);
 451
 452                 if (fname.empty())
 453                         continue;
 454
 455                 Buffer * buf = pimpl_->buffer_list_.newBuffer(fname.absFilename(), false);
 456                 if (buf->loadLyXFile(fname)) {
 457                         ErrorList const & el = buf->errorList("Parse");
 458                         if (!el.empty())
 459                                 for_each(el.begin(), el.end(),
 460                                 boost::bind(&LyX::printError, this, _1));
 461                 }
 462                 else {
 463                         pimpl_->buffer_list_.release(buf);
 464                         success = false;
 465                 }
 466         }
 467         return success;
 468 }
 469
 470
 471 void execBatchCommands()
 472 {
 473         LASSERT(singleton_, /**/);
 474         singleton_->execCommands();
 475 }
 476
 477
 478 void LyX::execCommands()
 479 {
 480         // The advantage of doing this here is that the event loop
 481         // is already started. So any need for interaction will be
 482         // aknowledged.
 483
 484         // if reconfiguration is needed.
 485         while (LayoutFileList::get().empty()) {
 486                 switch (Alert::prompt(
 487                         _("No textclass is found"),
 488                         _("LyX cannot continue because no textclass is found. "
 489                                 "You can either reconfigure normally, or reconfigure using "
 490                                 "default textclasses, or quit LyX."),
 491                         0, 2,
 492                         _("&Reconfigure"),
 493                         _("&Use Default"),
 494                         _("&Exit LyX")))
 495                 {
 496                 case 0:
 497                         // regular reconfigure
 498                         pimpl_->lyxfunc_.dispatch(FuncRequest(LFUN_RECONFIGURE, ""));
 499                         break;
 500                 case 1:
 501                         // reconfigure --without-latex-config
 502                         pimpl_->lyxfunc_.dispatch(FuncRequest(LFUN_RECONFIGURE,
 503                                 " --without-latex-config"));
 504                         break;
 505                 default:
 506                         pimpl_->lyxfunc_.dispatch(FuncRequest(LFUN_LYX_QUIT));
 507                         return;
 508                 }
 509         }
 510
 511         // create the first main window
 512         pimpl_->lyxfunc_.dispatch(FuncRequest(LFUN_WINDOW_NEW, geometryArg));
 513
 514         if (!pimpl_->files_to_load_.empty()) {
 515                 // if some files were specified at command-line we assume that the
 516                 // user wants to edit *these* files and not to restore the session.
 517                 for (size_t i = 0; i != pimpl_->files_to_load_.size(); ++i) {
 518                         pimpl_->lyxfunc_.dispatch(
 519                                 FuncRequest(LFUN_FILE_OPEN, pimpl_->files_to_load_[i]));
 520                 }
 521                 // clear this list to save a few bytes of RAM
 522                 pimpl_->files_to_load_.clear();
 523         } else
 524                 pimpl_->application_->restoreGuiSession();
 525
 526         // Execute batch commands if available
 527         if (pimpl_->batch_commands.empty())
 528                 return;
 529
 530         vector<string>::const_iterator bcit  = pimpl_->batch_commands.begin();
 531         vector<string>::const_iterator bcend = pimpl_->batch_commands.end();
 532         for (; bcit != bcend; bcit++) {
 533                 LYXERR(Debug::INIT, "About to handle -x '" << *bcit << '\'');
 534                 pimpl_->lyxfunc_.dispatch(lyxaction.lookupFunc(*bcit));
 535         }
 536 }
 537
 538
 539 /*
 540 Signals and Windows
 541 ===================
 542 The SIGHUP signal does not exist on Windows and does not need to be handled.
 543
 544 Windows handles SIGFPE and SIGSEGV signals as expected.
 545
 546 Ctrl+C interrupts (mapped to SIGINT by Windows' POSIX compatability layer)
 547 cause a new thread to be spawned. This may well result in unexpected
 548 behaviour by the single-threaded LyX.
 549
 550 SIGTERM signals will come only from another process actually sending
 551 that signal using 'raise' in Windows' POSIX compatability layer. It will
 552 not come from the general "terminate process" methods that everyone
 553 actually uses (and which can't be trapped). Killing an app 'politely' on
 554 Windows involves first sending a WM_CLOSE message, something that is
 555 caught already by the Qt frontend.
 556
 557 For more information see:
 558
 559 http://aspn.activestate.com/ASPN/Mail/Message/ActiveTcl/2034055
 560 ...signals are mostly useless on Windows for a variety of reasons that are
 561 Windows specific...
 562
 563 'UNIX Application Migration Guide, Chapter 9'
 564 http://msdn.microsoft.com/library/en-us/dnucmg/html/UCMGch09.asp
 565
 566 'How To Terminate an Application "Cleanly" in Win32'
 567 http://support.microsoft.com/default.aspx?scid=kb;en-us;178893
 568 */
 569 extern "C" {
 570
 571 static void error_handler(int err_sig)
 572 {
 573         // Throw away any signals other than the first one received.
 574         static sig_atomic_t handling_error = false;
 575         if (handling_error)
 576                 return;
 577         handling_error = true;
 578
 579         // We have received a signal indicating a fatal error, so
 580         // try and save the data ASAP.
 581         emergencyCleanup();
 582
 583         // These lyxerr calls may or may not work:
 584
 585         // Signals are asynchronous, so the main program may be in a very
 586         // fragile state when a signal is processed and thus while a signal
 587         // handler function executes.
 588         // In general, therefore, we should avoid performing any
 589         // I/O operations or calling most library and system functions from
 590         // signal handlers.
 591
 592         // This shouldn't matter here, however, as we've already invoked
 593         // emergencyCleanup.
 594         switch (err_sig) {
 595 #ifdef SIGHUP
 596         case SIGHUP:
 597                 lyxerr << "\nlyx: SIGHUP signal caught\nBye." << endl;
 598                 break;
 599 #endif
 600         case SIGFPE:
 601                 lyxerr << "\nlyx: SIGFPE signal caught\nBye." << endl;
 602                 break;
 603         case SIGSEGV:
 604                 lyxerr << "\nlyx: SIGSEGV signal caught\n"
 605                           "Sorry, you have found a bug in LyX. "
 606                           "Please read the bug-reporting instructions "
 607                           "in Help->Introduction and send us a bug report, "
 608                           "if necessary. Thanks !\nBye." << endl;
 609                 break;
 610         case SIGINT:
 611         case SIGTERM:
 612                 // no comments
 613                 break;
 614         }
 615
 616         // Deinstall the signal handlers
 617 #ifdef SIGHUP
 618         signal(SIGHUP, SIG_DFL);
 619 #endif
 620         signal(SIGINT, SIG_DFL);
 621         signal(SIGFPE, SIG_DFL);
 622         signal(SIGSEGV, SIG_DFL);
 623         signal(SIGTERM, SIG_DFL);
 624
 625 #ifdef SIGHUP
 626         if (err_sig == SIGSEGV ||
 627             (err_sig != SIGHUP && !getEnv("LYXDEBUG").empty()))
 628 #else
 629         if (err_sig == SIGSEGV || !getEnv("LYXDEBUG").empty())
 630 #endif
 631                 abort();
 632         exit(0);
 633 }
 634
 635 }
 636
 637
 638 void LyX::printError(ErrorItem const & ei)
 639 {
 640         docstring tmp = _("LyX: ") + ei.error + char_type(':')
 641                 + ei.description;
 642         cerr << to_utf8(tmp) << endl;
 643 }
 644
 645
 646 bool LyX::init()
 647 {
 648 #ifdef SIGHUP
 649         signal(SIGHUP, error_handler);
 650 #endif
 651         signal(SIGFPE, error_handler);
 652         signal(SIGSEGV, error_handler);
 653         signal(SIGINT, error_handler);
 654         signal(SIGTERM, error_handler);
 655         // SIGPIPE can be safely ignored.
 656
 657         lyxrc.tempdir_path = package().temp_dir().absFilename();
 658         lyxrc.document_path = package().document_dir().absFilename();
 659
 660         if (lyxrc.example_path.empty()) {
 661                 lyxrc.example_path = addPath(package().system_support().absFilename(),
 662                                               "examples");
 663         }
 664         if (lyxrc.template_path.empty()) {
 665                 lyxrc.template_path = addPath(package().system_support().absFilename(),
 666                                               "templates");
 667         }
 668
 669         //
 670         // Read configuration files
 671         //
 672
 673         // This one may have been distributed along with LyX.
 674         if (!readRcFile("lyxrc.dist"))
 675                 return false;
 676
 677         // Set the language defined by the distributor.
 678         setRcGuiLanguage();
 679
 680         // Set the PATH correctly.
 681 #if !defined (USE_POSIX_PACKAGING)
 682         // Add the directory containing the LyX executable to the path
 683         // so that LyX can find things like tex2lyx.
 684         if (package().build_support().empty())
 685                 prependEnvPath("PATH", package().binary_dir().absFilename());
 686 #endif
 687         if (!lyxrc.path_prefix.empty())
 688                 prependEnvPath("PATH", lyxrc.path_prefix);
 689
 690         // Check that user LyX directory is ok.
 691         if (queryUserLyXDir(package().explicit_user_support()))
 692                 reconfigureUserLyXDir();
 693
 694         // no need for a splash when there is no GUI
 695         if (!use_gui) {
 696                 first_start = false;
 697         }
 698
 699         // This one is generated in user_support directory by lib/configure.py.
 700         if (!readRcFile("lyxrc.defaults"))
 701                 return false;
 702
 703         // Query the OS to know what formats are viewed natively
 704         formats.setAutoOpen();
 705
 706         // Read lyxrc.dist again to be able to override viewer auto-detection.
 707         readRcFile("lyxrc.dist");
 708
 709         // Set again the language defined by the distributor.
 710         setRcGuiLanguage();
 711
 712         system_lyxrc = lyxrc;
 713         system_formats = formats;
 714         pimpl_->system_converters_ = pimpl_->converters_;
 715         pimpl_->system_movers_ = pimpl_->movers_;
 716         system_lcolor = lcolor;
 717
 718         // This one is edited through the preferences dialog.
 719         if (!readRcFile("preferences"))
 720                 return false;
 721
 722         if (!readEncodingsFile("encodings", "unicodesymbols"))
 723                 return false;
 724         if (!readLanguagesFile("languages"))
 725                 return false;
 726
 727         // Set the language defined by the user.
 728         setRcGuiLanguage();
 729
 730         // Load the layouts
 731         LYXERR(Debug::INIT, "Reading layouts...");
 732         if (!LyXSetStyle())
 733                 return false;
 734         //...and the modules
 735         moduleList.load();
 736
 737         // read keymap and ui files in batch mode as well
 738         // because InsetInfo needs to know these to produce
 739         // the correct output
 740
 741         // Set up command definitions
 742         pimpl_->toplevel_cmddef_.read(lyxrc.def_file);
 743
 744         // Set up bindings
 745         pimpl_->toplevel_keymap_.read("site");
 746         pimpl_->toplevel_keymap_.read(lyxrc.bind_file);
 747         // load user bind file user.bind
 748         pimpl_->toplevel_keymap_.read("user");
 749
 750         pimpl_->lyxfunc_.initKeySequences(&pimpl_->toplevel_keymap_);
 751
 752         if (lyxerr.debugging(Debug::LYXRC))
 753                 lyxrc.print();
 754
 755         os::windows_style_tex_paths(lyxrc.windows_style_tex_paths);
 756         if (!lyxrc.path_prefix.empty())
 757                 prependEnvPath("PATH", lyxrc.path_prefix);
 758
 759         FileName const document_path(lyxrc.document_path);
 760         if (document_path.exists() && document_path.isDirectory())
 761                 package().document_dir() = document_path;
 762
 763         package().set_temp_dir(createLyXTmpDir(FileName(lyxrc.tempdir_path)));
 764         if (package().temp_dir().empty()) {
 765                 Alert::error(_("Could not create temporary directory"),
 766                              bformat(_("Could not create a temporary directory in\n"
 767                                                        "\"%1$s\"\n"
 768                                                            "Make sure that this path exists and is writable and try again."),
 769                                      from_utf8(lyxrc.tempdir_path)));
 770                 // createLyXTmpDir() tries sufficiently hard to create a
 771                 // usable temp dir, so the probability to come here is
 772                 // close to zero. We therefore don't try to overcome this
 773                 // problem with e.g. asking the user for a new path and
 774                 // trying again but simply exit.
 775                 return false;
 776         }
 777
 778         LYXERR(Debug::INIT, "LyX tmp dir: `"
 779                             << package().temp_dir().absFilename() << '\'');
 780
 781         LYXERR(Debug::INIT, "Reading session information '.lyx/session'...");
 782         pimpl_->session_.reset(new Session(lyxrc.num_lastfiles));
 783
 784         // This must happen after package initialization and after lyxrc is
 785         // read, therefore it can't be done by a static object.
 786         ConverterCache::init();
 787
 788         return true;
 789 }
 790
 791
 792 void emergencyCleanup()
 793 {
 794         // what to do about tmpfiles is non-obvious. we would
 795         // like to delete any we find, but our lyxdir might
 796         // contain documents etc. which might be helpful on
 797         // a crash
 798
 799         singleton_->pimpl_->buffer_list_.emergencyWriteAll();
 800         if (use_gui) {
 801                 if (singleton_->pimpl_->lyx_server_)
 802                         singleton_->pimpl_->lyx_server_->emergencyCleanup();
 803                 singleton_->pimpl_->lyx_server_.reset();
 804                 singleton_->pimpl_->lyx_socket_.reset();
 805         }
 806 }
 807
 808
 809 // return true if file does not exist or is older than configure.py.
 810 static bool needsUpdate(string const & file)
 811 {
 812         // We cannot initialize configure_script directly because the package
 813         // is not initialized yet when  static objects are constructed.
 814         static FileName configure_script;
 815         static bool firstrun = true;
 816         if (firstrun) {
 817                 configure_script =
 818                         FileName(addName(package().system_support().absFilename(),
 819                                 "configure.py"));
 820                 firstrun = false;
 821         }
 822
 823         FileName absfile =
 824                 FileName(addName(package().user_support().absFilename(), file));
 825         return !absfile.exists()
 826                 || configure_script.lastModified() > absfile.lastModified();
 827 }
 828
 829
 830 bool LyX::queryUserLyXDir(bool explicit_userdir)
 831 {
 832         // Does user directory exist?
 833         FileName const sup = package().user_support();
 834         if (sup.exists() && sup.isDirectory()) {
 835                 first_start = false;
 836
 837                 return needsUpdate("lyxrc.defaults")
 838                         || needsUpdate("lyxmodules.lst")
 839                         || needsUpdate("textclass.lst")
 840                         || needsUpdate("packages.lst");
 841         }
 842
 843         first_start = !explicit_userdir;
 844
 845         // If the user specified explicitly a directory, ask whether
 846         // to create it. If the user says "no", then exit.
 847         if (explicit_userdir &&
 848             Alert::prompt(
 849                     _("Missing user LyX directory"),
 850                     bformat(_("You have specified a non-existent user "
 851                                            "LyX directory, %1$s.\n"
 852                                            "It is needed to keep your own configuration."),
 853                             from_utf8(package().user_support().absFilename())),
 854                     1, 0,
 855                     _("&Create directory"),
 856                     _("&Exit LyX"))) {
 857                 lyxerr << to_utf8(_("No user LyX directory. Exiting.")) << endl;
 858                 earlyExit(EXIT_FAILURE);
 859         }
 860
 861         lyxerr << to_utf8(bformat(_("LyX: Creating directory %1$s"),
 862                           from_utf8(sup.absFilename()))) << endl;
 863
 864         if (!sup.createDirectory(0755)) {
 865                 // Failed, so let's exit.
 866                 lyxerr << to_utf8(_("Failed to create directory. Exiting."))
 867                        << endl;
 868                 earlyExit(EXIT_FAILURE);
 869         }
 870
 871         return true;
 872 }
 873
 874
 875 bool LyX::readRcFile(string const & name)
 876 {
 877         LYXERR(Debug::INIT, "About to read " << name << "... ");
 878
 879         FileName const lyxrc_path = libFileSearch(string(), name);
 880         if (!lyxrc_path.empty()) {
 881                 LYXERR(Debug::INIT, "Found in " << lyxrc_path);
 882                 if (lyxrc.read(lyxrc_path) < 0) {
 883                         showFileError(name);
 884                         return false;
 885                 }
 886         } else {
 887                 LYXERR(Debug::INIT, "Not found." << lyxrc_path);
 888         }
 889         return true;
 890 }
 891
 892 // Read the languages file `name'
 893 bool LyX::readLanguagesFile(string const & name)
 894 {
 895         LYXERR(Debug::INIT, "About to read " << name << "...");
 896
 897         FileName const lang_path = libFileSearch(string(), name);
 898         if (lang_path.empty()) {
 899                 showFileError(name);
 900                 return false;
 901         }
 902         languages.read(lang_path);
 903         return true;
 904 }
 905
 906
 907 // Read the encodings file `name'
 908 bool LyX::readEncodingsFile(string const & enc_name,
 909                             string const & symbols_name)
 910 {
 911         LYXERR(Debug::INIT, "About to read " << enc_name << " and "
 912                             << symbols_name << "...");
 913
 914         FileName const symbols_path = libFileSearch(string(), symbols_name);
 915         if (symbols_path.empty()) {
 916                 showFileError(symbols_name);
 917                 return false;
 918         }
 919
 920         FileName const enc_path = libFileSearch(string(), enc_name);
 921         if (enc_path.empty()) {
 922                 showFileError(enc_name);
 923                 return false;
 924         }
 925         encodings.read(enc_path, symbols_path);
 926         return true;
 927 }
 928
 929
 930 namespace {
 931
 932 /// return the the number of arguments consumed
 933 typedef boost::function<int(string const &, string const &, string &)> cmd_helper;
 934
 935 int parse_dbg(string const & arg, string const &, string &)
 936 {
 937         if (arg.empty()) {
 938                 lyxerr << to_utf8(_("List of supported debug flags:")) << endl;
 939                 Debug::showTags(lyxerr);
 940                 exit(0);
 941         }
 942         lyxerr << to_utf8(bformat(_("Setting debug level to %1$s"), from_utf8(arg))) << endl;
 943
 944         lyxerr.level(Debug::value(arg));
 945         Debug::showLevel(lyxerr, lyxerr.level());
 946         return 1;
 947 }
 948
 949
 950 int parse_help(string const &, string const &, string &)
 951 {
 952         lyxerr <<
 953                 to_utf8(_("Usage: lyx [ command line switches ] [ name.lyx ... ]\n"
 954                   "Command line switches (case sensitive):\n"
 955                   "\t-help              summarize LyX usage\n"
 956                   "\t-userdir dir       set user directory to dir\n"
 957                   "\t-sysdir dir        set system directory to dir\n"
 958                   "\t-geometry WxH+X+Y  set geometry of the main window\n"
 959                   "\t-dbg feature[,feature]...\n"
 960                   "                  select the features to debug.\n"
 961                   "                  Type `lyx -dbg' to see the list of features\n"
 962                   "\t-x [--execute] command\n"
 963                   "                  where command is a lyx command.\n"
 964                   "\t-e [--export] fmt\n"
 965                   "                  where fmt is the export format of choice.\n"
 966                   "                  Look on Tools->Preferences->File formats->Format\n"
 967                   "                  to get an idea which parameters should be passed.\n"
 968                   "\t-i [--import] fmt file.xxx\n"
 969                   "                  where fmt is the import format of choice\n"
 970                   "                  and file.xxx is the file to be imported.\n"
 971                   "\t-version        summarize version and build info\n"
 972                                "Check the LyX man page for more details.")) << endl;
 973         exit(0);
 974         return 0;
 975 }
 976
 977
 978 int parse_version(string const &, string const &, string &)
 979 {
 980         lyxerr << "LyX " << lyx_version
 981                << " (" << lyx_release_date << ")" << endl;
 982         lyxerr << "Built on " << __DATE__ << ", " << __TIME__ << endl;
 983
 984         lyxerr << lyx_version_info << endl;
 985         exit(0);
 986         return 0;
 987 }
 988
 989
 990 int parse_sysdir(string const & arg, string const &, string &)
 991 {
 992         if (arg.empty()) {
 993                 Alert::error(_("No system directory"),
 994                         _("Missing directory for -sysdir switch"));
 995                 exit(1);
 996         }
 997         cl_system_support = arg;
 998         return 1;
 999 }
1000
1001
1002 int parse_userdir(string const & arg, string const &, string &)
1003 {
1004         if (arg.empty()) {
1005                 Alert::error(_("No user directory"),
1006                         _("Missing directory for -userdir switch"));
1007                 exit(1);
1008         }
1009         cl_user_support = arg;
1010         return 1;
1011 }
1012
1013
1014 int parse_execute(string const & arg, string const &, string & batch)
1015 {
1016         if (arg.empty()) {
1017                 Alert::error(_("Incomplete command"),
1018                         _("Missing command string after --execute switch"));
1019                 exit(1);
1020         }
1021         batch = arg;
1022         return 1;
1023 }
1024
1025
1026 int parse_export(string const & type, string const &, string & batch)
1027 {
1028         if (type.empty()) {
1029                 lyxerr << to_utf8(_("Missing file type [eg latex, ps...] after "
1030                                          "--export switch")) << endl;
1031                 exit(1);
1032         }
1033         batch = "buffer-export " + type;
1034         use_gui = false;
1035         return 1;
1036 }
1037
1038
1039 int parse_import(string const & type, string const & file, string & batch)
1040 {
1041         if (type.empty()) {
1042                 lyxerr << to_utf8(_("Missing file type [eg latex, ps...] after "
1043                                          "--import switch")) << endl;
1044                 exit(1);
1045         }
1046         if (file.empty()) {
1047                 lyxerr << to_utf8(_("Missing filename for --import")) << endl;
1048                 exit(1);
1049         }
1050
1051         batch = "buffer-import " + type + ' ' + file;
1052         return 2;
1053 }
1054
1055
1056 int parse_geometry(string const & arg1, string const &, string &)
1057 {
1058         geometryArg = arg1;
1059         // don't remove "-geometry", it will be pruned out later in the
1060         // frontend if need be.
1061         return -1;
1062 }
1063
1064
1065 } // namespace anon
1066
1067
1068 void LyX::easyParse(int & argc, char * argv[])
1069 {
1070         map<string, cmd_helper> cmdmap;
1071
1072         cmdmap["-dbg"] = parse_dbg;
1073         cmdmap["-help"] = parse_help;
1074         cmdmap["--help"] = parse_help;
1075         cmdmap["-version"] = parse_version;
1076         cmdmap["--version"] = parse_version;
1077         cmdmap["-sysdir"] = parse_sysdir;
1078         cmdmap["-userdir"] = parse_userdir;
1079         cmdmap["-x"] = parse_execute;
1080         cmdmap["--execute"] = parse_execute;
1081         cmdmap["-e"] = parse_export;
1082         cmdmap["--export"] = parse_export;
1083         cmdmap["-i"] = parse_import;
1084         cmdmap["--import"] = parse_import;
1085         cmdmap["-geometry"] = parse_geometry;
1086
1087         for (int i = 1; i < argc; ++i) {
1088                 map<string, cmd_helper>::const_iterator it
1089                         = cmdmap.find(argv[i]);
1090
1091                 // don't complain if not found - may be parsed later
1092                 if (it == cmdmap.end())
1093                         continue;
1094
1095                 string const arg =
1096                         (i + 1 < argc) ? to_utf8(from_local8bit(argv[i + 1])) : string();
1097                 string const arg2 =
1098                         (i + 2 < argc) ? to_utf8(from_local8bit(argv[i + 2])) : string();
1099
1100                 string batch;
1101                 int const remove = 1 + it->second(arg, arg2, batch);
1102                 if (!batch.empty())
1103                         pimpl_->batch_commands.push_back(batch);
1104
1105                 // Now, remove used arguments by shifting
1106                 // the following ones remove places down.
1107                 if (remove > 0) {
1108                         argc -= remove;
1109                         for (int j = i; j < argc; ++j)
1110                                 argv[j] = argv[j + remove];
1111                         --i;
1112                 }
1113         }
1114 }
1115
1116
1117 FuncStatus getStatus(FuncRequest const & action)
1118 {
1119         LASSERT(singleton_, /**/);
1120         return singleton_->pimpl_->lyxfunc_.getStatus(action);
1121 }
1122
1123
1124 void dispatch(FuncRequest const & action)
1125 {
1126         LASSERT(singleton_, /**/);
1127         singleton_->pimpl_->lyxfunc_.dispatch(action);
1128 }
1129
1130
1131 BufferList & theBufferList()
1132 {
1133         LASSERT(singleton_, /**/);
1134         return singleton_->pimpl_->buffer_list_;
1135 }
1136
1137
1138 LyXFunc & theLyXFunc()
1139 {
1140         LASSERT(singleton_, /**/);
1141         return singleton_->pimpl_->lyxfunc_;
1142 }
1143
1144
1145 Server & theServer()
1146 {
1147         // FIXME: this should not be use_gui dependent
1148         LASSERT(use_gui, /**/);
1149         LASSERT(singleton_, /**/);
1150         return *singleton_->pimpl_->lyx_server_.get();
1151 }
1152
1153
1154 ServerSocket & theServerSocket()
1155 {
1156         // FIXME: this should not be use_gui dependent
1157         LASSERT(use_gui, /**/);
1158         LASSERT(singleton_, /**/);
1159         return *singleton_->pimpl_->lyx_socket_.get();
1160 }
1161
1162
1163 KeyMap & theTopLevelKeymap()
1164 {
1165         LASSERT(singleton_, /**/);
1166         return singleton_->pimpl_->toplevel_keymap_;
1167 }
1168
1169
1170 Converters & theConverters()
1171 {
1172         LASSERT(singleton_, /**/);
1173         return  singleton_->pimpl_->converters_;
1174 }
1175
1176
1177 Converters & theSystemConverters()
1178 {
1179         LASSERT(singleton_, /**/);
1180         return  singleton_->pimpl_->system_converters_;
1181 }
1182
1183
1184 Movers & theMovers()
1185 {
1186         LASSERT(singleton_, /**/);
1187         return singleton_->pimpl_->movers_;
1188 }
1189
1190
1191 Mover const & getMover(string  const & fmt)
1192 {
1193         LASSERT(singleton_, /**/);
1194         return singleton_->pimpl_->movers_(fmt);
1195 }
1196
1197
1198 void setMover(string const & fmt, string const & command)
1199 {
1200         LASSERT(singleton_, /**/);
1201         singleton_->pimpl_->movers_.set(fmt, command);
1202 }
1203
1204
1205 Movers & theSystemMovers()
1206 {
1207         LASSERT(singleton_, /**/);
1208         return singleton_->pimpl_->system_movers_;
1209 }
1210
1211
1212 Messages & getMessages(string const & language)
1213 {
1214         LASSERT(singleton_, /**/);
1215         return singleton_->messages(language);
1216 }
1217
1218
1219 Messages & getGuiMessages()
1220 {
1221         LASSERT(singleton_, /**/);
1222         return singleton_->pimpl_->messages_["GUI"];
1223 }
1224
1225
1226 graphics::Previews & thePreviews()
1227 {
1228         LASSERT(singleton_, /**/);
1229         return singleton_->pimpl_->preview_;
1230 }
1231
1232
1233 Session & theSession()
1234 {
1235         LASSERT(singleton_, /**/);
1236         return *singleton_->pimpl_->session_.get();
1237 }
1238
1239
1240 CmdDef & theTopLevelCmdDef()
1241 {
1242         LASSERT(singleton_, /**/);
1243         return singleton_->pimpl_->toplevel_cmddef_;
1244 }
1245
1246 } // namespace lyx