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