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 "Color.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         singleton_->pimpl_->messages_["GUI"] = Messages();
 249 }
 250
 251
 252 int LyX::exec(int & argc, char * argv[])
 253 {
 254         // Here we need to parse the command line. At least
 255         // we need to parse for "-dbg" and "-help"
 256         easyParse(argc, argv);
 257
 258         try {
 259                 init_package(to_utf8(from_local8bit(argv[0])),
 260                               cl_system_support, cl_user_support,
 261                               top_build_dir_is_one_level_up);
 262         } catch (ExceptionMessage const & message) {
 263                 if (message.type_ == ErrorException) {
 264                         Alert::error(message.title_, message.details_);
 265                         lyx_exit(1);
 266                 } else if (message.type_ == WarningException) {
 267                         Alert::warning(message.title_, message.details_);
 268                 }
 269         }
 270
 271         // Reinit the messages machinery in case package() knows
 272         // something interesting about the locale directory.
 273         Messages::init();
 274
 275         if (!use_gui) {
 276                 // FIXME: create a ConsoleApplication
 277                 int exit_status = init(argc, argv);
 278                 if (exit_status) {
 279                         prepareExit();
 280                         return exit_status;
 281                 }
 282
 283                 // this is correct, since return values are inverted.
 284                 exit_status = !loadFiles();
 285
 286                 if (pimpl_->batch_commands.empty() || pimpl_->buffer_list_.empty()) {
 287                         prepareExit();
 288                         return exit_status;
 289                 }
 290
 291                 BufferList::iterator begin = pimpl_->buffer_list_.begin();
 292
 293                 bool final_success = false;
 294                 for (BufferList::iterator I = begin; I != pimpl_->buffer_list_.end(); ++I) {
 295                         Buffer * buf = *I;
 296                         if (buf != buf->masterBuffer())
 297                                 continue;
 298                         bool success = false;
 299                         vector<string>::const_iterator bcit  = pimpl_->batch_commands.begin();
 300                         vector<string>::const_iterator bcend = pimpl_->batch_commands.end();
 301                         for (; bcit != bcend; bcit++) {
 302                                 buf->dispatch(*bcit, &success);
 303                                 final_success |= success;
 304                         }
 305                 }
 306                 prepareExit();
 307                 return !final_success;
 308         }
 309
 310         // Let the frontend parse and remove all arguments that it knows
 311         pimpl_->application_.reset(createApplication(argc, argv));
 312
 313         // Reestablish our defaults, as Qt overwrites them
 314         // after createApplication()
 315         locale_init();
 316
 317         // Parse and remove all known arguments in the LyX singleton
 318         // Give an error for all remaining ones.
 319         int exit_status = init(argc, argv);
 320         if (exit_status) {
 321                 // Kill the application object before exiting.
 322                 pimpl_->application_.reset();
 323                 use_gui = false;
 324                 prepareExit();
 325                 return exit_status;
 326         }
 327
 328         // FIXME
 329         /* Create a CoreApplication class that will provide the main event loop
 330         * and the socket callback registering. With Qt4, only QtCore
 331         * library would be needed.
 332         * When this is done, a server_mode could be created and the following two
 333         * line would be moved out from here.
 334         */
 335         // Note: socket callback must be registered after init(argc, argv)
 336         // such that package().temp_dir() is properly initialized.
 337         pimpl_->lyx_server_.reset(new Server(&pimpl_->lyxfunc_, lyxrc.lyxpipes));
 338         pimpl_->lyx_socket_.reset(new ServerSocket(&pimpl_->lyxfunc_,
 339                         FileName(package().temp_dir().absFilename() + "/lyxsocket")));
 340
 341         // Start the real execution loop.
 342         exit_status = pimpl_->application_->exec();
 343
 344         prepareExit();
 345
 346         return exit_status;
 347 }
 348
 349
 350 void LyX::prepareExit()
 351 {
 352         // Clear the clipboard and selection stack:
 353         cap::clearCutStack();
 354         cap::clearSelection();
 355
 356         // close buffers first
 357         pimpl_->buffer_list_.closeAll();
 358
 359         // register session changes and shutdown server and socket
 360         if (use_gui) {
 361                 if (pimpl_->session_)
 362                         pimpl_->session_->writeFile();
 363                 pimpl_->session_.reset();
 364                 pimpl_->lyx_server_.reset();
 365                 pimpl_->lyx_socket_.reset();
 366         }
 367
 368         // do any other cleanup procedures now
 369         if (package().temp_dir() != package().system_temp_dir()) {
 370                 string const abs_tmpdir = package().temp_dir().absFilename();
 371                 if (!contains(package().temp_dir().absFilename(), "lyx_tmpdir")) {
 372                         docstring const msg =
 373                                 bformat(_("%1$s does not appear like a LyX created temporary directory."),
 374                                 from_utf8(abs_tmpdir));
 375                         Alert::warning(_("Cannot remove temporary directory"), msg);
 376                 } else {
 377                         LYXERR(Debug::INFO, "Deleting tmp dir "
 378                                 << package().temp_dir().absFilename());
 379                         if (!package().temp_dir().destroyDirectory()) {
 380                                 docstring const msg =
 381                                         bformat(_("Unable to remove the temporary directory %1$s"),
 382                                         from_utf8(package().temp_dir().absFilename()));
 383                                 Alert::warning(_("Unable to remove temporary directory"), msg);
 384                         }
 385                 }
 386         }
 387
 388         // Kill the application object before exiting. This avoids crashes
 389         // when exiting on Linux.
 390         if (pimpl_->application_)
 391                 pimpl_->application_.reset();
 392 }
 393
 394
 395 void LyX::earlyExit(int status)
 396 {
 397         LASSERT(pimpl_->application_.get(), /**/);
 398         // LyX::pimpl_::application_ is not initialised at this
 399         // point so it's safe to just exit after some cleanup.
 400         prepareExit();
 401         exit(status);
 402 }
 403
 404
 405 int LyX::init(int & argc, char * argv[])
 406 {
 407         // check for any spurious extra arguments
 408         // other than documents
 409         for (int argi = 1; argi < argc ; ++argi) {
 410                 if (argv[argi][0] == '-') {
 411                         lyxerr << to_utf8(
 412                                 bformat(_("Wrong command line option `%1$s'. Exiting."),
 413                                 from_utf8(argv[argi]))) << endl;
 414                         return EXIT_FAILURE;
 415                 }
 416         }
 417
 418         // Initialization of LyX (reads lyxrc and more)
 419         LYXERR(Debug::INIT, "Initializing LyX::init...");
 420         bool success = init();
 421         LYXERR(Debug::INIT, "Initializing LyX::init...done");
 422         if (!success)
 423                 return EXIT_FAILURE;
 424
 425         // Remaining arguments are assumed to be files to load.
 426         for (int argi = argc - 1; argi >= 1; --argi)
 427                 pimpl_->files_to_load_.push_back(to_utf8(from_local8bit(argv[argi])));
 428
 429         if (first_start) {
 430                 pimpl_->files_to_load_.push_back(
 431                         i18nLibFileSearch("examples", "splash.lyx").absFilename());
 432         }
 433
 434         return EXIT_SUCCESS;
 435 }
 436
 437
 438 bool LyX::loadFiles()
 439 {
 440         LASSERT(!use_gui, /**/);
 441         bool success = true;
 442         vector<string>::const_iterator it = pimpl_->files_to_load_.begin();
 443         vector<string>::const_iterator end = pimpl_->files_to_load_.end();
 444
 445         for (; it != end; ++it) {
 446                 // get absolute path of file and add ".lyx" to
 447                 // the filename if necessary
 448                 FileName fname = fileSearch(string(), os::internal_path(*it), "lyx",
 449                         may_not_exist);
 450
 451                 if (fname.empty())
 452                         continue;
 453
 454                 Buffer * buf = pimpl_->buffer_list_.newBuffer(fname.absFilename(), false);
 455                 if (buf->loadLyXFile(fname)) {
 456                         ErrorList const & el = buf->errorList("Parse");
 457                         if (!el.empty())
 458                                 for_each(el.begin(), el.end(),
 459                                 boost::bind(&LyX::printError, this, _1));
 460                 }
 461                 else {
 462                         pimpl_->buffer_list_.release(buf);
 463                         success = false;
 464                 }
 465         }
 466         return success;
 467 }
 468
 469
 470 void execBatchCommands()
 471 {
 472         LASSERT(singleton_, /**/);
 473         singleton_->execCommands();
 474 }
 475
 476
 477 void LyX::execCommands()
 478 {
 479         // The advantage of doing this here is that the event loop
 480         // is already started. So any need for interaction will be
 481         // aknowledged.
 482
 483         // if reconfiguration is needed.
 484         while (LayoutFileList::get().empty()) {
 485                 switch (Alert::prompt(
 486                         _("No textclass is found"),
 487                         _("LyX cannot continue because no textclass is found. "
 488                                 "You can either reconfigure normally, or reconfigure using "
 489                                 "default textclasses, or quit LyX."),
 490                         0, 2,
 491                         _("&Reconfigure"),
 492                         _("&Use Default"),
 493                         _("&Exit LyX")))
 494                 {
 495                 case 0:
 496                         // regular reconfigure
 497                         pimpl_->lyxfunc_.dispatch(FuncRequest(LFUN_RECONFIGURE, ""));
 498                         break;
 499                 case 1:
 500                         // reconfigure --without-latex-config
 501                         pimpl_->lyxfunc_.dispatch(FuncRequest(LFUN_RECONFIGURE,
 502                                 " --without-latex-config"));
 503                         break;
 504                 default:
 505                         pimpl_->lyxfunc_.dispatch(FuncRequest(LFUN_LYX_QUIT));
 506                         return;
 507                 }
 508         }
 509
 510         // create the first main window
 511         pimpl_->lyxfunc_.dispatch(FuncRequest(LFUN_WINDOW_NEW, geometryArg));
 512
 513         if (!pimpl_->files_to_load_.empty()) {
 514                 // if some files were specified at command-line we assume that the
 515                 // user wants to edit *these* files and not to restore the session.
 516                 for (size_t i = 0; i != pimpl_->files_to_load_.size(); ++i) {
 517                         pimpl_->lyxfunc_.dispatch(
 518                                 FuncRequest(LFUN_FILE_OPEN, pimpl_->files_to_load_[i]));
 519                 }
 520                 // clear this list to save a few bytes of RAM
 521                 pimpl_->files_to_load_.clear();
 522         }
 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 Cntl+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 #if defined(_WIN32) || (defined(__CYGWIN__) && defined(X_DISPLAY_MISSING))
1060         // remove also the arg
1061         return 1;
1062 #else
1063         // don't remove "-geometry"
1064         return -1;
1065 #endif
1066 }
1067
1068
1069 } // namespace anon
1070
1071
1072 void LyX::easyParse(int & argc, char * argv[])
1073 {
1074         map<string, cmd_helper> cmdmap;
1075
1076         cmdmap["-dbg"] = parse_dbg;
1077         cmdmap["-help"] = parse_help;
1078         cmdmap["--help"] = parse_help;
1079         cmdmap["-version"] = parse_version;
1080         cmdmap["--version"] = parse_version;
1081         cmdmap["-sysdir"] = parse_sysdir;
1082         cmdmap["-userdir"] = parse_userdir;
1083         cmdmap["-x"] = parse_execute;
1084         cmdmap["--execute"] = parse_execute;
1085         cmdmap["-e"] = parse_export;
1086         cmdmap["--export"] = parse_export;
1087         cmdmap["-i"] = parse_import;
1088         cmdmap["--import"] = parse_import;
1089         cmdmap["-geometry"] = parse_geometry;
1090
1091         for (int i = 1; i < argc; ++i) {
1092                 map<string, cmd_helper>::const_iterator it
1093                         = cmdmap.find(argv[i]);
1094
1095                 // don't complain if not found - may be parsed later
1096                 if (it == cmdmap.end())
1097                         continue;
1098
1099                 string const arg =
1100                         (i + 1 < argc) ? to_utf8(from_local8bit(argv[i + 1])) : string();
1101                 string const arg2 =
1102                         (i + 2 < argc) ? to_utf8(from_local8bit(argv[i + 2])) : string();
1103
1104                 string batch;
1105                 int const remove = 1 + it->second(arg, arg2, batch);
1106                 if (!batch.empty())
1107                         pimpl_->batch_commands.push_back(batch);
1108
1109                 // Now, remove used arguments by shifting
1110                 // the following ones remove places down.
1111                 if (remove > 0) {
1112                         argc -= remove;
1113                         for (int j = i; j < argc; ++j)
1114                                 argv[j] = argv[j + remove];
1115                         --i;
1116                 }
1117         }
1118 }
1119
1120
1121 FuncStatus getStatus(FuncRequest const & action)
1122 {
1123         LASSERT(singleton_, /**/);
1124         return singleton_->pimpl_->lyxfunc_.getStatus(action);
1125 }
1126
1127
1128 void dispatch(FuncRequest const & action)
1129 {
1130         LASSERT(singleton_, /**/);
1131         singleton_->pimpl_->lyxfunc_.dispatch(action);
1132 }
1133
1134
1135 BufferList & theBufferList()
1136 {
1137         LASSERT(singleton_, /**/);
1138         return singleton_->pimpl_->buffer_list_;
1139 }
1140
1141
1142 LyXFunc & theLyXFunc()
1143 {
1144         LASSERT(singleton_, /**/);
1145         return singleton_->pimpl_->lyxfunc_;
1146 }
1147
1148
1149 Server & theServer()
1150 {
1151         // FIXME: this should not be use_gui dependent
1152         LASSERT(use_gui, /**/);
1153         LASSERT(singleton_, /**/);
1154         return *singleton_->pimpl_->lyx_server_.get();
1155 }
1156
1157
1158 ServerSocket & theServerSocket()
1159 {
1160         // FIXME: this should not be use_gui dependent
1161         LASSERT(use_gui, /**/);
1162         LASSERT(singleton_, /**/);
1163         return *singleton_->pimpl_->lyx_socket_.get();
1164 }
1165
1166
1167 KeyMap & theTopLevelKeymap()
1168 {
1169         LASSERT(singleton_, /**/);
1170         return singleton_->pimpl_->toplevel_keymap_;
1171 }
1172
1173
1174 Converters & theConverters()
1175 {
1176         LASSERT(singleton_, /**/);
1177         return  singleton_->pimpl_->converters_;
1178 }
1179
1180
1181 Converters & theSystemConverters()
1182 {
1183         LASSERT(singleton_, /**/);
1184         return  singleton_->pimpl_->system_converters_;
1185 }
1186
1187
1188 Movers & theMovers()
1189 {
1190         LASSERT(singleton_, /**/);
1191         return singleton_->pimpl_->movers_;
1192 }
1193
1194
1195 Mover const & getMover(string  const & fmt)
1196 {
1197         LASSERT(singleton_, /**/);
1198         return singleton_->pimpl_->movers_(fmt);
1199 }
1200
1201
1202 void setMover(string const & fmt, string const & command)
1203 {
1204         LASSERT(singleton_, /**/);
1205         singleton_->pimpl_->movers_.set(fmt, command);
1206 }
1207
1208
1209 Movers & theSystemMovers()
1210 {
1211         LASSERT(singleton_, /**/);
1212         return singleton_->pimpl_->system_movers_;
1213 }
1214
1215
1216 Messages & getMessages(string const & language)
1217 {
1218         LASSERT(singleton_, /**/);
1219         return singleton_->messages(language);
1220 }
1221
1222
1223 Messages & getGuiMessages()
1224 {
1225         LASSERT(singleton_, /**/);
1226         return singleton_->pimpl_->messages_["GUI"];
1227 }
1228
1229
1230 graphics::Previews & thePreviews()
1231 {
1232         LASSERT(singleton_, /**/);
1233         return singleton_->pimpl_->preview_;
1234 }
1235
1236
1237 Session & theSession()
1238 {
1239         LASSERT(singleton_, /**/);
1240         return *singleton_->pimpl_->session_.get();
1241 }
1242
1243
1244 CmdDef & theTopLevelCmdDef()
1245 {
1246         LASSERT(singleton_, /**/);
1247         return singleton_->pimpl_->toplevel_cmddef_;
1248 }
1249
1250 } // namespace lyx