src/LyX.cpp

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