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 "AppleSpellChecker.h"
  21 #include "AspellChecker.h"
  22 #include "Buffer.h"
  23 #include "BufferList.h"
  24 #include "CmdDef.h"
  25 #include "ColorSet.h"
  26 #include "ConverterCache.h"
  27 #include "Converter.h"
  28 #include "CutAndPaste.h"
  29 #include "EnchantChecker.h"
  30 #include "Encoding.h"
  31 #include "ErrorList.h"
  32 #include "Format.h"
  33 #include "FuncStatus.h"
  34 #include "HunspellChecker.h"
  35 #include "KeyMap.h"
  36 #include "Language.h"
  37 #include "LaTeXFonts.h"
  38 #include "LayoutFile.h"
  39 #include "Lexer.h"
  40 #include "LyX.h"
  41 #include "LyXAction.h"
  42 #include "LyXRC.h"
  43 #include "ModuleList.h"
  44 #include "Mover.h"
  45 #include "Server.h"
  46 #include "ServerSocket.h"
  47 #include "Session.h"
  48 #include "WordList.h"
  49
  50 #include "frontends/alert.h"
  51 #include "frontends/Application.h"
  52
  53 #include "support/ConsoleApplication.h"
  54 #include "support/lassert.h"
  55 #include "support/debug.h"
  56 #include "support/environment.h"
  57 #include "support/ExceptionMessage.h"
  58 #include "support/filetools.h"
  59 #include "support/gettext.h"
  60 #include "support/lstrings.h"
  61 #include "support/Messages.h"
  62 #include "support/os.h"
  63 #include "support/Package.h"
  64
  65 #include "support/bind.h"
  66 #include <boost/scoped_ptr.hpp>
  67
  68 #include <algorithm>
  69 #include <iostream>
  70 #include <csignal>
  71 #include <map>
  72 #include <stdlib.h>
  73 #include <string>
  74 #include <vector>
  75
  76 using namespace std;
  77 using namespace lyx::support;
  78
  79 #if defined (USE_MACOSX_PACKAGING)
  80 #include <crt_externs.h>
  81 #endif
  82
  83 namespace lyx {
  84
  85 namespace Alert = frontend::Alert;
  86 namespace os = support::os;
  87
  88
  89
  90 // Are we using the GUI at all?  We default to true and this is changed
  91 // to false when the export feature is used.
  92
  93 bool use_gui = true;
  94
  95
  96 // We default to open documents in an already running instance, provided that
  97 // the lyxpipe has been setup. This can be overridden either on the command
  98 // line or through preference settings.
  99
 100 RunMode run_mode = PREFERRED;
 101
 102
 103 // Tell what files can be silently overwritten during batch export.
 104 // Possible values are: NO_FILES, MAIN_FILE, ALL_FILES, UNSPECIFIED.
 105 // Unless specified on command line (through the -f switch) or through the
 106 // environment variable LYX_FORCE_OVERWRITE, the default will be MAIN_FILE.
 107
 108 OverwriteFiles force_overwrite = UNSPECIFIED;
 109
 110
 111 namespace {
 112
 113 // Filled with the command line arguments "foo" of "-sysdir foo" or
 114 // "-userdir foo".
 115 string cl_system_support;
 116 string cl_user_support;
 117
 118 string geometryArg;
 119
 120 LyX * singleton_ = 0;
 121
 122 void showFileError(string const & error)
 123 {
 124         Alert::warning(_("Could not read configuration file"),
 125                        bformat(_("Error while reading the configuration file\n%1$s.\n"
 126                            "Please check your installation."), from_utf8(error)));
 127 }
 128
 129 } // namespace anon
 130
 131 /// The main application class private implementation.
 132 struct LyX::Impl {
 133         Impl()
 134                 : latexfonts_(0), spell_checker_(0), apple_spell_checker_(0), aspell_checker_(0), enchant_checker_(0), hunspell_checker_(0)
 135         {}
 136
 137         ~Impl()
 138         {
 139                 delete latexfonts_;
 140                 delete apple_spell_checker_;
 141                 delete aspell_checker_;
 142                 delete enchant_checker_;
 143                 delete hunspell_checker_;
 144         }
 145
 146         ///
 147         BufferList buffer_list_;
 148         ///
 149         KeyMap toplevel_keymap_;
 150         ///
 151         CmdDef toplevel_cmddef_;
 152         ///
 153         boost::scoped_ptr<Server> lyx_server_;
 154         ///
 155         boost::scoped_ptr<ServerSocket> lyx_socket_;
 156         ///
 157         boost::scoped_ptr<frontend::Application> application_;
 158         /// lyx session, containing lastfiles, lastfilepos, and lastopened
 159         boost::scoped_ptr<Session> session_;
 160
 161         /// Files to load at start.
 162         vector<string> files_to_load_;
 163
 164         /// The messages translators.
 165         map<string, Messages> messages_;
 166
 167         /// The file converters.
 168         Converters converters_;
 169
 170         // The system converters copy after reading lyxrc.defaults.
 171         Converters system_converters_;
 172
 173         ///
 174         Movers movers_;
 175         ///
 176         Movers system_movers_;
 177
 178         /// the parsed command line batch command if any
 179         vector<string> batch_commands;
 180
 181         ///
 182         LaTeXFonts * latexfonts_;
 183
 184         ///
 185         SpellChecker * spell_checker_;
 186         ///
 187         SpellChecker * apple_spell_checker_;
 188         ///
 189         SpellChecker * aspell_checker_;
 190         ///
 191         SpellChecker * enchant_checker_;
 192         ///
 193         SpellChecker * hunspell_checker_;
 194 };
 195
 196
 197 /// The main application class for console mode
 198 class LyXConsoleApp : public ConsoleApplication
 199 {
 200 public:
 201         LyXConsoleApp(LyX * lyx, int & argc, char * argv[])
 202                 : ConsoleApplication(lyx_package, argc, argv), lyx_(lyx),
 203                   argc_(argc), argv_(argv)
 204         {
 205         }
 206         void doExec()
 207         {
 208                 int const exit_status = lyx_->execWithoutGui(argc_, argv_);
 209                 exit(exit_status);
 210         }
 211 private:
 212         LyX * lyx_;
 213         int & argc_;
 214         char ** argv_;
 215 };
 216
 217
 218 ///
 219 frontend::Application * theApp()
 220 {
 221         if (singleton_)
 222                 return singleton_->pimpl_->application_.get();
 223         else
 224                 return 0;
 225 }
 226
 227
 228 LyX::~LyX()
 229 {
 230         delete pimpl_;
 231         singleton_ = 0;
 232         WordList::cleanupWordLists();
 233 }
 234
 235
 236 void lyx_exit(int exit_code)
 237 {
 238         if (exit_code)
 239                 // Something wrong happened so better save everything, just in
 240                 // case.
 241                 emergencyCleanup();
 242
 243 #ifndef NDEBUG
 244         // Properly crash in debug mode in order to get a useful backtrace.
 245         abort();
 246 #endif
 247
 248         // In release mode, try to exit gracefully.
 249         if (theApp())
 250                 theApp()->exit(exit_code);
 251         else
 252                 exit(exit_code);
 253 }
 254
 255
 256 LyX::LyX()
 257         : first_start(false)
 258 {
 259         singleton_ = this;
 260         pimpl_ = new Impl;
 261 }
 262
 263
 264 Messages & LyX::messages(string const & language)
 265 {
 266         map<string, Messages>::iterator it = pimpl_->messages_.find(language);
 267
 268         if (it != pimpl_->messages_.end())
 269                 return it->second;
 270
 271         pair<map<string, Messages>::iterator, bool> result =
 272                         pimpl_->messages_.insert(make_pair(language, Messages(language)));
 273
 274         LATTEST(result.second);
 275         return result.first->second;
 276 }
 277
 278
 279 int LyX::exec(int & argc, char * argv[])
 280 {
 281         // Minimal setting of locale before parsing command line
 282         try {
 283                 init_package(os::utf8_argv(0), string(), string());
 284                 // we do not get to this point when init_package throws an exception
 285                 setLocale();
 286         } catch (ExceptionMessage const & message) {
 287                 LYXERR(Debug::LOCALE, message.title_ + ", " + message.details_);
 288         }
 289
 290         // Here we need to parse the command line. At least
 291         // we need to parse for "-dbg" and "-help"
 292         easyParse(argc, argv);
 293
 294         try {
 295                 init_package(os::utf8_argv(0), cl_system_support, cl_user_support);
 296         } catch (ExceptionMessage const & message) {
 297                 if (message.type_ == ErrorException) {
 298                         Alert::error(message.title_, message.details_);
 299                         lyx_exit(1);
 300                 } else if (message.type_ == WarningException) {
 301                         Alert::warning(message.title_, message.details_);
 302                 }
 303         }
 304
 305         // Reinit the messages machinery in case package() knows
 306         // something interesting about the locale directory.
 307         setLocale();
 308
 309         if (!use_gui) {
 310                 LyXConsoleApp app(this, argc, argv);
 311
 312                 // Reestablish our defaults, as Qt overwrites them
 313                 // after creating app
 314                 setLocale();//???
 315
 316                 return app.exec();
 317         }
 318
 319         // Let the frontend parse and remove all arguments that it knows
 320         pimpl_->application_.reset(createApplication(argc, argv));
 321
 322         // Reestablish our defaults, as Qt overwrites them
 323         // after createApplication()
 324         setLocale();//???
 325
 326         // Parse and remove all known arguments in the LyX singleton
 327         // Give an error for all remaining ones.
 328         int exit_status = init(argc, argv);
 329         if (exit_status) {
 330                 // Kill the application object before exiting.
 331                 pimpl_->application_.reset();
 332                 use_gui = false;
 333                 prepareExit();
 334                 return exit_status;
 335         }
 336
 337         // If not otherwise specified by a command line option or
 338         // by preferences, we default to reuse a running instance.
 339         if (run_mode == PREFERRED)
 340                 run_mode = USE_REMOTE;
 341
 342         // FIXME
 343         /* Create a CoreApplication class that will provide the main event loop
 344         * and the socket callback registering. With Qt, only QtCore
 345         * library would be needed.
 346         * When this is done, a server_mode could be created and the following two
 347         * line would be moved out from here.
 348         * However, note that the first of the two lines below triggers the
 349         * "single instance" behavior, which should occur right at this point.
 350         */
 351         // Note: socket callback must be registered after init(argc, argv)
 352         // such that package().temp_dir() is properly initialized.
 353         pimpl_->lyx_server_.reset(new Server(lyxrc.lyxpipes));
 354         pimpl_->lyx_socket_.reset(new ServerSocket(
 355                         FileName(package().temp_dir().absFileName() + "/lyxsocket")));
 356
 357         // Start the real execution loop.
 358         if (!theServer().deferredLoadingToOtherInstance())
 359                 exit_status = pimpl_->application_->exec();
 360         else if (!pimpl_->files_to_load_.empty()) {
 361                 vector<string>::const_iterator it = pimpl_->files_to_load_.begin();
 362                 vector<string>::const_iterator end = pimpl_->files_to_load_.end();
 363                 lyxerr << _("The following files could not be loaded:") << endl;
 364                 for (; it != end; ++it)
 365                         lyxerr << *it << endl;
 366         }
 367
 368         prepareExit();
 369
 370         return exit_status;
 371 }
 372
 373
 374 void LyX::prepareExit()
 375 {
 376         // Clear the clipboard and selection stack:
 377         cap::clearCutStack();
 378         cap::clearSelection();
 379
 380         // Write the index file of the converter cache
 381         ConverterCache::get().writeIndex();
 382
 383         // close buffers first
 384         pimpl_->buffer_list_.closeAll();
 385
 386         // register session changes and shutdown server and socket
 387         if (use_gui) {
 388                 if (pimpl_->session_)
 389                         pimpl_->session_->writeFile();
 390                 pimpl_->session_.reset();
 391                 pimpl_->lyx_server_.reset();
 392                 pimpl_->lyx_socket_.reset();
 393         }
 394
 395         // do any other cleanup procedures now
 396         if (package().temp_dir() != package().system_temp_dir()) {
 397                 string const abs_tmpdir = package().temp_dir().absFileName();
 398                 if (!contains(package().temp_dir().absFileName(), "lyx_tmpdir")) {
 399                         docstring const msg =
 400                                 bformat(_("%1$s does not appear like a LyX created temporary directory."),
 401                                 from_utf8(abs_tmpdir));
 402                         Alert::warning(_("Cannot remove temporary directory"), msg);
 403                 } else {
 404                         LYXERR(Debug::INFO, "Deleting tmp dir "
 405                                 << package().temp_dir().absFileName());
 406                         if (!package().temp_dir().destroyDirectory()) {
 407                                 docstring const msg =
 408                                         bformat(_("Unable to remove the temporary directory %1$s"),
 409                                         from_utf8(package().temp_dir().absFileName()));
 410                                 Alert::warning(_("Unable to remove temporary directory"), msg);
 411                         }
 412                 }
 413         }
 414
 415         // Kill the application object before exiting. This avoids crashes
 416         // when exiting on Linux.
 417         pimpl_->application_.reset();
 418 }
 419
 420
 421 void LyX::earlyExit(int status)
 422 {
 423         LATTEST(pimpl_->application_.get());
 424         // LyX::pimpl_::application_ is not initialised at this
 425         // point so it's safe to just exit after some cleanup.
 426         prepareExit();
 427         exit(status);
 428 }
 429
 430
 431 int LyX::init(int & argc, char * argv[])
 432 {
 433         // check for any spurious extra arguments
 434         // other than documents
 435         for (int argi = 1; argi < argc ; ++argi) {
 436                 if (argv[argi][0] == '-') {
 437                         lyxerr << to_utf8(
 438                                 bformat(_("Wrong command line option `%1$s'. Exiting."),
 439                                 from_utf8(os::utf8_argv(argi)))) << endl;
 440                         return EXIT_FAILURE;
 441                 }
 442         }
 443
 444         // Initialization of LyX (reads lyxrc and more)
 445         LYXERR(Debug::INIT, "Initializing LyX::init...");
 446         bool success = init();
 447         LYXERR(Debug::INIT, "Initializing LyX::init...done");
 448         if (!success)
 449                 return EXIT_FAILURE;
 450
 451         // Remaining arguments are assumed to be files to load.
 452         for (int argi = 1; argi < argc; ++argi)
 453                 pimpl_->files_to_load_.push_back(os::utf8_argv(argi));
 454
 455         if (!use_gui && pimpl_->files_to_load_.empty()) {
 456                 lyxerr << to_utf8(_("Missing filename for this operation.")) << endl;
 457                 return EXIT_FAILURE;
 458         }
 459
 460         if (first_start) {
 461                 pimpl_->files_to_load_.push_back(
 462                         i18nLibFileSearch("examples", "splash.lyx").absFileName());
 463         }
 464
 465         return EXIT_SUCCESS;
 466 }
 467
 468
 469 int LyX::execWithoutGui(int & argc, char * argv[])
 470 {
 471         int exit_status = init(argc, argv);
 472         if (exit_status) {
 473                 prepareExit();
 474                 return exit_status;
 475         }
 476
 477         // this is correct, since return values are inverted.
 478         exit_status = !loadFiles();
 479
 480         if (pimpl_->batch_commands.empty() || pimpl_->buffer_list_.empty()) {
 481                 prepareExit();
 482                 return exit_status;
 483         }
 484
 485         BufferList::iterator begin = pimpl_->buffer_list_.begin();
 486
 487         bool final_success = false;
 488         for (BufferList::iterator I = begin; I != pimpl_->buffer_list_.end(); ++I) {
 489                 Buffer * buf = *I;
 490                 if (buf != buf->masterBuffer())
 491                         continue;
 492                 vector<string>::const_iterator bcit  = pimpl_->batch_commands.begin();
 493                 vector<string>::const_iterator bcend = pimpl_->batch_commands.end();
 494                 DispatchResult dr;
 495                 for (; bcit != bcend; ++bcit) {
 496                         LYXERR(Debug::ACTION, "Buffer::dispatch: cmd: " << *bcit);
 497                         buf->dispatch(*bcit, dr);
 498                         final_success |= !dr.error();
 499                 }
 500         }
 501         prepareExit();
 502         return !final_success;
 503 }
 504
 505
 506 bool LyX::loadFiles()
 507 {
 508         LATTEST(!use_gui);
 509         bool success = true;
 510         vector<string>::const_iterator it = pimpl_->files_to_load_.begin();
 511         vector<string>::const_iterator end = pimpl_->files_to_load_.end();
 512
 513         for (; it != end; ++it) {
 514                 // get absolute path of file and add ".lyx" to
 515                 // the filename if necessary
 516                 FileName fname = fileSearch(string(), os::internal_path(*it), "lyx",
 517                         may_not_exist);
 518
 519                 if (fname.empty())
 520                         continue;
 521
 522                 Buffer * buf = pimpl_->buffer_list_.newBuffer(fname.absFileName());
 523                 if (buf->loadLyXFile() == Buffer::ReadSuccess) {
 524                         ErrorList const & el = buf->errorList("Parse");
 525                         if (!el.empty())
 526                                 for_each(el.begin(), el.end(),
 527                                 bind(&LyX::printError, this, _1));
 528                 }
 529                 else {
 530                         pimpl_->buffer_list_.release(buf);
 531                         docstring const error_message =
 532                                 bformat(_("LyX failed to load the following file: %1$s"),
 533                                 from_utf8(fname.absFileName()));
 534                         lyxerr << to_utf8(error_message) << endl;
 535                         success = false;
 536                 }
 537         }
 538         return success;
 539 }
 540
 541
 542 void execBatchCommands()
 543 {
 544         LAPPERR(singleton_);
 545         singleton_->execCommands();
 546 }
 547
 548
 549 void LyX::execCommands()
 550 {
 551         // The advantage of doing this here is that the event loop
 552         // is already started. So any need for interaction will be
 553         // aknowledged.
 554
 555         // if reconfiguration is needed.
 556         if (LayoutFileList::get().empty()) {
 557                 switch (Alert::prompt(
 558                         _("No textclass is found"),
 559                         _("LyX will only have minimal functionality because no textclasses "
 560                                 "have been found. You can either try to reconfigure LyX normally, "
 561                                 "try to reconfigure without checking your LaTeX installation, or continue."),
 562                         0, 2,
 563                         _("&Reconfigure"),
 564                         _("&Without LaTeX"),
 565                         _("&Continue")))
 566                 {
 567                 case 0:
 568                         // regular reconfigure
 569                         lyx::dispatch(FuncRequest(LFUN_RECONFIGURE, ""));
 570                         break;
 571                 case 1:
 572                         // reconfigure --without-latex-config
 573                         lyx::dispatch(FuncRequest(LFUN_RECONFIGURE,
 574                                 " --without-latex-config"));
 575                         break;
 576                 default:
 577                         break;
 578                 }
 579         }
 580
 581         // create the first main window
 582         lyx::dispatch(FuncRequest(LFUN_WINDOW_NEW, geometryArg));
 583
 584         if (!pimpl_->files_to_load_.empty()) {
 585                 // if some files were specified at command-line we assume that the
 586                 // user wants to edit *these* files and not to restore the session.
 587                 for (size_t i = 0; i != pimpl_->files_to_load_.size(); ++i) {
 588                         lyx::dispatch(
 589                                 FuncRequest(LFUN_FILE_OPEN, pimpl_->files_to_load_[i]));
 590                 }
 591                 // clear this list to save a few bytes of RAM
 592                 pimpl_->files_to_load_.clear();
 593         } else
 594                 pimpl_->application_->restoreGuiSession();
 595
 596         // Execute batch commands if available
 597         if (pimpl_->batch_commands.empty())
 598                 return;
 599
 600         vector<string>::const_iterator bcit  = pimpl_->batch_commands.begin();
 601         vector<string>::const_iterator bcend = pimpl_->batch_commands.end();
 602         for (; bcit != bcend; ++bcit) {
 603                 LYXERR(Debug::INIT, "About to handle -x '" << *bcit << '\'');
 604                 lyx::dispatch(lyxaction.lookupFunc(*bcit));
 605         }
 606 }
 607
 608
 609 /*
 610 Signals and Windows
 611 ===================
 612 The SIGHUP signal does not exist on Windows and does not need to be handled.
 613
 614 Windows handles SIGFPE and SIGSEGV signals as expected.
 615
 616 Ctrl+C interrupts (mapped to SIGINT by Windows' POSIX compatability layer)
 617 cause a new thread to be spawned. This may well result in unexpected
 618 behaviour by the single-threaded LyX.
 619
 620 SIGTERM signals will come only from another process actually sending
 621 that signal using 'raise' in Windows' POSIX compatability layer. It will
 622 not come from the general "terminate process" methods that everyone
 623 actually uses (and which can't be trapped). Killing an app 'politely' on
 624 Windows involves first sending a WM_CLOSE message, something that is
 625 caught already by the Qt frontend.
 626
 627 For more information see:
 628
 629 http://aspn.activestate.com/ASPN/Mail/Message/ActiveTcl/2034055
 630 ...signals are mostly useless on Windows for a variety of reasons that are
 631 Windows specific...
 632
 633 'UNIX Application Migration Guide, Chapter 9'
 634 http://msdn.microsoft.com/library/en-us/dnucmg/html/UCMGch09.asp
 635
 636 'How To Terminate an Application "Cleanly" in Win32'
 637 http://support.microsoft.com/default.aspx?scid=kb;en-us;178893
 638 */
 639 extern "C" {
 640
 641 static void error_handler(int err_sig)
 642 {
 643         // Throw away any signals other than the first one received.
 644         static sig_atomic_t handling_error = false;
 645         if (handling_error)
 646                 return;
 647         handling_error = true;
 648
 649         // We have received a signal indicating a fatal error, so
 650         // try and save the data ASAP.
 651         emergencyCleanup();
 652
 653         // These lyxerr calls may or may not work:
 654
 655         // Signals are asynchronous, so the main program may be in a very
 656         // fragile state when a signal is processed and thus while a signal
 657         // handler function executes.
 658         // In general, therefore, we should avoid performing any
 659         // I/O operations or calling most library and system functions from
 660         // signal handlers.
 661
 662         // This shouldn't matter here, however, as we've already invoked
 663         // emergencyCleanup.
 664         docstring msg;
 665         switch (err_sig) {
 666 #ifdef SIGHUP
 667         case SIGHUP:
 668                 msg = _("SIGHUP signal caught!\nBye.");
 669                 break;
 670 #endif
 671         case SIGFPE:
 672                 msg = _("SIGFPE signal caught!\nBye.");
 673                 break;
 674         case SIGSEGV:
 675                 msg = _("SIGSEGV signal caught!\n"
 676                           "Sorry, you have found a bug in LyX, "
 677                           "hope you have not lost any data.\n"
 678                           "Please read the bug-reporting instructions "
 679                           "in 'Help->Introduction' and send us a bug report, "
 680                           "if necessary. Thanks!\nBye.");
 681                 break;
 682         case SIGINT:
 683         case SIGTERM:
 684                 // no comments
 685                 break;
 686         }
 687
 688         if (!msg.empty()) {
 689                 lyxerr << "\nlyx: " << msg << endl;
 690                 // try to make a GUI message
 691                 Alert::error(_("LyX crashed!"), msg, true);
 692         }
 693
 694         // Deinstall the signal handlers
 695 #ifdef SIGHUP
 696         signal(SIGHUP, SIG_DFL);
 697 #endif
 698         signal(SIGINT, SIG_DFL);
 699         signal(SIGFPE, SIG_DFL);
 700         signal(SIGSEGV, SIG_DFL);
 701         signal(SIGTERM, SIG_DFL);
 702
 703 #ifdef SIGHUP
 704         if (err_sig == SIGSEGV ||
 705                 (err_sig != SIGHUP && !getEnv("LYXDEBUG").empty())) {
 706 #else
 707         if (err_sig == SIGSEGV || !getEnv("LYXDEBUG").empty()) {
 708 #endif
 709 #ifdef _MSC_VER
 710                 // with abort() it crashes again.
 711                 exit(err_sig);
 712 #else
 713                 abort();
 714 #endif
 715         }
 716
 717         exit(0);
 718 }
 719
 720 }
 721
 722
 723 void LyX::printError(ErrorItem const & ei)
 724 {
 725         docstring tmp = _("LyX: ") + ei.error + char_type(':')
 726                 + ei.description;
 727         cerr << to_utf8(tmp) << endl;
 728 }
 729
 730 #if defined (USE_MACOSX_PACKAGING)
 731 namespace {
 732         // Unexposed--extract an environment variable name from its NAME=VALUE
 733         // representation
 734         std::string varname(const char* line)
 735         {
 736                 size_t nameLen = strcspn(line, "=");
 737                 if (nameLen == strlen(line)) {
 738                         return std::string();
 739                 } else {
 740                         return std::string(line, nameLen);
 741                 }
 742         }
 743 }
 744
 745 void cleanDuplicateEnvVars()
 746 {
 747         std::set<std::string> seen;
 748         std::set<std::string> dupes;
 749
 750         // Create a list of the environment variables that appear more than once
 751         for (char **read = *_NSGetEnviron(); *read; read++) {
 752                 std::string name = varname(*read);
 753                 if (name.size() == 0) {
 754                         continue;
 755                 }
 756                 if (seen.find(name) != seen.end()) {
 757                         dupes.insert(name);
 758                 } else {
 759                         seen.insert(name);
 760                 }
 761         }
 762
 763         // Loop over the list of duplicated variables
 764         std::set<std::string>::iterator dupe = dupes.begin();
 765         std::set<std::string>::iterator const dend = dupes.end();
 766         for (; dupe != dend; ++dupe) {
 767                 const char *name = (*dupe).c_str();
 768                 char *val = getenv(name);
 769                 if (val != NULL) {
 770                         LYXERR(Debug::INIT, "Duplicate environment variable: " << name);
 771                         // unsetenv removes *all* instances of the variable from the environment
 772                         unsetenv(name);
 773
 774                         // replace with the value from getenv (in practice appears to be the
 775                         // first value in the list)
 776                         setenv(name, val, 0);
 777                 }
 778         }
 779 }
 780 #endif
 781
 782 bool LyX::init()
 783 {
 784 #ifdef SIGHUP
 785         signal(SIGHUP, error_handler);
 786 #endif
 787         signal(SIGFPE, error_handler);
 788         signal(SIGSEGV, error_handler);
 789         signal(SIGINT, error_handler);
 790         signal(SIGTERM, error_handler);
 791         // SIGPIPE can be safely ignored.
 792
 793 #if defined (USE_MACOSX_PACKAGING)
 794         cleanDuplicateEnvVars();
 795 #endif
 796
 797         lyxrc.tempdir_path = package().temp_dir().absFileName();
 798         lyxrc.document_path = package().document_dir().absFileName();
 799
 800         if (lyxrc.example_path.empty()) {
 801                 lyxrc.example_path = addPath(package().system_support().absFileName(),
 802                                               "examples");
 803         }
 804         if (lyxrc.template_path.empty()) {
 805                 lyxrc.template_path = addPath(package().system_support().absFileName(),
 806                                               "templates");
 807         }
 808
 809         // init LyXDir environment variable
 810         string const lyx_dir = package().lyx_dir().absFileName();
 811         LYXERR(Debug::INIT, "Setting LyXDir... to \"" << lyx_dir << "\"");
 812         if (!setEnv("LyXDir", lyx_dir))
 813                 LYXERR(Debug::INIT, "\t... failed!");
 814
 815         if (package().explicit_user_support() && getEnv(LYX_USERDIR_VER).empty()) {
 816                 // -userdir was given on the command line.
 817                 // Make it available to child processes, otherwise tex2lyx
 818                 // would not find all layout files, and other converters might
 819                 // use it as well.
 820                 string const user_dir = package().user_support().absFileName();
 821                 LYXERR(Debug::INIT, "Setting " LYX_USERDIR_VER "... to \""
 822                                     << user_dir << '"');
 823                 if (!setEnv(LYX_USERDIR_VER, user_dir))
 824                         LYXERR(Debug::INIT, "\t... failed!");
 825         }
 826
 827         //
 828         // Read configuration files
 829         //
 830
 831         // This one may have been distributed along with LyX.
 832         if (!readRcFile("lyxrc.dist"))
 833                 return false;
 834
 835         // Set the PATH correctly.
 836 #if !defined (USE_POSIX_PACKAGING)
 837         // Add the directory containing the LyX executable to the path
 838         // so that LyX can find things like tex2lyx.
 839         if (package().build_support().empty())
 840                 prependEnvPath("PATH", package().binary_dir().absFileName());
 841 #endif
 842         if (!lyxrc.path_prefix.empty())
 843                 prependEnvPath("PATH", replaceEnvironmentPath(lyxrc.path_prefix));
 844
 845         // Check that user LyX directory is ok.
 846         {
 847                 string const lock_file = package().getConfigureLockName();
 848                 int fd = fileLock(lock_file.c_str());
 849
 850                 if (queryUserLyXDir(package().explicit_user_support())) {
 851                         package().reconfigureUserLyXDir("");
 852                 }
 853                 fileUnlock(fd, lock_file.c_str());
 854         }
 855
 856         if (!use_gui) {
 857                 // No need for a splash when there is no GUI
 858                 first_start = false;
 859                 // Default is to overwrite the main file during export, unless
 860                 // the -f switch was specified or LYX_FORCE_OVERWRITE was set
 861                 if (force_overwrite == UNSPECIFIED) {
 862                         string const what = getEnv("LYX_FORCE_OVERWRITE");
 863                         if (what == "all")
 864                                 force_overwrite = ALL_FILES;
 865                         else if (what == "none")
 866                                 force_overwrite = NO_FILES;
 867                         else
 868                                 force_overwrite = MAIN_FILE;
 869                 }
 870         }
 871
 872         // This one is generated in user_support directory by lib/configure.py.
 873         if (!readRcFile("lyxrc.defaults"))
 874                 return false;
 875
 876         // Query the OS to know what formats are viewed natively
 877         formats.setAutoOpen();
 878
 879         // Read lyxrc.dist again to be able to override viewer auto-detection.
 880         readRcFile("lyxrc.dist");
 881
 882         system_lyxrc = lyxrc;
 883         system_formats = formats;
 884         pimpl_->system_converters_ = pimpl_->converters_;
 885         pimpl_->system_movers_ = pimpl_->movers_;
 886         system_lcolor = lcolor;
 887
 888         // This one is edited through the preferences dialog.
 889         if (!readRcFile("preferences", true))
 890                 return false;
 891
 892         // The language may have been set to someting useful through prefs
 893         setLocale();
 894
 895         if (!readEncodingsFile("encodings", "unicodesymbols"))
 896                 return false;
 897         if (!readLanguagesFile("languages"))
 898                 return false;
 899
 900         LYXERR(Debug::INIT, "Reading layouts...");
 901         // Load the layouts
 902         LayoutFileList::get().read();
 903         //...and the modules
 904         theModuleList.read();
 905
 906         // read keymap and ui files in batch mode as well
 907         // because InsetInfo needs to know these to produce
 908         // the correct output
 909
 910         // Set up command definitions
 911         pimpl_->toplevel_cmddef_.read(lyxrc.def_file);
 912
 913         // FIXME
 914         // Set up bindings
 915         pimpl_->toplevel_keymap_.read("site");
 916         pimpl_->toplevel_keymap_.read(lyxrc.bind_file);
 917         // load user bind file user.bind
 918         pimpl_->toplevel_keymap_.read("user", 0, KeyMap::MissingOK);
 919
 920         if (lyxerr.debugging(Debug::LYXRC))
 921                 lyxrc.print();
 922
 923         os::windows_style_tex_paths(lyxrc.windows_style_tex_paths);
 924         // Prepend path prefix a second time to take the user preferences into a account
 925         if (!lyxrc.path_prefix.empty())
 926                 prependEnvPath("PATH", replaceEnvironmentPath(lyxrc.path_prefix));
 927
 928         FileName const document_path(lyxrc.document_path);
 929         if (document_path.exists() && document_path.isDirectory())
 930                 package().document_dir() = document_path;
 931
 932         package().set_temp_dir(createLyXTmpDir(FileName(lyxrc.tempdir_path)));
 933         if (package().temp_dir().empty()) {
 934                 Alert::error(_("Could not create temporary directory"),
 935                              bformat(_("Could not create a temporary directory in\n"
 936                                                        "\"%1$s\"\n"
 937                                                            "Make sure that this path exists and is writable and try again."),
 938                                      from_utf8(lyxrc.tempdir_path)));
 939                 // createLyXTmpDir() tries sufficiently hard to create a
 940                 // usable temp dir, so the probability to come here is
 941                 // close to zero. We therefore don't try to overcome this
 942                 // problem with e.g. asking the user for a new path and
 943                 // trying again but simply exit.
 944                 return false;
 945         }
 946
 947         LYXERR(Debug::INIT, "LyX tmp dir: `"
 948                             << package().temp_dir().absFileName() << '\'');
 949
 950         LYXERR(Debug::INIT, "Reading session information '.lyx/session'...");
 951         pimpl_->session_.reset(new Session(lyxrc.num_lastfiles));
 952
 953         // This must happen after package initialization and after lyxrc is
 954         // read, therefore it can't be done by a static object.
 955         ConverterCache::init();
 956
 957         return true;
 958 }
 959
 960
 961 void emergencyCleanup()
 962 {
 963         // what to do about tmpfiles is non-obvious. we would
 964         // like to delete any we find, but our lyxdir might
 965         // contain documents etc. which might be helpful on
 966         // a crash
 967
 968         singleton_->pimpl_->buffer_list_.emergencyWriteAll();
 969         if (use_gui) {
 970                 if (singleton_->pimpl_->lyx_server_)
 971                         singleton_->pimpl_->lyx_server_->emergencyCleanup();
 972                 singleton_->pimpl_->lyx_server_.reset();
 973                 singleton_->pimpl_->lyx_socket_.reset();
 974         }
 975 }
 976
 977
 978 bool LyX::queryUserLyXDir(bool explicit_userdir)
 979 {
 980         // Does user directory exist?
 981         FileName const sup = package().user_support();
 982         if (sup.exists() && sup.isDirectory()) {
 983                 first_start = false;
 984
 985                 return configFileNeedsUpdate("lyxrc.defaults")
 986                         || configFileNeedsUpdate("lyxmodules.lst")
 987                         || configFileNeedsUpdate("textclass.lst")
 988                         || configFileNeedsUpdate("packages.lst");
 989         }
 990
 991         first_start = !explicit_userdir;
 992
 993         // If the user specified explicitly a directory, ask whether
 994         // to create it. If the user says "no", then exit.
 995         if (explicit_userdir &&
 996             Alert::prompt(
 997                     _("Missing user LyX directory"),
 998                     bformat(_("You have specified a non-existent user "
 999                                            "LyX directory, %1$s.\n"
1000                                            "It is needed to keep your own configuration."),
1001                             from_utf8(package().user_support().absFileName())),
1002                     1, 0,
1003                     _("&Create directory"),
1004                     _("&Exit LyX"))) {
1005                 lyxerr << to_utf8(_("No user LyX directory. Exiting.")) << endl;
1006                 earlyExit(EXIT_FAILURE);
1007         }
1008
1009         lyxerr << to_utf8(bformat(_("LyX: Creating directory %1$s"),
1010                           from_utf8(sup.absFileName()))) << endl;
1011
1012         if (!sup.createDirectory(0755)) {
1013                 // Failed, so let's exit.
1014                 lyxerr << to_utf8(_("Failed to create directory. Exiting."))
1015                        << endl;
1016                 earlyExit(EXIT_FAILURE);
1017         }
1018
1019         return true;
1020 }
1021
1022
1023 bool LyX::readRcFile(string const & name, bool check_format)
1024 {
1025         LYXERR(Debug::INIT, "About to read " << name << "... ");
1026
1027         FileName const lyxrc_path = libFileSearch(string(), name);
1028         if (lyxrc_path.empty()) {
1029                 LYXERR(Debug::INIT, "Not found." << lyxrc_path);
1030                 // FIXME
1031                 // This was the previous logic, but can it be right??
1032                 return true;
1033         }
1034         LYXERR(Debug::INIT, "Found in " << lyxrc_path);
1035         bool const success = lyxrc.read(lyxrc_path, check_format);
1036         if (!success)
1037                 showFileError(name);
1038         return success;
1039 }
1040
1041 // Read the languages file `name'
1042 bool LyX::readLanguagesFile(string const & name)
1043 {
1044         LYXERR(Debug::INIT, "About to read " << name << "...");
1045
1046         FileName const lang_path = libFileSearch(string(), name);
1047         if (lang_path.empty()) {
1048                 showFileError(name);
1049                 return false;
1050         }
1051         languages.read(lang_path);
1052         return true;
1053 }
1054
1055
1056 // Read the encodings file `name'
1057 bool LyX::readEncodingsFile(string const & enc_name,
1058                             string const & symbols_name)
1059 {
1060         LYXERR(Debug::INIT, "About to read " << enc_name << " and "
1061                             << symbols_name << "...");
1062
1063         FileName const symbols_path = libFileSearch(string(), symbols_name);
1064         if (symbols_path.empty()) {
1065                 showFileError(symbols_name);
1066                 return false;
1067         }
1068
1069         FileName const enc_path = libFileSearch(string(), enc_name);
1070         if (enc_path.empty()) {
1071                 showFileError(enc_name);
1072                 return false;
1073         }
1074         encodings.read(enc_path, symbols_path);
1075         return true;
1076 }
1077
1078
1079 namespace {
1080
1081 /// return the the number of arguments consumed
1082 typedef boost::function<int(string const &, string const &, string &)> cmd_helper;
1083
1084 int parse_dbg(string const & arg, string const &, string &)
1085 {
1086         if (arg.empty()) {
1087                 cout << to_utf8(_("List of supported debug flags:")) << endl;
1088                 Debug::showTags(cout);
1089                 exit(0);
1090         }
1091         lyxerr << to_utf8(bformat(_("Setting debug level to %1$s"), from_utf8(arg))) << endl;
1092
1093         lyxerr.setLevel(Debug::value(arg));
1094         Debug::showLevel(lyxerr, lyxerr.level());
1095         return 1;
1096 }
1097
1098
1099 int parse_help(string const &, string const &, string &)
1100 {
1101         cout <<
1102                 to_utf8(_("Usage: lyx [ command line switches ] [ name.lyx ... ]\n"
1103                   "Command line switches (case sensitive):\n"
1104                   "\t-help              summarize LyX usage\n"
1105                   "\t-userdir dir       set user directory to dir\n"
1106                   "\t-sysdir dir        set system directory to dir\n"
1107                   "\t-geometry WxH+X+Y  set geometry of the main window\n"
1108                   "\t-dbg feature[,feature]...\n"
1109                   "                  select the features to debug.\n"
1110                   "                  Type `lyx -dbg' to see the list of features\n"
1111                   "\t-x [--execute] command\n"
1112                   "                  where command is a lyx command.\n"
1113                   "\t-e [--export] fmt\n"
1114                   "                  where fmt is the export format of choice. Look in\n"
1115                   "                  Tools->Preferences->File Handling->File Formats->Short Name\n"
1116                   "                  to see which parameter (which differs from the format name\n"
1117                   "                  in the File->Export menu) should be passed.\n"
1118                   "                  Note that the order of -e and -x switches matters.\n"
1119                   "\t-E [--export-to] fmt filename\n"
1120                   "                  where fmt is the export format of choice (see --export),\n"
1121                   "                  and filename is the destination filename.\n"
1122                   "\t-i [--import] fmt file.xxx\n"
1123                   "                  where fmt is the import format of choice\n"
1124                   "                  and file.xxx is the file to be imported.\n"
1125                   "\t-f [--force-overwrite] what\n"
1126                   "                  where what is either `all', `main' or `none',\n"
1127                   "                  specifying whether all files, main file only, or no files,\n"
1128                   "                  respectively, are to be overwritten during a batch export.\n"
1129                   "                  Anything else is equivalent to `all', but is not consumed.\n"
1130                   "\t-n [--no-remote]\n"
1131                   "                  open documents in a new instance\n"
1132                   "\t-r [--remote]\n"
1133                   "                  open documents in an already running instance\n"
1134                   "                  (a working lyxpipe is needed)\n"
1135                   "\t-batch    execute commands without launching GUI and exit.\n"
1136                   "\t-version  summarize version and build info\n"
1137                                "Check the LyX man page for more details.")) << endl;
1138         exit(0);
1139         return 0;
1140 }
1141
1142
1143 int parse_version(string const &, string const &, string &)
1144 {
1145         cout << "LyX " << lyx_version
1146                << " (" << lyx_release_date << ")" << endl;
1147         if (string(lyx_git_commit_hash) != "none")
1148                 cout << to_utf8(_("  Git commit hash "))
1149                      << string(lyx_git_commit_hash).substr(0,8) << endl;
1150         cout << to_utf8(bformat(_("Built on %1$s[[date]], %2$s[[time]]"),
1151                 from_ascii(lyx_build_date), from_ascii(lyx_build_time))) << endl;
1152         cout << lyx_version_info << endl;
1153         exit(0);
1154         return 0;
1155 }
1156
1157
1158 int parse_sysdir(string const & arg, string const &, string &)
1159 {
1160         if (arg.empty()) {
1161                 Alert::error(_("No system directory"),
1162                         _("Missing directory for -sysdir switch"));
1163                 exit(1);
1164         }
1165         cl_system_support = arg;
1166         return 1;
1167 }
1168
1169
1170 int parse_userdir(string const & arg, string const &, string &)
1171 {
1172         if (arg.empty()) {
1173                 Alert::error(_("No user directory"),
1174                         _("Missing directory for -userdir switch"));
1175                 exit(1);
1176         }
1177         cl_user_support = arg;
1178         return 1;
1179 }
1180
1181
1182 int parse_execute(string const & arg, string const &, string & batch)
1183 {
1184         if (arg.empty()) {
1185                 Alert::error(_("Incomplete command"),
1186                         _("Missing command string after --execute switch"));
1187                 exit(1);
1188         }
1189         batch = arg;
1190         return 1;
1191 }
1192
1193
1194 int parse_export_to(string const & type, string const & output_file, string & batch)
1195 {
1196         if (type.empty()) {
1197                 lyxerr << to_utf8(_("Missing file type [eg latex, ps...] after "
1198                                          "--export-to switch")) << endl;
1199                 exit(1);
1200         }
1201         if (output_file.empty()) {
1202                 lyxerr << to_utf8(_("Missing destination filename after "
1203                                          "--export-to switch")) << endl;
1204                 exit(1);
1205         }
1206         batch = "buffer-export " + type + " " + output_file;
1207         use_gui = false;
1208         return 2;
1209 }
1210
1211
1212 int parse_export(string const & type, string const &, string & batch)
1213 {
1214         if (type.empty()) {
1215                 lyxerr << to_utf8(_("Missing file type [eg latex, ps...] after "
1216                                          "--export switch")) << endl;
1217                 exit(1);
1218         }
1219         batch = "buffer-export " + type;
1220         use_gui = false;
1221         return 1;
1222 }
1223
1224
1225 int parse_import(string const & type, string const & file, string & batch)
1226 {
1227         if (type.empty()) {
1228                 lyxerr << to_utf8(_("Missing file type [eg latex, ps...] after "
1229                                          "--import switch")) << endl;
1230                 exit(1);
1231         }
1232         if (file.empty()) {
1233                 lyxerr << to_utf8(_("Missing filename for --import")) << endl;
1234                 exit(1);
1235         }
1236         batch = "buffer-import " + type + ' ' + file;
1237         return 2;
1238 }
1239
1240
1241 int parse_geometry(string const & arg1, string const &, string &)
1242 {
1243         geometryArg = arg1;
1244         // don't remove "-geometry", it will be pruned out later in the
1245         // frontend if need be.
1246         return -1;
1247 }
1248
1249
1250 int parse_batch(string const &, string const &, string &)
1251 {
1252         use_gui = false;
1253         return 0;
1254 }
1255
1256
1257 int parse_noremote(string const &, string const &, string &)
1258 {
1259         run_mode = NEW_INSTANCE;
1260         return 0;
1261 }
1262
1263
1264 int parse_remote(string const &, string const &, string &)
1265 {
1266         run_mode = USE_REMOTE;
1267         return 0;
1268 }
1269
1270
1271 int parse_force(string const & arg, string const &, string &)
1272 {
1273         if (arg == "all") {
1274                 force_overwrite = ALL_FILES;
1275                 return 1;
1276         } else if (arg == "main") {
1277                 force_overwrite = MAIN_FILE;
1278                 return 1;
1279         } else if (arg == "none") {
1280                 force_overwrite = NO_FILES;
1281                 return 1;
1282         }
1283         force_overwrite = ALL_FILES;
1284         return 0;
1285 }
1286
1287
1288 } // namespace anon
1289
1290
1291 void LyX::easyParse(int & argc, char * argv[])
1292 {
1293         map<string, cmd_helper> cmdmap;
1294
1295         cmdmap["-dbg"] = parse_dbg;
1296         cmdmap["-help"] = parse_help;
1297         cmdmap["--help"] = parse_help;
1298         cmdmap["-version"] = parse_version;
1299         cmdmap["--version"] = parse_version;
1300         cmdmap["-sysdir"] = parse_sysdir;
1301         cmdmap["-userdir"] = parse_userdir;
1302         cmdmap["-x"] = parse_execute;
1303         cmdmap["--execute"] = parse_execute;
1304         cmdmap["-e"] = parse_export;
1305         cmdmap["--export"] = parse_export;
1306         cmdmap["-E"] = parse_export_to;
1307         cmdmap["--export-to"] = parse_export_to;
1308         cmdmap["-i"] = parse_import;
1309         cmdmap["--import"] = parse_import;
1310         cmdmap["-geometry"] = parse_geometry;
1311         cmdmap["-batch"] = parse_batch;
1312         cmdmap["-f"] = parse_force;
1313         cmdmap["--force-overwrite"] = parse_force;
1314         cmdmap["-n"] = parse_noremote;
1315         cmdmap["--no-remote"] = parse_noremote;
1316         cmdmap["-r"] = parse_remote;
1317         cmdmap["--remote"] = parse_remote;
1318
1319         for (int i = 1; i < argc; ++i) {
1320                 map<string, cmd_helper>::const_iterator it
1321                         = cmdmap.find(argv[i]);
1322
1323                 // don't complain if not found - may be parsed later
1324                 if (it == cmdmap.end())
1325                         continue;
1326
1327                 string const arg =
1328                         (i + 1 < argc) ? os::utf8_argv(i + 1) : string();
1329                 string const arg2 =
1330                         (i + 2 < argc) ? os::utf8_argv(i + 2) : string();
1331
1332                 string batch;
1333                 int const remove = 1 + it->second(arg, arg2, batch);
1334                 if (!batch.empty())
1335                         pimpl_->batch_commands.push_back(batch);
1336
1337                 // Now, remove used arguments by shifting
1338                 // the following ones remove places down.
1339                 if (remove > 0) {
1340                         os::remove_internal_args(i, remove);
1341                         argc -= remove;
1342                         for (int j = i; j < argc; ++j)
1343                                 argv[j] = argv[j + remove];
1344                         --i;
1345                 }
1346         }
1347 }
1348
1349
1350 FuncStatus getStatus(FuncRequest const & action)
1351 {
1352         LAPPERR(theApp());
1353         return theApp()->getStatus(action);
1354 }
1355
1356
1357 void dispatch(FuncRequest const & action)
1358 {
1359         LAPPERR(theApp());
1360         return theApp()->dispatch(action);
1361 }
1362
1363
1364 void dispatch(FuncRequest const & action, DispatchResult & dr)
1365 {
1366         LAPPERR(theApp());
1367         return theApp()->dispatch(action, dr);
1368 }
1369
1370
1371 vector<string> & theFilesToLoad()
1372 {
1373         LAPPERR(singleton_);
1374         return singleton_->pimpl_->files_to_load_;
1375 }
1376
1377
1378 BufferList & theBufferList()
1379 {
1380         LAPPERR(singleton_);
1381         return singleton_->pimpl_->buffer_list_;
1382 }
1383
1384
1385 Server & theServer()
1386 {
1387         // FIXME: this should not be use_gui dependent
1388         LWARNIF(use_gui);
1389         LAPPERR(singleton_);
1390         return *singleton_->pimpl_->lyx_server_.get();
1391 }
1392
1393
1394 ServerSocket & theServerSocket()
1395 {
1396         // FIXME: this should not be use_gui dependent
1397         LWARNIF(use_gui);
1398         LAPPERR(singleton_);
1399         return *singleton_->pimpl_->lyx_socket_.get();
1400 }
1401
1402
1403 KeyMap & theTopLevelKeymap()
1404 {
1405         LAPPERR(singleton_);
1406         return singleton_->pimpl_->toplevel_keymap_;
1407 }
1408
1409
1410 Converters & theConverters()
1411 {
1412         LAPPERR(singleton_);
1413         return  singleton_->pimpl_->converters_;
1414 }
1415
1416
1417 Converters & theSystemConverters()
1418 {
1419         LAPPERR(singleton_);
1420         return  singleton_->pimpl_->system_converters_;
1421 }
1422
1423
1424 Movers & theMovers()
1425 {
1426         LAPPERR(singleton_);
1427         return singleton_->pimpl_->movers_;
1428 }
1429
1430
1431 Mover const & getMover(string  const & fmt)
1432 {
1433         LAPPERR(singleton_);
1434         return singleton_->pimpl_->movers_(fmt);
1435 }
1436
1437
1438 void setMover(string const & fmt, string const & command)
1439 {
1440         LAPPERR(singleton_);
1441         singleton_->pimpl_->movers_.set(fmt, command);
1442 }
1443
1444
1445 Movers & theSystemMovers()
1446 {
1447         LAPPERR(singleton_);
1448         return singleton_->pimpl_->system_movers_;
1449 }
1450
1451
1452 Messages const & getMessages(string const & language)
1453 {
1454         LAPPERR(singleton_);
1455         return singleton_->messages(language);
1456 }
1457
1458
1459 Messages const & getGuiMessages()
1460 {
1461         LAPPERR(singleton_);
1462         return singleton_->messages(Messages::guiLanguage());
1463 }
1464
1465
1466 Session & theSession()
1467 {
1468         LAPPERR(singleton_);
1469         return *singleton_->pimpl_->session_.get();
1470 }
1471
1472
1473 LaTeXFonts & theLaTeXFonts()
1474 {
1475         LAPPERR(singleton_);
1476         if (!singleton_->pimpl_->latexfonts_)
1477                 singleton_->pimpl_->latexfonts_ = new LaTeXFonts;
1478         return *singleton_->pimpl_->latexfonts_;
1479 }
1480
1481
1482 CmdDef & theTopLevelCmdDef()
1483 {
1484         LAPPERR(singleton_);
1485         return singleton_->pimpl_->toplevel_cmddef_;
1486 }
1487
1488
1489 SpellChecker * theSpellChecker()
1490 {
1491         if (!singleton_->pimpl_->spell_checker_)
1492                 setSpellChecker();
1493         return singleton_->pimpl_->spell_checker_;
1494 }
1495
1496
1497 void setSpellChecker()
1498 {
1499         SpellChecker::ChangeNumber speller_change_number =singleton_->pimpl_->spell_checker_ ?
1500                 singleton_->pimpl_->spell_checker_->changeNumber() : 0;
1501
1502         if (lyxrc.spellchecker == "native") {
1503 #if defined(USE_MACOSX_PACKAGING)
1504                 if (!singleton_->pimpl_->apple_spell_checker_)
1505                         singleton_->pimpl_->apple_spell_checker_ = new AppleSpellChecker;
1506                 singleton_->pimpl_->spell_checker_ = singleton_->pimpl_->apple_spell_checker_;
1507 #else
1508                 singleton_->pimpl_->spell_checker_ = 0;
1509 #endif
1510         } else if (lyxrc.spellchecker == "aspell") {
1511 #if defined(USE_ASPELL)
1512                 if (!singleton_->pimpl_->aspell_checker_)
1513                         singleton_->pimpl_->aspell_checker_ = new AspellChecker;
1514                 singleton_->pimpl_->spell_checker_ = singleton_->pimpl_->aspell_checker_;
1515 #else
1516                 singleton_->pimpl_->spell_checker_ = 0;
1517 #endif
1518         } else if (lyxrc.spellchecker == "enchant") {
1519 #if defined(USE_ENCHANT)
1520                 if (!singleton_->pimpl_->enchant_checker_)
1521                         singleton_->pimpl_->enchant_checker_ = new EnchantChecker;
1522                 singleton_->pimpl_->spell_checker_ = singleton_->pimpl_->enchant_checker_;
1523 #else
1524                 singleton_->pimpl_->spell_checker_ = 0;
1525 #endif
1526         } else if (lyxrc.spellchecker == "hunspell") {
1527 #if defined(USE_HUNSPELL)
1528                 if (!singleton_->pimpl_->hunspell_checker_)
1529                         singleton_->pimpl_->hunspell_checker_ = new HunspellChecker;
1530                 singleton_->pimpl_->spell_checker_ = singleton_->pimpl_->hunspell_checker_;
1531 #else
1532                 singleton_->pimpl_->spell_checker_ = 0;
1533 #endif
1534         } else {
1535                 singleton_->pimpl_->spell_checker_ = 0;
1536         }
1537         if (singleton_->pimpl_->spell_checker_) {
1538                 singleton_->pimpl_->spell_checker_->changeNumber(speller_change_number);
1539                 singleton_->pimpl_->spell_checker_->advanceChangeNumber();
1540         }
1541 }
1542
1543 } // namespace lyx