#include "LyX.h"
-#include "ConverterCache.h"
+#include "LayoutFile.h"
#include "Buffer.h"
-#include "buffer_funcs.h"
#include "BufferList.h"
+#include "CmdDef.h"
+#include "Color.h"
+#include "ConverterCache.h"
#include "Converter.h"
#include "CutAndPaste.h"
-#include "debug.h"
#include "Encoding.h"
#include "ErrorList.h"
#include "Format.h"
-#include "gettext.h"
+#include "FuncStatus.h"
#include "KeyMap.h"
#include "Language.h"
-#include "Session.h"
-#include "Color.h"
-#include "callback.h"
+#include "Lexer.h"
#include "LyXAction.h"
#include "LyXFunc.h"
-#include "Lexer.h"
#include "LyXRC.h"
#include "ModuleList.h"
+#include "Mover.h"
#include "Server.h"
#include "ServerSocket.h"
-#include "TextClassList.h"
-#include "MenuBackend.h"
-#include "Messages.h"
-#include "Mover.h"
+#include "Session.h"
#include "ToolbarBackend.h"
#include "frontends/alert.h"
#include "frontends/Application.h"
-#include "frontends/Dialogs.h"
-#include "frontends/Gui.h"
-#include "frontends/LyXView.h"
+#include "support/assert.h"
+#include "support/debug.h"
#include "support/environment.h"
-#include "support/filetools.h"
-#include "support/lyxlib.h"
-#include "support/convert.h"
#include "support/ExceptionMessage.h"
+#include "support/filetools.h"
+#include "support/gettext.h"
+#include "support/lstrings.h"
+#include "support/Messages.h"
#include "support/os.h"
#include "support/Package.h"
#include "support/Path.h"
#include "support/Systemcall.h"
#include <boost/bind.hpp>
-#include <boost/filesystem/operations.hpp>
+#include <boost/scoped_ptr.hpp>
#include <algorithm>
#include <iostream>
#include <csignal>
#include <map>
+#include <stdlib.h>
#include <string>
#include <vector>
-using std::endl;
-using std::for_each;
-using std::map;
-using std::make_pair;
-using std::string;
-using std::vector;
-
-#ifndef CXX_GLOBAL_CSTD
-using std::exit;
-using std::signal;
-using std::system;
-#endif
-
-namespace fs = boost::filesystem;
+using namespace std;
+using namespace lyx::support;
namespace lyx {
-using support::addName;
-using support::addPath;
-using support::bformat;
-using support::changeExtension;
-using support::createDirectory;
-using support::createLyXTmpDir;
-using support::destroyDir;
-using support::FileName;
-using support::fileSearch;
-using support::getEnv;
-using support::i18nLibFileSearch;
-using support::libFileSearch;
-using support::package;
-using support::prependEnvPath;
-using support::rtrim;
-using support::Systemcall;
-using frontend::LyXView;
-
namespace Alert = frontend::Alert;
namespace os = support::os;
-/// 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;
+// 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;
namespace {
string cl_system_support;
string cl_user_support;
-std::string geometryArg;
+string geometryArg;
LyX * singleton_ = 0;
string const configure_command = package().configure_command();
lyxerr << to_utf8(_("LyX: reconfiguring user directory")) << endl;
- support::Path p(package().user_support());
+ PathChanger p(package().user_support());
Systemcall one;
one.startscript(Systemcall::Wait, configure_command);
lyxerr << "LyX: " << to_utf8(_("Done!")) << endl;
/// The main application class private implementation.
-struct LyX::Singletons
+struct LyX::Impl
{
- Singletons()
+ Impl()
{
// Set the default User Interface language as soon as possible.
// The language used will be derived from the environment
///
BufferList buffer_list_;
///
- boost::scoped_ptr<KeyMap> toplevel_keymap_;
+ KeyMap toplevel_keymap_;
+ ///
+ CmdDef toplevel_cmddef_;
///
boost::scoped_ptr<Server> lyx_server_;
///
boost::scoped_ptr<Session> session_;
/// Files to load at start.
- vector<FileName> files_to_load_;
+ vector<string> files_to_load_;
/// The messages translators.
map<string, Messages> messages_;
///
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
+ string batch_command;
};
///
LyX::~LyX()
{
+ delete pimpl_;
+}
+
+
+void LyX::exit(int exit_code) const
+{
+ if (exit_code)
+ // Something wrong happened so better save everything, just in
+ // case.
+ emergencyCleanup();
+
+#ifndef NDEBUG
+ // Properly crash in debug mode in order to get a useful backtrace.
+ abort();
+#endif
+
+ // In release mode, try to exit gracefully.
+ if (theApp())
+ theApp()->exit(exit_code);
+ else
+ exit(exit_code);
}
LyX & LyX::ref()
{
- BOOST_ASSERT(singleton_);
+ LASSERT(singleton_, /**/);
return *singleton_;
}
LyX const & LyX::cref()
{
- BOOST_ASSERT(singleton_);
+ LASSERT(singleton_, /**/);
return *singleton_;
}
: first_start(false)
{
singleton_ = this;
- pimpl_.reset(new Singletons);
+ pimpl_ = new Impl;
}
Session & LyX::session()
{
- BOOST_ASSERT(pimpl_->session_.get());
+ LASSERT(pimpl_->session_.get(), /**/);
return *pimpl_->session_.get();
}
Session const & LyX::session() const
{
- BOOST_ASSERT(pimpl_->session_.get());
+ LASSERT(pimpl_->session_.get(), /**/);
return *pimpl_->session_.get();
}
Server & LyX::server()
{
- BOOST_ASSERT(pimpl_->lyx_server_.get());
+ LASSERT(pimpl_->lyx_server_.get(), /**/);
return *pimpl_->lyx_server_.get();
}
Server const & LyX::server() const
{
- BOOST_ASSERT(pimpl_->lyx_server_.get());
+ LASSERT(pimpl_->lyx_server_.get(), /**/);
return *pimpl_->lyx_server_.get();
}
ServerSocket & LyX::socket()
{
- BOOST_ASSERT(pimpl_->lyx_socket_.get());
+ LASSERT(pimpl_->lyx_socket_.get(), /**/);
return *pimpl_->lyx_socket_.get();
}
ServerSocket const & LyX::socket() const
{
- BOOST_ASSERT(pimpl_->lyx_socket_.get());
+ LASSERT(pimpl_->lyx_socket_.get(), /**/);
return *pimpl_->lyx_socket_.get();
}
frontend::Application & LyX::application()
{
- BOOST_ASSERT(pimpl_->application_.get());
+ LASSERT(pimpl_->application_.get(), /**/);
return *pimpl_->application_.get();
}
frontend::Application const & LyX::application() const
{
- BOOST_ASSERT(pimpl_->application_.get());
+ LASSERT(pimpl_->application_.get(), /**/);
return *pimpl_->application_.get();
}
-KeyMap & LyX::topLevelKeymap()
+CmdDef & LyX::topLevelCmdDef()
{
- BOOST_ASSERT(pimpl_->toplevel_keymap_.get());
- return *pimpl_->toplevel_keymap_.get();
+ return pimpl_->toplevel_cmddef_;
}
}
-KeyMap const & LyX::topLevelKeymap() const
-{
- BOOST_ASSERT(pimpl_->toplevel_keymap_.get());
- return *pimpl_->toplevel_keymap_.get();
-}
-
-
-Messages & LyX::getMessages(std::string const & language)
+Messages & LyX::getMessages(string const & language)
{
map<string, Messages>::iterator it = pimpl_->messages_.find(language);
if (it != pimpl_->messages_.end())
return it->second;
- std::pair<map<string, Messages>::iterator, bool> result =
- pimpl_->messages_.insert(std::make_pair(language, Messages(language)));
+ pair<map<string, Messages>::iterator, bool> result =
+ pimpl_->messages_.insert(make_pair(language, Messages(language)));
- BOOST_ASSERT(result.second);
+ LASSERT(result.second, /**/);
return result.first->second;
}
}
-void LyX::setGuiLanguage(std::string const & language)
+void LyX::setGuiLanguage(string const & language)
{
pimpl_->messages_["GUI"] = Messages(language);
}
-Buffer const * LyX::updateInset(Inset const * inset) const
-{
- if (quitting || !inset)
- return 0;
-
- Buffer const * buffer_ptr = 0;
- 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();
- for (; it != end; ++it) {
- Buffer const * ptr =
- pimpl_->application_->gui().view(*it).updateInset(inset);
- if (ptr)
- buffer_ptr = ptr;
- }
- return buffer_ptr;
-}
-
-
-void LyX::hideDialogs(std::string const & name, Inset * inset) const
-{
- if (quitting || !use_gui)
- return;
-
- 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();
- for (; it != end; ++it)
- pimpl_->application_->gui().view(*it).getDialogs().
- hide(name, inset);
-}
-
-
int LyX::exec(int & argc, char * argv[])
{
// Here we need to parse the command line. At least
// we need to parse for "-dbg" and "-help"
easyParse(argc, argv);
- try { support::init_package(to_utf8(from_local8bit(argv[0])),
+ try {
+ init_package(to_utf8(from_local8bit(argv[0])),
cl_system_support, cl_user_support,
- support::top_build_dir_is_one_level_up);
- } catch (support::ExceptionMessage const & message) {
- if (message.type_ == support::ErrorException) {
+ top_build_dir_is_one_level_up);
+ } catch (ExceptionMessage const & message) {
+ if (message.type_ == ErrorException) {
Alert::error(message.title_, message.details_);
exit(1);
- } else if (message.type_ == support::WarningException) {
+ } else if (message.type_ == WarningException) {
Alert::warning(message.title_, message.details_);
}
}
loadFiles();
- if (batch_command.empty() || pimpl_->buffer_list_.empty()) {
+ if (pimpl_->batch_command.empty() || pimpl_->buffer_list_.empty()) {
prepareExit();
return EXIT_SUCCESS;
}
bool final_success = false;
for (BufferList::iterator I = begin; I != pimpl_->buffer_list_.end(); ++I) {
Buffer * buf = *I;
- if (buf != buf->getMasterBuffer())
+ if (buf != buf->masterBuffer())
continue;
bool success = false;
- buf->dispatch(batch_command, &success);
+ buf->dispatch(pimpl_->batch_command, &success);
final_success |= success;
}
prepareExit();
// Let the frontend parse and remove all arguments that it knows
pimpl_->application_.reset(createApplication(argc, argv));
- initGuiFont();
-
// Parse and remove all known arguments in the LyX singleton
// Give an error for all remaining ones.
int exit_status = init(argc, argv);
cap::clearCutStack();
cap::clearSelection();
- // Set a flag that we do quitting from the program,
- // so no refreshes are necessary.
- quitting = true;
-
// close buffers first
pimpl_->buffer_list_.closeAll();
+ // register session changes and shutdown server and socket
+ if (use_gui) {
+ if (pimpl_->session_)
+ pimpl_->session_->writeFile();
+ pimpl_->session_.reset();
+ pimpl_->lyx_server_.reset();
+ pimpl_->lyx_socket_.reset();
+ }
+
// do any other cleanup procedures now
if (package().temp_dir() != package().system_temp_dir()) {
- LYXERR(Debug::INFO) << "Deleting tmp dir "
- << package().temp_dir().absFilename() << endl;
+ LYXERR(Debug::INFO, "Deleting tmp dir "
+ << package().temp_dir().absFilename());
- if (!destroyDir(package().temp_dir())) {
+ if (!package().temp_dir().destroyDirectory()) {
docstring const msg =
bformat(_("Unable to remove the temporary directory %1$s"),
from_utf8(package().temp_dir().absFilename()));
}
}
- if (use_gui) {
- if (pimpl_->session_)
- pimpl_->session_->writeFile();
- pimpl_->session_.reset();
- pimpl_->lyx_server_.reset();
- pimpl_->lyx_socket_.reset();
- }
-
// Kill the application object before exiting. This avoids crashes
// when exiting on Linux.
if (pimpl_->application_)
void LyX::earlyExit(int status)
{
- BOOST_ASSERT(pimpl_->application_.get());
+ LASSERT(pimpl_->application_.get(), /**/);
// LyX::pimpl_::application_ is not initialised at this
// point so it's safe to just exit after some cleanup.
prepareExit();
}
// Initialization of LyX (reads lyxrc and more)
- LYXERR(Debug::INIT) << "Initializing LyX::init..." << endl;
+ LYXERR(Debug::INIT, "Initializing LyX::init...");
bool success = init();
- LYXERR(Debug::INIT) << "Initializing LyX::init...done" << endl;
+ LYXERR(Debug::INIT, "Initializing LyX::init...done");
if (!success)
return EXIT_FAILURE;
- for (int argi = argc - 1; argi >= 1; --argi) {
- // get absolute path of file and add ".lyx" to
- // the filename if necessary
- pimpl_->files_to_load_.push_back(fileSearch(string(),
- os::internal_path(to_utf8(from_local8bit(argv[argi]))),
- "lyx", support::allow_unreadable));
- }
+ // Remaining arguments are assumed to be files to load.
+ for (int argi = argc - 1; argi >= 1; --argi)
+ pimpl_->files_to_load_.push_back(to_utf8(from_local8bit(argv[argi])));
- if (first_start)
- pimpl_->files_to_load_.push_back(i18nLibFileSearch("examples", "splash.lyx"));
+ if (first_start) {
+ pimpl_->files_to_load_.push_back(
+ i18nLibFileSearch("examples", "splash.lyx").absFilename());
+ }
return EXIT_SUCCESS;
}
-void LyX::addFileToLoad(FileName const & fname)
+void LyX::addFileToLoad(string const & fname)
{
- vector<FileName>::const_iterator cit = std::find(
+ vector<string>::const_iterator cit = find(
pimpl_->files_to_load_.begin(), pimpl_->files_to_load_.end(),
fname);
void LyX::loadFiles()
{
- vector<FileName>::const_iterator it = pimpl_->files_to_load_.begin();
- vector<FileName>::const_iterator end = pimpl_->files_to_load_.end();
+ vector<string>::const_iterator it = pimpl_->files_to_load_.begin();
+ vector<string>::const_iterator end = pimpl_->files_to_load_.end();
for (; it != end; ++it) {
- if (it->empty())
+ // 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);
+
+ if (fname.empty())
continue;
- Buffer * buf = pimpl_->buffer_list_.newBuffer(it->absFilename(), false);
- if (loadLyXFile(buf, *it)) {
+ Buffer * buf = pimpl_->buffer_list_.newBuffer(fname.absFilename(), false);
+ if (buf->loadLyXFile(fname)) {
ErrorList const & el = buf->errorList("Parse");
if (!el.empty())
for_each(el.begin(), el.end(),
// The advantage of doing this here is that the event loop
// is already started. So any need for interaction will be
// aknowledged.
- restoreGuiSession();
// if reconfiguration is needed.
- if (textclasslist.empty()) {
+ while (LayoutFileList::get().empty()) {
switch (Alert::prompt(
_("No textclass is found"),
_("LyX cannot continue because no textclass is found. "
"You can either reconfigure normally, or reconfigure using "
- "default textclasses, or quit lyx."),
+ "default textclasses, or quit LyX."),
0, 2,
_("&Reconfigure"),
_("&Use Default"),
pimpl_->lyxfunc_.dispatch(FuncRequest(LFUN_RECONFIGURE,
" --without-latex-config"));
break;
+ default:
+ pimpl_->lyxfunc_.dispatch(FuncRequest(LFUN_LYX_QUIT));
+ return;
}
- pimpl_->lyxfunc_.dispatch(FuncRequest(LFUN_LYX_QUIT));
- return;
}
- // 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));
-}
-
+ // create the first main window
+ pimpl_->lyxfunc_.dispatch(FuncRequest(LFUN_WINDOW_NEW, geometryArg));
-void LyX::restoreGuiSession()
-{
- LyXView * view = newLyXView();
-
- // if there is no valid class list, do not load any file.
- if (textclasslist.empty())
- return;
-
- // if some files were specified at command-line we assume that the
- // user wants to edit *these* files and not to restore the session.
if (!pimpl_->files_to_load_.empty()) {
- for_each(pimpl_->files_to_load_.begin(),
- pimpl_->files_to_load_.end(),
- bind(&LyXView::loadLyXFile, view, _1, true));
+ // if some files were specified at command-line we assume that the
+ // user wants to edit *these* files and not to restore the session.
+ for (size_t i = 0; i != pimpl_->files_to_load_.size(); ++i) {
+ pimpl_->lyxfunc_.dispatch(
+ FuncRequest(LFUN_FILE_OPEN, pimpl_->files_to_load_[i]));
+ }
// clear this list to save a few bytes of RAM
pimpl_->files_to_load_.clear();
- pimpl_->session_->lastOpened().clear();
-
- } else if (lyxrc.load_session) {
- vector<FileName> const & lastopened = pimpl_->session_->lastOpened().getfiles();
- // do not add to the lastfile list since these files are restored from
- // last session, 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
- pimpl_->session_->lastOpened().clear();
- }
-
- BufferList::iterator I = pimpl_->buffer_list_.begin();
- BufferList::iterator end = pimpl_->buffer_list_.end();
- for (; I != end; ++I) {
- Buffer * buf = *I;
- if (buf != buf->getMasterBuffer())
- continue;
- updateLabels(*buf);
- }
-
- // FIXME: Switch to the last loaded Buffer. This must not be the first one
- // because the Buffer won't be connected in this case. The correct solution
- // would be to avoid the manual connection of the current Buffer in LyXView.
- if (!pimpl_->buffer_list_.empty())
- view->setBuffer(pimpl_->buffer_list_.last());
-}
-
-
-LyXView * LyX::newLyXView()
-{
- if (!lyx::use_gui)
- return 0;
-
- // determine windows size and position, from lyxrc and/or session
- // initial geometry
- unsigned int width = 690;
- unsigned int height = 510;
- // default icon size, will be overwritten by stored session value
- unsigned int iconSizeXY = 0;
- int maximized = LyXView::NotMaximized;
- // 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 {
- string val = session().sessionInfo().load("WindowWidth");
- if (!val.empty())
- width = convert<unsigned int>(val);
- val = session().sessionInfo().load("WindowHeight");
- if (!val.empty())
- height = convert<unsigned int>(val);
- val = session().sessionInfo().load("WindowMaximized");
- if (!val.empty())
- maximized = convert<int>(val);
- val = session().sessionInfo().load("IconSizeXY");
- if (!val.empty())
- iconSizeXY = convert<unsigned int>(val);
- }
-
- // if user wants to restore window position
- int posx = -1;
- int posy = -1;
- if (lyxrc.geometry_xysaved) {
- string val = session().sessionInfo().load("WindowPosX");
- if (!val.empty())
- posx = convert<int>(val);
- val = session().sessionInfo().load("WindowPosY");
- if (!val.empty())
- posy = convert<int>(val);
}
+ else
+ pimpl_->application_->restoreGuiSession();
- if (!geometryArg.empty())
- {
- width = 0;
- height = 0;
- }
+ // Execute batch commands if available
+ if (pimpl_->batch_command.empty())
+ return;
- // create the main window
- LyXView * view = &pimpl_->application_->createView(width, height, posx, posy, maximized, iconSizeXY, geometryArg);
+ LYXERR(Debug::INIT, "About to handle -x '" << pimpl_->batch_command << '\'');
- return view;
+ pimpl_->lyxfunc_.dispatch(lyxaction.lookupFunc(pimpl_->batch_command));
}
+
/*
Signals and Windows
===================
#else
if (err_sig == SIGSEGV || !getEnv("LYXDEBUG").empty())
#endif
- support::abort();
+ abort();
exit(0);
}
{
docstring tmp = _("LyX: ") + ei.error + char_type(':')
+ ei.description;
- std::cerr << to_utf8(tmp) << std::endl;
-}
-
-
-void LyX::initGuiFont()
-{
- if (lyxrc.roman_font_name.empty())
- lyxrc.roman_font_name = pimpl_->application_->romanFontName();
-
- if (lyxrc.sans_font_name.empty())
- lyxrc.sans_font_name = pimpl_->application_->sansFontName();
-
- if (lyxrc.typewriter_font_name.empty())
- lyxrc.typewriter_font_name
- = pimpl_->application_->typewriterFontName();
+ cerr << to_utf8(tmp) << endl;
}
lyxrc.tempdir_path = package().temp_dir().absFilename();
lyxrc.document_path = package().document_dir().absFilename();
+ if (lyxrc.example_path.empty()) {
+ lyxrc.example_path = addPath(package().system_support().absFilename(),
+ "examples");
+ }
if (lyxrc.template_path.empty()) {
lyxrc.template_path = addPath(package().system_support().absFilename(),
"templates");
return false;
// Load the layouts
- LYXERR(Debug::INIT) << "Reading layouts..." << endl;
+ LYXERR(Debug::INIT, "Reading layouts...");
if (!LyXSetStyle())
return false;
//...and the modules
moduleList.load();
- if (use_gui) {
- // Set the language defined by the user.
- //setGuiLanguage(lyxrc.gui_language);
+ // read keymap and ui files in batch mode as well
+ // because InsetInfo needs to know these to produce
+ // the correct output
- // Set up bindings
- pimpl_->toplevel_keymap_.reset(new KeyMap);
- defaultKeyBindings(pimpl_->toplevel_keymap_.get());
- pimpl_->toplevel_keymap_->read(lyxrc.bind_file);
+ // Set the language defined by the user.
+ //setGuiLanguage(lyxrc.gui_language);
- pimpl_->lyxfunc_.initKeySequences(pimpl_->toplevel_keymap_.get());
+ // Set up command definitions
+ pimpl_->toplevel_cmddef_.read(lyxrc.def_file);
- // Read menus
- if (!readUIFile(lyxrc.ui_file))
- return false;
- }
+ // Set up bindings
+ pimpl_->toplevel_keymap_.read("site");
+ pimpl_->toplevel_keymap_.read(lyxrc.bind_file);
+ // load user bind file user.bind
+ pimpl_->toplevel_keymap_.read("user");
+
+ pimpl_->lyxfunc_.initKeySequences(&pimpl_->toplevel_keymap_);
+
+ // Read menus
+ if (use_gui && !readUIFile(lyxrc.ui_file))
+ return false;
if (lyxerr.debugging(Debug::LYXRC))
lyxrc.print();
prependEnvPath("PATH", lyxrc.path_prefix);
FileName const document_path(lyxrc.document_path);
- if (fs::exists(document_path.toFilesystemEncoding()) &&
- fs::is_directory(document_path.toFilesystemEncoding()))
+ if (document_path.exists() && document_path.isDirectory())
package().document_dir() = document_path;
package().temp_dir() = createLyXTmpDir(FileName(lyxrc.tempdir_path));
return false;
}
- LYXERR(Debug::INIT) << "LyX tmp dir: `"
- << package().temp_dir().absFilename()
- << '\'' << endl;
+ LYXERR(Debug::INIT, "LyX tmp dir: `"
+ << package().temp_dir().absFilename() << '\'');
- LYXERR(Debug::INIT) << "Reading session information '.lyx/session'..." << endl;
+ LYXERR(Debug::INIT, "Reading session information '.lyx/session'...");
pimpl_->session_.reset(new Session(lyxrc.num_lastfiles));
// This must happen after package initialization and after lyxrc is
// read, therefore it can't be done by a static object.
ConverterCache::init();
-
+
+ // init the global menubar on Mac. This must be done after the session
+ // was recovered to know the "last files".
+ if (use_gui)
+ theApp()->initGlobalMenu();
+
return true;
}
-void LyX::defaultKeyBindings(KeyMap * kbmap)
-{
- kbmap->bind("Right", FuncRequest(LFUN_CHAR_FORWARD));
- kbmap->bind("Left", FuncRequest(LFUN_CHAR_BACKWARD));
- kbmap->bind("Up", FuncRequest(LFUN_UP));
- kbmap->bind("Down", FuncRequest(LFUN_DOWN));
-
- kbmap->bind("Tab", FuncRequest(LFUN_CELL_FORWARD));
- 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));
-
- 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));
-
- kbmap->bind("Return", FuncRequest(LFUN_BREAK_PARAGRAPH));
- //kbmap->bind("~C-~S-~M-nobreakspace", FuncRequest(LFUN_PROTECTEDSPACE));
-
- kbmap->bind("Delete", FuncRequest(LFUN_CHAR_DELETE_FORWARD));
- kbmap->bind("BackSpace", FuncRequest(LFUN_CHAR_DELETE_BACKWARD));
-
- // kbmap->bindings to enable the use of the numeric keypad
- // e.g. Num Lock set
- //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));
- kbmap->bind("KP_Up", FuncRequest(LFUN_UP));
- kbmap->bind("KP_Down", FuncRequest(LFUN_DOWN));
- 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));
-}
-
-
void LyX::emergencyCleanup() const
{
// what to do about tmpfiles is non-obvious. we would
}
-void LyX::deadKeyBindings(KeyMap * kbmap)
-{
- // bindKeyings for transparent handling of deadkeys
- // The keysyms are gotten from XFree86 X11R6
- 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));
- // nothing with this name
- // 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));
- // nothing with this name either...
- //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));
-}
-
-
-namespace {
-
// return true if file does not exist or is older than configure.py.
-bool needsUpdate(string const & file)
+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 string configure_script;
+ static FileName configure_script;
static bool firstrun = true;
if (firstrun) {
- configure_script = FileName(addName(
- package().system_support().absFilename(),
- "configure.py")).toFilesystemEncoding();
+ configure_script =
+ FileName(addName(package().system_support().absFilename(),
+ "configure.py"));
firstrun = false;
}
- string const absfile = FileName(addName(
- package().user_support().absFilename(), file)).toFilesystemEncoding();
- return (! fs::exists(absfile))
- || (fs::last_write_time(configure_script)
- > fs::last_write_time(absfile));
-}
-
+ 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?
- string const user_support =
- package().user_support().toFilesystemEncoding();
- if (fs::exists(user_support) && fs::is_directory(user_support)) {
+ FileName const sup = package().user_support();
+ if (sup.exists() && sup.isDirectory()) {
first_start = false;
return needsUpdate("lyxrc.defaults")
}
lyxerr << to_utf8(bformat(_("LyX: Creating directory %1$s"),
- from_utf8(package().user_support().absFilename())))
- << endl;
+ from_utf8(sup.absFilename()))) << endl;
- if (!createDirectory(package().user_support(), 0755)) {
+ if (!sup.createDirectory(0755)) {
// Failed, so let's exit.
lyxerr << to_utf8(_("Failed to create directory. Exiting."))
<< endl;
bool LyX::readRcFile(string const & name)
{
- LYXERR(Debug::INIT) << "About to read " << name << "... ";
+ LYXERR(Debug::INIT, "About to read " << name << "... ");
FileName const lyxrc_path = libFileSearch(string(), name);
if (!lyxrc_path.empty()) {
-
- LYXERR(Debug::INIT) << "Found in " << lyxrc_path << endl;
-
+ LYXERR(Debug::INIT, "Found in " << lyxrc_path);
if (lyxrc.read(lyxrc_path) < 0) {
showFileError(name);
return false;
}
- } else
- LYXERR(Debug::INIT) << "Not found." << lyxrc_path << endl;
+ } else {
+ LYXERR(Debug::INIT, "Not found." << lyxrc_path);
+ }
return true;
-
}
// Read the ui file `name'
bool LyX::readUIFile(string const & name, bool include)
{
- enum Uitags {
+ enum {
ui_menuset = 1,
ui_toolbars,
ui_toolbarset,
ui_last
};
- struct keyword_item uitags[ui_last - 1] = {
+ LexerKeyword uitags[] = {
{ "include", ui_include },
{ "menuset", ui_menuset },
{ "toolbars", ui_toolbars },
};
// 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);
+ static list<string> uifiles;
+ list<string>::const_iterator it = uifiles.begin();
+ list<string>::const_iterator end = uifiles.end();
+ it = find(it, end, name);
if (it != end) {
- LYXERR(Debug::INIT) << "UI file '" << name
- << "' has been read already. "
- << "Is this an include loop?"
- << endl;
+ LYXERR(Debug::INIT, "UI file '" << name << "' has been read already. "
+ << "Is this an include loop?");
return false;
}
- LYXERR(Debug::INIT) << "About to read " << name << "..." << endl;
+ LYXERR(Debug::INIT, "About to read " << name << "...");
FileName ui_path;
ui_path = libFileSearch("ui", name, "ui");
if (ui_path.empty()) {
- LYXERR(Debug::INIT) << "Could not find " << name << endl;
+ LYXERR(Debug::INIT, "Could not find " << name);
showFileError(name);
return false;
}
uifiles.push_back(name);
- LYXERR(Debug::INIT) << "Found " << name
- << " in " << ui_path << endl;
- Lexer lex(uitags, ui_last - 1);
+ LYXERR(Debug::INIT, "Found " << name << " in " << ui_path);
+ Lexer lex(uitags);
lex.setFile(ui_path);
if (!lex.isOK()) {
lyxerr << "Unable to set LyXLeX for ui file: " << ui_path
break;
}
case ui_menuset:
- menubackend.read(lex);
+ theApp()->readMenus(lex);
break;
case ui_toolbarset:
// Read the languages file `name'
bool LyX::readLanguagesFile(string const & name)
{
- LYXERR(Debug::INIT) << "About to read " << name << "..." << endl;
+ LYXERR(Debug::INIT, "About to read " << name << "...");
FileName const lang_path = libFileSearch(string(), name);
if (lang_path.empty()) {
bool LyX::readEncodingsFile(string const & enc_name,
string const & symbols_name)
{
- LYXERR(Debug::INIT) << "About to read " << enc_name << " and "
- << symbols_name << "..." << endl;
+ LYXERR(Debug::INIT, "About to read " << enc_name << " and "
+ << symbols_name << "...");
FileName const symbols_path = libFileSearch(string(), symbols_name);
if (symbols_path.empty()) {
" where command is a lyx command.\n"
"\t-e [--export] fmt\n"
" where fmt is the export format of choice.\n"
+ " Look on Tools->Preferences->File formats->Format\n"
+ " to get an idea which parameters should be passed.\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"
return 0;
}
+
int parse_version(string const &, string const &)
{
lyxerr << "LyX " << lyx_version
return 0;
}
+
int parse_sysdir(string const & arg, string const &)
{
if (arg.empty()) {
return 1;
}
+
int parse_userdir(string const & arg, string const &)
{
if (arg.empty()) {
return 1;
}
+
int parse_execute(string const & arg, string const &)
{
if (arg.empty()) {
return 1;
}
+
int parse_export(string const & type, string const &)
{
if (type.empty()) {
return 1;
}
+
int parse_import(string const & type, string const & file)
{
if (type.empty()) {
return 2;
}
+
int parse_geometry(string const & arg1, string const &)
{
geometryArg = arg1;
void LyX::easyParse(int & argc, char * argv[])
{
- std::map<string, cmd_helper> cmdmap;
+ map<string, cmd_helper> cmdmap;
cmdmap["-dbg"] = parse_dbg;
cmdmap["-help"] = parse_help;
cmdmap["-geometry"] = parse_geometry;
for (int i = 1; i < argc; ++i) {
- std::map<string, cmd_helper>::const_iterator it
+ map<string, cmd_helper>::const_iterator it
= cmdmap.find(argv[i]);
// don't complain if not found - may be parsed later
if (it == cmdmap.end())
continue;
- string const arg((i + 1 < argc) ? to_utf8(from_local8bit(argv[i + 1])) : string());
- string const arg2((i + 2 < argc) ? to_utf8(from_local8bit(argv[i + 2])) : string());
+ string const arg =
+ (i + 1 < argc) ? to_utf8(from_local8bit(argv[i + 1])) : string();
+ string const arg2 =
+ (i + 2 < argc) ? to_utf8(from_local8bit(argv[i + 2])) : string();
int const remove = 1 + it->second(arg, arg2);
}
}
- batch_command = batch;
+ pimpl_->batch_command = batch;
}
Server & theServer()
{
// FIXME: this should not be use_gui dependent
- BOOST_ASSERT(use_gui);
+ LASSERT(use_gui, /**/);
return LyX::ref().server();
}
ServerSocket & theServerSocket()
{
// FIXME: this should not be use_gui dependent
- BOOST_ASSERT(use_gui);
+ LASSERT(use_gui, /**/);
return LyX::ref().socket();
}
KeyMap & theTopLevelKeymap()
{
- BOOST_ASSERT(use_gui);
- return LyX::ref().topLevelKeymap();
+ return LyX::ref().pimpl_->toplevel_keymap_;
}
}
-Mover const & getMover(std::string const & fmt)
+Mover const & getMover(string const & fmt)
{
return LyX::ref().pimpl_->movers_(fmt);
}
-void setMover(std::string const & fmt, std::string const & command)
+void setMover(string const & fmt, string const & command)
{
LyX::ref().pimpl_->movers_.set(fmt, command);
}
}
-Messages & getMessages(std::string const & language)
+Messages & getMessages(string const & language)
{
return LyX::ref().getMessages(language);
}
projects / lyx.git / blobdiff