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 using only the defaults, or continue."),
 556                         0, 2,
 557                         _("&Reconfigure"),
 558                         _("&Use Defaults"),
 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"))
 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)
 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, "Found in " << lyxrc_path);
 970                 if (lyxrc.read(lyxrc_path) < 0) {
 971                         showFileError(name);
 972                         return false;
 973                 }
 974         } else {
 975                 LYXERR(Debug::INIT, "Not found." << lyxrc_path);
 976         }
 977         return true;
 978 }
 979
 980 // Read the languages file `name'
 981 bool LyX::readLanguagesFile(string const & name)
 982 {
 983         LYXERR(Debug::INIT, "About to read " << name << "...");
 984
 985         FileName const lang_path = libFileSearch(string(), name);
 986         if (lang_path.empty()) {
 987                 showFileError(name);
 988                 return false;
 989         }
 990         languages.read(lang_path);
 991         return true;
 992 }
 993
 994
 995 // Read the encodings file `name'
 996 bool LyX::readEncodingsFile(string const & enc_name,
 997                             string const & symbols_name)
 998 {
 999         LYXERR(Debug::INIT, "About to read " << enc_name << " and "
1000                             << symbols_name << "...");
1001
1002         FileName const symbols_path = libFileSearch(string(), symbols_name);
1003         if (symbols_path.empty()) {
1004                 showFileError(symbols_name);
1005                 return false;
1006         }
1007
1008         FileName const enc_path = libFileSearch(string(), enc_name);
1009         if (enc_path.empty()) {
1010                 showFileError(enc_name);
1011                 return false;
1012         }
1013         encodings.read(enc_path, symbols_path);
1014         return true;
1015 }
1016
1017
1018 namespace {
1019
1020 /// return the the number of arguments consumed
1021 typedef boost::function<int(string const &, string const &, string &)> cmd_helper;
1022
1023 int parse_dbg(string const & arg, string const &, string &)
1024 {
1025         if (arg.empty()) {
1026                 lyxerr << to_utf8(_("List of supported debug flags:")) << endl;
1027                 Debug::showTags(lyxerr);
1028                 exit(0);
1029         }
1030         lyxerr << to_utf8(bformat(_("Setting debug level to %1$s"), from_utf8(arg))) << endl;
1031
1032         lyxerr.setLevel(Debug::value(arg));
1033         Debug::showLevel(lyxerr, lyxerr.level());
1034         return 1;
1035 }
1036
1037
1038 int parse_help(string const &, string const &, string &)
1039 {
1040         lyxerr <<
1041                 to_utf8(_("Usage: lyx [ command line switches ] [ name.lyx ... ]\n"
1042                   "Command line switches (case sensitive):\n"
1043                   "\t-help              summarize LyX usage\n"
1044                   "\t-userdir dir       set user directory to dir\n"
1045                   "\t-sysdir dir        set system directory to dir\n"
1046                   "\t-geometry WxH+X+Y  set geometry of the main window\n"
1047                   "\t-dbg feature[,feature]...\n"
1048                   "                  select the features to debug.\n"
1049                   "                  Type `lyx -dbg' to see the list of features\n"
1050                   "\t-x [--execute] command\n"
1051                   "                  where command is a lyx command.\n"
1052                   "\t-e [--export] fmt\n"
1053                   "                  where fmt is the export format of choice.\n"
1054                   "                  Look on Tools->Preferences->File formats->Format\n"
1055                   "                  to get an idea which parameters should be passed.\n"
1056                   "                  Note that the order of -e and -x switches matters.\n"
1057                   "\t-i [--import] fmt file.xxx\n"
1058                   "                  where fmt is the import format of choice\n"
1059                   "                  and file.xxx is the file to be imported.\n"
1060                   "\t-f [--force-overwrite] what\n"
1061                   "                  where what is either `all', `main' or `none',\n"
1062                   "                  specifying whether all files, main file only, or no files,\n"
1063                   "                  respectively, are to be overwritten during a batch export.\n"
1064                   "                  Anything else is equivalent to `all', but is not consumed.\n"
1065                   "\t-n [--no-remote]\n"
1066                   "                  open documents in a new instance\n"
1067                   "\t-r [--remote]\n"
1068                   "                  open documents in an already running instance\n"
1069                   "                  (a working lyxpipe is needed)\n"
1070                   "\t-batch    execute commands without launching GUI and exit.\n"
1071                   "\t-version  summarize version and build info\n"
1072                                "Check the LyX man page for more details.")) << endl;
1073         exit(0);
1074         return 0;
1075 }
1076
1077
1078 int parse_version(string const &, string const &, string &)
1079 {
1080         lyxerr << "LyX " << lyx_version
1081                << " (" << lyx_release_date << ")" << endl;
1082         lyxerr << "Built on " << __DATE__ << ", " << __TIME__ << endl;
1083
1084         lyxerr << lyx_version_info << endl;
1085         exit(0);
1086         return 0;
1087 }
1088
1089
1090 int parse_sysdir(string const & arg, string const &, string &)
1091 {
1092         if (arg.empty()) {
1093                 Alert::error(_("No system directory"),
1094                         _("Missing directory for -sysdir switch"));
1095                 exit(1);
1096         }
1097         cl_system_support = arg;
1098         return 1;
1099 }
1100
1101
1102 int parse_userdir(string const & arg, string const &, string &)
1103 {
1104         if (arg.empty()) {
1105                 Alert::error(_("No user directory"),
1106                         _("Missing directory for -userdir switch"));
1107                 exit(1);
1108         }
1109         cl_user_support = arg;
1110         return 1;
1111 }
1112
1113
1114 int parse_execute(string const & arg, string const &, string & batch)
1115 {
1116         if (arg.empty()) {
1117                 Alert::error(_("Incomplete command"),
1118                         _("Missing command string after --execute switch"));
1119                 exit(1);
1120         }
1121         batch = arg;
1122         return 1;
1123 }
1124
1125
1126 int parse_export(string const & type, string const &, string & batch)
1127 {
1128         if (type.empty()) {
1129                 lyxerr << to_utf8(_("Missing file type [eg latex, ps...] after "
1130                                          "--export switch")) << endl;
1131                 exit(1);
1132         }
1133         batch = "buffer-export " + type;
1134         use_gui = false;
1135         return 1;
1136 }
1137
1138
1139 int parse_import(string const & type, string const & file, string & batch)
1140 {
1141         if (type.empty()) {
1142                 lyxerr << to_utf8(_("Missing file type [eg latex, ps...] after "
1143                                          "--import switch")) << endl;
1144                 exit(1);
1145         }
1146         if (file.empty()) {
1147                 lyxerr << to_utf8(_("Missing filename for --import")) << endl;
1148                 exit(1);
1149         }
1150
1151         batch = "buffer-import " + type + ' ' + file;
1152         return 2;
1153 }
1154
1155
1156 int parse_geometry(string const & arg1, string const &, string &)
1157 {
1158         geometryArg = arg1;
1159         // don't remove "-geometry", it will be pruned out later in the
1160         // frontend if need be.
1161         return -1;
1162 }
1163
1164
1165 int parse_batch(string const &, string const &, string &)
1166 {
1167         use_gui = false;
1168         return 0;
1169 }
1170
1171
1172 int parse_noremote(string const &, string const &, string &)
1173 {
1174         run_mode = NEW_INSTANCE;
1175         return 0;
1176 }
1177
1178
1179 int parse_remote(string const &, string const &, string &)
1180 {
1181         run_mode = USE_REMOTE;
1182         return 0;
1183 }
1184
1185
1186 int parse_force(string const & arg, string const &, string &)
1187 {
1188         if (arg == "all") {
1189                 force_overwrite = ALL_FILES;
1190                 return 1;
1191         } else if (arg == "main") {
1192                 force_overwrite = MAIN_FILE;
1193                 return 1;
1194         } else if (arg == "none") {
1195                 force_overwrite = NO_FILES;
1196                 return 1;
1197         }
1198         force_overwrite = ALL_FILES;
1199         return 0;
1200 }
1201
1202
1203 } // namespace anon
1204
1205
1206 void LyX::easyParse(int & argc, char * argv[])
1207 {
1208         map<string, cmd_helper> cmdmap;
1209
1210         cmdmap["-dbg"] = parse_dbg;
1211         cmdmap["-help"] = parse_help;
1212         cmdmap["--help"] = parse_help;
1213         cmdmap["-version"] = parse_version;
1214         cmdmap["--version"] = parse_version;
1215         cmdmap["-sysdir"] = parse_sysdir;
1216         cmdmap["-userdir"] = parse_userdir;
1217         cmdmap["-x"] = parse_execute;
1218         cmdmap["--execute"] = parse_execute;
1219         cmdmap["-e"] = parse_export;
1220         cmdmap["--export"] = parse_export;
1221         cmdmap["-i"] = parse_import;
1222         cmdmap["--import"] = parse_import;
1223         cmdmap["-geometry"] = parse_geometry;
1224         cmdmap["-batch"] = parse_batch;
1225         cmdmap["-f"] = parse_force;
1226         cmdmap["--force-overwrite"] = parse_force;
1227         cmdmap["-n"] = parse_noremote;
1228         cmdmap["--no-remote"] = parse_noremote;
1229         cmdmap["-r"] = parse_remote;
1230         cmdmap["--remote"] = parse_remote;
1231
1232         for (int i = 1; i < argc; ++i) {
1233                 map<string, cmd_helper>::const_iterator it
1234                         = cmdmap.find(argv[i]);
1235
1236                 // don't complain if not found - may be parsed later
1237                 if (it == cmdmap.end())
1238                         continue;
1239
1240                 string const arg =
1241                         (i + 1 < argc) ? os::utf8_argv(i + 1) : string();
1242                 string const arg2 =
1243                         (i + 2 < argc) ? os::utf8_argv(i + 2) : string();
1244
1245                 string batch;
1246                 int const remove = 1 + it->second(arg, arg2, batch);
1247                 if (!batch.empty())
1248                         pimpl_->batch_commands.push_back(batch);
1249
1250                 // Now, remove used arguments by shifting
1251                 // the following ones remove places down.
1252                 if (remove > 0) {
1253                         os::remove_internal_args(i, remove);
1254                         argc -= remove;
1255                         for (int j = i; j < argc; ++j)
1256                                 argv[j] = argv[j + remove];
1257                         --i;
1258                 }
1259         }
1260 }
1261
1262
1263 FuncStatus getStatus(FuncRequest const & action)
1264 {
1265         LASSERT(theApp(), /**/);
1266         return theApp()->getStatus(action);
1267 }
1268
1269
1270 void dispatch(FuncRequest const & action)
1271 {
1272         LASSERT(theApp(), /**/);
1273         return theApp()->dispatch(action);
1274 }
1275
1276
1277 void dispatch(FuncRequest const & action, DispatchResult & dr)
1278 {
1279         LASSERT(theApp(), /**/);
1280         return theApp()->dispatch(action, dr);
1281 }
1282
1283
1284 vector<string> & theFilesToLoad()
1285 {
1286         LASSERT(singleton_, /**/);
1287         return singleton_->pimpl_->files_to_load_;
1288 }
1289
1290
1291 BufferList & theBufferList()
1292 {
1293         LASSERT(singleton_, /**/);
1294         return singleton_->pimpl_->buffer_list_;
1295 }
1296
1297
1298 Server & theServer()
1299 {
1300         // FIXME: this should not be use_gui dependent
1301         LASSERT(use_gui, /**/);
1302         LASSERT(singleton_, /**/);
1303         return *singleton_->pimpl_->lyx_server_.get();
1304 }
1305
1306
1307 ServerSocket & theServerSocket()
1308 {
1309         // FIXME: this should not be use_gui dependent
1310         LASSERT(use_gui, /**/);
1311         LASSERT(singleton_, /**/);
1312         return *singleton_->pimpl_->lyx_socket_.get();
1313 }
1314
1315
1316 KeyMap & theTopLevelKeymap()
1317 {
1318         LASSERT(singleton_, /**/);
1319         return singleton_->pimpl_->toplevel_keymap_;
1320 }
1321
1322
1323 Converters & theConverters()
1324 {
1325         LASSERT(singleton_, /**/);
1326         return  singleton_->pimpl_->converters_;
1327 }
1328
1329
1330 Converters & theSystemConverters()
1331 {
1332         LASSERT(singleton_, /**/);
1333         return  singleton_->pimpl_->system_converters_;
1334 }
1335
1336
1337 Movers & theMovers()
1338 {
1339         LASSERT(singleton_, /**/);
1340         return singleton_->pimpl_->movers_;
1341 }
1342
1343
1344 Mover const & getMover(string  const & fmt)
1345 {
1346         LASSERT(singleton_, /**/);
1347         return singleton_->pimpl_->movers_(fmt);
1348 }
1349
1350
1351 void setMover(string const & fmt, string const & command)
1352 {
1353         LASSERT(singleton_, /**/);
1354         singleton_->pimpl_->movers_.set(fmt, command);
1355 }
1356
1357
1358 Movers & theSystemMovers()
1359 {
1360         LASSERT(singleton_, /**/);
1361         return singleton_->pimpl_->system_movers_;
1362 }
1363
1364
1365 Messages const & getMessages(string const & language)
1366 {
1367         LASSERT(singleton_, /**/);
1368         return singleton_->messages(language);
1369 }
1370
1371
1372 Messages const & getGuiMessages()
1373 {
1374         LASSERT(singleton_, /**/);
1375         return singleton_->pimpl_->messages_["GUI"];
1376 }
1377
1378
1379 graphics::Previews & thePreviews()
1380 {
1381         LASSERT(singleton_, /**/);
1382         return singleton_->pimpl_->preview_;
1383 }
1384
1385
1386 Session & theSession()
1387 {
1388         LASSERT(singleton_, /**/);
1389         return *singleton_->pimpl_->session_.get();
1390 }
1391
1392
1393 CmdDef & theTopLevelCmdDef()
1394 {
1395         LASSERT(singleton_, /**/);
1396         return singleton_->pimpl_->toplevel_cmddef_;
1397 }
1398
1399
1400 SpellChecker * theSpellChecker()
1401 {
1402         if (!singleton_->pimpl_->spell_checker_)
1403                 setSpellChecker();
1404         return singleton_->pimpl_->spell_checker_;
1405 }
1406
1407
1408 void setSpellChecker()
1409 {
1410         SpellChecker::ChangeNumber speller_change_number =singleton_->pimpl_->spell_checker_ ?
1411                 singleton_->pimpl_->spell_checker_->changeNumber() : 0;
1412
1413         if (lyxrc.spellchecker == "native") {
1414 #if defined(USE_MACOSX_PACKAGING)
1415                 if (!singleton_->pimpl_->apple_spell_checker_)
1416                         singleton_->pimpl_->apple_spell_checker_ = new AppleSpellChecker();
1417                 singleton_->pimpl_->spell_checker_ = singleton_->pimpl_->apple_spell_checker_;
1418 #else
1419                 singleton_->pimpl_->spell_checker_ = 0;
1420 #endif
1421         } else if (lyxrc.spellchecker == "aspell") {
1422 #if defined(USE_ASPELL)
1423                 if (!singleton_->pimpl_->aspell_checker_)
1424                         singleton_->pimpl_->aspell_checker_ = new AspellChecker();
1425                 singleton_->pimpl_->spell_checker_ = singleton_->pimpl_->aspell_checker_;
1426 #else
1427                 singleton_->pimpl_->spell_checker_ = 0;
1428 #endif
1429         } else if (lyxrc.spellchecker == "enchant") {
1430 #if defined(USE_ENCHANT)
1431                 if (!singleton_->pimpl_->enchant_checker_)
1432                         singleton_->pimpl_->enchant_checker_ = new EnchantChecker();
1433                 singleton_->pimpl_->spell_checker_ = singleton_->pimpl_->enchant_checker_;
1434 #else
1435                 singleton_->pimpl_->spell_checker_ = 0;
1436 #endif
1437         } else if (lyxrc.spellchecker == "hunspell") {
1438 #if defined(USE_HUNSPELL)
1439                 if (!singleton_->pimpl_->hunspell_checker_)
1440                         singleton_->pimpl_->hunspell_checker_ = new HunspellChecker();
1441                 singleton_->pimpl_->spell_checker_ = singleton_->pimpl_->hunspell_checker_;
1442 #else
1443                 singleton_->pimpl_->spell_checker_ = 0;
1444 #endif
1445         } else {
1446                 singleton_->pimpl_->spell_checker_ = 0;
1447         }
1448         if (singleton_->pimpl_->spell_checker_) {
1449                 singleton_->pimpl_->spell_checker_->changeNumber(speller_change_number);
1450                 singleton_->pimpl_->spell_checker_->advanceChangeNumber();
1451         }
1452 }
1453
1454 } // namespace lyx