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         //
 749         // Read configuration files
 750         //
 751
 752         // This one may have been distributed along with LyX.
 753         if (!readRcFile("lyxrc.dist"))
 754                 return false;
 755
 756         // Set the language defined by the distributor.
 757         setRcGuiLanguage();
 758
 759         // Set the PATH correctly.
 760 #if !defined (USE_POSIX_PACKAGING)
 761         // Add the directory containing the LyX executable to the path
 762         // so that LyX can find things like tex2lyx.
 763         if (package().build_support().empty())
 764                 prependEnvPath("PATH", package().binary_dir().absFileName());
 765 #endif
 766         if (!lyxrc.path_prefix.empty())
 767                 prependEnvPath("PATH", lyxrc.path_prefix);
 768
 769         // Check that user LyX directory is ok.
 770         if (queryUserLyXDir(package().explicit_user_support()))
 771                 reconfigureUserLyXDir();
 772
 773         if (!use_gui) {
 774                 // No need for a splash when there is no GUI
 775                 first_start = false;
 776                 // Default is to overwrite the main file during export, unless
 777                 // the -f switch was specified or LYX_FORCE_OVERWRITE was set
 778                 if (force_overwrite == UNSPECIFIED) {
 779                         string const what = getEnv("LYX_FORCE_OVERWRITE");
 780                         if (what == "all")
 781                                 force_overwrite = ALL_FILES;
 782                         else if (what == "none")
 783                                 force_overwrite = NO_FILES;
 784                         else
 785                                 force_overwrite = MAIN_FILE;
 786                 }
 787         }
 788
 789         // This one is generated in user_support directory by lib/configure.py.
 790         if (!readRcFile("lyxrc.defaults"))
 791                 return false;
 792
 793         // Query the OS to know what formats are viewed natively
 794         formats.setAutoOpen();
 795
 796         // Read lyxrc.dist again to be able to override viewer auto-detection.
 797         readRcFile("lyxrc.dist");
 798
 799         // Set again the language defined by the distributor.
 800         setRcGuiLanguage();
 801
 802         system_lyxrc = lyxrc;
 803         system_formats = formats;
 804         pimpl_->system_converters_ = pimpl_->converters_;
 805         pimpl_->system_movers_ = pimpl_->movers_;
 806         system_lcolor = lcolor;
 807
 808         // This one is edited through the preferences dialog.
 809         if (!readRcFile("preferences", true))
 810                 return false;
 811
 812         if (!readEncodingsFile("encodings", "unicodesymbols"))
 813                 return false;
 814         if (!readLanguagesFile("languages"))
 815                 return false;
 816
 817         // Set the language defined by the user.
 818         setRcGuiLanguage();
 819
 820         LYXERR(Debug::INIT, "Reading layouts...");
 821         // Load the layouts
 822         LayoutFileList::get().read();
 823         //...and the modules
 824         theModuleList.read();
 825
 826         // read keymap and ui files in batch mode as well
 827         // because InsetInfo needs to know these to produce
 828         // the correct output
 829
 830         // Set up command definitions
 831         pimpl_->toplevel_cmddef_.read(lyxrc.def_file);
 832
 833         // FIXME
 834         // Set up bindings
 835         pimpl_->toplevel_keymap_.read("site");
 836         pimpl_->toplevel_keymap_.read(lyxrc.bind_file);
 837         // load user bind file user.bind
 838         pimpl_->toplevel_keymap_.read("user", 0, KeyMap::MissingOK);
 839
 840         if (lyxerr.debugging(Debug::LYXRC))
 841                 lyxrc.print();
 842
 843         os::windows_style_tex_paths(lyxrc.windows_style_tex_paths);
 844         if (!lyxrc.path_prefix.empty())
 845                 prependEnvPath("PATH", lyxrc.path_prefix);
 846
 847         FileName const document_path(lyxrc.document_path);
 848         if (document_path.exists() && document_path.isDirectory())
 849                 package().document_dir() = document_path;
 850
 851         package().set_temp_dir(createLyXTmpDir(FileName(lyxrc.tempdir_path)));
 852         if (package().temp_dir().empty()) {
 853                 Alert::error(_("Could not create temporary directory"),
 854                              bformat(_("Could not create a temporary directory in\n"
 855                                                        "\"%1$s\"\n"
 856                                                            "Make sure that this path exists and is writable and try again."),
 857                                      from_utf8(lyxrc.tempdir_path)));
 858                 // createLyXTmpDir() tries sufficiently hard to create a
 859                 // usable temp dir, so the probability to come here is
 860                 // close to zero. We therefore don't try to overcome this
 861                 // problem with e.g. asking the user for a new path and
 862                 // trying again but simply exit.
 863                 return false;
 864         }
 865
 866         LYXERR(Debug::INIT, "LyX tmp dir: `"
 867                             << package().temp_dir().absFileName() << '\'');
 868
 869         LYXERR(Debug::INIT, "Reading session information '.lyx/session'...");
 870         pimpl_->session_.reset(new Session(lyxrc.num_lastfiles));
 871
 872         // This must happen after package initialization and after lyxrc is
 873         // read, therefore it can't be done by a static object.
 874         ConverterCache::init();
 875
 876         return true;
 877 }
 878
 879
 880 void emergencyCleanup()
 881 {
 882         // what to do about tmpfiles is non-obvious. we would
 883         // like to delete any we find, but our lyxdir might
 884         // contain documents etc. which might be helpful on
 885         // a crash
 886
 887         singleton_->pimpl_->buffer_list_.emergencyWriteAll();
 888         if (use_gui) {
 889                 if (singleton_->pimpl_->lyx_server_)
 890                         singleton_->pimpl_->lyx_server_->emergencyCleanup();
 891                 singleton_->pimpl_->lyx_server_.reset();
 892                 singleton_->pimpl_->lyx_socket_.reset();
 893         }
 894 }
 895
 896
 897 // return true if file does not exist or is older than configure.py.
 898 static bool needsUpdate(string const & file)
 899 {
 900         // We cannot initialize configure_script directly because the package
 901         // is not initialized yet when  static objects are constructed.
 902         static FileName configure_script;
 903         static bool firstrun = true;
 904         if (firstrun) {
 905                 configure_script =
 906                         FileName(addName(package().system_support().absFileName(),
 907                                 "configure.py"));
 908                 firstrun = false;
 909         }
 910
 911         FileName absfile =
 912                 FileName(addName(package().user_support().absFileName(), file));
 913         return !absfile.exists()
 914                 || configure_script.lastModified() > absfile.lastModified();
 915 }
 916
 917
 918 bool LyX::queryUserLyXDir(bool explicit_userdir)
 919 {
 920         // Does user directory exist?
 921         FileName const sup = package().user_support();
 922         if (sup.exists() && sup.isDirectory()) {
 923                 first_start = false;
 924
 925                 return needsUpdate("lyxrc.defaults")
 926                         || needsUpdate("lyxmodules.lst")
 927                         || needsUpdate("textclass.lst")
 928                         || needsUpdate("packages.lst");
 929         }
 930
 931         first_start = !explicit_userdir;
 932
 933         // If the user specified explicitly a directory, ask whether
 934         // to create it. If the user says "no", then exit.
 935         if (explicit_userdir &&
 936             Alert::prompt(
 937                     _("Missing user LyX directory"),
 938                     bformat(_("You have specified a non-existent user "
 939                                            "LyX directory, %1$s.\n"
 940                                            "It is needed to keep your own configuration."),
 941                             from_utf8(package().user_support().absFileName())),
 942                     1, 0,
 943                     _("&Create directory"),
 944                     _("&Exit LyX"))) {
 945                 lyxerr << to_utf8(_("No user LyX directory. Exiting.")) << endl;
 946                 earlyExit(EXIT_FAILURE);
 947         }
 948
 949         lyxerr << to_utf8(bformat(_("LyX: Creating directory %1$s"),
 950                           from_utf8(sup.absFileName()))) << endl;
 951
 952         if (!sup.createDirectory(0755)) {
 953                 // Failed, so let's exit.
 954                 lyxerr << to_utf8(_("Failed to create directory. Exiting."))
 955                        << endl;
 956                 earlyExit(EXIT_FAILURE);
 957         }
 958
 959         return true;
 960 }
 961
 962
 963 bool LyX::readRcFile(string const & name, bool check_format)
 964 {
 965         LYXERR(Debug::INIT, "About to read " << name << "... ");
 966
 967         FileName const lyxrc_path = libFileSearch(string(), name);
 968         if (lyxrc_path.empty()) {
 969                 LYXERR(Debug::INIT, "Not found." << lyxrc_path);
 970                 // FIXME
 971                 // This was the previous logic, but can it be right??
 972                 return true;
 973         }
 974         LYXERR(Debug::INIT, "Found in " << lyxrc_path);
 975         bool const success = lyxrc.read(lyxrc_path, check_format);
 976         if (!success)
 977                 showFileError(name);
 978         return success;
 979 }
 980
 981 // Read the languages file `name'
 982 bool LyX::readLanguagesFile(string const & name)
 983 {
 984         LYXERR(Debug::INIT, "About to read " << name << "...");
 985
 986         FileName const lang_path = libFileSearch(string(), name);
 987         if (lang_path.empty()) {
 988                 showFileError(name);
 989                 return false;
 990         }
 991         languages.read(lang_path);
 992         return true;
 993 }
 994
 995
 996 // Read the encodings file `name'
 997 bool LyX::readEncodingsFile(string const & enc_name,
 998                             string const & symbols_name)
 999 {
1000         LYXERR(Debug::INIT, "About to read " << enc_name << " and "
1001                             << symbols_name << "...");
1002
1003         FileName const symbols_path = libFileSearch(string(), symbols_name);
1004         if (symbols_path.empty()) {
1005                 showFileError(symbols_name);
1006                 return false;
1007         }
1008
1009         FileName const enc_path = libFileSearch(string(), enc_name);
1010         if (enc_path.empty()) {
1011                 showFileError(enc_name);
1012                 return false;
1013         }
1014         encodings.read(enc_path, symbols_path);
1015         return true;
1016 }
1017
1018
1019 namespace {
1020
1021 /// return the the number of arguments consumed
1022 typedef boost::function<int(string const &, string const &, string &)> cmd_helper;
1023
1024 int parse_dbg(string const & arg, string const &, string &)
1025 {
1026         if (arg.empty()) {
1027                 lyxerr << to_utf8(_("List of supported debug flags:")) << endl;
1028                 Debug::showTags(lyxerr);
1029                 exit(0);
1030         }
1031         lyxerr << to_utf8(bformat(_("Setting debug level to %1$s"), from_utf8(arg))) << endl;
1032
1033         lyxerr.setLevel(Debug::value(arg));
1034         Debug::showLevel(lyxerr, lyxerr.level());
1035         return 1;
1036 }
1037
1038
1039 int parse_help(string const &, string const &, string &)
1040 {
1041         lyxerr <<
1042                 to_utf8(_("Usage: lyx [ command line switches ] [ name.lyx ... ]\n"
1043                   "Command line switches (case sensitive):\n"
1044                   "\t-help              summarize LyX usage\n"
1045                   "\t-userdir dir       set user directory to dir\n"
1046                   "\t-sysdir dir        set system directory to dir\n"
1047                   "\t-geometry WxH+X+Y  set geometry of the main window\n"
1048                   "\t-dbg feature[,feature]...\n"
1049                   "                  select the features to debug.\n"
1050                   "                  Type `lyx -dbg' to see the list of features\n"
1051                   "\t-x [--execute] command\n"
1052                   "                  where command is a lyx command.\n"
1053                   "\t-e [--export] fmt\n"
1054                   "                  where fmt is the export format of choice.\n"
1055                   "                  Look on Tools->Preferences->File formats->Format\n"
1056                   "                  to get an idea which parameters should be passed.\n"
1057                   "                  Note that the order of -e and -x switches matters.\n"
1058                   "\t-i [--import] fmt file.xxx\n"
1059                   "                  where fmt is the import format of choice\n"
1060                   "                  and file.xxx is the file to be imported.\n"
1061                   "\t-f [--force-overwrite] what\n"
1062                   "                  where what is either `all', `main' or `none',\n"
1063                   "                  specifying whether all files, main file only, or no files,\n"
1064                   "                  respectively, are to be overwritten during a batch export.\n"
1065                   "                  Anything else is equivalent to `all', but is not consumed.\n"
1066                   "\t-n [--no-remote]\n"
1067                   "                  open documents in a new instance\n"
1068                   "\t-r [--remote]\n"
1069                   "                  open documents in an already running instance\n"
1070                   "                  (a working lyxpipe is needed)\n"
1071                   "\t-batch    execute commands without launching GUI and exit.\n"
1072                   "\t-version  summarize version and build info\n"
1073                                "Check the LyX man page for more details.")) << endl;
1074         exit(0);
1075         return 0;
1076 }
1077
1078
1079 int parse_version(string const &, string const &, string &)
1080 {
1081         lyxerr << "LyX " << lyx_version
1082                << " (" << lyx_release_date << ")" << endl;
1083         lyxerr << "Built on " << __DATE__ << ", " << __TIME__ << endl;
1084
1085         lyxerr << lyx_version_info << endl;
1086         exit(0);
1087         return 0;
1088 }
1089
1090
1091 int parse_sysdir(string const & arg, string const &, string &)
1092 {
1093         if (arg.empty()) {
1094                 Alert::error(_("No system directory"),
1095                         _("Missing directory for -sysdir switch"));
1096                 exit(1);
1097         }
1098         cl_system_support = arg;
1099         return 1;
1100 }
1101
1102
1103 int parse_userdir(string const & arg, string const &, string &)
1104 {
1105         if (arg.empty()) {
1106                 Alert::error(_("No user directory"),
1107                         _("Missing directory for -userdir switch"));
1108                 exit(1);
1109         }
1110         cl_user_support = arg;
1111         return 1;
1112 }
1113
1114
1115 int parse_execute(string const & arg, string const &, string & batch)
1116 {
1117         if (arg.empty()) {
1118                 Alert::error(_("Incomplete command"),
1119                         _("Missing command string after --execute switch"));
1120                 exit(1);
1121         }
1122         batch = arg;
1123         return 1;
1124 }
1125
1126
1127 int parse_export(string const & type, string const &, string & batch)
1128 {
1129         if (type.empty()) {
1130                 lyxerr << to_utf8(_("Missing file type [eg latex, ps...] after "
1131                                          "--export switch")) << endl;
1132                 exit(1);
1133         }
1134         batch = "buffer-export " + type;
1135         use_gui = false;
1136         return 1;
1137 }
1138
1139
1140 int parse_import(string const & type, string const & file, string & batch)
1141 {
1142         if (type.empty()) {
1143                 lyxerr << to_utf8(_("Missing file type [eg latex, ps...] after "
1144                                          "--import switch")) << endl;
1145                 exit(1);
1146         }
1147         if (file.empty()) {
1148                 lyxerr << to_utf8(_("Missing filename for --import")) << endl;
1149                 exit(1);
1150         }
1151
1152         batch = "buffer-import " + type + ' ' + file;
1153         return 2;
1154 }
1155
1156
1157 int parse_geometry(string const & arg1, string const &, string &)
1158 {
1159         geometryArg = arg1;
1160         // don't remove "-geometry", it will be pruned out later in the
1161         // frontend if need be.
1162         return -1;
1163 }
1164
1165
1166 int parse_batch(string const &, string const &, string &)
1167 {
1168         use_gui = false;
1169         return 0;
1170 }
1171
1172
1173 int parse_noremote(string const &, string const &, string &)
1174 {
1175         run_mode = NEW_INSTANCE;
1176         return 0;
1177 }
1178
1179
1180 int parse_remote(string const &, string const &, string &)
1181 {
1182         run_mode = USE_REMOTE;
1183         return 0;
1184 }
1185
1186
1187 int parse_force(string const & arg, string const &, string &)
1188 {
1189         if (arg == "all") {
1190                 force_overwrite = ALL_FILES;
1191                 return 1;
1192         } else if (arg == "main") {
1193                 force_overwrite = MAIN_FILE;
1194                 return 1;
1195         } else if (arg == "none") {
1196                 force_overwrite = NO_FILES;
1197                 return 1;
1198         }
1199         force_overwrite = ALL_FILES;
1200         return 0;
1201 }
1202
1203
1204 } // namespace anon
1205
1206
1207 void LyX::easyParse(int & argc, char * argv[])
1208 {
1209         map<string, cmd_helper> cmdmap;
1210
1211         cmdmap["-dbg"] = parse_dbg;
1212         cmdmap["-help"] = parse_help;
1213         cmdmap["--help"] = parse_help;
1214         cmdmap["-version"] = parse_version;
1215         cmdmap["--version"] = parse_version;
1216         cmdmap["-sysdir"] = parse_sysdir;
1217         cmdmap["-userdir"] = parse_userdir;
1218         cmdmap["-x"] = parse_execute;
1219         cmdmap["--execute"] = parse_execute;
1220         cmdmap["-e"] = parse_export;
1221         cmdmap["--export"] = parse_export;
1222         cmdmap["-i"] = parse_import;
1223         cmdmap["--import"] = parse_import;
1224         cmdmap["-geometry"] = parse_geometry;
1225         cmdmap["-batch"] = parse_batch;
1226         cmdmap["-f"] = parse_force;
1227         cmdmap["--force-overwrite"] = parse_force;
1228         cmdmap["-n"] = parse_noremote;
1229         cmdmap["--no-remote"] = parse_noremote;
1230         cmdmap["-r"] = parse_remote;
1231         cmdmap["--remote"] = parse_remote;
1232
1233         for (int i = 1; i < argc; ++i) {
1234                 map<string, cmd_helper>::const_iterator it
1235                         = cmdmap.find(argv[i]);
1236
1237                 // don't complain if not found - may be parsed later
1238                 if (it == cmdmap.end())
1239                         continue;
1240
1241                 string const arg =
1242                         (i + 1 < argc) ? os::utf8_argv(i + 1) : string();
1243                 string const arg2 =
1244                         (i + 2 < argc) ? os::utf8_argv(i + 2) : string();
1245
1246                 string batch;
1247                 int const remove = 1 + it->second(arg, arg2, batch);
1248                 if (!batch.empty())
1249                         pimpl_->batch_commands.push_back(batch);
1250
1251                 // Now, remove used arguments by shifting
1252                 // the following ones remove places down.
1253                 if (remove > 0) {
1254                         os::remove_internal_args(i, remove);
1255                         argc -= remove;
1256                         for (int j = i; j < argc; ++j)
1257                                 argv[j] = argv[j + remove];
1258                         --i;
1259                 }
1260         }
1261 }
1262
1263
1264 FuncStatus getStatus(FuncRequest const & action)
1265 {
1266         LASSERT(theApp(), /**/);
1267         return theApp()->getStatus(action);
1268 }
1269
1270
1271 void dispatch(FuncRequest const & action)
1272 {
1273         LASSERT(theApp(), /**/);
1274         return theApp()->dispatch(action);
1275 }
1276
1277
1278 void dispatch(FuncRequest const & action, DispatchResult & dr)
1279 {
1280         LASSERT(theApp(), /**/);
1281         return theApp()->dispatch(action, dr);
1282 }
1283
1284
1285 vector<string> & theFilesToLoad()
1286 {
1287         LASSERT(singleton_, /**/);
1288         return singleton_->pimpl_->files_to_load_;
1289 }
1290
1291
1292 BufferList & theBufferList()
1293 {
1294         LASSERT(singleton_, /**/);
1295         return singleton_->pimpl_->buffer_list_;
1296 }
1297
1298
1299 Server & theServer()
1300 {
1301         // FIXME: this should not be use_gui dependent
1302         LASSERT(use_gui, /**/);
1303         LASSERT(singleton_, /**/);
1304         return *singleton_->pimpl_->lyx_server_.get();
1305 }
1306
1307
1308 ServerSocket & theServerSocket()
1309 {
1310         // FIXME: this should not be use_gui dependent
1311         LASSERT(use_gui, /**/);
1312         LASSERT(singleton_, /**/);
1313         return *singleton_->pimpl_->lyx_socket_.get();
1314 }
1315
1316
1317 KeyMap & theTopLevelKeymap()
1318 {
1319         LASSERT(singleton_, /**/);
1320         return singleton_->pimpl_->toplevel_keymap_;
1321 }
1322
1323
1324 Converters & theConverters()
1325 {
1326         LASSERT(singleton_, /**/);
1327         return  singleton_->pimpl_->converters_;
1328 }
1329
1330
1331 Converters & theSystemConverters()
1332 {
1333         LASSERT(singleton_, /**/);
1334         return  singleton_->pimpl_->system_converters_;
1335 }
1336
1337
1338 Movers & theMovers()
1339 {
1340         LASSERT(singleton_, /**/);
1341         return singleton_->pimpl_->movers_;
1342 }
1343
1344
1345 Mover const & getMover(string  const & fmt)
1346 {
1347         LASSERT(singleton_, /**/);
1348         return singleton_->pimpl_->movers_(fmt);
1349 }
1350
1351
1352 void setMover(string const & fmt, string const & command)
1353 {
1354         LASSERT(singleton_, /**/);
1355         singleton_->pimpl_->movers_.set(fmt, command);
1356 }
1357
1358
1359 Movers & theSystemMovers()
1360 {
1361         LASSERT(singleton_, /**/);
1362         return singleton_->pimpl_->system_movers_;
1363 }
1364
1365
1366 Messages const & getMessages(string const & language)
1367 {
1368         LASSERT(singleton_, /**/);
1369         return singleton_->messages(language);
1370 }
1371
1372
1373 Messages const & getGuiMessages()
1374 {
1375         LASSERT(singleton_, /**/);
1376         return singleton_->pimpl_->messages_["GUI"];
1377 }
1378
1379
1380 graphics::Previews & thePreviews()
1381 {
1382         LASSERT(singleton_, /**/);
1383         return singleton_->pimpl_->preview_;
1384 }
1385
1386
1387 Session & theSession()
1388 {
1389         LASSERT(singleton_, /**/);
1390         return *singleton_->pimpl_->session_.get();
1391 }
1392
1393
1394 CmdDef & theTopLevelCmdDef()
1395 {
1396         LASSERT(singleton_, /**/);
1397         return singleton_->pimpl_->toplevel_cmddef_;
1398 }
1399
1400
1401 SpellChecker * theSpellChecker()
1402 {
1403         if (!singleton_->pimpl_->spell_checker_)
1404                 setSpellChecker();
1405         return singleton_->pimpl_->spell_checker_;
1406 }
1407
1408
1409 void setSpellChecker()
1410 {
1411         SpellChecker::ChangeNumber speller_change_number =singleton_->pimpl_->spell_checker_ ?
1412                 singleton_->pimpl_->spell_checker_->changeNumber() : 0;
1413
1414         if (lyxrc.spellchecker == "native") {
1415 #if defined(USE_MACOSX_PACKAGING)
1416                 if (!singleton_->pimpl_->apple_spell_checker_)
1417                         singleton_->pimpl_->apple_spell_checker_ = new AppleSpellChecker();
1418                 singleton_->pimpl_->spell_checker_ = singleton_->pimpl_->apple_spell_checker_;
1419 #else
1420                 singleton_->pimpl_->spell_checker_ = 0;
1421 #endif
1422         } else if (lyxrc.spellchecker == "aspell") {
1423 #if defined(USE_ASPELL)
1424                 if (!singleton_->pimpl_->aspell_checker_)
1425                         singleton_->pimpl_->aspell_checker_ = new AspellChecker();
1426                 singleton_->pimpl_->spell_checker_ = singleton_->pimpl_->aspell_checker_;
1427 #else
1428                 singleton_->pimpl_->spell_checker_ = 0;
1429 #endif
1430         } else if (lyxrc.spellchecker == "enchant") {
1431 #if defined(USE_ENCHANT)
1432                 if (!singleton_->pimpl_->enchant_checker_)
1433                         singleton_->pimpl_->enchant_checker_ = new EnchantChecker();
1434                 singleton_->pimpl_->spell_checker_ = singleton_->pimpl_->enchant_checker_;
1435 #else
1436                 singleton_->pimpl_->spell_checker_ = 0;
1437 #endif
1438         } else if (lyxrc.spellchecker == "hunspell") {
1439 #if defined(USE_HUNSPELL)
1440                 if (!singleton_->pimpl_->hunspell_checker_)
1441                         singleton_->pimpl_->hunspell_checker_ = new HunspellChecker();
1442                 singleton_->pimpl_->spell_checker_ = singleton_->pimpl_->hunspell_checker_;
1443 #else
1444                 singleton_->pimpl_->spell_checker_ = 0;
1445 #endif
1446         } else {
1447                 singleton_->pimpl_->spell_checker_ = 0;
1448         }
1449         if (singleton_->pimpl_->spell_checker_) {
1450                 singleton_->pimpl_->spell_checker_->changeNumber(speller_change_number);
1451                 singleton_->pimpl_->spell_checker_->advanceChangeNumber();
1452         }
1453 }
1454
1455 } // namespace lyx