#include "insets/insetexternal.h"
#include "insets/insetfloat.h"
#include "insets/insetgraphics.h"
+#include "insets/insetinclude.h"
#include "insets/insetnote.h"
#include "insets/insettabular.h"
#include "insets/insetvspace.h"
#include "frontends/Menubar.h"
#include "frontends/Toolbars.h"
+#include "support/environment.h"
#include "support/filefilterlist.h"
-#include "support/FileInfo.h"
#include "support/filetools.h"
#include "support/forkedcontr.h"
+#include "support/fs_extras.h"
#include "support/lstrings.h"
#include "support/path.h"
-#include "support/path_defines.h"
+#include "support/package.h"
#include "support/systemcall.h"
-#include "support/tostr.h"
+#include "support/convert.h"
#include "support/os.h"
+#include <boost/current_function.hpp>
+#include <boost/filesystem/operations.hpp>
+
#include <sstream>
using bv_funcs::freefont2string;
+using lyx::support::AbsolutePath;
using lyx::support::AddName;
using lyx::support::AddPath;
using lyx::support::bformat;
using lyx::support::ChangeExtension;
using lyx::support::contains;
using lyx::support::FileFilterList;
-using lyx::support::FileInfo;
using lyx::support::FileSearch;
using lyx::support::ForkedcallsController;
using lyx::support::i18nLibFileSearch;
using lyx::support::isStrInt;
using lyx::support::MakeAbsPath;
using lyx::support::MakeDisplayPath;
+using lyx::support::package;
using lyx::support::Path;
using lyx::support::QuoteName;
using lyx::support::rtrim;
using lyx::support::split;
-using lyx::support::strToInt;
-using lyx::support::strToUnsignedInt;
using lyx::support::subst;
-using lyx::support::system_lyxdir;
using lyx::support::Systemcall;
using lyx::support::token;
using lyx::support::trim;
-using lyx::support::user_lyxdir;
using lyx::support::prefixIs;
-using lyx::support::os::getTmpDir;
using std::endl;
using std::make_pair;
using std::istringstream;
namespace biblio = lyx::biblio;
+namespace fs = boost::filesystem;
extern BufferList bufferlist;
bool getStatus(LCursor cursor,
FuncRequest const & cmd, FuncStatus & status)
{
+ // Try to fix cursor in case it is broken.
+ cursor.fixIfBroken();
+
// This is, of course, a mess. Better create a new doc iterator and use
// this in Inset::getStatus. This might require an additional
// BufferView * arg, though (which should be avoided)
//LCursor safe = *this;
bool res = false;
- for ( ; cursor.size(); cursor.pop()) {
+ for ( ; cursor.depth(); cursor.pop()) {
//lyxerr << "\nLCursor::getStatus: cmd: " << cmd << endl << *this << endl;
- DocIterator::idx_type & idx = cursor.idx();
- DocIterator::idx_type const lastidx = cursor.lastidx();
-
- if (idx > lastidx) {
- lyxerr << "wrong idx " << idx << ", max is " << lastidx
- << ". Trying to correct this." << endl;
- idx = lastidx;
- }
-
- DocIterator::pit_type & pit = cursor.pit();
- DocIterator::pit_type const lastpit = cursor.lastpit();
-
- if (pit > lastpit) {
- lyxerr << "wrong par " << pit << ", max is " << lastpit
- << ". Trying to correct this." << endl;
- pit = lastpit;
- }
-
- DocIterator::pos_type & pos = cursor.pos();
- DocIterator::pos_type const lastpos = cursor.lastpos();
-
- if (pos > lastpos) {
- lyxerr << "wrong pos " << pos << ", max is " << lastpos
- << ". Trying to correct this." << endl;
- pos = lastpos;
- }
+ BOOST_ASSERT(cursor.idx() <= cursor.lastidx());
+ BOOST_ASSERT(cursor.pit() <= cursor.lastpit());
+ BOOST_ASSERT(cursor.pos() <= cursor.lastpos());
// The inset's getStatus() will return 'true' if it made
// a definitive decision on whether it want to handle the
return res;
}
+
+/** Return the change status at cursor position, taking in account the
+ * status at each level of the document iterator (a table in a deleted
+ * footnote is deleted).
+ * When \param outer is true, the top slice is not looked at.
+ */
+Change::Type lookupChange(DocIterator const & dit, bool outer = false)
+{
+ size_t const depth = dit.depth() - (outer ? 1 : 0);
+
+ for (size_t i = 0 ; i < depth ; ++i) {
+ CursorSlice const & slice = dit[i];
+ if (!slice.inset().inMathed()
+ && slice.pos() < slice.paragraph().size()) {
+ Change::Type const ch = slice.paragraph().lookupChange(slice.pos());
+ if (ch != Change::UNCHANGED)
+ return ch;
+ }
+ }
+ return Change::UNCHANGED;
+}
+
}
LyXFunc::LyXFunc(LyXView * lv)
cancel_meta_seq.reset();
FuncRequest func = cancel_meta_seq.addkey(keysym, state);
- lyxerr[Debug::KEY] << "action first set to [" << func.action << ']' << endl;
+ lyxerr[Debug::KEY] << BOOST_CURRENT_FUNCTION
+ << " action first set to [" << func.action << ']'
+ << endl;
// When not cancel or meta-fake, do the normal lookup.
// Note how the meta_fake Mod1 bit is OR-ed in and reset afterwards.
if ((func.action != LFUN_CANCEL) && (func.action != LFUN_META_FAKE)) {
// remove Caps Lock and Mod2 as a modifiers
func = keyseq.addkey(keysym, (state | meta_fake_bit));
- lyxerr[Debug::KEY] << "action now set to ["
- << func.action << ']' << endl;
+ lyxerr[Debug::KEY] << BOOST_CURRENT_FUNCTION
+ << "action now set to ["
+ << func.action << ']' << endl;
}
// Dont remove this unless you know what you are doing.
meta_fake_bit = key_modifier::none;
- // can this happen now ?
+ // Can this happen now ?
if (func.action == LFUN_NOACTION) {
func = FuncRequest(LFUN_PREFIX);
}
if (lyxerr.debugging(Debug::KEY)) {
- lyxerr << "Key [action="
+ lyxerr << BOOST_CURRENT_FUNCTION
+ << " Key [action="
<< func.action << "]["
<< keyseq.print() << ']'
<< endl;
// by a binding
if (keysym->isText() && keyseq.length() == 1) {
lyxerr[Debug::KEY] << "isText() is true, inserting." << endl;
- func = FuncRequest(LFUN_SELFINSERT);
+ func = FuncRequest(LFUN_SELFINSERT,
+ FuncRequest::KEYBOARD);
} else {
lyxerr[Debug::KEY] << "Unknown, !isText() - giving up" << endl;
owner->message(_("Unknown function."));
if (func.action == LFUN_SELFINSERT) {
if (encoded_last_key != 0) {
- string arg(1, encoded_last_key);
- dispatch(FuncRequest(LFUN_SELFINSERT, arg));
+ string const arg(1, encoded_last_key);
+ dispatch(FuncRequest(LFUN_SELFINSERT, arg,
+ FuncRequest::KEYBOARD));
lyxerr[Debug::KEY]
<< "SelfInsert arg[`" << arg << "']" << endl;
}
application can still be accessed without giving focus to
the main window. In this case, we want to disable the menu
entries that are buffer-related.
+
+ Note that this code is not perfect, as bug 1941 attests:
+ http://bugzilla.lyx.org/show_bug.cgi?id=1941#c4
*/
Buffer * buf;
if (cmd.origin == FuncRequest::UI && !owner->hasFocus())
enable = cmd.argument == "custom"
|| Exporter::IsExportable(*buf, cmd.argument);
break;
- case LFUN_CUT:
- case LFUN_COPY:
- enable = cur.selection();
- break;
case LFUN_RUNCHKTEX:
enable = buf->isLatex() && lyxrc.chktex_command != "none";
case LFUN_LAYOUT:
case LFUN_LAYOUT_PARAGRAPH:
- enable = !cur.inset().forceDefaultParagraphs(&cur.inset());
+ enable = !cur.inset().forceDefaultParagraphs(cur.idx());
break;
case LFUN_VC_REGISTER:
enable = !buf->isUnnamed() && !buf->isClean();
break;
-
case LFUN_INSET_SETTINGS: {
enable = false;
- if (!cur.size())
- break;
- UpdatableInset * inset = cur.inset().asUpdatableInset();
- lyxerr << "inset: " << inset << endl;
- if (!inset)
+ if (!cur)
break;
-
- InsetBase::Code code = inset->lyxCode();
+ InsetBase::Code code = cur.inset().lyxCode();
switch (code) {
case InsetBase::TABULAR_CODE:
enable = cmd.argument == "tabular";
break;
}
+ case LFUN_INSET_APPLY: {
+ string const name = cmd.getArg(0);
+ InsetBase * inset = owner->getDialogs().getOpenInset(name);
+ if (inset) {
+ FuncRequest fr(LFUN_INSET_MODIFY, cmd.argument);
+ FuncStatus fs;
+ bool const success = inset->getStatus(cur, fr, fs);
+ // Every inset is supposed to handle this
+ BOOST_ASSERT(success);
+ flag |= fs;
+ } else {
+ FuncRequest fr(LFUN_INSET_INSERT, cmd.argument);
+ flag |= getStatus(fr);
+ }
+ enable = flag.enabled();
+ break;
+ }
+
case LFUN_DIALOG_SHOW: {
string const name = cmd.getArg(0);
if (!buf)
else if (name == "print")
enable = Exporter::IsExportable(*buf, "dvi")
&& lyxrc.print_command != "none";
- else if (name == "character")
+ else if (name == "character" || name == "mathpanel")
enable = cur.inset().lyxCode() != InsetBase::ERT_CODE;
- else if (name == "vclog")
- enable = buf->lyxvc().inUse();
else if (name == "latexlog")
enable = IsFileReadable(buf->getLogName().second);
+#if !defined (USE_ASPELL) && !defined (USE_ISPELL) && !defined (USE_PSPELL)
+ else if (name == "spellchecker")
+ enable = false;
+#endif
+ else if (name == "vclog")
+ enable = buf->lyxvc().inUse();
break;
}
+ case LFUN_DIALOG_SHOW_NEW_INSET:
+ enable = cur.inset().lyxCode() != InsetBase::ERT_CODE;
+ break;
+
case LFUN_DIALOG_UPDATE: {
string const name = cmd.getArg(0);
if (!buf)
break;
}
+ case LFUN_INSERT_CITATION: {
+ FuncRequest fr(LFUN_INSET_INSERT, "citation");
+ enable = getStatus(fr).enabled();
+ break;
+ }
+
// this one is difficult to get right. As a half-baked
// solution, we consider only the first action of the sequence
case LFUN_SEQUENCE: {
case LFUN_GETNAME:
case LFUN_NOTIFY:
case LFUN_GOTOFILEROW:
- case LFUN_GOTO_PARAGRAPH:
- case LFUN_DIALOG_SHOW_NEW_INSET:
case LFUN_DIALOG_SHOW_NEXT_INSET:
case LFUN_DIALOG_HIDE:
case LFUN_DIALOG_DISCONNECT_INSET:
flag.enabled(false);
}
+ // Are we in a DELETED change-tracking region?
+ if (buf && buf->params().tracking_changes
+ && lookupChange(cur, true) == Change::DELETED
+ && !lyxaction.funcHasFlag(cmd.action, LyXAction::ReadOnly)
+ && !lyxaction.funcHasFlag(cmd.action, LyXAction::NoBuffer)) {
+ flag.message(N_("This portion of the document is deleted."));
+ flag.enabled(false);
+ }
+
// the default error message if we disable the command
if (!flag.enabled() && flag.message().empty())
flag.message(N_("Command disabled"));
}
}
+
+void actOnUpdatedPrefs(LyXRC const & lyxrc_orig, LyXRC const & lyxrc_new);
+
} //namespace anon
errorstat = false;
dispatch_buffer.erase();
- bool update = true;
+ bool update = false;
FuncStatus const flag = getStatus(cmd);
if (!flag.enabled()) {
break;
case LFUN_QUIT:
- QuitLyX();
+ QuitLyX(argument == "force");
break;
case LFUN_TOCVIEW: {
int row;
istringstream is(argument);
is >> file_name >> row;
- if (prefixIs(file_name, getTmpDir())) {
+ if (prefixIs(file_name, package().temp_dir())) {
// Needed by inverse dvi search. If it is a file
// in tmpdir, call the apropriated function
view()->setBuffer(bufferlist.getBufferFromTmp(file_name));
break;
}
- case LFUN_GOTO_PARAGRAPH: {
- istringstream is(argument);
- int id;
- is >> id;
- ParIterator par = owner->buffer()->getParFromID(id);
- if (par == owner->buffer()->par_iterator_end()) {
- lyxerr[Debug::INFO] << "No matching paragraph found! ["
- << id << ']' << endl;
- break;
- } else {
- lyxerr[Debug::INFO] << "Paragraph " << par->id()
- << " found." << endl;
- }
-
- // Set the cursor
- view()->setCursor(par, 0);
-
- view()->switchKeyMap();
- owner->view_state_changed();
-
- view()->center();
- // see BufferView_pimpl::center()
- view()->updateScrollbar();
- break;
- }
-
case LFUN_DIALOG_SHOW: {
string const name = cmd.getArg(0);
string data = trim(cmd.argument.substr(name.size()));
string data = trim(cmd.argument.substr(name.size()));
if (name == "bibitem" ||
name == "bibtex" ||
- name == "include" ||
name == "index" ||
name == "label" ||
name == "ref" ||
name == "url") {
InsetCommandParams p(name);
data = InsetCommandMailer::params2string(name, p);
+ } else if (name == "include") {
+ InsetCommandParams p(data);
+ data = InsetIncludeMailer::params2string(p);
} else if (name == "box") {
// \c data == "Boxed" || "Frameless" etc
InsetBoxParams p(data);
owner->getDialogs().disconnect(argument);
break;
+
+ case LFUN_INSERT_CITATION: {
+ if (!argument.empty()) {
+ // we can have one optional argument, delimited by '|'
+ // citation-insert <key>|<text_before>
+ // this should be enhanced to also support text_after
+ // and citation style
+ string arg = argument;
+ string opt1;
+ if (contains(argument, "|")) {
+ arg = token(argument, '|', 0);
+ opt1 = '[' + token(argument, '|', 1) + ']';
+ }
+ std::ostringstream os;
+ os << "citation LatexCommand\n"
+ << "\\cite" << opt1 << "{" << arg << "}\n"
+ << "\\end_inset";
+ FuncRequest fr(LFUN_INSET_INSERT, os.str());
+ dispatch(fr);
+ } else
+ dispatch(FuncRequest(LFUN_DIALOG_SHOW, "citation"));
+ break;
+ }
+
case LFUN_CHILDOPEN: {
string const filename =
MakeAbsPath(argument, owner->buffer()->filePath());
}
case LFUN_SAVEPREFERENCES: {
- Path p(user_lyxdir());
+ Path p(package().user_support());
lyxrc.write("preferences", false);
break;
}
break;
}
+ case LFUN_INSET_APPLY: {
+ string const name = cmd.getArg(0);
+ InsetBase * inset = owner->getDialogs().getOpenInset(name);
+ if (inset) {
+ FuncRequest fr(LFUN_INSET_MODIFY, argument);
+ inset->dispatch(view()->cursor(), fr);
+ } else {
+ FuncRequest fr(LFUN_INSET_INSERT, argument);
+ dispatch(fr);
+ }
+ // ideally, the update flag should be set by the insets,
+ // but this is not possible currently
+ update = true;
+ break;
+ }
+
case LFUN_ALL_INSETS_TOGGLE: {
string action;
string const name = split(argument, action, ' ');
InsetIterator const end = inset_iterator_end(inset);
for (; it != end; ++it) {
if (inset_code == InsetBase::NO_CODE
- || inset_code == it->lyxCode())
- it->dispatch(cur, fr);
+ || inset_code == it->lyxCode()) {
+ LCursor tmpcur = cur;
+ tmpcur.pushLeft(*it);
+ it->dispatch(tmpcur, fr);
+ }
}
+ update = true;
break;
}
case LFUN_SAVE_AS_DEFAULT: {
string const fname =
- AddName(AddPath(user_lyxdir(), "templates/"),
+ AddName(AddPath(package().user_support(), "templates/"),
"defaults.lyx");
Buffer defaults(fname);
break;
owner->message(_("Converting document to new document class..."));
+ recordUndoFullDocument(view());
+ buffer->params().textclass = new_class;
+ StableDocIterator backcur(view()->cursor());
ErrorList el;
- lyx::cap::SwitchLayoutsBetweenClasses(
+ lyx::cap::SwitchBetweenClasses(
old_class, new_class,
buffer->paragraphs(), el);
+ view()->setCursor(backcur.asDocIterator(&(buffer->inset())));
bufferErrors(*buffer, el);
view()->showErrorList(_("Class switch"));
+ updateCounters(*buffer);
+ update = true;
break;
}
break;
case LFUN_LYXRC_APPLY: {
+ LyXRC const lyxrc_orig = lyxrc;
+
istringstream ss(argument);
bool const success = lyxrc.read(ss) == 0;
lyxerr << "Warning in LFUN_LYXRC_APPLY!\n"
<< "Unable to read lyxrc data"
<< endl;
+ break;
}
+
+ actOnUpdatedPrefs(lyxrc_orig, lyxrc);
break;
}
default: {
- update = false;
view()->cursor().dispatch(cmd);
- if (view()->cursor().result().dispatched())
- update |= view()->cursor().result().update();
- else
+ update |= view()->cursor().result().update();
+ if (!view()->cursor().result().dispatched())
update |= view()->dispatch(cmd);
break;
}
// Redraw screen unless explicitly told otherwise.
// This also initializes the position cache for all insets
// in (at least partially) visible top-level paragraphs.
- view()->update(true, update);
+ if (update)
+ view()->update(Update::FitCursor | Update::Force);
+ else
+ view()->update(Update::FitCursor);
// if we executed a mutating lfun, mark the buffer as dirty
- if (getStatus(cmd).enabled()
- && !lyxaction.funcHasFlag(cmd.action, LyXAction::NoBuffer)
- && !lyxaction.funcHasFlag(cmd.action, LyXAction::ReadOnly))
+ if (flag.enabled()
+ && !lyxaction.funcHasFlag(cmd.action, LyXAction::NoBuffer)
+ && !lyxaction.funcHasFlag(cmd.action, LyXAction::ReadOnly))
view()->buffer()->markDirty();
}
view()->owner()->updateLayoutChoice();
}
}
- sendDispatchMessage(getMessage(), cmd);
+ sendDispatchMessage(_(getMessage()), cmd);
}
void LyXFunc::sendDispatchMessage(string const & msg, FuncRequest const & cmd)
{
- owner->updateMenubar();
- owner->updateToolbars();
+ /* When an action did not originate from the UI/kbd, it makes
+ * sense to avoid updating the GUI. It turns out that this
+ * fixes bug 1941, for reasons that are described here:
+ * http://bugzilla.lyx.org/show_bug.cgi?id=1941#c4
+ */
+ if (cmd.origin != FuncRequest::INTERNAL) {
+ owner->updateMenubar();
+ owner->updateToolbars();
+ }
const bool verbose = (cmd.origin == FuncRequest::UI
|| cmd.origin == FuncRequest::COMMANDBUFFER);
string const shortcuts = toplevel_keymap->printbindings(cmd);
- if (!shortcuts.empty()) {
+ if (!shortcuts.empty())
comname += ": " + shortcuts;
- } else if (!argsadded && !cmd.argument.empty()) {
+ else if (!argsadded && !cmd.argument.empty())
comname += ' ' + cmd.argument;
- }
if (!comname.empty()) {
comname = rtrim(comname);
- dispatch_msg += '(' + comname + ')';
+ dispatch_msg += '(' + rtrim(comname) + ')';
}
lyxerr[Debug::ACTION] << "verbose dispatch msg " << dispatch_msg << endl;
if (filename.empty()) {
filename = AddName(lyxrc.document_path,
- "newfile" + tostr(++newfile_number) + ".lyx");
- FileInfo fi(filename);
- while (bufferlist.exists(filename) || fi.readable()) {
+ "newfile" + convert<string>(++newfile_number) + ".lyx");
+ while (bufferlist.exists(filename) || fs::is_readable(filename)) {
++newfile_number;
filename = AddName(lyxrc.document_path,
- "newfile" + tostr(newfile_number) +
+ "newfile" + convert<string>(newfile_number) +
".lyx");
- fi.newFile(filename);
}
}
make_pair(string(_("Documents|#o#O")),
string(lyxrc.document_path)),
make_pair(string(_("Examples|#E#e")),
- string(AddPath(system_lyxdir(), "examples"))));
+ string(AddPath(package().system_support(), "examples"))));
FileDialog::Result result =
fileDlg.open(initpath,
string const disp_fn(MakeDisplayPath(filename));
// if the file doesn't exist, let the user create one
- FileInfo const f(filename, true);
- if (!f.exist()) {
+ if (!fs::exists(filename)) {
// the user specifically chose this name. Believe them.
view()->newFile(filename, "", true);
return;
make_pair(string(_("Documents|#o#O")),
string(lyxrc.document_path)),
make_pair(string(_("Examples|#E#e")),
- string(AddPath(system_lyxdir(), "examples"))));
+ string(AddPath(package().system_support(), "examples"))));
string const filter = formats.prettyName(format)
+ " (*." + formats.extension(format) + ')';
// if the file exists already, and we didn't do
// -i lyx thefile.lyx, warn
- if (FileInfo(lyxfile, true).exist() && filename != lyxfile) {
+ if (fs::exists(lyxfile) && filename != lyxfile) {
string const file = MakeDisplayPath(lyxfile, 30);
string text = bformat(_("The document %1$s already exists.\n\n"
{
return (meta_fake_bit != key_modifier::none);
}
+
+
+namespace {
+
+void actOnUpdatedPrefs(LyXRC const & lyxrc_orig, LyXRC const & lyxrc_new)
+{
+ // Why the switch you might ask. It is a trick to ensure that all
+ // the elements in the LyXRCTags enum is handled. As you can see
+ // there are no breaks at all. So it is just a huge fall-through.
+ // The nice thing is that we will get a warning from the compiler
+ // if we forget an element.
+ LyXRC::LyXRCTags tag = LyXRC::RC_LAST;
+ switch (tag) {
+ case LyXRC::RC_ACCEPT_COMPOUND:
+ case LyXRC::RC_ALT_LANG:
+ case LyXRC::RC_ASCIIROFF_COMMAND:
+ case LyXRC::RC_ASCII_LINELEN:
+ case LyXRC::RC_AUTOREGIONDELETE:
+ case LyXRC::RC_AUTORESET_OPTIONS:
+ case LyXRC::RC_AUTOSAVE:
+ case LyXRC::RC_AUTO_NUMBER:
+ case LyXRC::RC_BACKUPDIR_PATH:
+ case LyXRC::RC_BIBTEX_COMMAND:
+ case LyXRC::RC_BINDFILE:
+ case LyXRC::RC_CHECKLASTFILES:
+ case LyXRC::RC_CHKTEX_COMMAND:
+ case LyXRC::RC_CONVERTER:
+ case LyXRC::RC_COPIER:
+ case LyXRC::RC_CURSOR_FOLLOWS_SCROLLBAR:
+ case LyXRC::RC_CUSTOM_EXPORT_COMMAND:
+ case LyXRC::RC_CUSTOM_EXPORT_FORMAT:
+ case LyXRC::RC_CYGWIN_PATH_FIX:
+ if (lyxrc_orig.cygwin_path_fix != lyxrc_new.cygwin_path_fix) {
+ namespace os = lyx::support::os;
+ os::cygwin_path_fix(lyxrc_new.cygwin_path_fix);
+ }
+ case LyXRC::RC_DATE_INSERT_FORMAT:
+ case LyXRC::RC_DEFAULT_LANGUAGE:
+ case LyXRC::RC_DEFAULT_PAPERSIZE:
+ case LyXRC::RC_DIALOGS_ICONIFY_WITH_MAIN:
+ case LyXRC::RC_DISPLAY_GRAPHICS:
+ case LyXRC::RC_DOCUMENTPATH:
+ if (lyxrc_orig.document_path != lyxrc_new.document_path) {
+ if (fs::exists(lyxrc_new.document_path) &&
+ fs::is_directory(lyxrc_new.document_path)) {
+ using lyx::support::package;
+ package().document_dir() = lyxrc.document_path;
+ }
+ }
+ case LyXRC::RC_ESC_CHARS:
+ case LyXRC::RC_FONT_ENCODING:
+ case LyXRC::RC_FORMAT:
+ case LyXRC::RC_INDEX_COMMAND:
+ case LyXRC::RC_INPUT:
+ case LyXRC::RC_KBMAP:
+ case LyXRC::RC_KBMAP_PRIMARY:
+ case LyXRC::RC_KBMAP_SECONDARY:
+ case LyXRC::RC_LABEL_INIT_LENGTH:
+ case LyXRC::RC_LANGUAGE_AUTO_BEGIN:
+ case LyXRC::RC_LANGUAGE_AUTO_END:
+ case LyXRC::RC_LANGUAGE_COMMAND_BEGIN:
+ case LyXRC::RC_LANGUAGE_COMMAND_END:
+ case LyXRC::RC_LANGUAGE_COMMAND_LOCAL:
+ case LyXRC::RC_LANGUAGE_GLOBAL_OPTIONS:
+ case LyXRC::RC_LANGUAGE_PACKAGE:
+ case LyXRC::RC_LANGUAGE_USE_BABEL:
+ case LyXRC::RC_LASTFILES:
+ case LyXRC::RC_MAKE_BACKUP:
+ case LyXRC::RC_MARK_FOREIGN_LANGUAGE:
+ case LyXRC::RC_NUMLASTFILES:
+ case LyXRC::RC_PATH_PREFIX:
+ if (lyxrc_orig.path_prefix != lyxrc_new.path_prefix) {
+ using lyx::support::prependEnvPath;
+ prependEnvPath("PATH", lyxrc.path_prefix);
+ }
+ case LyXRC::RC_PERS_DICT:
+ case LyXRC::RC_POPUP_BOLD_FONT:
+ case LyXRC::RC_POPUP_FONT_ENCODING:
+ case LyXRC::RC_POPUP_NORMAL_FONT:
+ case LyXRC::RC_PREVIEW:
+ case LyXRC::RC_PREVIEW_HASHED_LABELS:
+ case LyXRC::RC_PREVIEW_SCALE_FACTOR:
+ case LyXRC::RC_PRINTCOLLCOPIESFLAG:
+ case LyXRC::RC_PRINTCOPIESFLAG:
+ case LyXRC::RC_PRINTER:
+ case LyXRC::RC_PRINTEVENPAGEFLAG:
+ case LyXRC::RC_PRINTEXSTRAOPTIONS:
+ case LyXRC::RC_PRINTFILEEXTENSION:
+ case LyXRC::RC_PRINTLANDSCAPEFLAG:
+ case LyXRC::RC_PRINTODDPAGEFLAG:
+ case LyXRC::RC_PRINTPAGERANGEFLAG:
+ case LyXRC::RC_PRINTPAPERDIMENSIONFLAG:
+ case LyXRC::RC_PRINTPAPERFLAG:
+ case LyXRC::RC_PRINTREVERSEFLAG:
+ case LyXRC::RC_PRINTSPOOL_COMMAND:
+ case LyXRC::RC_PRINTSPOOL_PRINTERPREFIX:
+ case LyXRC::RC_PRINTTOFILE:
+ case LyXRC::RC_PRINTTOPRINTER:
+ case LyXRC::RC_PRINT_ADAPTOUTPUT:
+ case LyXRC::RC_PRINT_COMMAND:
+ case LyXRC::RC_RTL_SUPPORT:
+ case LyXRC::RC_SCREEN_DPI:
+ case LyXRC::RC_SCREEN_FONT_ENCODING:
+ case LyXRC::RC_SCREEN_FONT_ROMAN:
+ case LyXRC::RC_SCREEN_FONT_ROMAN_FOUNDRY:
+ case LyXRC::RC_SCREEN_FONT_SANS:
+ case LyXRC::RC_SCREEN_FONT_SANS_FOUNDRY:
+ case LyXRC::RC_SCREEN_FONT_SCALABLE:
+ case LyXRC::RC_SCREEN_FONT_SIZES:
+ case LyXRC::RC_SCREEN_FONT_TYPEWRITER:
+ case LyXRC::RC_SCREEN_FONT_TYPEWRITER_FOUNDRY:
+ case LyXRC::RC_SCREEN_ZOOM:
+ case LyXRC::RC_SERVERPIPE:
+ case LyXRC::RC_SET_COLOR:
+ case LyXRC::RC_SHOW_BANNER:
+ case LyXRC::RC_SPELL_COMMAND:
+ case LyXRC::RC_TEMPDIRPATH:
+ case LyXRC::RC_TEMPLATEPATH:
+ case LyXRC::RC_TEX_ALLOWS_SPACES:
+ case LyXRC::RC_UIFILE:
+ case LyXRC::RC_USER_EMAIL:
+ case LyXRC::RC_USER_NAME:
+ case LyXRC::RC_USETEMPDIR:
+ case LyXRC::RC_USE_ALT_LANG:
+ case LyXRC::RC_USE_ESC_CHARS:
+ case LyXRC::RC_USE_INP_ENC:
+ case LyXRC::RC_USE_PERS_DICT:
+ case LyXRC::RC_USE_SPELL_LIB:
+ case LyXRC::RC_VIEWDVI_PAPEROPTION:
+ case LyXRC::RC_VIEWER:
+ case LyXRC::RC_WHEEL_JUMP:
+ case LyXRC::RC_LAST:
+ break;
+ }
+}
+
+} // namespace anon
projects / lyx.git / blobdiff