2002-06-12 03:16:41 +00:00
|
|
|
|
/**
|
|
|
|
|
* \file lyx_main.C
|
2003-08-23 00:17:00 +00:00
|
|
|
|
* This file is part of LyX, the document processor.
|
|
|
|
|
* Licence details can be found in the file COPYING.
|
2002-03-21 17:27:08 +00:00
|
|
|
|
*
|
2003-08-23 00:17:00 +00:00
|
|
|
|
* \author Alfredo Braunstein
|
2003-07-04 08:23:23 +00:00
|
|
|
|
* \author Lars Gullik Bj<EFBFBD>nnes
|
2003-08-23 00:17:00 +00:00
|
|
|
|
* \author Jean-Marc Lasgouttes
|
|
|
|
|
* \author John Levon
|
|
|
|
|
* \author Andr<EFBFBD> P<EFBFBD>nitz
|
|
|
|
|
*
|
|
|
|
|
* Full author contact details are available in file CREDITS.
|
2002-06-12 03:16:41 +00:00
|
|
|
|
*/
|
1999-09-27 18:44:28 +00:00
|
|
|
|
|
|
|
|
|
#include <config.h>
|
2001-12-28 13:26:54 +00:00
|
|
|
|
#include <version.h>
|
1999-09-27 18:44:28 +00:00
|
|
|
|
|
|
|
|
|
#include "lyx_main.h"
|
2002-06-24 20:28:12 +00:00
|
|
|
|
|
2006-11-13 10:27:57 +00:00
|
|
|
|
#include "ConverterCache.h"
|
2002-08-06 14:40:13 +00:00
|
|
|
|
#include "buffer.h"
|
2003-06-20 12:46:28 +00:00
|
|
|
|
#include "buffer_funcs.h"
|
2006-09-29 22:06:28 +00:00
|
|
|
|
#include "bufferlist.h"
|
2003-09-04 03:54:04 +00:00
|
|
|
|
#include "converter.h"
|
|
|
|
|
#include "debug.h"
|
|
|
|
|
#include "encoding.h"
|
2003-09-06 18:38:02 +00:00
|
|
|
|
#include "errorlist.h"
|
2003-09-04 03:54:04 +00:00
|
|
|
|
#include "format.h"
|
|
|
|
|
#include "gettext.h"
|
2000-02-04 09:38:32 +00:00
|
|
|
|
#include "kbmap.h"
|
2002-06-12 09:47:10 +00:00
|
|
|
|
#include "language.h"
|
2006-04-05 22:56:18 +00:00
|
|
|
|
#include "session.h"
|
2003-09-15 15:20:22 +00:00
|
|
|
|
#include "LColor.h"
|
2006-04-09 00:26:19 +00:00
|
|
|
|
#include "lyx_cb.h"
|
2006-10-19 07:20:32 +00:00
|
|
|
|
#include "LyXAction.h"
|
2003-09-04 03:54:04 +00:00
|
|
|
|
#include "lyxfunc.h"
|
|
|
|
|
#include "lyxlex.h"
|
2003-09-06 23:36:02 +00:00
|
|
|
|
#include "lyxrc.h"
|
2006-09-29 22:06:28 +00:00
|
|
|
|
#include "lyxserver.h"
|
2006-10-19 07:20:32 +00:00
|
|
|
|
#include "lyxsocket.h"
|
2002-07-21 21:21:06 +00:00
|
|
|
|
#include "lyxtextclasslist.h"
|
2003-09-04 03:54:04 +00:00
|
|
|
|
#include "MenuBackend.h"
|
2004-10-26 18:39:13 +00:00
|
|
|
|
#include "mover.h"
|
2003-09-04 03:54:04 +00:00
|
|
|
|
#include "ToolbarBackend.h"
|
2001-12-28 13:26:54 +00:00
|
|
|
|
|
|
|
|
|
#include "frontends/Alert.h"
|
2006-09-22 12:34:13 +00:00
|
|
|
|
#include "frontends/Application.h"
|
2006-10-23 16:29:24 +00:00
|
|
|
|
#include "frontends/Gui.h"
|
2003-10-14 21:30:23 +00:00
|
|
|
|
#include "frontends/LyXView.h"
|
1999-09-27 18:44:28 +00:00
|
|
|
|
|
2005-02-15 13:45:41 +00:00
|
|
|
|
#include "support/environment.h"
|
2003-09-04 03:54:04 +00:00
|
|
|
|
#include "support/filetools.h"
|
2006-10-02 10:48:03 +00:00
|
|
|
|
#include "support/fontutils.h"
|
2003-09-04 03:54:04 +00:00
|
|
|
|
#include "support/lyxlib.h"
|
2006-05-29 15:11:19 +00:00
|
|
|
|
#include "support/convert.h"
|
2003-09-04 03:54:04 +00:00
|
|
|
|
#include "support/os.h"
|
2005-01-10 19:17:43 +00:00
|
|
|
|
#include "support/package.h"
|
2003-09-04 03:54:04 +00:00
|
|
|
|
#include "support/path.h"
|
2006-05-09 15:41:42 +00:00
|
|
|
|
#include "support/systemcall.h"
|
2006-11-18 17:47:12 +00:00
|
|
|
|
#include "support/unicode.h"
|
2003-09-04 03:54:04 +00:00
|
|
|
|
|
2003-06-20 23:03:43 +00:00
|
|
|
|
#include <boost/bind.hpp>
|
2005-01-31 10:42:26 +00:00
|
|
|
|
#include <boost/filesystem/operations.hpp>
|
2002-08-07 23:43:38 +00:00
|
|
|
|
|
2003-06-20 23:03:43 +00:00
|
|
|
|
#include <iostream>
|
2003-09-07 21:25:37 +00:00
|
|
|
|
#include <csignal>
|
2001-12-28 13:26:54 +00:00
|
|
|
|
|
2006-10-21 00:16:43 +00:00
|
|
|
|
|
|
|
|
|
namespace lyx {
|
|
|
|
|
|
|
|
|
|
using support::addName;
|
|
|
|
|
using support::addPath;
|
|
|
|
|
using support::bformat;
|
|
|
|
|
using support::createDirectory;
|
|
|
|
|
using support::createLyXTmpDir;
|
|
|
|
|
using support::destroyDir;
|
2006-11-26 21:30:39 +00:00
|
|
|
|
using support::FileName;
|
2006-10-21 00:16:43 +00:00
|
|
|
|
using support::fileSearch;
|
|
|
|
|
using support::getEnv;
|
|
|
|
|
using support::i18nLibFileSearch;
|
|
|
|
|
using support::libFileSearch;
|
|
|
|
|
using support::package;
|
|
|
|
|
using support::prependEnvPath;
|
|
|
|
|
using support::rtrim;
|
|
|
|
|
using support::Systemcall;
|
|
|
|
|
|
|
|
|
|
namespace Alert = frontend::Alert;
|
|
|
|
|
namespace os = support::os;
|
2005-01-31 10:42:26 +00:00
|
|
|
|
namespace fs = boost::filesystem;
|
2004-12-15 19:35:43 +00:00
|
|
|
|
|
2000-03-28 02:18:55 +00:00
|
|
|
|
using std::endl;
|
2003-10-06 15:43:21 +00:00
|
|
|
|
using std::string;
|
2003-09-09 22:13:45 +00:00
|
|
|
|
using std::vector;
|
2006-09-28 00:42:47 +00:00
|
|
|
|
using std::for_each;
|
2003-09-09 22:13:45 +00:00
|
|
|
|
|
2001-05-02 10:47:07 +00:00
|
|
|
|
#ifndef CXX_GLOBAL_CSTD
|
2002-06-10 07:57:39 +00:00
|
|
|
|
using std::exit;
|
2001-05-02 10:47:07 +00:00
|
|
|
|
using std::signal;
|
2002-06-10 07:57:39 +00:00
|
|
|
|
using std::system;
|
2001-05-02 10:47:07 +00:00
|
|
|
|
#endif
|
|
|
|
|
|
2006-10-12 14:10:13 +00:00
|
|
|
|
///
|
2006-10-21 00:16:43 +00:00
|
|
|
|
frontend::Application * theApp = 0;
|
2006-10-12 14:10:13 +00:00
|
|
|
|
|
|
|
|
|
/// are we using the GUI at all?
|
|
|
|
|
/**
|
|
|
|
|
* We default to true and this is changed to false when the export feature is used.
|
|
|
|
|
*/
|
|
|
|
|
bool use_gui = true;
|
|
|
|
|
|
|
|
|
|
|
2003-04-02 18:08:05 +00:00
|
|
|
|
namespace {
|
|
|
|
|
|
2005-01-10 19:17:43 +00:00
|
|
|
|
// Filled with the command line arguments "foo" of "-sysdir foo" or
|
|
|
|
|
// "-userdir foo".
|
|
|
|
|
string cl_system_support;
|
|
|
|
|
string cl_user_support;
|
|
|
|
|
|
2006-11-29 16:45:38 +00:00
|
|
|
|
std::string geometryArg;
|
|
|
|
|
|
2006-11-18 17:47:12 +00:00
|
|
|
|
LyX * singleton_ = 0;
|
2005-01-10 19:17:43 +00:00
|
|
|
|
|
2003-04-02 18:08:05 +00:00
|
|
|
|
void showFileError(string const & error)
|
|
|
|
|
{
|
2006-09-11 08:54:10 +00:00
|
|
|
|
Alert::warning(_("Could not read configuration file"),
|
|
|
|
|
bformat(_("Error while reading the configuration file\n%1$s.\n"
|
2006-10-21 00:16:43 +00:00
|
|
|
|
"Please check your installation."), from_utf8(error)));
|
2003-04-02 18:08:05 +00:00
|
|
|
|
}
|
|
|
|
|
|
2005-01-16 21:01:41 +00:00
|
|
|
|
|
|
|
|
|
void reconfigureUserLyXDir()
|
|
|
|
|
{
|
2006-04-22 11:58:02 +00:00
|
|
|
|
string const configure_command = package().configure_command();
|
2005-01-16 21:01:41 +00:00
|
|
|
|
|
2006-10-21 00:16:43 +00:00
|
|
|
|
lyxerr << to_utf8(_("LyX: reconfiguring user directory")) << endl;
|
|
|
|
|
support::Path p(package().user_support());
|
2006-05-09 15:41:42 +00:00
|
|
|
|
Systemcall one;
|
|
|
|
|
one.startscript(Systemcall::Wait, configure_command);
|
2006-10-21 00:16:43 +00:00
|
|
|
|
lyxerr << "LyX: " << to_utf8(_("Done!")) << endl;
|
2005-01-16 21:01:41 +00:00
|
|
|
|
}
|
|
|
|
|
|
2003-10-14 21:30:23 +00:00
|
|
|
|
} // namespace anon
|
|
|
|
|
|
|
|
|
|
|
2006-10-19 07:20:32 +00:00
|
|
|
|
/// The main application class private implementation.
|
|
|
|
|
struct LyX::Singletons
|
|
|
|
|
{
|
2006-11-18 17:47:12 +00:00
|
|
|
|
Singletons(): iconv(ucs4_codeset, "UTF-8")
|
|
|
|
|
{
|
|
|
|
|
}
|
2006-10-19 07:20:32 +00:00
|
|
|
|
/// our function handler
|
|
|
|
|
LyXFunc lyxfunc_;
|
|
|
|
|
///
|
|
|
|
|
BufferList buffer_list_;
|
|
|
|
|
///
|
|
|
|
|
boost::scoped_ptr<kb_keymap> toplevel_keymap_;
|
|
|
|
|
///
|
|
|
|
|
boost::scoped_ptr<LyXServer> lyx_server_;
|
|
|
|
|
///
|
|
|
|
|
boost::scoped_ptr<LyXServerSocket> lyx_socket_;
|
|
|
|
|
///
|
2006-10-21 00:16:43 +00:00
|
|
|
|
boost::scoped_ptr<frontend::Application> application_;
|
2006-10-19 07:20:32 +00:00
|
|
|
|
/// lyx session, containing lastfiles, lastfilepos, and lastopened
|
2006-10-21 00:16:43 +00:00
|
|
|
|
boost::scoped_ptr<Session> session_;
|
2006-10-19 07:20:32 +00:00
|
|
|
|
|
2006-11-18 17:47:12 +00:00
|
|
|
|
///
|
|
|
|
|
IconvProcessor iconv;
|
|
|
|
|
};
|
2006-10-19 07:20:32 +00:00
|
|
|
|
|
2003-10-14 21:30:23 +00:00
|
|
|
|
|
2006-11-17 15:24:26 +00:00
|
|
|
|
LyX::~LyX()
|
|
|
|
|
{
|
|
|
|
|
// Static data are not treated in the same way at all on the Mac (and
|
|
|
|
|
// the LyX singleton has static methods). This is the reason why the
|
|
|
|
|
// exit command on the Mac bypasses our dispatch machinery altogether.
|
|
|
|
|
// On Linux and Windows we won't pass a second time through quit()
|
|
|
|
|
// because quitting will already be set to true.
|
|
|
|
|
if (!quitting)
|
|
|
|
|
quit();
|
|
|
|
|
}
|
|
|
|
|
|
2006-10-19 07:20:32 +00:00
|
|
|
|
|
2003-10-14 21:30:23 +00:00
|
|
|
|
LyX & LyX::ref()
|
|
|
|
|
{
|
2006-11-18 17:47:12 +00:00
|
|
|
|
BOOST_ASSERT(singleton_);
|
|
|
|
|
return *singleton_;
|
2003-10-14 21:30:23 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
LyX const & LyX::cref()
|
|
|
|
|
{
|
2006-11-18 17:47:12 +00:00
|
|
|
|
BOOST_ASSERT(singleton_);
|
|
|
|
|
return *singleton_;
|
2003-10-14 21:30:23 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
LyX::LyX()
|
2006-11-29 16:45:38 +00:00
|
|
|
|
: first_start(false)
|
2006-10-11 22:30:31 +00:00
|
|
|
|
{
|
2006-11-18 17:47:12 +00:00
|
|
|
|
singleton_ = this;
|
2006-10-19 07:20:32 +00:00
|
|
|
|
pimpl_.reset(new Singletons);
|
2006-11-29 16:45:38 +00:00
|
|
|
|
geometryArg.clear();
|
2006-10-11 22:30:31 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
BufferList & LyX::bufferList()
|
|
|
|
|
{
|
2006-10-19 07:20:32 +00:00
|
|
|
|
return pimpl_->buffer_list_;
|
2006-10-11 22:30:31 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
BufferList const & LyX::bufferList() const
|
|
|
|
|
{
|
2006-10-19 07:20:32 +00:00
|
|
|
|
return pimpl_->buffer_list_;
|
2006-10-11 22:30:31 +00:00
|
|
|
|
}
|
2003-10-14 21:30:23 +00:00
|
|
|
|
|
|
|
|
|
|
2006-10-21 00:16:43 +00:00
|
|
|
|
Session & LyX::session()
|
2003-10-14 21:30:23 +00:00
|
|
|
|
{
|
2006-10-19 07:20:32 +00:00
|
|
|
|
BOOST_ASSERT(pimpl_->session_.get());
|
|
|
|
|
return *pimpl_->session_.get();
|
2003-10-14 21:30:23 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2006-10-21 00:16:43 +00:00
|
|
|
|
Session const & LyX::session() const
|
2003-10-14 21:30:23 +00:00
|
|
|
|
{
|
2006-10-19 07:20:32 +00:00
|
|
|
|
BOOST_ASSERT(pimpl_->session_.get());
|
|
|
|
|
return *pimpl_->session_.get();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
LyXFunc & LyX::lyxFunc()
|
|
|
|
|
{
|
|
|
|
|
return pimpl_->lyxfunc_;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
LyXFunc const & LyX::lyxFunc() const
|
|
|
|
|
{
|
|
|
|
|
return pimpl_->lyxfunc_;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
LyXServer & LyX::server()
|
|
|
|
|
{
|
|
|
|
|
BOOST_ASSERT(pimpl_->lyx_server_.get());
|
|
|
|
|
return *pimpl_->lyx_server_.get();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
LyXServer const & LyX::server() const
|
|
|
|
|
{
|
|
|
|
|
BOOST_ASSERT(pimpl_->lyx_server_.get());
|
|
|
|
|
return *pimpl_->lyx_server_.get();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
LyXServerSocket & LyX::socket()
|
|
|
|
|
{
|
|
|
|
|
BOOST_ASSERT(pimpl_->lyx_socket_.get());
|
|
|
|
|
return *pimpl_->lyx_socket_.get();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
LyXServerSocket const & LyX::socket() const
|
|
|
|
|
{
|
|
|
|
|
BOOST_ASSERT(pimpl_->lyx_socket_.get());
|
|
|
|
|
return *pimpl_->lyx_socket_.get();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2006-10-21 00:16:43 +00:00
|
|
|
|
frontend::Application & LyX::application()
|
2006-10-19 07:20:32 +00:00
|
|
|
|
{
|
|
|
|
|
BOOST_ASSERT(pimpl_->application_.get());
|
|
|
|
|
return *pimpl_->application_.get();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2006-10-21 00:16:43 +00:00
|
|
|
|
frontend::Application const & LyX::application() const
|
2006-10-19 07:20:32 +00:00
|
|
|
|
{
|
|
|
|
|
BOOST_ASSERT(pimpl_->application_.get());
|
|
|
|
|
return *pimpl_->application_.get();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
kb_keymap & LyX::topLevelKeymap()
|
|
|
|
|
{
|
|
|
|
|
BOOST_ASSERT(pimpl_->toplevel_keymap_.get());
|
|
|
|
|
return *pimpl_->toplevel_keymap_.get();
|
2003-10-14 21:30:23 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2006-11-18 17:47:12 +00:00
|
|
|
|
IconvProcessor & LyX::iconvProcessor()
|
|
|
|
|
{
|
|
|
|
|
return pimpl_->iconv;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2006-10-19 07:20:32 +00:00
|
|
|
|
kb_keymap const & LyX::topLevelKeymap() const
|
|
|
|
|
{
|
|
|
|
|
BOOST_ASSERT(pimpl_->toplevel_keymap_.get());
|
|
|
|
|
return *pimpl_->toplevel_keymap_.get();
|
|
|
|
|
}
|
|
|
|
|
|
2003-10-14 21:30:23 +00:00
|
|
|
|
|
2004-04-13 13:10:33 +00:00
|
|
|
|
Buffer const * const LyX::updateInset(InsetBase const * inset) const
|
2003-10-14 21:30:23 +00:00
|
|
|
|
{
|
|
|
|
|
if (!inset)
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
Buffer const * buffer_ptr = 0;
|
2006-10-23 16:29:24 +00:00
|
|
|
|
vector<int> const & view_ids = pimpl_->application_->gui().viewIds();
|
|
|
|
|
vector<int>::const_iterator it = view_ids.begin();
|
|
|
|
|
vector<int>::const_iterator const end = view_ids.end();
|
2003-10-14 21:30:23 +00:00
|
|
|
|
for (; it != end; ++it) {
|
2006-10-23 16:29:24 +00:00
|
|
|
|
Buffer const * ptr =
|
|
|
|
|
pimpl_->application_->gui().view(*it).updateInset(inset);
|
2003-10-14 21:30:23 +00:00
|
|
|
|
if (ptr)
|
|
|
|
|
buffer_ptr = ptr;
|
|
|
|
|
}
|
|
|
|
|
return buffer_ptr;
|
2003-04-02 18:08:05 +00:00
|
|
|
|
}
|
1999-09-27 18:44:28 +00:00
|
|
|
|
|
2003-10-14 21:30:23 +00:00
|
|
|
|
|
2006-11-18 17:47:12 +00:00
|
|
|
|
int LyX::exec(int & argc, char * argv[])
|
1999-09-27 18:44:28 +00:00
|
|
|
|
{
|
|
|
|
|
// Here we need to parse the command line. At least
|
|
|
|
|
// we need to parse for "-dbg" and "-help"
|
2006-10-12 14:10:13 +00:00
|
|
|
|
easyParse(argc, argv);
|
1999-09-27 18:44:28 +00:00
|
|
|
|
|
2006-10-21 00:16:43 +00:00
|
|
|
|
support::init_package(argv[0], cl_system_support, cl_user_support,
|
|
|
|
|
support::top_build_dir_is_one_level_up);
|
2005-01-10 19:17:43 +00:00
|
|
|
|
|
2006-10-17 08:36:04 +00:00
|
|
|
|
vector<string> files;
|
2006-10-19 07:20:32 +00:00
|
|
|
|
|
2006-11-24 11:18:56 +00:00
|
|
|
|
if (!use_gui) {
|
|
|
|
|
// FIXME: create a ConsoleApplication
|
2006-11-26 02:18:32 +00:00
|
|
|
|
int exit_status = loadFiles(argc, argv, files);
|
2006-11-26 15:47:45 +00:00
|
|
|
|
if (exit_status) {
|
|
|
|
|
prepareExit();
|
2006-11-26 02:18:32 +00:00
|
|
|
|
return exit_status;
|
2006-11-26 15:47:45 +00:00
|
|
|
|
}
|
2006-11-26 16:39:39 +00:00
|
|
|
|
|
|
|
|
|
if (batch_command.empty() || pimpl_->buffer_list_.empty()) {
|
2006-11-26 15:47:45 +00:00
|
|
|
|
prepareExit();
|
|
|
|
|
return EXIT_SUCCESS;
|
|
|
|
|
}
|
|
|
|
|
|
2006-11-26 16:39:39 +00:00
|
|
|
|
BufferList::iterator begin = pimpl_->buffer_list_.begin();
|
|
|
|
|
BufferList::iterator end = pimpl_->buffer_list_.end();
|
|
|
|
|
|
|
|
|
|
bool final_success = false;
|
|
|
|
|
for (BufferList::iterator I = begin; I != end; ++I) {
|
|
|
|
|
Buffer * buf = *I;
|
|
|
|
|
bool success = false;
|
|
|
|
|
buf->dispatch(batch_command, &success);
|
|
|
|
|
final_success |= success;
|
|
|
|
|
}
|
2006-11-26 15:47:45 +00:00
|
|
|
|
prepareExit();
|
2006-11-26 16:39:39 +00:00
|
|
|
|
return !final_success;
|
2006-11-24 11:18:56 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Force adding of font path _before_ Application is initialized
|
|
|
|
|
support::addFontResources();
|
|
|
|
|
|
|
|
|
|
// Let the frontend parse and remove all arguments that it knows
|
|
|
|
|
pimpl_->application_.reset(createApplication(argc, argv));
|
2006-11-26 02:18:32 +00:00
|
|
|
|
// FIXME: this global pointer should probably go.
|
|
|
|
|
theApp = pimpl_->application_.get();
|
|
|
|
|
|
|
|
|
|
initGuiFont();
|
2006-10-19 07:20:32 +00:00
|
|
|
|
|
2006-11-24 11:18:56 +00:00
|
|
|
|
// Parse and remove all known arguments in the LyX singleton
|
|
|
|
|
// Give an error for all remaining ones.
|
2006-11-26 02:18:32 +00:00
|
|
|
|
int exit_status = loadFiles(argc, argv, files);
|
2006-11-24 11:18:56 +00:00
|
|
|
|
if (exit_status) {
|
|
|
|
|
// Kill the application object before exiting.
|
2006-10-19 07:20:32 +00:00
|
|
|
|
pimpl_->application_.reset();
|
2006-11-24 11:18:56 +00:00
|
|
|
|
use_gui = false;
|
|
|
|
|
prepareExit();
|
|
|
|
|
return exit_status;
|
2006-10-02 10:48:03 +00:00
|
|
|
|
}
|
2006-11-24 11:18:56 +00:00
|
|
|
|
|
|
|
|
|
restoreGuiSession(files);
|
|
|
|
|
// Start the real execution loop.
|
|
|
|
|
|
|
|
|
|
// FIXME
|
|
|
|
|
/* Create a CoreApplication class that will provide the main event loop
|
|
|
|
|
* and the socket callback registering. With Qt4, 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.
|
|
|
|
|
*/
|
|
|
|
|
pimpl_->lyx_server_.reset(new LyXServer(&pimpl_->lyxfunc_, lyxrc.lyxpipes));
|
|
|
|
|
pimpl_->lyx_socket_.reset(new LyXServerSocket(&pimpl_->lyxfunc_,
|
|
|
|
|
support::os::internal_path(package().temp_dir() + "/lyxsocket")));
|
|
|
|
|
|
2006-11-26 02:18:32 +00:00
|
|
|
|
exit_status = pimpl_->application_->exec();
|
2006-11-24 11:18:56 +00:00
|
|
|
|
// Kill the application object before exiting. This avoid crash
|
|
|
|
|
// on exit on Linux.
|
|
|
|
|
pimpl_->application_.reset();
|
|
|
|
|
// Restore original font resources after Application is destroyed.
|
|
|
|
|
support::restoreFontResources();
|
|
|
|
|
|
2006-10-17 08:36:04 +00:00
|
|
|
|
return exit_status;
|
|
|
|
|
}
|
|
|
|
|
|
2006-10-13 19:45:10 +00:00
|
|
|
|
|
2006-10-17 08:36:04 +00:00
|
|
|
|
void LyX::prepareExit()
|
|
|
|
|
{
|
|
|
|
|
// Set a flag that we do quitting from the program,
|
|
|
|
|
// so no refreshes are necessary.
|
|
|
|
|
quitting = true;
|
2006-10-13 19:45:10 +00:00
|
|
|
|
|
2006-10-17 08:36:04 +00:00
|
|
|
|
// close buffers first
|
2006-10-19 07:20:32 +00:00
|
|
|
|
pimpl_->buffer_list_.closeAll();
|
2006-10-17 08:36:04 +00:00
|
|
|
|
|
|
|
|
|
// do any other cleanup procedures now
|
|
|
|
|
lyxerr[Debug::INFO] << "Deleting tmp dir " << package().temp_dir() << endl;
|
|
|
|
|
|
2006-11-28 20:04:16 +00:00
|
|
|
|
// Prevent the deletion of /tmp if LyX was called with invalid
|
|
|
|
|
// arguments. Does not work on windows.
|
|
|
|
|
// FIXME: Fix the real bug instead.
|
|
|
|
|
if (package().temp_dir() == "/tmp") {
|
|
|
|
|
lyxerr << "Not deleting /tmp." << endl;
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
2006-10-17 08:36:04 +00:00
|
|
|
|
if (!destroyDir(package().temp_dir())) {
|
2006-11-17 17:28:14 +00:00
|
|
|
|
docstring const msg =
|
|
|
|
|
bformat(_("Unable to remove the temporary directory %1$s"),
|
2006-11-18 17:47:12 +00:00
|
|
|
|
from_utf8(package().temp_dir()));
|
2006-10-17 08:36:04 +00:00
|
|
|
|
Alert::warning(_("Unable to remove temporary directory"), msg);
|
|
|
|
|
}
|
2006-06-07 20:08:37 +00:00
|
|
|
|
}
|
|
|
|
|
|
1999-09-27 18:44:28 +00:00
|
|
|
|
|
2006-10-17 08:36:04 +00:00
|
|
|
|
void LyX::earlyExit(int status)
|
|
|
|
|
{
|
2006-10-19 07:20:32 +00:00
|
|
|
|
BOOST_ASSERT(pimpl_->application_.get());
|
|
|
|
|
// LyX::pimpl_::application_ is not initialised at this
|
2006-10-17 08:36:04 +00:00
|
|
|
|
// point so it's safe to just exit after some cleanup.
|
|
|
|
|
prepareExit();
|
|
|
|
|
exit(status);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2006-10-24 15:01:07 +00:00
|
|
|
|
void LyX::quit()
|
2006-10-17 08:36:04 +00:00
|
|
|
|
{
|
|
|
|
|
lyxerr[Debug::INFO] << "Running QuitLyX." << endl;
|
|
|
|
|
|
|
|
|
|
prepareExit();
|
|
|
|
|
|
2006-10-21 00:16:43 +00:00
|
|
|
|
if (use_gui) {
|
2006-10-24 15:01:07 +00:00
|
|
|
|
pimpl_->session_->writeFile();
|
2006-10-20 09:56:28 +00:00
|
|
|
|
pimpl_->lyx_server_.reset();
|
|
|
|
|
pimpl_->lyx_socket_.reset();
|
2006-10-19 07:20:32 +00:00
|
|
|
|
pimpl_->application_->exit(0);
|
2006-11-19 11:10:04 +00:00
|
|
|
|
theApp = 0;
|
2006-10-17 08:36:04 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2006-11-26 02:18:32 +00:00
|
|
|
|
int LyX::loadFiles(int & argc, char * argv[],
|
2006-10-17 08:36:04 +00:00
|
|
|
|
vector<string> & files)
|
2006-06-07 20:08:37 +00:00
|
|
|
|
{
|
2006-11-24 11:18:56 +00:00
|
|
|
|
// check for any spurious extra arguments
|
|
|
|
|
// other than documents
|
|
|
|
|
for (int argi = 1; argi < argc ; ++argi) {
|
|
|
|
|
if (argv[argi][0] == '-') {
|
|
|
|
|
lyxerr << to_utf8(
|
|
|
|
|
bformat(_("Wrong command line option `%1$s'. Exiting."),
|
|
|
|
|
from_utf8(argv[argi]))) << endl;
|
|
|
|
|
return EXIT_FAILURE;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
1999-09-27 18:44:28 +00:00
|
|
|
|
// Initialization of LyX (reads lyxrc and more)
|
1999-11-09 23:52:04 +00:00
|
|
|
|
lyxerr[Debug::INIT] << "Initializing LyX::init..." << endl;
|
2006-10-17 08:36:04 +00:00
|
|
|
|
bool success = init();
|
1999-11-09 23:52:04 +00:00
|
|
|
|
lyxerr[Debug::INIT] << "Initializing LyX::init...done" << endl;
|
2006-07-05 17:01:26 +00:00
|
|
|
|
if (!success)
|
|
|
|
|
return EXIT_FAILURE;
|
1999-09-27 18:44:28 +00:00
|
|
|
|
|
2006-11-23 15:18:09 +00:00
|
|
|
|
for (int argi = argc - 1; argi >= 1; --argi) {
|
|
|
|
|
// check for any remaining extra arguments other than
|
|
|
|
|
// document file names. These will be passed out to the
|
|
|
|
|
// frontend.
|
|
|
|
|
if (argv[argi][0] == '-')
|
|
|
|
|
continue;
|
2005-03-29 14:47:54 +00:00
|
|
|
|
files.push_back(os::internal_path(argv[argi]));
|
2006-11-23 15:18:09 +00:00
|
|
|
|
}
|
1999-09-27 18:44:28 +00:00
|
|
|
|
|
2003-04-02 18:08:05 +00:00
|
|
|
|
if (first_start)
|
2006-11-26 21:30:39 +00:00
|
|
|
|
files.push_back(i18nLibFileSearch("examples", "splash.lyx").absFilename());
|
2002-06-24 20:28:12 +00:00
|
|
|
|
|
2006-11-26 02:18:32 +00:00
|
|
|
|
Buffer * last_loaded = 0;
|
|
|
|
|
|
|
|
|
|
vector<string>::const_iterator it = files.begin();
|
|
|
|
|
vector<string>::const_iterator end = files.end();
|
2002-08-06 14:40:13 +00:00
|
|
|
|
|
2006-11-26 02:18:32 +00:00
|
|
|
|
for (; it != end; ++it) {
|
|
|
|
|
// get absolute path of file and add ".lyx" to
|
|
|
|
|
// the filename if necessary
|
2006-11-26 21:30:39 +00:00
|
|
|
|
string s = fileSearch(string(), *it, "lyx").absFilename();
|
2006-11-26 02:18:32 +00:00
|
|
|
|
if (s.empty()) {
|
|
|
|
|
Buffer * const b = newFile(*it, string(), true);
|
|
|
|
|
if (b)
|
|
|
|
|
last_loaded = b;
|
|
|
|
|
} else {
|
|
|
|
|
Buffer * buf = pimpl_->buffer_list_.newBuffer(s, false);
|
|
|
|
|
if (loadLyXFile(buf, s)) {
|
|
|
|
|
last_loaded = buf;
|
|
|
|
|
ErrorList const & el = buf->errorList("Parse");
|
|
|
|
|
if (!el.empty())
|
|
|
|
|
for_each(el.begin(), el.end(),
|
|
|
|
|
boost::bind(&LyX::printError, this, _1));
|
2003-07-18 07:51:21 +00:00
|
|
|
|
}
|
2006-11-26 02:18:32 +00:00
|
|
|
|
else
|
|
|
|
|
pimpl_->buffer_list_.release(buf);
|
2003-09-09 18:27:24 +00:00
|
|
|
|
}
|
1999-12-10 00:07:59 +00:00
|
|
|
|
}
|
2002-03-21 17:27:08 +00:00
|
|
|
|
|
2006-11-26 02:18:32 +00:00
|
|
|
|
files.clear(); // the files are already loaded
|
|
|
|
|
|
2006-10-17 08:36:04 +00:00
|
|
|
|
return EXIT_SUCCESS;
|
|
|
|
|
}
|
2006-06-21 10:30:32 +00:00
|
|
|
|
|
|
|
|
|
|
2006-11-26 02:18:32 +00:00
|
|
|
|
void LyX::execBatchCommands()
|
|
|
|
|
{
|
|
|
|
|
// Execute batch commands if available
|
|
|
|
|
if (batch_command.empty())
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
lyxerr[Debug::INIT] << "About to handle -x '"
|
|
|
|
|
<< batch_command << '\'' << endl;
|
|
|
|
|
|
|
|
|
|
pimpl_->lyxfunc_.dispatch(lyxaction.lookupFunc(batch_command));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2006-10-17 08:36:04 +00:00
|
|
|
|
void LyX::restoreGuiSession(vector<string> const & files)
|
2006-10-21 09:45:11 +00:00
|
|
|
|
{
|
|
|
|
|
LyXView * view = newLyXView();
|
|
|
|
|
|
|
|
|
|
// load files
|
|
|
|
|
for_each(files.begin(), files.end(),
|
|
|
|
|
bind(&LyXView::loadLyXFile, view, _1, true));
|
|
|
|
|
|
|
|
|
|
// if a file is specified, I assume that user wants to edit *that* file
|
|
|
|
|
if (files.empty() && lyxrc.load_session) {
|
2006-10-29 20:01:00 +00:00
|
|
|
|
vector<string> const & lastopened = pimpl_->session_->lastOpened().getfiles();
|
2006-10-21 09:45:11 +00:00
|
|
|
|
// do not add to the lastfile list since these files are restored from
|
|
|
|
|
// last seesion, and should be already there (regular files), or should
|
|
|
|
|
// not be added at all (help files).
|
|
|
|
|
for_each(lastopened.begin(), lastopened.end(),
|
|
|
|
|
bind(&LyXView::loadLyXFile, view, _1, false));
|
|
|
|
|
}
|
|
|
|
|
// clear this list to save a few bytes of RAM
|
2006-10-29 20:01:00 +00:00
|
|
|
|
pimpl_->session_->lastOpened().clear();
|
2006-10-21 09:45:11 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
LyXView * LyX::newLyXView()
|
2006-10-17 08:36:04 +00:00
|
|
|
|
{
|
2006-10-23 16:29:24 +00:00
|
|
|
|
if (!lyx::use_gui)
|
|
|
|
|
return 0;
|
|
|
|
|
|
2006-10-17 08:36:04 +00:00
|
|
|
|
// determine windows size and position, from lyxrc and/or session
|
|
|
|
|
// initial geometry
|
|
|
|
|
unsigned int width = 690;
|
|
|
|
|
unsigned int height = 510;
|
2006-11-27 23:35:43 +00:00
|
|
|
|
// default icon size, will be overwritten by stored session value
|
2006-11-29 10:04:35 +00:00
|
|
|
|
unsigned int iconSizeXY = 0;
|
2006-10-17 08:36:04 +00:00
|
|
|
|
bool maximize = false;
|
|
|
|
|
// first try lyxrc
|
|
|
|
|
if (lyxrc.geometry_width != 0 && lyxrc.geometry_height != 0 ) {
|
|
|
|
|
width = lyxrc.geometry_width;
|
|
|
|
|
height = lyxrc.geometry_height;
|
|
|
|
|
}
|
|
|
|
|
// if lyxrc returns (0,0), then use session info
|
|
|
|
|
else {
|
2006-10-29 20:01:00 +00:00
|
|
|
|
string val = session().sessionInfo().load("WindowWidth");
|
2006-10-17 08:36:04 +00:00
|
|
|
|
if (!val.empty())
|
|
|
|
|
width = convert<unsigned int>(val);
|
2006-10-29 20:01:00 +00:00
|
|
|
|
val = session().sessionInfo().load("WindowHeight");
|
2006-10-17 08:36:04 +00:00
|
|
|
|
if (!val.empty())
|
|
|
|
|
height = convert<unsigned int>(val);
|
2006-10-29 20:01:00 +00:00
|
|
|
|
if (session().sessionInfo().load("WindowIsMaximized") == "yes")
|
2006-10-17 08:36:04 +00:00
|
|
|
|
maximize = true;
|
2006-11-27 23:35:43 +00:00
|
|
|
|
val = session().sessionInfo().load("IconSizeXY");
|
|
|
|
|
if (!val.empty())
|
|
|
|
|
iconSizeXY = convert<unsigned int>(val);
|
2006-10-17 08:36:04 +00:00
|
|
|
|
}
|
2006-10-21 09:45:11 +00:00
|
|
|
|
|
2006-10-17 08:36:04 +00:00
|
|
|
|
// if user wants to restore window position
|
|
|
|
|
int posx = -1;
|
|
|
|
|
int posy = -1;
|
|
|
|
|
if (lyxrc.geometry_xysaved) {
|
2006-10-29 20:01:00 +00:00
|
|
|
|
string val = session().sessionInfo().load("WindowPosX");
|
2006-10-17 08:36:04 +00:00
|
|
|
|
if (!val.empty())
|
|
|
|
|
posx = convert<int>(val);
|
2006-10-29 20:01:00 +00:00
|
|
|
|
val = session().sessionInfo().load("WindowPosY");
|
2006-10-17 08:36:04 +00:00
|
|
|
|
if (!val.empty())
|
|
|
|
|
posy = convert<int>(val);
|
2005-05-19 09:44:20 +00:00
|
|
|
|
}
|
2006-10-17 08:36:04 +00:00
|
|
|
|
|
2006-11-29 16:45:38 +00:00
|
|
|
|
if (!geometryArg.empty())
|
|
|
|
|
{
|
2006-10-17 08:36:04 +00:00
|
|
|
|
width = 0;
|
|
|
|
|
height = 0;
|
|
|
|
|
}
|
2006-11-29 16:45:38 +00:00
|
|
|
|
|
2006-10-17 08:36:04 +00:00
|
|
|
|
// create the main window
|
2006-11-29 16:45:38 +00:00
|
|
|
|
LyXView * view = &pimpl_->application_->createView(width, height, posx, posy, maximize, iconSizeXY, geometryArg);
|
2006-10-17 08:36:04 +00:00
|
|
|
|
|
2006-10-21 09:45:11 +00:00
|
|
|
|
return view;
|
1999-09-27 18:44:28 +00:00
|
|
|
|
}
|
|
|
|
|
|
2005-01-19 14:17:36 +00:00
|
|
|
|
/*
|
|
|
|
|
Signals and Windows
|
|
|
|
|
===================
|
|
|
|
|
The SIGHUP signal does not exist on Windows and does not need to be handled.
|
|
|
|
|
|
|
|
|
|
Windows handles SIGFPE and SIGSEGV signals as expected.
|
|
|
|
|
|
|
|
|
|
Cntl+C interrupts (mapped to SIGINT by Windows' POSIX compatability layer)
|
|
|
|
|
cause a new thread to be spawned. This may well result in unexpected
|
|
|
|
|
behaviour by the single-threaded LyX.
|
|
|
|
|
|
|
|
|
|
SIGTERM signals will come only from another process actually sending
|
|
|
|
|
that signal using 'raise' in Windows' POSIX compatability layer. It will
|
|
|
|
|
not come from the general "terminate process" methods that everyone
|
|
|
|
|
actually uses (and which can't be trapped). Killing an app 'politely' on
|
|
|
|
|
Windows involves first sending a WM_CLOSE message, something that is
|
|
|
|
|
caught already by the Qt frontend.
|
|
|
|
|
|
|
|
|
|
For more information see:
|
|
|
|
|
|
|
|
|
|
http://aspn.activestate.com/ASPN/Mail/Message/ActiveTcl/2034055
|
|
|
|
|
...signals are mostly useless on Windows for a variety of reasons that are
|
|
|
|
|
Windows specific...
|
|
|
|
|
|
|
|
|
|
'UNIX Application Migration Guide, Chapter 9'
|
|
|
|
|
http://msdn.microsoft.com/library/en-us/dnucmg/html/UCMGch09.asp
|
|
|
|
|
|
|
|
|
|
'How To Terminate an Application "Cleanly" in Win32'
|
|
|
|
|
http://support.microsoft.com/default.aspx?scid=kb;en-us;178893
|
|
|
|
|
*/
|
2001-09-09 22:02:19 +00:00
|
|
|
|
extern "C" {
|
2002-03-21 17:27:08 +00:00
|
|
|
|
|
2002-08-07 23:43:38 +00:00
|
|
|
|
static void error_handler(int err_sig)
|
2001-09-09 22:02:19 +00:00
|
|
|
|
{
|
2004-03-22 13:09:59 +00:00
|
|
|
|
// Throw away any signals other than the first one received.
|
|
|
|
|
static sig_atomic_t handling_error = false;
|
|
|
|
|
if (handling_error)
|
|
|
|
|
return;
|
|
|
|
|
handling_error = true;
|
|
|
|
|
|
|
|
|
|
// We have received a signal indicating a fatal error, so
|
|
|
|
|
// try and save the data ASAP.
|
|
|
|
|
LyX::cref().emergencyCleanup();
|
|
|
|
|
|
|
|
|
|
// These lyxerr calls may or may not work:
|
|
|
|
|
|
|
|
|
|
// Signals are asynchronous, so the main program may be in a very
|
|
|
|
|
// fragile state when a signal is processed and thus while a signal
|
|
|
|
|
// handler function executes.
|
|
|
|
|
// In general, therefore, we should avoid performing any
|
|
|
|
|
// I/O operations or calling most library and system functions from
|
|
|
|
|
// signal handlers.
|
|
|
|
|
|
|
|
|
|
// This shouldn't matter here, however, as we've already invoked
|
|
|
|
|
// emergencyCleanup.
|
2001-09-09 22:02:19 +00:00
|
|
|
|
switch (err_sig) {
|
2005-01-19 14:17:36 +00:00
|
|
|
|
#ifdef SIGHUP
|
2001-09-09 22:02:19 +00:00
|
|
|
|
case SIGHUP:
|
2004-03-22 13:09:59 +00:00
|
|
|
|
lyxerr << "\nlyx: SIGHUP signal caught\nBye." << endl;
|
2001-09-09 22:02:19 +00:00
|
|
|
|
break;
|
2005-01-19 14:17:36 +00:00
|
|
|
|
#endif
|
2001-09-09 22:02:19 +00:00
|
|
|
|
case SIGFPE:
|
2004-03-22 13:09:59 +00:00
|
|
|
|
lyxerr << "\nlyx: SIGFPE signal caught\nBye." << endl;
|
2001-09-09 22:02:19 +00:00
|
|
|
|
break;
|
|
|
|
|
case SIGSEGV:
|
2004-03-22 13:09:59 +00:00
|
|
|
|
lyxerr << "\nlyx: SIGSEGV signal caught\n"
|
2006-04-05 23:56:29 +00:00
|
|
|
|
"Sorry, you have found a bug in LyX. "
|
|
|
|
|
"Please read the bug-reporting instructions "
|
|
|
|
|
"in Help->Introduction and send us a bug report, "
|
|
|
|
|
"if necessary. Thanks !\nBye." << endl;
|
2001-09-09 22:02:19 +00:00
|
|
|
|
break;
|
2004-03-22 13:09:59 +00:00
|
|
|
|
case SIGINT:
|
2001-09-09 22:02:19 +00:00
|
|
|
|
case SIGTERM:
|
|
|
|
|
// no comments
|
|
|
|
|
break;
|
|
|
|
|
}
|
2002-03-21 17:27:08 +00:00
|
|
|
|
|
2001-09-09 22:02:19 +00:00
|
|
|
|
// Deinstall the signal handlers
|
2005-01-19 14:17:36 +00:00
|
|
|
|
#ifdef SIGHUP
|
2001-09-09 22:02:19 +00:00
|
|
|
|
signal(SIGHUP, SIG_DFL);
|
2005-01-19 14:17:36 +00:00
|
|
|
|
#endif
|
2001-09-09 22:02:19 +00:00
|
|
|
|
signal(SIGINT, SIG_DFL);
|
|
|
|
|
signal(SIGFPE, SIG_DFL);
|
|
|
|
|
signal(SIGSEGV, SIG_DFL);
|
|
|
|
|
signal(SIGTERM, SIG_DFL);
|
|
|
|
|
|
2005-01-19 14:17:36 +00:00
|
|
|
|
#ifdef SIGHUP
|
2004-03-22 13:09:59 +00:00
|
|
|
|
if (err_sig == SIGSEGV ||
|
2005-02-15 13:45:41 +00:00
|
|
|
|
(err_sig != SIGHUP && !getEnv("LYXDEBUG").empty()))
|
2005-01-19 14:17:36 +00:00
|
|
|
|
#else
|
2005-02-15 13:45:41 +00:00
|
|
|
|
if (err_sig == SIGSEGV || !getEnv("LYXDEBUG").empty())
|
2005-01-19 14:17:36 +00:00
|
|
|
|
#endif
|
2006-10-21 00:16:43 +00:00
|
|
|
|
support::abort();
|
2001-09-09 22:02:19 +00:00
|
|
|
|
exit(0);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
1999-09-27 18:44:28 +00:00
|
|
|
|
|
2003-06-20 23:03:43 +00:00
|
|
|
|
void LyX::printError(ErrorItem const & ei)
|
|
|
|
|
{
|
2006-10-21 00:16:43 +00:00
|
|
|
|
docstring tmp = _("LyX: ") + ei.error + char_type(':')
|
2006-09-11 08:54:10 +00:00
|
|
|
|
+ ei.description;
|
2006-10-21 00:16:43 +00:00
|
|
|
|
std::cerr << to_utf8(tmp) << std::endl;
|
2003-06-20 23:03:43 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2006-10-17 08:36:04 +00:00
|
|
|
|
void LyX::initGuiFont()
|
|
|
|
|
{
|
|
|
|
|
if (lyxrc.roman_font_name.empty())
|
2006-10-19 07:20:32 +00:00
|
|
|
|
lyxrc.roman_font_name = pimpl_->application_->romanFontName();
|
2006-10-17 08:36:04 +00:00
|
|
|
|
|
|
|
|
|
if (lyxrc.sans_font_name.empty())
|
2006-10-19 07:20:32 +00:00
|
|
|
|
lyxrc.sans_font_name = pimpl_->application_->sansFontName();
|
2006-10-17 08:36:04 +00:00
|
|
|
|
|
|
|
|
|
if (lyxrc.typewriter_font_name.empty())
|
|
|
|
|
lyxrc.typewriter_font_name
|
2006-10-19 07:20:32 +00:00
|
|
|
|
= pimpl_->application_->typewriterFontName();
|
2006-10-17 08:36:04 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2006-07-05 17:01:26 +00:00
|
|
|
|
bool LyX::init()
|
1999-09-27 18:44:28 +00:00
|
|
|
|
{
|
2005-01-19 14:17:36 +00:00
|
|
|
|
#ifdef SIGHUP
|
2000-05-21 18:40:10 +00:00
|
|
|
|
signal(SIGHUP, error_handler);
|
2005-01-19 14:17:36 +00:00
|
|
|
|
#endif
|
2000-05-21 18:40:10 +00:00
|
|
|
|
signal(SIGFPE, error_handler);
|
|
|
|
|
signal(SIGSEGV, error_handler);
|
|
|
|
|
signal(SIGINT, error_handler);
|
|
|
|
|
signal(SIGTERM, error_handler);
|
2004-03-22 13:09:59 +00:00
|
|
|
|
// SIGPIPE can be safely ignored.
|
1999-09-27 18:44:28 +00:00
|
|
|
|
|
2005-01-10 19:17:43 +00:00
|
|
|
|
lyxrc.tempdir_path = package().temp_dir();
|
|
|
|
|
lyxrc.document_path = package().document_dir();
|
2005-01-12 10:30:46 +00:00
|
|
|
|
|
2001-12-28 13:26:54 +00:00
|
|
|
|
if (lyxrc.template_path.empty()) {
|
2006-04-08 22:31:11 +00:00
|
|
|
|
lyxrc.template_path = addPath(package().system_support(),
|
2005-01-10 19:17:43 +00:00
|
|
|
|
"templates");
|
1999-09-27 18:44:28 +00:00
|
|
|
|
}
|
2002-03-21 17:27:08 +00:00
|
|
|
|
|
1999-09-27 18:44:28 +00:00
|
|
|
|
//
|
|
|
|
|
// Read configuration files
|
|
|
|
|
//
|
|
|
|
|
|
2006-05-02 12:53:48 +00:00
|
|
|
|
// This one may have been distributed along with LyX.
|
2006-07-05 17:01:26 +00:00
|
|
|
|
if (!readRcFile("lyxrc.dist"))
|
|
|
|
|
return false;
|
2006-05-09 15:41:42 +00:00
|
|
|
|
|
|
|
|
|
// Set the PATH correctly.
|
|
|
|
|
#if !defined (USE_POSIX_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());
|
|
|
|
|
#endif
|
|
|
|
|
if (!lyxrc.path_prefix.empty())
|
|
|
|
|
prependEnvPath("PATH", lyxrc.path_prefix);
|
|
|
|
|
|
2006-09-09 15:27:44 +00:00
|
|
|
|
// Check that user LyX directory is ok.
|
2006-08-11 22:11:33 +00:00
|
|
|
|
if (queryUserLyXDir(package().explicit_user_support()))
|
|
|
|
|
reconfigureUserLyXDir();
|
|
|
|
|
|
|
|
|
|
// no need for a splash when there is no GUI
|
2006-10-21 00:16:43 +00:00
|
|
|
|
if (!use_gui) {
|
2006-05-09 15:41:42 +00:00
|
|
|
|
first_start = false;
|
|
|
|
|
}
|
|
|
|
|
|
2006-05-02 12:53:48 +00:00
|
|
|
|
// This one is generated in user_support directory by lib/configure.py.
|
2006-07-05 17:01:26 +00:00
|
|
|
|
if (!readRcFile("lyxrc.defaults"))
|
|
|
|
|
return false;
|
2006-05-02 12:53:48 +00:00
|
|
|
|
|
2006-05-17 22:13:33 +00:00
|
|
|
|
// Query the OS to know what formats are viewed natively
|
|
|
|
|
formats.setAutoOpen();
|
|
|
|
|
|
2006-10-23 18:01:31 +00:00
|
|
|
|
// Read lyxrc.dist again to be able to override viewer auto-detection.
|
|
|
|
|
readRcFile("lyxrc.dist");
|
|
|
|
|
|
2000-10-10 14:17:33 +00:00
|
|
|
|
system_lyxrc = lyxrc;
|
2000-11-06 11:20:22 +00:00
|
|
|
|
system_formats = formats;
|
2000-11-13 10:35:02 +00:00
|
|
|
|
system_converters = converters;
|
2004-10-26 18:39:13 +00:00
|
|
|
|
system_movers = movers;
|
2000-11-15 18:02:45 +00:00
|
|
|
|
system_lcolor = lcolor;
|
2000-11-06 11:20:22 +00:00
|
|
|
|
|
2006-05-02 12:53:48 +00:00
|
|
|
|
// This one is edited through the preferences dialog.
|
2006-07-05 17:01:26 +00:00
|
|
|
|
if (!readRcFile("preferences"))
|
|
|
|
|
return false;
|
1999-09-27 18:44:28 +00:00
|
|
|
|
|
2006-07-05 17:01:26 +00:00
|
|
|
|
if (!readEncodingsFile("encodings"))
|
|
|
|
|
return false;
|
|
|
|
|
if (!readLanguagesFile("languages"))
|
|
|
|
|
return false;
|
2000-10-10 12:36:36 +00:00
|
|
|
|
|
|
|
|
|
// Load the layouts
|
|
|
|
|
lyxerr[Debug::INIT] << "Reading layouts..." << endl;
|
2006-07-05 17:01:26 +00:00
|
|
|
|
if (!LyXSetStyle())
|
|
|
|
|
return false;
|
2000-10-10 12:36:36 +00:00
|
|
|
|
|
2006-10-21 00:16:43 +00:00
|
|
|
|
if (use_gui) {
|
2003-07-26 23:04:39 +00:00
|
|
|
|
// Set up bindings
|
2006-10-19 07:20:32 +00:00
|
|
|
|
pimpl_->toplevel_keymap_.reset(new kb_keymap);
|
|
|
|
|
defaultKeyBindings(pimpl_->toplevel_keymap_.get());
|
|
|
|
|
pimpl_->toplevel_keymap_->read(lyxrc.bind_file);
|
|
|
|
|
|
|
|
|
|
pimpl_->lyxfunc_.initKeySequences(pimpl_->toplevel_keymap_.get());
|
1999-09-27 18:44:28 +00:00
|
|
|
|
|
2003-07-26 23:04:39 +00:00
|
|
|
|
// Read menus
|
2006-07-05 17:01:26 +00:00
|
|
|
|
if (!readUIFile(lyxrc.ui_file))
|
|
|
|
|
return false;
|
2003-07-26 23:04:39 +00:00
|
|
|
|
}
|
2000-05-10 11:50:11 +00:00
|
|
|
|
|
2003-04-02 18:08:05 +00:00
|
|
|
|
if (lyxerr.debugging(Debug::LYXRC))
|
2000-03-12 10:35:05 +00:00
|
|
|
|
lyxrc.print();
|
1999-09-27 18:44:28 +00:00
|
|
|
|
|
2006-06-27 10:51:24 +00:00
|
|
|
|
os::windows_style_tex_paths(lyxrc.windows_style_tex_paths);
|
2005-02-13 17:12:34 +00:00
|
|
|
|
if (!lyxrc.path_prefix.empty())
|
|
|
|
|
prependEnvPath("PATH", lyxrc.path_prefix);
|
2005-01-16 21:01:41 +00:00
|
|
|
|
|
2005-02-01 16:41:24 +00:00
|
|
|
|
if (fs::exists(lyxrc.document_path) &&
|
|
|
|
|
fs::is_directory(lyxrc.document_path))
|
2005-01-16 21:01:41 +00:00
|
|
|
|
package().document_dir() = lyxrc.document_path;
|
2005-01-10 19:17:43 +00:00
|
|
|
|
|
2006-11-26 21:30:39 +00:00
|
|
|
|
package().temp_dir() = createLyXTmpDir(FileName(lyxrc.tempdir_path)).absFilename();
|
2005-01-10 19:17:43 +00:00
|
|
|
|
if (package().temp_dir().empty()) {
|
2006-09-11 08:54:10 +00:00
|
|
|
|
Alert::error(_("Could not create temporary directory"),
|
|
|
|
|
bformat(_("Could not create a temporary directory in\n"
|
2006-09-09 15:27:44 +00:00
|
|
|
|
"%1$s. Make sure that this\n"
|
2006-09-11 08:54:10 +00:00
|
|
|
|
"path exists and is writable and try again."),
|
2006-10-21 00:16:43 +00:00
|
|
|
|
from_utf8(lyxrc.tempdir_path)));
|
2004-02-25 12:00:53 +00:00
|
|
|
|
// createLyXTmpDir() tries sufficiently hard to create a
|
|
|
|
|
// usable temp dir, so the probability to come here is
|
|
|
|
|
// close to zero. We therefore don't try to overcome this
|
|
|
|
|
// problem with e.g. asking the user for a new path and
|
|
|
|
|
// trying again but simply exit.
|
2006-07-05 17:01:26 +00:00
|
|
|
|
return false;
|
2004-02-25 12:00:53 +00:00
|
|
|
|
}
|
|
|
|
|
|
1999-10-07 18:44:17 +00:00
|
|
|
|
if (lyxerr.debugging(Debug::INIT)) {
|
2005-01-10 19:17:43 +00:00
|
|
|
|
lyxerr << "LyX tmp dir: `" << package().temp_dir() << '\'' << endl;
|
1999-09-27 18:44:28 +00:00
|
|
|
|
}
|
|
|
|
|
|
2006-04-05 22:56:18 +00:00
|
|
|
|
lyxerr[Debug::INIT] << "Reading session information '.lyx/session'..." << endl;
|
2006-10-21 00:16:43 +00:00
|
|
|
|
pimpl_->session_.reset(new Session(lyxrc.num_lastfiles));
|
2006-11-13 10:27:57 +00:00
|
|
|
|
|
|
|
|
|
// This must happen after package initialization and after lyxrc is
|
|
|
|
|
// read, therefore it can't be done by a static object.
|
|
|
|
|
ConverterCache::init();
|
|
|
|
|
|
2006-07-05 17:01:26 +00:00
|
|
|
|
return true;
|
1999-09-27 18:44:28 +00:00
|
|
|
|
}
|
|
|
|
|
|
2000-10-11 21:06:43 +00:00
|
|
|
|
|
2000-05-10 11:50:11 +00:00
|
|
|
|
void LyX::defaultKeyBindings(kb_keymap * kbmap)
|
|
|
|
|
{
|
2006-05-05 20:23:12 +00:00
|
|
|
|
kbmap->bind("Right", FuncRequest(LFUN_CHAR_FORWARD));
|
|
|
|
|
kbmap->bind("Left", FuncRequest(LFUN_CHAR_BACKWARD));
|
2003-09-21 23:00:47 +00:00
|
|
|
|
kbmap->bind("Up", FuncRequest(LFUN_UP));
|
|
|
|
|
kbmap->bind("Down", FuncRequest(LFUN_DOWN));
|
2002-03-21 17:27:08 +00:00
|
|
|
|
|
2003-09-21 23:00:47 +00:00
|
|
|
|
kbmap->bind("Tab", FuncRequest(LFUN_CELL_FORWARD));
|
2005-03-21 11:14:54 +00:00
|
|
|
|
kbmap->bind("C-Tab", FuncRequest(LFUN_CELL_SPLIT));
|
|
|
|
|
kbmap->bind("~S-ISO_Left_Tab", FuncRequest(LFUN_CELL_BACKWARD));
|
|
|
|
|
kbmap->bind("~S-BackTab", FuncRequest(LFUN_CELL_BACKWARD));
|
2002-03-21 17:27:08 +00:00
|
|
|
|
|
2006-05-05 20:23:12 +00:00
|
|
|
|
kbmap->bind("Home", FuncRequest(LFUN_LINE_BEGIN));
|
|
|
|
|
kbmap->bind("End", FuncRequest(LFUN_LINE_END));
|
|
|
|
|
kbmap->bind("Prior", FuncRequest(LFUN_SCREEN_UP));
|
|
|
|
|
kbmap->bind("Next", FuncRequest(LFUN_SCREEN_DOWN));
|
2002-03-21 17:27:08 +00:00
|
|
|
|
|
2006-05-05 20:23:12 +00:00
|
|
|
|
kbmap->bind("Return", FuncRequest(LFUN_BREAK_PARAGRAPH));
|
2003-09-21 23:00:47 +00:00
|
|
|
|
//kbmap->bind("~C-~S-~M-nobreakspace", FuncRequest(LFUN_PROTECTEDSPACE));
|
2002-03-21 17:27:08 +00:00
|
|
|
|
|
2006-05-08 18:09:19 +00:00
|
|
|
|
kbmap->bind("Delete", FuncRequest(LFUN_CHAR_DELETE_FORWARD));
|
|
|
|
|
kbmap->bind("BackSpace", FuncRequest(LFUN_CHAR_DELETE_BACKWARD));
|
2001-12-12 14:37:59 +00:00
|
|
|
|
|
2000-05-10 11:50:11 +00:00
|
|
|
|
// kbmap->bindings to enable the use of the numeric keypad
|
|
|
|
|
// e.g. Num Lock set
|
2006-05-05 20:23:12 +00:00
|
|
|
|
//kbmap->bind("KP_0", FuncRequest(LFUN_SELF_INSERT));
|
|
|
|
|
//kbmap->bind("KP_Decimal", FuncRequest(LFUN_SELF_INSERT));
|
|
|
|
|
kbmap->bind("KP_Enter", FuncRequest(LFUN_BREAK_PARAGRAPH));
|
|
|
|
|
//kbmap->bind("KP_1", FuncRequest(LFUN_SELF_INSERT));
|
|
|
|
|
//kbmap->bind("KP_2", FuncRequest(LFUN_SELF_INSERT));
|
|
|
|
|
//kbmap->bind("KP_3", FuncRequest(LFUN_SELF_INSERT));
|
|
|
|
|
//kbmap->bind("KP_4", FuncRequest(LFUN_SELF_INSERT));
|
|
|
|
|
//kbmap->bind("KP_5", FuncRequest(LFUN_SELF_INSERT));
|
|
|
|
|
//kbmap->bind("KP_6", FuncRequest(LFUN_SELF_INSERT));
|
|
|
|
|
//kbmap->bind("KP_Add", FuncRequest(LFUN_SELF_INSERT));
|
|
|
|
|
//kbmap->bind("KP_7", FuncRequest(LFUN_SELF_INSERT));
|
|
|
|
|
//kbmap->bind("KP_8", FuncRequest(LFUN_SELF_INSERT));
|
|
|
|
|
//kbmap->bind("KP_9", FuncRequest(LFUN_SELF_INSERT));
|
|
|
|
|
//kbmap->bind("KP_Divide", FuncRequest(LFUN_SELF_INSERT));
|
|
|
|
|
//kbmap->bind("KP_Multiply", FuncRequest(LFUN_SELF_INSERT));
|
|
|
|
|
//kbmap->bind("KP_Subtract", FuncRequest(LFUN_SELF_INSERT));
|
|
|
|
|
kbmap->bind("KP_Right", FuncRequest(LFUN_CHAR_FORWARD));
|
|
|
|
|
kbmap->bind("KP_Left", FuncRequest(LFUN_CHAR_BACKWARD));
|
2003-09-21 23:00:47 +00:00
|
|
|
|
kbmap->bind("KP_Up", FuncRequest(LFUN_UP));
|
|
|
|
|
kbmap->bind("KP_Down", FuncRequest(LFUN_DOWN));
|
2006-05-05 20:23:12 +00:00
|
|
|
|
kbmap->bind("KP_Home", FuncRequest(LFUN_LINE_BEGIN));
|
|
|
|
|
kbmap->bind("KP_End", FuncRequest(LFUN_LINE_END));
|
|
|
|
|
kbmap->bind("KP_Prior", FuncRequest(LFUN_SCREEN_UP));
|
|
|
|
|
kbmap->bind("KP_Next", FuncRequest(LFUN_SCREEN_DOWN));
|
2000-05-10 11:50:11 +00:00
|
|
|
|
}
|
|
|
|
|
|
2000-10-11 21:06:43 +00:00
|
|
|
|
|
2003-10-14 21:30:23 +00:00
|
|
|
|
void LyX::emergencyCleanup() const
|
2001-10-19 15:13:49 +00:00
|
|
|
|
{
|
|
|
|
|
// what to do about tmpfiles is non-obvious. we would
|
|
|
|
|
// like to delete any we find, but our lyxdir might
|
|
|
|
|
// contain documents etc. which might be helpful on
|
|
|
|
|
// a crash
|
2002-03-21 17:27:08 +00:00
|
|
|
|
|
2006-10-19 07:20:32 +00:00
|
|
|
|
pimpl_->buffer_list_.emergencyWriteAll();
|
2006-10-21 00:16:43 +00:00
|
|
|
|
if (use_gui) {
|
2006-10-19 07:20:32 +00:00
|
|
|
|
pimpl_->lyx_server_->emergencyCleanup();
|
2006-10-20 09:56:28 +00:00
|
|
|
|
pimpl_->lyx_server_.reset();
|
|
|
|
|
pimpl_->lyx_socket_.reset();
|
|
|
|
|
}
|
2001-10-19 15:13:49 +00:00
|
|
|
|
}
|
|
|
|
|
|
2002-03-21 17:27:08 +00:00
|
|
|
|
|
2000-05-10 11:50:11 +00:00
|
|
|
|
void LyX::deadKeyBindings(kb_keymap * kbmap)
|
|
|
|
|
{
|
|
|
|
|
// bindKeyings for transparent handling of deadkeys
|
|
|
|
|
// The keysyms are gotten from XFree86 X11R6
|
2006-05-05 20:23:12 +00:00
|
|
|
|
kbmap->bind("~C-~S-~M-dead_acute", FuncRequest(LFUN_ACCENT_ACUTE));
|
|
|
|
|
kbmap->bind("~C-~S-~M-dead_breve", FuncRequest(LFUN_ACCENT_BREVE));
|
|
|
|
|
kbmap->bind("~C-~S-~M-dead_caron", FuncRequest(LFUN_ACCENT_CARON));
|
|
|
|
|
kbmap->bind("~C-~S-~M-dead_cedilla", FuncRequest(LFUN_ACCENT_CEDILLA));
|
|
|
|
|
kbmap->bind("~C-~S-~M-dead_abovering", FuncRequest(LFUN_ACCENT_CIRCLE));
|
|
|
|
|
kbmap->bind("~C-~S-~M-dead_circumflex", FuncRequest(LFUN_ACCENT_CIRCUMFLEX));
|
|
|
|
|
kbmap->bind("~C-~S-~M-dead_abovedot", FuncRequest(LFUN_ACCENT_DOT));
|
|
|
|
|
kbmap->bind("~C-~S-~M-dead_grave", FuncRequest(LFUN_ACCENT_GRAVE));
|
|
|
|
|
kbmap->bind("~C-~S-~M-dead_doubleacute", FuncRequest(LFUN_ACCENT_HUNGARIAN_UMLAUT));
|
|
|
|
|
kbmap->bind("~C-~S-~M-dead_macron", FuncRequest(LFUN_ACCENT_MACRON));
|
2000-05-10 11:50:11 +00:00
|
|
|
|
// nothing with this name
|
2006-05-05 20:23:12 +00:00
|
|
|
|
// kbmap->bind("~C-~S-~M-dead_special_caron", LFUN_ACCENT_SPECIAL_CARON);
|
|
|
|
|
kbmap->bind("~C-~S-~M-dead_tilde", FuncRequest(LFUN_ACCENT_TILDE));
|
|
|
|
|
kbmap->bind("~C-~S-~M-dead_diaeresis", FuncRequest(LFUN_ACCENT_UMLAUT));
|
2000-05-10 11:50:11 +00:00
|
|
|
|
// nothing with this name either...
|
2006-05-05 20:23:12 +00:00
|
|
|
|
//kbmap->bind("~C-~S-~M-dead_underbar", FuncRequest(LFUN_ACCENT_UNDERBAR));
|
|
|
|
|
kbmap->bind("~C-~S-~M-dead_belowdot", FuncRequest(LFUN_ACCENT_UNDERDOT));
|
|
|
|
|
kbmap->bind("~C-~S-~M-dead_tie", FuncRequest(LFUN_ACCENT_TIE));
|
|
|
|
|
kbmap->bind("~C-~S-~M-dead_ogonek",FuncRequest(LFUN_ACCENT_OGONEK));
|
2000-05-10 11:50:11 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2006-05-09 15:41:42 +00:00
|
|
|
|
namespace {
|
|
|
|
|
|
|
|
|
|
// return true if file does not exist or is older than configure.py.
|
|
|
|
|
bool needsUpdate(string const & file)
|
1999-09-27 18:44:28 +00:00
|
|
|
|
{
|
2006-05-09 15:41:42 +00:00
|
|
|
|
static string const configure_script =
|
|
|
|
|
addName(package().system_support(), "configure.py");
|
|
|
|
|
string const absfile =
|
|
|
|
|
addName(package().user_support(), file);
|
|
|
|
|
|
|
|
|
|
return (! fs::exists(absfile))
|
2006-09-09 15:27:44 +00:00
|
|
|
|
|| (fs::last_write_time(configure_script)
|
2006-05-09 15:41:42 +00:00
|
|
|
|
> fs::last_write_time(absfile));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
2002-10-07 13:31:37 +00:00
|
|
|
|
|
2006-05-09 15:41:42 +00:00
|
|
|
|
bool LyX::queryUserLyXDir(bool explicit_userdir)
|
|
|
|
|
{
|
1999-09-27 18:44:28 +00:00
|
|
|
|
// Does user directory exist?
|
2005-02-01 16:41:24 +00:00
|
|
|
|
if (fs::exists(package().user_support()) &&
|
|
|
|
|
fs::is_directory(package().user_support())) {
|
1999-09-27 18:44:28 +00:00
|
|
|
|
first_start = false;
|
2006-09-09 15:27:44 +00:00
|
|
|
|
|
|
|
|
|
return needsUpdate("lyxrc.defaults")
|
|
|
|
|
|| needsUpdate("textclass.lst")
|
2006-05-09 15:41:42 +00:00
|
|
|
|
|| needsUpdate("packages.lst");
|
1999-09-27 18:44:28 +00:00
|
|
|
|
}
|
2002-08-11 16:27:10 +00:00
|
|
|
|
|
2002-08-07 23:43:38 +00:00
|
|
|
|
first_start = !explicit_userdir;
|
2002-03-21 17:27:08 +00:00
|
|
|
|
|
2005-01-10 19:17:43 +00:00
|
|
|
|
// If the user specified explicitly a directory, ask whether
|
|
|
|
|
// to create it. If the user says "no", then exit.
|
|
|
|
|
if (explicit_userdir &&
|
2005-03-18 16:17:05 +00:00
|
|
|
|
Alert::prompt(
|
2006-09-11 08:54:10 +00:00
|
|
|
|
_("Missing user LyX directory"),
|
|
|
|
|
bformat(_("You have specified a non-existent user "
|
2006-09-09 15:27:44 +00:00
|
|
|
|
"LyX directory, %1$s.\n"
|
2006-09-11 08:54:10 +00:00
|
|
|
|
"It is needed to keep your own configuration."),
|
2006-10-21 00:16:43 +00:00
|
|
|
|
from_utf8(package().user_support())),
|
2005-01-10 19:17:43 +00:00
|
|
|
|
1, 0,
|
2006-09-11 08:54:10 +00:00
|
|
|
|
_("&Create directory"),
|
|
|
|
|
_("&Exit LyX"))) {
|
2006-10-21 00:16:43 +00:00
|
|
|
|
lyxerr << to_utf8(_("No user LyX directory. Exiting.")) << endl;
|
2006-10-17 08:36:04 +00:00
|
|
|
|
earlyExit(EXIT_FAILURE);
|
2005-01-10 19:17:43 +00:00
|
|
|
|
}
|
|
|
|
|
|
2006-10-21 00:16:43 +00:00
|
|
|
|
lyxerr << to_utf8(bformat(_("LyX: Creating directory %1$s"),
|
|
|
|
|
from_utf8(package().user_support())))
|
2005-01-16 21:01:41 +00:00
|
|
|
|
<< endl;
|
1999-09-27 18:44:28 +00:00
|
|
|
|
|
2005-01-10 19:17:43 +00:00
|
|
|
|
if (!createDirectory(package().user_support(), 0755)) {
|
|
|
|
|
// Failed, so let's exit.
|
2006-10-21 00:16:43 +00:00
|
|
|
|
lyxerr << to_utf8(_("Failed to create directory. Exiting."))
|
2005-01-10 19:17:43 +00:00
|
|
|
|
<< endl;
|
2006-10-17 08:36:04 +00:00
|
|
|
|
earlyExit(EXIT_FAILURE);
|
1999-09-27 18:44:28 +00:00
|
|
|
|
}
|
|
|
|
|
|
2006-05-09 15:41:42 +00:00
|
|
|
|
return true;
|
1999-09-27 18:44:28 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2006-07-05 17:01:26 +00:00
|
|
|
|
bool LyX::readRcFile(string const & name)
|
1999-09-27 18:44:28 +00:00
|
|
|
|
{
|
2006-05-02 12:53:48 +00:00
|
|
|
|
lyxerr[Debug::INIT] << "About to read " << name << "... ";
|
2002-03-21 17:27:08 +00:00
|
|
|
|
|
2006-11-26 21:30:39 +00:00
|
|
|
|
FileName const lyxrc_path = libFileSearch(string(), name);
|
2002-02-16 15:59:55 +00:00
|
|
|
|
if (!lyxrc_path.empty()) {
|
2003-04-02 18:08:05 +00:00
|
|
|
|
|
2006-05-02 12:53:48 +00:00
|
|
|
|
lyxerr[Debug::INIT] << "Found in " << lyxrc_path << endl;
|
2003-04-02 18:08:05 +00:00
|
|
|
|
|
2006-07-05 17:01:26 +00:00
|
|
|
|
if (lyxrc.read(lyxrc_path) < 0) {
|
2006-05-02 12:53:48 +00:00
|
|
|
|
showFileError(name);
|
2006-07-05 17:01:26 +00:00
|
|
|
|
return false;
|
|
|
|
|
}
|
2006-05-02 12:53:48 +00:00
|
|
|
|
} else
|
|
|
|
|
lyxerr[Debug::INIT] << "Not found." << lyxrc_path << endl;
|
2006-07-05 17:01:26 +00:00
|
|
|
|
return true;
|
2002-03-21 17:27:08 +00:00
|
|
|
|
|
1999-09-27 18:44:28 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2000-07-24 13:53:19 +00:00
|
|
|
|
// Read the ui file `name'
|
2006-07-05 17:01:26 +00:00
|
|
|
|
bool LyX::readUIFile(string const & name)
|
2000-07-24 13:53:19 +00:00
|
|
|
|
{
|
|
|
|
|
enum Uitags {
|
|
|
|
|
ui_menuset = 1,
|
|
|
|
|
ui_toolbar,
|
2003-06-11 19:21:46 +00:00
|
|
|
|
ui_toolbars,
|
2003-04-15 02:28:53 +00:00
|
|
|
|
ui_include,
|
2000-07-24 13:53:19 +00:00
|
|
|
|
ui_last
|
|
|
|
|
};
|
|
|
|
|
|
2002-08-11 16:27:10 +00:00
|
|
|
|
struct keyword_item uitags[ui_last - 1] = {
|
2003-04-15 02:28:53 +00:00
|
|
|
|
{ "include", ui_include },
|
2000-07-24 13:53:19 +00:00
|
|
|
|
{ "menuset", ui_menuset },
|
2003-06-11 19:21:46 +00:00
|
|
|
|
{ "toolbar", ui_toolbar },
|
|
|
|
|
{ "toolbars", ui_toolbars }
|
2000-07-24 13:53:19 +00:00
|
|
|
|
};
|
|
|
|
|
|
2003-04-15 02:28:53 +00:00
|
|
|
|
// Ensure that a file is read only once (prevents include loops)
|
|
|
|
|
static std::list<string> uifiles;
|
|
|
|
|
std::list<string>::const_iterator it = uifiles.begin();
|
|
|
|
|
std::list<string>::const_iterator end = uifiles.end();
|
|
|
|
|
it = std::find(it, end, name);
|
|
|
|
|
if (it != end) {
|
|
|
|
|
lyxerr[Debug::INIT] << "UI file '" << name
|
|
|
|
|
<< "' has been read already. "
|
|
|
|
|
<< "Is this an include loop?"
|
|
|
|
|
<< endl;
|
2006-07-05 17:01:26 +00:00
|
|
|
|
return false;
|
2003-04-15 02:28:53 +00:00
|
|
|
|
}
|
|
|
|
|
|
2000-07-24 13:53:19 +00:00
|
|
|
|
lyxerr[Debug::INIT] << "About to read " << name << "..." << endl;
|
2002-03-21 17:27:08 +00:00
|
|
|
|
|
2006-11-26 21:30:39 +00:00
|
|
|
|
FileName const ui_path = libFileSearch("ui", name, "ui");
|
2000-07-24 13:53:19 +00:00
|
|
|
|
|
|
|
|
|
if (ui_path.empty()) {
|
2002-03-21 17:27:08 +00:00
|
|
|
|
lyxerr[Debug::INIT] << "Could not find " << name << endl;
|
2003-04-02 18:08:05 +00:00
|
|
|
|
showFileError(name);
|
2006-07-05 17:01:26 +00:00
|
|
|
|
return false;
|
2000-07-24 13:53:19 +00:00
|
|
|
|
}
|
2003-04-15 02:28:53 +00:00
|
|
|
|
uifiles.push_back(name);
|
2002-03-21 17:27:08 +00:00
|
|
|
|
|
2000-07-24 13:53:19 +00:00
|
|
|
|
lyxerr[Debug::INIT] << "Found " << name
|
|
|
|
|
<< " in " << ui_path << endl;
|
|
|
|
|
LyXLex lex(uitags, ui_last - 1);
|
|
|
|
|
lex.setFile(ui_path);
|
2001-08-07 07:36:56 +00:00
|
|
|
|
if (!lex.isOK()) {
|
2000-07-24 21:49:58 +00:00
|
|
|
|
lyxerr << "Unable to set LyXLeX for ui file: " << ui_path
|
|
|
|
|
<< endl;
|
|
|
|
|
}
|
2002-03-21 17:27:08 +00:00
|
|
|
|
|
2000-07-24 13:53:19 +00:00
|
|
|
|
if (lyxerr.debugging(Debug::PARSER))
|
|
|
|
|
lex.printTable(lyxerr);
|
|
|
|
|
|
2001-08-07 07:36:56 +00:00
|
|
|
|
while (lex.isOK()) {
|
2000-11-04 10:00:12 +00:00
|
|
|
|
switch (lex.lex()) {
|
2003-04-15 02:28:53 +00:00
|
|
|
|
case ui_include: {
|
|
|
|
|
lex.next(true);
|
|
|
|
|
string const file = lex.getString();
|
2006-07-05 17:01:26 +00:00
|
|
|
|
if (!readUIFile(file))
|
|
|
|
|
return false;
|
2003-04-15 02:28:53 +00:00
|
|
|
|
break;
|
|
|
|
|
}
|
2002-03-21 17:27:08 +00:00
|
|
|
|
case ui_menuset:
|
2000-07-24 13:53:19 +00:00
|
|
|
|
menubackend.read(lex);
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case ui_toolbar:
|
2003-04-02 18:08:05 +00:00
|
|
|
|
toolbarbackend.read(lex);
|
2000-07-24 13:53:19 +00:00
|
|
|
|
break;
|
|
|
|
|
|
2003-06-11 19:21:46 +00:00
|
|
|
|
case ui_toolbars:
|
|
|
|
|
toolbarbackend.readToolbars(lex);
|
|
|
|
|
break;
|
|
|
|
|
|
2000-07-24 13:53:19 +00:00
|
|
|
|
default:
|
2002-07-28 22:50:13 +00:00
|
|
|
|
if (!rtrim(lex.getString()).empty())
|
2001-05-03 15:38:24 +00:00
|
|
|
|
lex.printError("LyX::ReadUIFile: "
|
|
|
|
|
"Unknown menu tag: `$$Token'");
|
2000-07-24 13:53:19 +00:00
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
2006-07-05 17:01:26 +00:00
|
|
|
|
return true;
|
2000-07-24 13:53:19 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2000-10-10 12:36:36 +00:00
|
|
|
|
// Read the languages file `name'
|
2006-07-05 17:01:26 +00:00
|
|
|
|
bool LyX::readLanguagesFile(string const & name)
|
2000-10-10 12:36:36 +00:00
|
|
|
|
{
|
|
|
|
|
lyxerr[Debug::INIT] << "About to read " << name << "..." << endl;
|
|
|
|
|
|
2006-11-26 21:30:39 +00:00
|
|
|
|
FileName const lang_path = libFileSearch(string(), name);
|
2000-10-10 12:36:36 +00:00
|
|
|
|
if (lang_path.empty()) {
|
2003-04-02 18:08:05 +00:00
|
|
|
|
showFileError(name);
|
2006-07-05 17:01:26 +00:00
|
|
|
|
return false;
|
2000-10-10 12:36:36 +00:00
|
|
|
|
}
|
|
|
|
|
languages.read(lang_path);
|
2006-07-05 17:01:26 +00:00
|
|
|
|
return true;
|
2000-10-10 12:36:36 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// Read the encodings file `name'
|
2006-07-05 17:01:26 +00:00
|
|
|
|
bool LyX::readEncodingsFile(string const & name)
|
2000-10-10 12:36:36 +00:00
|
|
|
|
{
|
|
|
|
|
lyxerr[Debug::INIT] << "About to read " << name << "..." << endl;
|
|
|
|
|
|
2006-11-26 21:30:39 +00:00
|
|
|
|
FileName const enc_path = libFileSearch(string(), name);
|
2000-10-10 12:36:36 +00:00
|
|
|
|
if (enc_path.empty()) {
|
2003-04-02 18:08:05 +00:00
|
|
|
|
showFileError(name);
|
2006-07-05 17:01:26 +00:00
|
|
|
|
return false;
|
2000-10-10 12:36:36 +00:00
|
|
|
|
}
|
|
|
|
|
encodings.read(enc_path);
|
2006-07-05 17:01:26 +00:00
|
|
|
|
return true;
|
2000-10-10 12:36:36 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2001-03-20 01:22:46 +00:00
|
|
|
|
namespace {
|
|
|
|
|
|
2002-08-07 23:43:38 +00:00
|
|
|
|
string batch;
|
|
|
|
|
|
|
|
|
|
/// return the the number of arguments consumed
|
2002-11-21 18:33:09 +00:00
|
|
|
|
typedef boost::function<int(string const &, string const &)> cmd_helper;
|
2002-08-07 23:43:38 +00:00
|
|
|
|
|
|
|
|
|
int parse_dbg(string const & arg, string const &)
|
1999-09-27 18:44:28 +00:00
|
|
|
|
{
|
2002-08-07 23:43:38 +00:00
|
|
|
|
if (arg.empty()) {
|
2006-10-21 00:16:43 +00:00
|
|
|
|
lyxerr << to_utf8(_("List of supported debug flags:")) << endl;
|
2002-08-07 23:43:38 +00:00
|
|
|
|
Debug::showTags(lyxerr);
|
|
|
|
|
exit(0);
|
|
|
|
|
}
|
2006-10-21 00:16:43 +00:00
|
|
|
|
lyxerr << to_utf8(bformat(_("Setting debug level to %1$s"), from_utf8(arg))) << endl;
|
2002-11-24 15:20:31 +00:00
|
|
|
|
|
2002-08-07 23:43:38 +00:00
|
|
|
|
lyxerr.level(Debug::value(arg));
|
1999-12-13 15:31:52 +00:00
|
|
|
|
Debug::showLevel(lyxerr, lyxerr.level());
|
2002-08-07 23:43:38 +00:00
|
|
|
|
return 1;
|
1999-09-27 18:44:28 +00:00
|
|
|
|
}
|
|
|
|
|
|
2003-05-13 09:48:57 +00:00
|
|
|
|
|
2002-08-07 23:43:38 +00:00
|
|
|
|
int parse_help(string const &, string const &)
|
1999-09-27 18:44:28 +00:00
|
|
|
|
{
|
1999-10-07 18:44:17 +00:00
|
|
|
|
lyxerr <<
|
2006-10-21 00:16:43 +00:00
|
|
|
|
to_utf8(_("Usage: lyx [ command line switches ] [ name.lyx ... ]\n"
|
1999-10-07 18:44:17 +00:00
|
|
|
|
"Command line switches (case sensitive):\n"
|
2000-07-04 20:32:37 +00:00
|
|
|
|
"\t-help summarize LyX usage\n"
|
2006-04-01 13:23:24 +00:00
|
|
|
|
"\t-userdir dir set user directory to dir\n"
|
|
|
|
|
"\t-sysdir dir set system directory to dir\n"
|
2000-07-05 20:16:38 +00:00
|
|
|
|
"\t-geometry WxH+X+Y set geometry of the main window\n"
|
2002-03-21 17:27:08 +00:00
|
|
|
|
"\t-dbg feature[,feature]...\n"
|
|
|
|
|
" select the features to debug.\n"
|
|
|
|
|
" Type `lyx -dbg' to see the list of features\n"
|
2000-11-30 18:11:54 +00:00
|
|
|
|
"\t-x [--execute] command\n"
|
|
|
|
|
" where command is a lyx command.\n"
|
|
|
|
|
"\t-e [--export] fmt\n"
|
|
|
|
|
" where fmt is the export format of choice.\n"
|
|
|
|
|
"\t-i [--import] fmt file.xxx\n"
|
|
|
|
|
" where fmt is the import format of choice\n"
|
|
|
|
|
" and file.xxx is the file to be imported.\n"
|
2001-09-11 13:13:03 +00:00
|
|
|
|
"\t-version summarize version and build info\n"
|
2006-09-09 15:27:44 +00:00
|
|
|
|
"Check the LyX man page for more details.")) << endl;
|
2002-08-07 23:43:38 +00:00
|
|
|
|
exit(0);
|
|
|
|
|
return 0;
|
1999-09-27 18:44:28 +00:00
|
|
|
|
}
|
|
|
|
|
|
2002-08-07 23:43:38 +00:00
|
|
|
|
int parse_version(string const &, string const &)
|
2001-09-11 13:13:03 +00:00
|
|
|
|
{
|
2001-10-03 15:49:32 +00:00
|
|
|
|
lyxerr << "LyX " << lyx_version
|
2006-08-16 21:54:55 +00:00
|
|
|
|
<< " (" << lyx_release_date << ")" << endl;
|
2001-09-11 13:13:03 +00:00
|
|
|
|
lyxerr << "Built on " << __DATE__ << ", " << __TIME__ << endl;
|
|
|
|
|
|
2001-10-03 15:49:32 +00:00
|
|
|
|
lyxerr << lyx_version_info << endl;
|
2002-08-07 23:43:38 +00:00
|
|
|
|
exit(0);
|
|
|
|
|
return 0;
|
2001-09-11 13:13:03 +00:00
|
|
|
|
}
|
|
|
|
|
|
2002-08-07 23:43:38 +00:00
|
|
|
|
int parse_sysdir(string const & arg, string const &)
|
|
|
|
|
{
|
|
|
|
|
if (arg.empty()) {
|
2006-10-21 00:16:43 +00:00
|
|
|
|
lyxerr << to_utf8(_("Missing directory for -sysdir switch")) << endl;
|
2002-08-07 23:43:38 +00:00
|
|
|
|
exit(1);
|
|
|
|
|
}
|
2005-01-10 19:17:43 +00:00
|
|
|
|
cl_system_support = arg;
|
2002-08-07 23:43:38 +00:00
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int parse_userdir(string const & arg, string const &)
|
|
|
|
|
{
|
|
|
|
|
if (arg.empty()) {
|
2006-10-21 00:16:43 +00:00
|
|
|
|
lyxerr << to_utf8(_("Missing directory for -userdir switch")) << endl;
|
2002-08-07 23:43:38 +00:00
|
|
|
|
exit(1);
|
|
|
|
|
}
|
2005-01-10 19:17:43 +00:00
|
|
|
|
cl_user_support = arg;
|
2002-08-07 23:43:38 +00:00
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int parse_execute(string const & arg, string const &)
|
|
|
|
|
{
|
|
|
|
|
if (arg.empty()) {
|
2006-10-21 00:16:43 +00:00
|
|
|
|
lyxerr << to_utf8(_("Missing command string after --execute switch")) << endl;
|
2002-08-07 23:43:38 +00:00
|
|
|
|
exit(1);
|
|
|
|
|
}
|
|
|
|
|
batch = arg;
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int parse_export(string const & type, string const &)
|
|
|
|
|
{
|
|
|
|
|
if (type.empty()) {
|
2006-10-21 00:16:43 +00:00
|
|
|
|
lyxerr << to_utf8(_("Missing file type [eg latex, ps...] after "
|
2006-09-09 15:27:44 +00:00
|
|
|
|
"--export switch")) << endl;
|
2002-08-07 23:43:38 +00:00
|
|
|
|
exit(1);
|
|
|
|
|
}
|
|
|
|
|
batch = "buffer-export " + type;
|
2006-10-21 00:16:43 +00:00
|
|
|
|
use_gui = false;
|
2002-08-07 23:43:38 +00:00
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int parse_import(string const & type, string const & file)
|
|
|
|
|
{
|
|
|
|
|
if (type.empty()) {
|
2006-10-21 00:16:43 +00:00
|
|
|
|
lyxerr << to_utf8(_("Missing file type [eg latex, ps...] after "
|
2006-09-09 15:27:44 +00:00
|
|
|
|
"--import switch")) << endl;
|
2002-08-07 23:43:38 +00:00
|
|
|
|
exit(1);
|
|
|
|
|
}
|
|
|
|
|
if (file.empty()) {
|
2006-10-21 00:16:43 +00:00
|
|
|
|
lyxerr << to_utf8(_("Missing filename for --import")) << endl;
|
2002-08-07 23:43:38 +00:00
|
|
|
|
exit(1);
|
|
|
|
|
}
|
|
|
|
|
|
2002-11-27 10:30:28 +00:00
|
|
|
|
batch = "buffer-import " + type + ' ' + file;
|
2002-08-07 23:43:38 +00:00
|
|
|
|
return 2;
|
|
|
|
|
}
|
2001-09-11 13:13:03 +00:00
|
|
|
|
|
2006-11-29 16:45:38 +00:00
|
|
|
|
int parse_geometry(string const & arg1, string const &)
|
|
|
|
|
{
|
|
|
|
|
geometryArg = arg1;
|
|
|
|
|
#if defined(_WIN32) || (defined(__CYGWIN__) && defined(X_DISPLAY_MISSING))
|
|
|
|
|
// remove also the arg
|
|
|
|
|
return 1;
|
|
|
|
|
#else
|
|
|
|
|
// don't remove "-geometry"
|
|
|
|
|
return -1;
|
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2001-03-20 01:22:46 +00:00
|
|
|
|
} // namespace anon
|
|
|
|
|
|
2000-10-11 21:06:43 +00:00
|
|
|
|
|
2006-10-12 14:10:13 +00:00
|
|
|
|
void LyX::easyParse(int & argc, char * argv[])
|
1999-09-27 18:44:28 +00:00
|
|
|
|
{
|
2002-08-07 23:43:38 +00:00
|
|
|
|
std::map<string, cmd_helper> cmdmap;
|
|
|
|
|
|
|
|
|
|
cmdmap["-dbg"] = parse_dbg;
|
|
|
|
|
cmdmap["-help"] = parse_help;
|
|
|
|
|
cmdmap["--help"] = parse_help;
|
|
|
|
|
cmdmap["-version"] = parse_version;
|
|
|
|
|
cmdmap["--version"] = parse_version;
|
|
|
|
|
cmdmap["-sysdir"] = parse_sysdir;
|
|
|
|
|
cmdmap["-userdir"] = parse_userdir;
|
|
|
|
|
cmdmap["-x"] = parse_execute;
|
|
|
|
|
cmdmap["--execute"] = parse_execute;
|
|
|
|
|
cmdmap["-e"] = parse_export;
|
|
|
|
|
cmdmap["--export"] = parse_export;
|
|
|
|
|
cmdmap["-i"] = parse_import;
|
|
|
|
|
cmdmap["--import"] = parse_import;
|
2006-11-29 16:45:38 +00:00
|
|
|
|
cmdmap["-geometry"] = parse_geometry;
|
1999-12-10 00:07:59 +00:00
|
|
|
|
|
2002-08-07 23:43:38 +00:00
|
|
|
|
for (int i = 1; i < argc; ++i) {
|
|
|
|
|
std::map<string, cmd_helper>::const_iterator it
|
|
|
|
|
= cmdmap.find(argv[i]);
|
2000-05-29 15:29:50 +00:00
|
|
|
|
|
2002-08-07 23:43:38 +00:00
|
|
|
|
// don't complain if not found - may be parsed later
|
|
|
|
|
if (it == cmdmap.end())
|
|
|
|
|
continue;
|
2000-05-29 15:29:50 +00:00
|
|
|
|
|
2002-08-07 23:43:38 +00:00
|
|
|
|
string arg((i + 1 < argc) ? argv[i + 1] : "");
|
|
|
|
|
string arg2((i + 2 < argc) ? argv[i + 2] : "");
|
2002-08-11 16:27:10 +00:00
|
|
|
|
|
2002-08-07 23:43:38 +00:00
|
|
|
|
int const remove = 1 + it->second(arg, arg2);
|
|
|
|
|
|
|
|
|
|
// Now, remove used arguments by shifting
|
|
|
|
|
// the following ones remove places down.
|
|
|
|
|
argc -= remove;
|
|
|
|
|
for (int j = i; j < argc; ++j)
|
|
|
|
|
argv[j] = argv[j + remove];
|
|
|
|
|
--i;
|
1999-09-27 18:44:28 +00:00
|
|
|
|
}
|
2000-04-28 11:18:04 +00:00
|
|
|
|
|
2002-08-07 23:43:38 +00:00
|
|
|
|
batch_command = batch;
|
1999-09-27 18:44:28 +00:00
|
|
|
|
}
|
2006-10-19 07:20:32 +00:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
FuncStatus getStatus(FuncRequest const & action)
|
|
|
|
|
{
|
|
|
|
|
return LyX::ref().lyxFunc().getStatus(action);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void dispatch(FuncRequest const & action)
|
|
|
|
|
{
|
|
|
|
|
LyX::ref().lyxFunc().dispatch(action);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
BufferList & theBufferList()
|
|
|
|
|
{
|
|
|
|
|
return LyX::ref().bufferList();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
LyXFunc & theLyXFunc()
|
|
|
|
|
{
|
|
|
|
|
return LyX::ref().lyxFunc();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
LyXServer & theLyXServer()
|
|
|
|
|
{
|
|
|
|
|
// FIXME: this should not be use_gui dependent
|
2006-10-21 00:16:43 +00:00
|
|
|
|
BOOST_ASSERT(use_gui);
|
2006-10-19 07:20:32 +00:00
|
|
|
|
return LyX::ref().server();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
LyXServerSocket & theLyXServerSocket()
|
|
|
|
|
{
|
|
|
|
|
// FIXME: this should not be use_gui dependent
|
2006-10-21 00:16:43 +00:00
|
|
|
|
BOOST_ASSERT(use_gui);
|
2006-10-19 07:20:32 +00:00
|
|
|
|
return LyX::ref().socket();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
kb_keymap & theTopLevelKeymap()
|
|
|
|
|
{
|
2006-10-21 00:16:43 +00:00
|
|
|
|
BOOST_ASSERT(use_gui);
|
2006-10-19 07:20:32 +00:00
|
|
|
|
return LyX::ref().topLevelKeymap();
|
|
|
|
|
}
|
2006-10-21 00:16:43 +00:00
|
|
|
|
|
2006-11-18 17:47:12 +00:00
|
|
|
|
|
|
|
|
|
IconvProcessor & utf8ToUcs4()
|
|
|
|
|
{
|
|
|
|
|
return LyX::ref().iconvProcessor();
|
|
|
|
|
}
|
|
|
|
|
|
2006-10-21 00:16:43 +00:00
|
|
|
|
} // namespace lyx
|