#include "Buffer.h"
#include "BufferList.h"
#include "CmdDef.h"
+#include "CiteEnginesList.h"
#include "ColorSet.h"
#include "ConverterCache.h"
#include "Converter.h"
#include "CutAndPaste.h"
+#include "DispatchResult.h"
#include "EnchantChecker.h"
#include "Encoding.h"
#include "ErrorList.h"
#include "FuncStatus.h"
#include "HunspellChecker.h"
#include "KeyMap.h"
+#include "Language.h"
#include "LaTeXFonts.h"
#include "LayoutFile.h"
-#include "Lexer.h"
-#include "LyX.h"
#include "LyXAction.h"
#include "LyXRC.h"
#include "ModuleList.h"
#include "Server.h"
#include "ServerSocket.h"
#include "Session.h"
-#include "WordList.h"
#include "frontends/alert.h"
#include "frontends/Application.h"
+#include "support/ConsoleApplication.h"
+#include "support/convert.h"
#include "support/lassert.h"
#include "support/debug.h"
#include "support/environment.h"
#include "support/Messages.h"
#include "support/os.h"
#include "support/Package.h"
-#include "support/PathChanger.h"
-#include "support/Systemcall.h"
-
-#include "support/bind.h"
-#include <boost/scoped_ptr.hpp>
+#include "support/unique_ptr.h"
-#include <algorithm>
-#include <iostream>
#include <csignal>
+#include <iostream>
+#include <functional>
#include <map>
#include <stdlib.h>
#include <string>
#include <vector>
+#include <qglobal.h> // For QT_VERSION
+
using namespace std;
using namespace lyx::support;
+#if defined (USE_MACOSX_PACKAGING)
+#include <crt_externs.h>
+#endif
+
namespace lyx {
namespace Alert = frontend::Alert;
bool use_gui = true;
+// Report on the terminal about spawned commands. The default is false
+// and can be changed with the option -v (--verbose).
+
+bool verbose = false;
+
+
+// Do not treat the "missing glyphs" warning of fontspec as an error message.
+// The default is false and can be changed with the option
+// --ignore-error-message missing_glyphs
+// This is used in automated testing.
+bool ignore_missing_glyphs = false;
+
+
// We default to open documents in an already running instance, provided that
// the lyxpipe has been setup. This can be overridden either on the command
// line or through preference settings.
OverwriteFiles force_overwrite = UNSPECIFIED;
+// Scale the GUI by this factor. This works whether we have a HiDpi screen
+// or not and scales everything, also fonts. Can only be changed by setting
+// the QT_SCALE_FACTOR environment variable before launching LyX and only
+// works properly with Qt 5.6 or higher.
+
+double qt_scale_factor = 1.0;
+
+
namespace {
// Filled with the command line arguments "foo" of "-sysdir foo" or
string geometryArg;
-LyX * singleton_ = 0;
+LyX * singleton_ = nullptr;
void showFileError(string const & error)
{
"Please check your installation."), from_utf8(error)));
}
-
-void reconfigureUserLyXDir()
-{
- string const configure_command = package().configure_command();
-
- lyxerr << to_utf8(_("LyX: reconfiguring user directory")) << endl;
- PathChanger p(package().user_support());
- Systemcall one;
- one.startscript(Systemcall::Wait, configure_command);
- lyxerr << "LyX: " << to_utf8(_("Done!")) << endl;
-}
-
-} // namespace anon
+} // namespace
/// The main application class private implementation.
struct LyX::Impl {
Impl()
- : latexfonts_(0), spell_checker_(0), apple_spell_checker_(0), aspell_checker_(0), enchant_checker_(0), hunspell_checker_(0)
+ : latexfonts_(nullptr), spell_checker_(nullptr),
+ apple_spell_checker_(nullptr), aspell_checker_(nullptr),
+ enchant_checker_(nullptr), hunspell_checker_(nullptr)
{}
~Impl()
///
CmdDef toplevel_cmddef_;
///
- boost::scoped_ptr<Server> lyx_server_;
+ unique_ptr<Server> lyx_server_;
///
- boost::scoped_ptr<ServerSocket> lyx_socket_;
+ unique_ptr<ServerSocket> lyx_socket_;
///
- boost::scoped_ptr<frontend::Application> application_;
+ unique_ptr<frontend::Application> application_;
/// lyx session, containing lastfiles, lastfilepos, and lastopened
- boost::scoped_ptr<Session> session_;
+ unique_ptr<Session> session_;
/// Files to load at start.
vector<string> files_to_load_;
/// The file converters.
Converters converters_;
-
- // The system converters copy after reading lyxrc.defaults.
+ /// The system converters after reading lyxrc.defaults.
Converters system_converters_;
+ /// Global format information
+ Formats formats_;
+ /// The system formats after reading lyxrc.defaults.
+ Formats system_formats_;
+
+
///
Movers movers_;
///
Movers system_movers_;
- /// has this user started lyx for the first time?
- bool first_start;
/// the parsed command line batch command if any
vector<string> batch_commands;
};
+/// The main application class for console mode
+class LyXConsoleApp : public ConsoleApplication
+{
+public:
+ LyXConsoleApp(LyX * lyx, int & argc, char * argv[])
+ : ConsoleApplication(lyx_package, argc, argv), lyx_(lyx),
+ argc_(argc), argv_(argv)
+ {
+ }
+ void doExec() override
+ {
+ int const exit_status = lyx_->execWithoutGui(argc_, argv_);
+ exit(exit_status);
+ }
+private:
+ LyX * lyx_;
+ int & argc_;
+ char ** argv_;
+};
+
+
///
frontend::Application * theApp()
{
if (singleton_)
return singleton_->pimpl_->application_.get();
else
- return 0;
+ return nullptr;
}
LyX::~LyX()
{
delete pimpl_;
- singleton_ = 0;
- WordList::cleanupWordLists();
+ singleton_ = nullptr;
}
// we need to parse for "-dbg" and "-help"
easyParse(argc, argv);
+#if QT_VERSION >= 0x050600
+ // Check whether Qt will scale all GUI elements and accordingly
+ // set the scale factor so that to avoid blurred images and text
+ char const * const scale_factor = getenv("QT_SCALE_FACTOR");
+ if (scale_factor) {
+ qt_scale_factor = convert<double>(scale_factor);
+ if (qt_scale_factor < 1.0)
+ qt_scale_factor = 1.0;
+ }
+#endif
+
try {
init_package(os::utf8_argv(0), cl_system_support, cl_user_support);
} catch (ExceptionMessage const & message) {
setLocale();
if (!use_gui) {
- // FIXME: create a ConsoleApplication
- int exit_status = init(argc, argv);
- if (exit_status) {
- prepareExit();
- return exit_status;
- }
+ LyXConsoleApp app(this, argc, argv);
- // this is correct, since return values are inverted.
- exit_status = !loadFiles();
-
- if (pimpl_->batch_commands.empty() || pimpl_->buffer_list_.empty()) {
- prepareExit();
- return exit_status;
- }
+ // Reestablish our defaults, as Qt overwrites them
+ // after creating app
+ setLocale();//???
- BufferList::iterator begin = pimpl_->buffer_list_.begin();
-
- bool final_success = false;
- for (BufferList::iterator I = begin; I != pimpl_->buffer_list_.end(); ++I) {
- Buffer * buf = *I;
- if (buf != buf->masterBuffer())
- continue;
- vector<string>::const_iterator bcit = pimpl_->batch_commands.begin();
- vector<string>::const_iterator bcend = pimpl_->batch_commands.end();
- DispatchResult dr;
- for (; bcit != bcend; ++bcit) {
- LYXERR(Debug::ACTION, "Buffer::dispatch: cmd: " << *bcit);
- buf->dispatch(*bcit, dr);
- final_success |= !dr.error();
- }
- }
- prepareExit();
- return !final_success;
+ return app.exec();
}
// Let the frontend parse and remove all arguments that it knows
// FIXME
/* Create a CoreApplication class that will provide the main event loop
- * and the socket callback registering. With Qt4, only QtCore
+ * and the socket callback registering. With Qt, only QtCore
* library would be needed.
* When this is done, a server_mode could be created and the following two
* line would be moved out from here.
FileName(package().temp_dir().absFileName() + "/lyxsocket")));
// Start the real execution loop.
- if (!theServer().deferredLoadingToOtherInstance())
+ if (!pimpl_->lyx_server_->deferredLoadingToOtherInstance())
exit_status = pimpl_->application_->exec();
else if (!pimpl_->files_to_load_.empty()) {
- vector<string>::const_iterator it = pimpl_->files_to_load_.begin();
- vector<string>::const_iterator end = pimpl_->files_to_load_.end();
lyxerr << _("The following files could not be loaded:") << endl;
- for (; it != end; ++it)
- lyxerr << *it << endl;
+ for (auto const & f : pimpl_->files_to_load_)
+ lyxerr << f << endl;
}
prepareExit();
// Write the index file of the converter cache
ConverterCache::get().writeIndex();
- // close buffers first
- pimpl_->buffer_list_.closeAll();
+ // closing buffer may throw exceptions, but we ignore them since we
+ // are quitting.
+ try {
+ // close buffers first
+ pimpl_->buffer_list_.closeAll();
+ } catch (ExceptionMessage const &) {}
// register session changes and shutdown server and socket
if (use_gui) {
// do any other cleanup procedures now
if (package().temp_dir() != package().system_temp_dir()) {
string const abs_tmpdir = package().temp_dir().absFileName();
- if (!contains(package().temp_dir().absFileName(), "lyx_tmpdir")) {
+ if (!contains(abs_tmpdir, "lyx_tmpdir")) {
docstring const msg =
bformat(_("%1$s does not appear like a LyX created temporary directory."),
from_utf8(abs_tmpdir));
Alert::warning(_("Cannot remove temporary directory"), msg);
} else {
- LYXERR(Debug::INFO, "Deleting tmp dir "
- << package().temp_dir().absFileName());
+ LYXERR(Debug::INFO, "Deleting tmp dir " << abs_tmpdir);
if (!package().temp_dir().destroyDirectory()) {
- docstring const msg =
- bformat(_("Unable to remove the temporary directory %1$s"),
- from_utf8(package().temp_dir().absFileName()));
- Alert::warning(_("Unable to remove temporary directory"), msg);
+ LYXERR0(bformat(_("Unable to remove the temporary directory %1$s"),
+ from_utf8(abs_tmpdir)));
}
}
}
if (first_start) {
pimpl_->files_to_load_.push_back(
- i18nLibFileSearch("examples", "splash.lyx").absFileName());
+ i18nLibFileSearch("examples", "Welcome.lyx").absFileName());
}
return EXIT_SUCCESS;
}
-bool LyX::loadFiles()
+int LyX::execWithoutGui(int & argc, char * argv[])
{
- LATTEST(!use_gui);
- bool success = true;
+ int exit_status = init(argc, argv);
+ if (exit_status) {
+ prepareExit();
+ return exit_status;
+ }
+
+ // Used to keep track of which buffers were explicitly loaded by user request.
+ // This is necessary because master and child document buffers are loaded, even
+ // if they were not named on the command line. We do not want to dispatch to
+ // those.
+ vector<Buffer *> command_line_buffers;
+
+ // Load the files specified on the command line
vector<string>::const_iterator it = pimpl_->files_to_load_.begin();
vector<string>::const_iterator end = pimpl_->files_to_load_.end();
-
for (; it != end; ++it) {
- // get absolute path of file and add ".lyx" to
- // the filename if necessary
+ // get absolute path of file and add ".lyx" to the filename if necessary
FileName fname = fileSearch(string(), os::internal_path(*it), "lyx",
- may_not_exist);
+ may_not_exist);
if (fname.empty())
continue;
Buffer * buf = pimpl_->buffer_list_.newBuffer(fname.absFileName());
- if (buf->loadLyXFile() == Buffer::ReadSuccess) {
+ LYXERR(Debug::FILES, "Loading " << fname);
+ if (buf && buf->loadLyXFile() == Buffer::ReadSuccess) {
ErrorList const & el = buf->errorList("Parse");
- if (!el.empty())
- for_each(el.begin(), el.end(),
- bind(&LyX::printError, this, _1));
- }
- else {
- pimpl_->buffer_list_.release(buf);
+ for(ErrorItem const & e : el)
+ printError(e);
+ command_line_buffers.push_back(buf);
+ } else {
+ if (buf)
+ pimpl_->buffer_list_.release(buf);
docstring const error_message =
- bformat(_("LyX failed to load the following file: %1$s"),
- from_utf8(fname.absFileName()));
+ bformat(_("LyX failed to load the following file: %1$s"),
+ from_utf8(fname.absFileName()));
lyxerr << to_utf8(error_message) << endl;
- success = false;
+ exit_status = 1; // failed
}
}
- return success;
+
+ if (exit_status || pimpl_->batch_commands.empty() || pimpl_->buffer_list_.empty()) {
+ prepareExit();
+ return exit_status;
+ }
+
+ // Iterate through the buffers that were specified on the command line
+ bool final_success = false;
+ vector<Buffer *>::iterator buf_it = command_line_buffers.begin();
+ for (; buf_it != command_line_buffers.end(); ++buf_it) {
+ Buffer * buf = *buf_it;
+ vector<string>::const_iterator bcit = pimpl_->batch_commands.begin();
+ vector<string>::const_iterator bcend = pimpl_->batch_commands.end();
+ DispatchResult dr;
+ for (; bcit != bcend; ++bcit) {
+ LYXERR(Debug::ACTION, "Buffer::dispatch: cmd: " << *bcit);
+ buf->dispatch(*bcit, dr);
+ final_success |= !dr.error();
+ }
+ }
+ prepareExit();
+ return !final_success;
}
{
// The advantage of doing this here is that the event loop
// is already started. So any need for interaction will be
- // aknowledged.
+ // acknowledged.
// if reconfiguration is needed.
- if (LayoutFileList::get().empty()) {
+ const bool noLayouts = LayoutFileList::get().empty();
+ if (noLayouts && os::hasPython()) {
switch (Alert::prompt(
_("No textclass is found"),
_("LyX will only have minimal functionality because no textclasses "
0, 2,
_("&Reconfigure"),
_("&Without LaTeX"),
- _("&Continue")))
+ _("&Continue"),
+ _("&Exit LyX")))
{
case 0:
// regular reconfigure
lyx::dispatch(FuncRequest(LFUN_RECONFIGURE,
" --without-latex-config"));
break;
+ case 3:
+ lyx::dispatch(FuncRequest(LFUN_LYX_QUIT, ""));
+ return;
+ default:
+ break;
+ }
+ } else if (noLayouts) {
+ switch (Alert::prompt(
+ _("No python is found"),
+ _("LyX will only have minimal functionality because no python interpreter "
+ "has been found. Consider installing python with your software manager "
+ "or from the python.org website."),
+ 0, 1,
+ _("&Continue"),
+ _("&Exit LyX")))
+ {
+ case 1:
+ lyx::dispatch(FuncRequest(LFUN_LYX_QUIT, ""));
+ return;
default:
break;
}
if (!msg.empty()) {
lyxerr << "\nlyx: " << msg << endl;
// try to make a GUI message
- Alert::error(_("LyX crashed!"), msg);
+ Alert::error(_("LyX crashed!"), msg, true);
}
// Deinstall the signal handlers
cerr << to_utf8(tmp) << endl;
}
+#if defined (USE_MACOSX_PACKAGING)
+namespace {
+ // Unexposed--extract an environment variable name from its NAME=VALUE
+ // representation
+ std::string varname(const char* line)
+ {
+ size_t nameLen = strcspn(line, "=");
+ if (nameLen == strlen(line)) {
+ return std::string();
+ } else {
+ return std::string(line, nameLen);
+ }
+ }
+} // namespace
+
+void cleanDuplicateEnvVars()
+{
+ std::set<std::string> seen;
+ std::set<std::string> dupes;
+
+ // Create a list of the environment variables that appear more than once
+ for (char **read = *_NSGetEnviron(); *read; read++) {
+ std::string name = varname(*read);
+ if (name.size() == 0) {
+ continue;
+ }
+ if (seen.find(name) != seen.end()) {
+ dupes.insert(name);
+ } else {
+ seen.insert(name);
+ }
+ }
+
+ // Loop over the list of duplicated variables
+ std::set<std::string>::iterator dupe = dupes.begin();
+ std::set<std::string>::iterator const dend = dupes.end();
+ for (; dupe != dend; ++dupe) {
+ const char *name = (*dupe).c_str();
+ char *val = getenv(name);
+ if (val != NULL) {
+ LYXERR(Debug::INIT, "Duplicate environment variable: " << name);
+ // unsetenv removes *all* instances of the variable from the environment
+ unsetenv(name);
+
+ // replace with the value from getenv (in practice appears to be the
+ // first value in the list)
+ setenv(name, val, 0);
+ }
+ }
+}
+#endif
+
+
+static void initTemplatePath()
+{
+ FileName const package_template_path =
+ FileName(addName(package().system_support().absFileName(), "templates"));
+
+ if (lyxrc.template_path.empty()) {
+ lyxrc.template_path = package_template_path.absFileName();
+ }
+#if defined (USE_MACOSX_PACKAGING)
+ FileName const user_template_path =
+ FileName(addName(package().user_support().absFileName(), "templates"));
+
+ if (package_template_path != FileName(lyxrc.template_path) &&
+ user_template_path != FileName(lyxrc.template_path))
+ {
+ return;
+ }
+ FileName const user_template_link =
+ FileName(addName(user_template_path.absFileName(),"SystemTemplates"));
+ if (user_template_link.isSymLink() && !equivalent(user_template_link, package_template_path)) {
+ user_template_link.removeFile();
+ }
+ if (!user_template_link.exists()) {
+ if (!package_template_path.link(user_template_link)) {
+ FileName const user_support = package().user_support();
+ if (user_support.exists() && user_support.isDirectory()) {
+ LYXERR(Debug::INIT, "Cannot create symlink " + user_template_link.absFileName());
+ lyxrc.template_path = package_template_path.absFileName();
+ }
+ return;
+ }
+ LYXERR(Debug::INIT, "Symlink \"" << user_template_link.absFileName() << "\" created.");
+ }
+ lyxrc.template_path = user_template_path.absFileName();
+#endif
+}
+
bool LyX::init()
{
signal(SIGTERM, error_handler);
// SIGPIPE can be safely ignored.
+#if defined (USE_MACOSX_PACKAGING)
+ cleanDuplicateEnvVars();
+#endif
+
lyxrc.tempdir_path = package().temp_dir().absFileName();
lyxrc.document_path = package().document_dir().absFileName();
lyxrc.example_path = addPath(package().system_support().absFileName(),
"examples");
}
- if (lyxrc.template_path.empty()) {
- lyxrc.template_path = addPath(package().system_support().absFileName(),
- "templates");
- }
+ initTemplatePath();
// init LyXDir environment variable
string const lyx_dir = package().lyx_dir().absFileName();
return false;
// Set the PATH correctly.
-#if !defined (USE_POSIX_PACKAGING)
+#if !defined (USE_POSIX_PACKAGING) && !defined (USE_HAIKU_PACKAGING)
// Add the directory containing the LyX executable to the path
// so that LyX can find things like tex2lyx.
if (package().build_support().empty())
prependEnvPath("PATH", package().binary_dir().absFileName());
#endif
+ {
+ // Add the directory containing the dt2dv and dv2dt executables to the path
+ FileName dtldir;
+ if (!package().build_support().empty()) {
+ // dtl executables should be in the same dir ar tex2lyx
+ dtldir = package().binary_dir();
+ }
+ else {
+ dtldir = FileName(addName(package().system_support().absFileName(), "extratools"));
+ }
+#if defined(_WIN32)
+ string dtlexe = "dt2dv.exe";
+#else
+ string dtlexe = "dt2dv";
+#endif
+ FileName const dt2dv = FileName(addName(dtldir.absFileName(), dtlexe));
+ if (dt2dv.exists())
+ prependEnvPath("PATH", dtldir.absFileName());
+ }
if (!lyxrc.path_prefix.empty())
prependEnvPath("PATH", replaceEnvironmentPath(lyxrc.path_prefix));
// Check that user LyX directory is ok.
{
- string const lock_file = package().user_support().absFileName() + ".lyx_configure_lock";
+ string const lock_file = package().getConfigureLockName();
int fd = fileLock(lock_file.c_str());
if (queryUserLyXDir(package().explicit_user_support())) {
- reconfigureUserLyXDir();
+ package().reconfigureUserLyXDir("");
+ // Now the user directory is present on first start.
+ initTemplatePath();
}
fileUnlock(fd, lock_file.c_str());
}
return false;
// Query the OS to know what formats are viewed natively
- formats.setAutoOpen();
+ theFormats().setAutoOpen();
// Read lyxrc.dist again to be able to override viewer auto-detection.
readRcFile("lyxrc.dist");
system_lyxrc = lyxrc;
- system_formats = formats;
+ theSystemFormats() = theFormats();
pimpl_->system_converters_ = pimpl_->converters_;
pimpl_->system_movers_ = pimpl_->movers_;
system_lcolor = lcolor;
LYXERR(Debug::INIT, "Reading layouts...");
// Load the layouts
LayoutFileList::get().read();
- //...and the modules
+ //... the modules
theModuleList.read();
+ //... and the cite engines
+ theCiteEnginesList.read();
// read keymap and ui files in batch mode as well
// because InsetInfo needs to know these to produce
pimpl_->toplevel_keymap_.read("site");
pimpl_->toplevel_keymap_.read(lyxrc.bind_file);
// load user bind file user.bind
- pimpl_->toplevel_keymap_.read("user", 0, KeyMap::MissingOK);
+ pimpl_->toplevel_keymap_.read("user", nullptr, KeyMap::MissingOK);
if (lyxerr.debugging(Debug::LYXRC))
lyxrc.print();
os::windows_style_tex_paths(lyxrc.windows_style_tex_paths);
+ // Prepend path prefix a second time to take the user preferences into a account
if (!lyxrc.path_prefix.empty())
prependEnvPath("PATH", replaceEnvironmentPath(lyxrc.path_prefix));
}
-// return true if file does not exist or is older than configure.py.
-static bool needsUpdate(string const & file)
-{
- // We cannot initialize configure_script directly because the package
- // is not initialized yet when static objects are constructed.
- static FileName configure_script;
- static bool firstrun = true;
- if (firstrun) {
- configure_script =
- FileName(addName(package().system_support().absFileName(),
- "configure.py"));
- firstrun = false;
- }
-
- FileName absfile =
- FileName(addName(package().user_support().absFileName(), file));
- return !absfile.exists()
- || configure_script.lastModified() > absfile.lastModified();
-}
-
-
bool LyX::queryUserLyXDir(bool explicit_userdir)
{
// Does user directory exist?
if (sup.exists() && sup.isDirectory()) {
first_start = false;
- return needsUpdate("lyxrc.defaults")
- || needsUpdate("lyxmodules.lst")
- || needsUpdate("textclass.lst")
- || needsUpdate("packages.lst");
+ return configFileNeedsUpdate("lyxrc.defaults")
+ || configFileNeedsUpdate("lyxmodules.lst")
+ || configFileNeedsUpdate("textclass.lst")
+ || configFileNeedsUpdate("packages.lst")
+ || configFileNeedsUpdate("lyxciteengines.lst")
+ || configFileNeedsUpdate("xtemplates.lst");
}
first_start = !explicit_userdir;
if (!sup.createDirectory(0755)) {
// Failed, so let's exit.
- lyxerr << to_utf8(_("Failed to create directory. Exiting."))
+ lyxerr << to_utf8(_("Failed to create directory. Perhaps wrong -userdir command-line option?\nExiting."))
<< endl;
earlyExit(EXIT_FAILURE);
}
namespace {
/// return the the number of arguments consumed
-typedef boost::function<int(string const &, string const &, string &)> cmd_helper;
+typedef function<int(string const &, string const &, string &)> cmd_helper;
int parse_dbg(string const & arg, string const &, string &)
{
Debug::showTags(cout);
exit(0);
}
- lyxerr << to_utf8(bformat(_("Setting debug level to %1$s"), from_utf8(arg))) << endl;
-
- lyxerr.setLevel(Debug::value(arg));
- Debug::showLevel(lyxerr, lyxerr.level());
+ string bad = Debug::badValue(arg);
+ if (bad.empty()) {
+ lyxerr.setLevel(Debug::value(arg));
+ Debug::showLevel(lyxerr, lyxerr.level());
+ } else {
+ cout << to_utf8(bformat(_("Bad debug value `%1$s'. Exiting."),
+ from_utf8(bad))) << endl;
+ exit(1);
+ }
return 1;
}
" where fmt is the export format of choice. Look in\n"
" Tools->Preferences->File Handling->File Formats->Short Name\n"
" to see which parameter (which differs from the format name\n"
- " in the File->Export menu) should be passed.\n"
+ " in the File->Export menu) should be passed. To export to\n"
+ " the document's default output format, use 'default'.\n"
" Note that the order of -e and -x switches matters.\n"
"\t-E [--export-to] fmt filename\n"
" where fmt is the export format of choice (see --export),\n"
" specifying whether all files, main file only, or no files,\n"
" respectively, are to be overwritten during a batch export.\n"
" Anything else is equivalent to `all', but is not consumed.\n"
+ "\t--ignore-error-message which\n"
+ " allows you to ignore specific LaTeX error messages.\n"
+ " Do not use for final documents! Currently supported values:\n"
+ " * missing_glyphs: Fontspec `missing glyphs' error.\n"
"\t-n [--no-remote]\n"
" open documents in a new instance\n"
"\t-r [--remote]\n"
" open documents in an already running instance\n"
" (a working lyxpipe is needed)\n"
+ "\t-v [--verbose]\n"
+ " report on terminal about spawned commands.\n"
"\t-batch execute commands without launching GUI and exit.\n"
"\t-version summarize version and build info\n"
"Check the LyX man page for more details.")) << endl;
{
cout << "LyX " << lyx_version
<< " (" << lyx_release_date << ")" << endl;
- cout << to_utf8(bformat(_("Built on %1$s[[date]], %2$s[[time]]"),
- from_ascii(__DATE__), from_ascii(__TIME__))) << endl;
-
+ if (string(lyx_git_commit_hash) != "none")
+ cout << to_utf8(_(" Git commit hash "))
+ << string(lyx_git_commit_hash).substr(0,8) << endl;
cout << lyx_version_info << endl;
exit(0);
return 0;
}
+int parse_verbose(string const &, string const &, string &)
+{
+ verbose = true;
+ return 0;
+}
+
+
+int parse_ignore_error_message(string const & arg1, string const &, string &)
+{
+ if (arg1 == "missing_glyphs") {
+ ignore_missing_glyphs = true;
+ return 1;
+ }
+ return 0;
+}
+
+
int parse_force(string const & arg, string const &, string &)
{
if (arg == "all") {
}
-} // namespace anon
+} // namespace
void LyX::easyParse(int & argc, char * argv[])
cmdmap["-userdir"] = parse_userdir;
cmdmap["-x"] = parse_execute;
cmdmap["--execute"] = parse_execute;
- cmdmap["-e"] = parse_export;
+ cmdmap["-e"] = parse_export;
cmdmap["--export"] = parse_export;
cmdmap["-E"] = parse_export_to;
cmdmap["--export-to"] = parse_export_to;
cmdmap["--no-remote"] = parse_noremote;
cmdmap["-r"] = parse_remote;
cmdmap["--remote"] = parse_remote;
+ cmdmap["-v"] = parse_verbose;
+ cmdmap["--verbose"] = parse_verbose;
+ cmdmap["--ignore-error-message"] = parse_ignore_error_message;
for (int i = 1; i < argc; ++i) {
map<string, cmd_helper>::const_iterator it
}
-void dispatch(FuncRequest const & action)
+DispatchResult const & dispatch(FuncRequest const & action)
{
LAPPERR(theApp());
return theApp()->dispatch(action);
void dispatch(FuncRequest const & action, DispatchResult & dr)
{
LAPPERR(theApp());
- return theApp()->dispatch(action, dr);
+ theApp()->dispatch(action, dr);
}
// FIXME: this should not be use_gui dependent
LWARNIF(use_gui);
LAPPERR(singleton_);
- return *singleton_->pimpl_->lyx_server_.get();
+ return *singleton_->pimpl_->lyx_server_;
}
// FIXME: this should not be use_gui dependent
LWARNIF(use_gui);
LAPPERR(singleton_);
- return *singleton_->pimpl_->lyx_socket_.get();
+ return *singleton_->pimpl_->lyx_socket_;
}
}
+Formats & theFormats()
+{
+ LAPPERR(singleton_);
+ return singleton_->pimpl_->formats_;
+}
+
+
+Formats & theSystemFormats()
+{
+ LAPPERR(singleton_);
+ return singleton_->pimpl_->system_formats_;
+}
+
+
Converters & theConverters()
{
LAPPERR(singleton_);
- return singleton_->pimpl_->converters_;
+ return singleton_->pimpl_->converters_;
}
Converters & theSystemConverters()
{
LAPPERR(singleton_);
- return singleton_->pimpl_->system_converters_;
+ return singleton_->pimpl_->system_converters_;
}
singleton_->pimpl_->apple_spell_checker_ = new AppleSpellChecker;
singleton_->pimpl_->spell_checker_ = singleton_->pimpl_->apple_spell_checker_;
#else
- singleton_->pimpl_->spell_checker_ = 0;
+ singleton_->pimpl_->spell_checker_ = nullptr;
#endif
} else if (lyxrc.spellchecker == "aspell") {
#if defined(USE_ASPELL)
singleton_->pimpl_->aspell_checker_ = new AspellChecker;
singleton_->pimpl_->spell_checker_ = singleton_->pimpl_->aspell_checker_;
#else
- singleton_->pimpl_->spell_checker_ = 0;
+ singleton_->pimpl_->spell_checker_ = nullptr;
#endif
} else if (lyxrc.spellchecker == "enchant") {
#if defined(USE_ENCHANT)
singleton_->pimpl_->enchant_checker_ = new EnchantChecker;
singleton_->pimpl_->spell_checker_ = singleton_->pimpl_->enchant_checker_;
#else
- singleton_->pimpl_->spell_checker_ = 0;
+ singleton_->pimpl_->spell_checker_ = nullptr;
#endif
} else if (lyxrc.spellchecker == "hunspell") {
#if defined(USE_HUNSPELL)
singleton_->pimpl_->hunspell_checker_ = new HunspellChecker;
singleton_->pimpl_->spell_checker_ = singleton_->pimpl_->hunspell_checker_;
#else
- singleton_->pimpl_->spell_checker_ = 0;
+ singleton_->pimpl_->spell_checker_ = nullptr;
#endif
} else {
- singleton_->pimpl_->spell_checker_ = 0;
+ singleton_->pimpl_->spell_checker_ = nullptr;
}
if (singleton_->pimpl_->spell_checker_) {
singleton_->pimpl_->spell_checker_->changeNumber(speller_change_number);
projects / lyx.git / blobdiff