X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Flyxfunc.C;h=7de71684d5d8267f2de39d929e5b4b88325e2ce3;hb=c66d2f1ee555358a0a378bcdc9783a1306bd8990;hp=2b80a2535a9108b6a1c26ce7ac33d1075d596727;hpb=d7bccc5f88fb0756fa817b6251da0d89d79574f3;p=lyx.git diff --git a/src/lyxfunc.C b/src/lyxfunc.C index 2b80a2535a..7de71684d5 100644 --- a/src/lyxfunc.C +++ b/src/lyxfunc.C @@ -36,6 +36,7 @@ #include "exporter.h" #include "format.h" #include "funcrequest.h" +#include "FuncStatus.h" #include "gettext.h" #include "importer.h" #include "insetiterator.h" @@ -72,10 +73,12 @@ #include "insets/insetvspace.h" #include "insets/insetwrap.h" +#include "frontends/Application.h" #include "frontends/Alert.h" #include "frontends/Dialogs.h" #include "frontends/FileDialog.h" -#include "frontends/lyx_gui.h" +#include "frontends/FontLoader.h" +#include "frontends/Gui.h" #include "frontends/LyXKeySym.h" #include "frontends/LyXView.h" #include "frontends/Menubar.h" @@ -98,33 +101,35 @@ #include + +namespace lyx { + 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::fileSearch; -using lyx::support::ForkedcallsController; -using lyx::support::i18nLibFileSearch; -using lyx::support::isDirWriteable; -using lyx::support::isFileReadable; -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::subst; -using lyx::support::Systemcall; -using lyx::support::token; -using lyx::support::trim; -using lyx::support::prefixIs; +using support::absolutePath; +using support::addName; +using support::addPath; +using support::bformat; +using support::changeExtension; +using support::contains; +using support::FileFilterList; +using support::fileSearch; +using support::ForkedcallsController; +using support::i18nLibFileSearch; +using support::isDirWriteable; +using support::isFileReadable; +using support::isStrInt; +using support::makeAbsPath; +using support::makeDisplayPath; +using support::package; +using support::quoteName; +using support::rtrim; +using support::split; +using support::subst; +using support::Systemcall; +using support::token; +using support::trim; +using support::prefixIs; using std::endl; using std::make_pair; @@ -133,22 +138,17 @@ using std::string; using std::istringstream; using std::ostringstream; -namespace biblio = lyx::biblio; +namespace Alert = frontend::Alert; namespace fs = boost::filesystem; -extern BufferList bufferlist; -extern LyXServer * lyxserver; - -extern boost::scoped_ptr toplevel_keymap; - // (alkis) extern tex_accent_struct get_accent(kb_action action); namespace { -bool getStatus(LCursor cursor, +bool getLocalStatus(LCursor cursor, FuncRequest const & cmd, FuncStatus & status) { // Try to fix cursor in case it is broken. @@ -183,7 +183,7 @@ bool getStatus(LCursor cursor, * footnote is deleted). * When \param outer is true, the top slice is not looked at. */ -Change::Type lookupChange(DocIterator const & dit, bool outer = false) +Change::Type lookupChangeType(DocIterator const & dit, bool outer = false) { size_t const depth = dit.depth() - (outer ? 1 : 0); @@ -191,7 +191,7 @@ Change::Type lookupChange(DocIterator const & dit, bool outer = false) CursorSlice const & slice = dit[i]; if (!slice.inset().inMathed() && slice.pos() < slice.paragraph().size()) { - Change::Type const ch = slice.paragraph().lookupChange(slice.pos()); + Change::Type const ch = slice.paragraph().lookupChange(slice.pos()).type; if (ch != Change::UNCHANGED) return ch; } @@ -201,29 +201,39 @@ Change::Type lookupChange(DocIterator const & dit, bool outer = false) } -LyXFunc::LyXFunc(LyXView * lv) - : owner(lv), +LyXFunc::LyXFunc() + : lyx_view_(0), encoded_last_key(0), - keyseq(toplevel_keymap.get(), toplevel_keymap.get()), - cancel_meta_seq(toplevel_keymap.get(), toplevel_keymap.get()), meta_fake_bit(key_modifier::none) { } +void LyXFunc::initKeySequences(kb_keymap * kb) +{ + keyseq.reset(new kb_sequence(kb, kb)); + cancel_meta_seq.reset(new kb_sequence(kb, kb)); +} + + +void LyXFunc::setLyXView(LyXView * lv) +{ + lyx_view_ = lv; +} + + void LyXFunc::handleKeyFunc(kb_action action) { - char c = encoded_last_key; + char_type c = encoded_last_key; - if (keyseq.length()) { + if (keyseq->length()) c = 0; - } - owner->getIntl().getTransManager() - .deadkey(c, get_accent(action).accent, view()->getLyXText()); + lyx_view_->view()->getIntl().getTransManager().deadkey( + c, get_accent(action).accent, view()->getLyXText(), view()->cursor()); // Need to clear, in case the minibuffer calls these // actions - keyseq.clear(); + keyseq->clear(); // copied verbatim from do_accent_char view()->cursor().resetAnchor(); view()->update(); @@ -246,15 +256,15 @@ void LyXFunc::processKeySym(LyXKeySymPtr keysym, key_modifier::state state) return; } - Encoding const * encoding = view()->cursor().getEncoding(); - - encoded_last_key = keysym->getISOEncoded(encoding ? encoding->name() : ""); + //Encoding const * encoding = view()->cursor().getEncoding(); + //encoded_last_key = keysym->getISOEncoded(encoding ? encoding->name() : ""); + size_t encoded_last_key = keysym->getUCSEncoded(); // Do a one-deep top-level lookup for // cancel and meta-fake keys. RVDK_PATCH_5 - cancel_meta_seq.reset(); + cancel_meta_seq->reset(); - FuncRequest func = cancel_meta_seq.addkey(keysym, state); + FuncRequest func = cancel_meta_seq->addkey(keysym, state); lyxerr[Debug::KEY] << BOOST_CURRENT_FUNCTION << " action first set to [" << func.action << ']' << endl; @@ -262,9 +272,9 @@ void LyXFunc::processKeySym(LyXKeySymPtr keysym, key_modifier::state state) // When not cancel or meta-fake, do the normal lookup. // Note how the meta_fake Mod1 bit is OR-ed in and reset afterwards. // Mostly, meta_fake_bit = key_modifier::none. RVDK_PATCH_5. - if ((func.action != LFUN_CANCEL) && (func.action != LFUN_META_FAKE)) { + if ((func.action != LFUN_CANCEL) && (func.action != LFUN_META_PREFIX)) { // remove Caps Lock and Mod2 as a modifiers - func = keyseq.addkey(keysym, (state | meta_fake_bit)); + func = keyseq->addkey(keysym, (state | meta_fake_bit)); lyxerr[Debug::KEY] << BOOST_CURRENT_FUNCTION << "action now set to [" << func.action << ']' << endl; @@ -275,14 +285,14 @@ void LyXFunc::processKeySym(LyXKeySymPtr keysym, key_modifier::state state) // Can this happen now ? if (func.action == LFUN_NOACTION) { - func = FuncRequest(LFUN_PREFIX); + func = FuncRequest(LFUN_COMMAND_PREFIX); } if (lyxerr.debugging(Debug::KEY)) { lyxerr << BOOST_CURRENT_FUNCTION << " Key [action=" << func.action << "][" - << keyseq.print() << ']' + << keyseq->print() << ']' << endl; } @@ -290,8 +300,8 @@ void LyXFunc::processKeySym(LyXKeySymPtr keysym, key_modifier::state state) // why not return already here if action == -1 and // num_bytes == 0? (Lgb) - if (keyseq.length() > 1) { - owner->message(keyseq.print()); + if (keyseq->length() > 1) { + lyx_view_->message(from_utf8(keyseq->print())); } @@ -300,7 +310,7 @@ void LyXFunc::processKeySym(LyXKeySymPtr keysym, key_modifier::state state) if (func.action == LFUN_UNKNOWN_ACTION && state == key_modifier::shift) { lyxerr[Debug::KEY] << "Trying without shift" << endl; - func = keyseq.addkey(keysym, key_modifier::none); + func = keyseq->addkey(keysym, key_modifier::none); lyxerr[Debug::KEY] << "Action now " << func.action << endl; } @@ -308,24 +318,24 @@ void LyXFunc::processKeySym(LyXKeySymPtr keysym, key_modifier::state state) // Hmm, we didn't match any of the keysequences. See // if it's normal insertable text not already covered // by a binding - if (keysym->isText() && keyseq.length() == 1) { + if (keysym->isText() && keyseq->length() == 1) { lyxerr[Debug::KEY] << "isText() is true, inserting." << endl; - func = FuncRequest(LFUN_SELFINSERT, + func = FuncRequest(LFUN_SELF_INSERT, FuncRequest::KEYBOARD); } else { lyxerr[Debug::KEY] << "Unknown, !isText() - giving up" << endl; - owner->message(_("Unknown function.")); + lyx_view_->message(_("Unknown function.")); return; } } - if (func.action == LFUN_SELFINSERT) { + if (func.action == LFUN_SELF_INSERT) { if (encoded_last_key != 0) { - string const arg(1, encoded_last_key); - dispatch(FuncRequest(LFUN_SELFINSERT, arg, + docstring const arg(1, encoded_last_key); + dispatch(FuncRequest(LFUN_SELF_INSERT, arg, FuncRequest::KEYBOARD)); lyxerr[Debug::KEY] - << "SelfInsert arg[`" << arg << "']" << endl; + << "SelfInsert arg[`" << to_utf8(arg) << "']" << endl; } } else { dispatch(func); @@ -337,6 +347,25 @@ FuncStatus LyXFunc::getStatus(FuncRequest const & cmd) const { //lyxerr << "LyXFunc::getStatus: cmd: " << cmd << endl; FuncStatus flag; + + if (cmd.action == LFUN_LYX_QUIT) { + flag.message(from_utf8(N_("Exiting"))); + flag.enabled(true); + return flag; + } else if (cmd.action == LFUN_BOOKMARK_GOTO) { + // bookmarks can be valid even if there is no opened buffer + flag.enabled(LyX::ref().session().bookmarks().isValid(convert(to_utf8(cmd.argument())))); + return flag; + } else if (cmd.action == LFUN_BOOKMARK_CLEAR) { + flag.enabled(LyX::ref().session().bookmarks().size() > 0); + return flag; + } else if (cmd.action == LFUN_TOOLBAR_TOGGLE_STATE) { + ToolbarBackend::Flags flags = lyx_view_->getToolbarState(to_utf8(cmd.argument())); + if (!(flags & ToolbarBackend::AUTO)) + flag.setOnOff(flags & ToolbarBackend::ON); + return flag; + } + LCursor & cur = view()->cursor(); /* In LyX/Mac, when a dialog is open, the menus of the @@ -348,13 +377,13 @@ FuncStatus LyXFunc::getStatus(FuncRequest const & cmd) const http://bugzilla.lyx.org/show_bug.cgi?id=1941#c4 */ Buffer * buf; - if (cmd.origin == FuncRequest::UI && !owner->hasFocus()) + if (cmd.origin == FuncRequest::MENU && !lyx_view_->hasFocus()) buf = 0; else - buf = owner->buffer(); + buf = lyx_view_->buffer(); if (cmd.action == LFUN_NOACTION) { - flag.message(N_("Nothing to do")); + flag.message(from_utf8(N_("Nothing to do"))); flag.enabled(false); return flag; } @@ -367,26 +396,27 @@ FuncStatus LyXFunc::getStatus(FuncRequest const & cmd) const flag.unknown(true); flag.enabled(false); break; + default: - flag |= lyx_gui::getStatus(cmd); + break; } if (flag.unknown()) { - flag.message(N_("Unknown action")); + flag.message(from_utf8(N_("Unknown action"))); return flag; } if (!flag.enabled()) { if (flag.message().empty()) - flag.message(N_("Command disabled")); + flag.message(from_utf8(N_("Command disabled"))); return flag; } // Check whether we need a buffer if (!lyxaction.funcHasFlag(cmd.action, LyXAction::NoBuffer) && !buf) { // no, exit directly - flag.message(N_("Command not allowed with" - "out any document open")); + flag.message(from_utf8(N_("Command not allowed with" + "out any document open"))); flag.enabled(false); return flag; } @@ -397,31 +427,27 @@ FuncStatus LyXFunc::getStatus(FuncRequest const & cmd) const // to handle (Andre') bool enable = true; switch (cmd.action) { - case LFUN_TOOLTIPS_TOGGLE: - flag.setOnOff(owner->getDialogs().tooltipsEnabled()); - break; - - case LFUN_READ_ONLY_TOGGLE: + case LFUN_BUFFER_TOGGLE_READ_ONLY: flag.setOnOff(buf->isReadonly()); break; - case LFUN_SWITCHBUFFER: + case LFUN_BUFFER_SWITCH: // toggle on the current buffer, but do not toggle off // the other ones (is that a good idea?) - if (cmd.argument == buf->fileName()) + if (to_utf8(cmd.argument()) == buf->fileName()) flag.setOnOff(true); break; - case LFUN_EXPORT: - enable = cmd.argument == "custom" - || Exporter::isExportable(*buf, cmd.argument); + case LFUN_BUFFER_EXPORT: + enable = cmd.argument() == "custom" + || Exporter::isExportable(*buf, to_utf8(cmd.argument())); break; - case LFUN_RUNCHKTEX: - enable = buf->isLatex() && lyxrc.chktex_command != "none"; + case LFUN_BUFFER_CHKTEX: + enable = buf->isLatex() && !lyxrc.chktex_command.empty(); break; - case LFUN_BUILDPROG: + case LFUN_BUILD_PROGRAM: enable = Exporter::isExportable(*buf, "program"); break; @@ -437,17 +463,17 @@ FuncStatus LyXFunc::getStatus(FuncRequest const & cmd) const case LFUN_VC_REGISTER: enable = !buf->lyxvc().inUse(); break; - case LFUN_VC_CHECKIN: + case LFUN_VC_CHECK_IN: enable = buf->lyxvc().inUse() && !buf->isReadonly(); break; - case LFUN_VC_CHECKOUT: + case LFUN_VC_CHECK_OUT: enable = buf->lyxvc().inUse() && buf->isReadonly(); break; case LFUN_VC_REVERT: - case LFUN_VC_UNDO: + case LFUN_VC_UNDO_LAST: enable = buf->lyxvc().inUse(); break; - case LFUN_MENURELOAD: + case LFUN_BUFFER_RELOAD: enable = !buf->isUnnamed() && !buf->isClean(); break; @@ -458,25 +484,25 @@ FuncStatus LyXFunc::getStatus(FuncRequest const & cmd) const InsetBase::Code code = cur.inset().lyxCode(); switch (code) { case InsetBase::TABULAR_CODE: - enable = cmd.argument == "tabular"; + enable = cmd.argument() == "tabular"; break; case InsetBase::ERT_CODE: - enable = cmd.argument == "ert"; + enable = cmd.argument() == "ert"; break; case InsetBase::FLOAT_CODE: - enable = cmd.argument == "float"; + enable = cmd.argument() == "float"; break; case InsetBase::WRAP_CODE: - enable = cmd.argument == "wrap"; + enable = cmd.argument() == "wrap"; break; case InsetBase::NOTE_CODE: - enable = cmd.argument == "note"; + enable = cmd.argument() == "note"; break; case InsetBase::BRANCH_CODE: - enable = cmd.argument == "branch"; + enable = cmd.argument() == "branch"; break; case InsetBase::BOX_CODE: - enable = cmd.argument == "box"; + enable = cmd.argument() == "box"; break; default: break; @@ -486,16 +512,16 @@ FuncStatus LyXFunc::getStatus(FuncRequest const & cmd) const case LFUN_INSET_APPLY: { string const name = cmd.getArg(0); - InsetBase * inset = owner->getDialogs().getOpenInset(name); + InsetBase * inset = lyx_view_->getDialogs().getOpenInset(name); if (inset) { - FuncRequest fr(LFUN_INSET_MODIFY, cmd.argument); + 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); + FuncRequest fr(LFUN_INSET_INSERT, cmd.argument()); flag |= getStatus(fr); } enable = flag.enabled(); @@ -539,86 +565,86 @@ FuncStatus LyXFunc::getStatus(FuncRequest const & cmd) const break; } - case LFUN_INSERT_CITATION: { + case LFUN_CITATION_INSERT: { FuncRequest fr(LFUN_INSET_INSERT, "citation"); enable = getStatus(fr).enabled(); break; } - case LFUN_MENUWRITE: { + case LFUN_BUFFER_WRITE: { enable = view()->buffer()->isUnnamed() || !view()->buffer()->isClean(); 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_COMMAND_SEQUENCE: { // argument contains ';'-terminated commands - string const firstcmd = token(cmd.argument, ';', 0); + string const firstcmd = token(to_utf8(cmd.argument()), ';', 0); FuncRequest func(lyxaction.lookupFunc(firstcmd)); func.origin = cmd.origin; flag = getStatus(func); } - case LFUN_MENUNEW: - case LFUN_MENUNEWTMPLT: - case LFUN_WORDFINDFORWARD: - case LFUN_WORDFINDBACKWARD: - case LFUN_PREFIX: - case LFUN_EXEC_COMMAND: + case LFUN_BUFFER_NEW: + case LFUN_BUFFER_NEW_TEMPLATE: + case LFUN_WORD_FIND_FORWARD: + case LFUN_WORD_FIND_BACKWARD: + case LFUN_COMMAND_PREFIX: + case LFUN_COMMAND_EXECUTE: case LFUN_CANCEL: - case LFUN_META_FAKE: - case LFUN_CLOSEBUFFER: - case LFUN_WRITEAS: - case LFUN_UPDATE: - case LFUN_PREVIEW: - case LFUN_IMPORT: - case LFUN_QUIT: - case LFUN_TOCVIEW: - case LFUN_AUTOSAVE: + case LFUN_META_PREFIX: + case LFUN_BUFFER_CLOSE: + case LFUN_BUFFER_WRITE_AS: + case LFUN_BUFFER_UPDATE: + case LFUN_BUFFER_VIEW: + case LFUN_BUFFER_IMPORT: + case LFUN_TOC_VIEW: + case LFUN_BUFFER_AUTO_SAVE: case LFUN_RECONFIGURE: case LFUN_HELP_OPEN: case LFUN_FILE_NEW: case LFUN_FILE_OPEN: case LFUN_DROP_LAYOUTS_CHOICE: - case LFUN_MENU_OPEN_BY_NAME: - case LFUN_GETNAME: - case LFUN_NOTIFY: - case LFUN_GOTOFILEROW: - case LFUN_DIALOG_SHOW_NEXT_INSET: + case LFUN_MENU_OPEN: + case LFUN_SERVER_GET_NAME: + case LFUN_SERVER_NOTIFY: + case LFUN_SERVER_GOTO_FILE_ROW: case LFUN_DIALOG_HIDE: case LFUN_DIALOG_DISCONNECT_INSET: - case LFUN_CHILDOPEN: - case LFUN_TOGGLECURSORFOLLOW: - case LFUN_KMAP_OFF: - case LFUN_KMAP_PRIM: - case LFUN_KMAP_SEC: - case LFUN_KMAP_TOGGLE: + case LFUN_BUFFER_CHILD_OPEN: + case LFUN_TOGGLE_CURSOR_FOLLOWS_SCROLLBAR: + case LFUN_KEYMAP_OFF: + case LFUN_KEYMAP_PRIMARY: + case LFUN_KEYMAP_SECONDARY: + case LFUN_KEYMAP_TOGGLE: case LFUN_REPEAT: - case LFUN_EXPORT_CUSTOM: - case LFUN_PRINT: - case LFUN_SAVEPREFERENCES: + case LFUN_BUFFER_EXPORT_CUSTOM: + case LFUN_BUFFER_PRINT: + case LFUN_PREFERENCES_SAVE: case LFUN_SCREEN_FONT_UPDATE: case LFUN_SET_COLOR: case LFUN_MESSAGE: case LFUN_EXTERNAL_EDIT: case LFUN_GRAPHICS_EDIT: case LFUN_ALL_INSETS_TOGGLE: - case LFUN_LANGUAGE_BUFFER: + case LFUN_BUFFER_LANGUAGE: case LFUN_TEXTCLASS_APPLY: case LFUN_TEXTCLASS_LOAD: - case LFUN_SAVE_AS_DEFAULT: - case LFUN_BUFFERPARAMS_APPLY: + case LFUN_BUFFER_SAVE_AS_DEFAULT: + case LFUN_BUFFER_PARAMS_APPLY: case LFUN_LYXRC_APPLY: - case LFUN_NEXTBUFFER: - case LFUN_PREVIOUSBUFFER: + case LFUN_BUFFER_NEXT: + case LFUN_BUFFER_PREVIOUS: + case LFUN_WINDOW_NEW: + case LFUN_WINDOW_CLOSE: // these are handled in our dispatch() break; default: - - if (!::getStatus(cur, cmd, flag)) + if (!getLocalStatus(cur, cmd, flag)) flag = view()->getStatus(cmd); } @@ -629,54 +655,53 @@ FuncStatus LyXFunc::getStatus(FuncRequest const & cmd) const if (buf && buf->isReadonly() && !lyxaction.funcHasFlag(cmd.action, LyXAction::ReadOnly) && !lyxaction.funcHasFlag(cmd.action, LyXAction::NoBuffer)) { - flag.message(N_("Document is read-only")); + flag.message(from_utf8(N_("Document is read-only"))); flag.enabled(false); } // Are we in a DELETED change-tracking region? - if (buf && buf->params().tracking_changes - && lookupChange(cur, true) == Change::DELETED + if (buf && lookupChangeType(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.message(from_utf8(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")); + flag.message(from_utf8(N_("Command disabled"))); return flag; } -namespace { - -bool ensureBufferClean(BufferView * bv) +bool LyXFunc::ensureBufferClean(BufferView * bv) { Buffer & buf = *bv->buffer(); if (buf.isClean()) return true; - string const file = makeDisplayPath(buf.fileName(), 30); - string text = bformat(_("The document %1$s has unsaved " - "changes.\n\nDo you want to save " - "the document?"), file); + docstring const file = makeDisplayPath(buf.fileName(), 30); + docstring text = bformat(_("The document %1$s has unsaved " + "changes.\n\nDo you want to save " + "the document?"), file); int const ret = Alert::prompt(_("Save changed document?"), text, 0, 1, _("&Save"), _("&Cancel")); if (ret == 0) - bv->owner()->dispatch(FuncRequest(LFUN_MENUWRITE)); + dispatch(FuncRequest(LFUN_BUFFER_WRITE)); return buf.isClean(); } +namespace { + void showPrintError(string const & name) { - string str = bformat(_("Could not print the document %1$s.\n" - "Check that your printer is set up correctly."), + docstring str = bformat(_("Could not print the document %1$s.\n" + "Check that your printer is set up correctly."), makeDisplayPath(name, 50)); Alert::error(_("Print document failed"), str); } @@ -684,7 +709,7 @@ void showPrintError(string const & name) void loadTextclass(string const & name) { - std::pair const tc_pair = + std::pair const tc_pair = textclasslist.numberOfClass(name); if (!tc_pair.first) { @@ -694,12 +719,12 @@ void loadTextclass(string const & name) return; } - lyx::textclass_type const tc = tc_pair.second; + textclass_type const tc = tc_pair.second; if (!textclasslist[tc].load()) { - string s = bformat(_("The document could not be converted\n" - "into the document class %1$s."), - textclasslist[tc].name()); + docstring s = bformat(_("The document could not be converted\n" + "into the document class %1$s."), + from_utf8(textclasslist[tc].name())); Alert::error(_("Could not change class"), s); } } @@ -712,18 +737,19 @@ void actOnUpdatedPrefs(LyXRC const & lyxrc_orig, LyXRC const & lyxrc_new); void LyXFunc::dispatch(FuncRequest const & cmd) { - BOOST_ASSERT(view()); - string const argument = cmd.argument; + string const argument = to_utf8(cmd.argument()); kb_action const action = cmd.action; - lyxerr[Debug::ACTION] << "LyXFunc::dispatch: cmd: " << cmd << endl; + lyxerr[Debug::ACTION] << endl << "LyXFunc::dispatch: cmd: " << cmd << endl; //lyxerr << "LyXFunc::dispatch: cmd: " << cmd << endl; // we have not done anything wrong yet. errorstat = false; dispatch_buffer.erase(); - bool update = false; + // redraw the screen at the end (first of the two drawing steps). + //This is done unless explicitely requested otherwise + Update::flags updateFlags = Update::FitCursor; FuncStatus const flag = getStatus(cmd); if (!flag.enabled()) { @@ -734,14 +760,11 @@ void LyXFunc::dispatch(FuncRequest const & cmd) << endl; setErrorMessage(flag.message()); } else { - - if (view()->available()) - view()->hideCursor(); - switch (action) { - case LFUN_WORDFINDFORWARD: - case LFUN_WORDFINDBACKWARD: { + case LFUN_WORD_FIND_FORWARD: + case LFUN_WORD_FIND_BACKWARD: { + BOOST_ASSERT(lyx_view_ && lyx_view_->view()); static string last_search; string searched_string; @@ -755,76 +778,86 @@ void LyXFunc::dispatch(FuncRequest const & cmd) if (searched_string.empty()) break; - bool const fw = action == LFUN_WORDFINDFORWARD; + bool const fw = action == LFUN_WORD_FIND_FORWARD; string const data = - lyx::find::find2string(searched_string, true, false, fw); - lyx::find::find(view(), FuncRequest(LFUN_WORD_FIND, data)); + find2string(searched_string, true, false, fw); + find(view(), FuncRequest(LFUN_WORD_FIND, data)); break; } - case LFUN_PREFIX: - owner->message(keyseq.printOptions()); + case LFUN_COMMAND_PREFIX: + BOOST_ASSERT(lyx_view_); + lyx_view_->message(from_utf8(keyseq->printOptions())); break; - case LFUN_EXEC_COMMAND: - owner->getToolbars().display("minibuffer", true); - owner->focus_command_buffer(); + case LFUN_COMMAND_EXECUTE: + BOOST_ASSERT(lyx_view_); + lyx_view_->getToolbars().display("minibuffer", true); + lyx_view_->focus_command_buffer(); break; case LFUN_CANCEL: - keyseq.reset(); + BOOST_ASSERT(lyx_view_ && lyx_view_->view()); + keyseq->reset(); meta_fake_bit = key_modifier::none; - if (view()->available()) + if (view()->buffer()) // cancel any selection dispatch(FuncRequest(LFUN_MARK_OFF)); - setMessage(N_("Cancel")); + setMessage(_("Cancel")); break; - case LFUN_META_FAKE: + case LFUN_META_PREFIX: meta_fake_bit = key_modifier::alt; - setMessage(keyseq.print()); + setMessage(from_utf8(keyseq->print())); break; - case LFUN_READ_ONLY_TOGGLE: - if (owner->buffer()->lyxvc().inUse()) - owner->buffer()->lyxvc().toggleReadOnly(); + case LFUN_BUFFER_TOGGLE_READ_ONLY: + BOOST_ASSERT(lyx_view_ && lyx_view_->view() && lyx_view_->buffer()); + if (lyx_view_->buffer()->lyxvc().inUse()) + lyx_view_->buffer()->lyxvc().toggleReadOnly(); else - owner->buffer()->setReadonly( - !owner->buffer()->isReadonly()); + lyx_view_->buffer()->setReadonly( + !lyx_view_->buffer()->isReadonly()); break; // --- Menus ----------------------------------------------- - case LFUN_MENUNEW: + case LFUN_BUFFER_NEW: menuNew(argument, false); break; - case LFUN_MENUNEWTMPLT: + case LFUN_BUFFER_NEW_TEMPLATE: menuNew(argument, true); break; - case LFUN_CLOSEBUFFER: + case LFUN_BUFFER_CLOSE: closeBuffer(); + view()->update(); break; - case LFUN_MENUWRITE: - if (!owner->buffer()->isUnnamed()) { - string const str = bformat(_("Saving document %1$s..."), - makeDisplayPath(owner->buffer()->fileName())); - owner->message(str); - menuWrite(owner->buffer()); - owner->message(str + _(" done.")); + case LFUN_BUFFER_WRITE: + BOOST_ASSERT(lyx_view_ && lyx_view_->buffer()); + if (!lyx_view_->buffer()->isUnnamed()) { + docstring const str = bformat(_("Saving document %1$s..."), + makeDisplayPath(lyx_view_->buffer()->fileName())); + lyx_view_->message(str); + menuWrite(lyx_view_->buffer()); + lyx_view_->message(str + _(" done.")); } else - writeAs(owner->buffer()); + writeAs(lyx_view_->buffer()); + updateFlags = Update::None; break; - case LFUN_WRITEAS: - writeAs(owner->buffer(), argument); + case LFUN_BUFFER_WRITE_AS: + BOOST_ASSERT(lyx_view_ && lyx_view_->buffer()); + writeAs(lyx_view_->buffer(), argument); + updateFlags = Update::None; break; - case LFUN_MENURELOAD: { - string const file = makeDisplayPath(view()->buffer()->fileName(), 20); - string text = bformat(_("Any changes will be lost. Are you sure " - "you want to revert to the saved version of the document %1$s?"), file); + case LFUN_BUFFER_RELOAD: { + BOOST_ASSERT(lyx_view_ && lyx_view_->buffer()); + docstring const file = makeDisplayPath(view()->buffer()->fileName(), 20); + docstring text = bformat(_("Any changes will be lost. Are you sure " + "you want to revert to the saved version of the document %1$s?"), file); int const ret = Alert::prompt(_("Revert to saved document?"), text, 0, 1, _("&Revert"), _("&Cancel")); @@ -833,36 +866,37 @@ void LyXFunc::dispatch(FuncRequest const & cmd) break; } - case LFUN_UPDATE: - Exporter::Export(owner->buffer(), argument, true); - view()->showErrorList(bufferFormat(*owner->buffer())); + case LFUN_BUFFER_UPDATE: + BOOST_ASSERT(lyx_view_ && lyx_view_->buffer()); + Exporter::Export(lyx_view_->buffer(), argument, true); break; - case LFUN_PREVIEW: - Exporter::preview(owner->buffer(), argument); - view()->showErrorList(bufferFormat(*owner->buffer())); + case LFUN_BUFFER_VIEW: + BOOST_ASSERT(lyx_view_ && lyx_view_->buffer()); + Exporter::preview(lyx_view_->buffer(), argument); break; - case LFUN_BUILDPROG: - Exporter::Export(owner->buffer(), "program", true); - view()->showErrorList(_("Build")); + case LFUN_BUILD_PROGRAM: + BOOST_ASSERT(lyx_view_ && lyx_view_->buffer()); + Exporter::Export(lyx_view_->buffer(), "program", true); break; - case LFUN_RUNCHKTEX: - owner->buffer()->runChktex(); - view()->showErrorList(_("ChkTeX")); + case LFUN_BUFFER_CHKTEX: + BOOST_ASSERT(lyx_view_ && lyx_view_->buffer()); + lyx_view_->buffer()->runChktex(); break; - case LFUN_EXPORT: + case LFUN_BUFFER_EXPORT: + BOOST_ASSERT(lyx_view_ && lyx_view_->buffer()); if (argument == "custom") - owner->getDialogs().show("sendto"); + lyx_view_->getDialogs().show("sendto"); else { - Exporter::Export(owner->buffer(), argument, false); - view()->showErrorList(bufferFormat(*owner->buffer())); + Exporter::Export(lyx_view_->buffer(), argument, false); } break; - case LFUN_EXPORT_CUSTOM: { + case LFUN_BUFFER_EXPORT_CUSTOM: { + BOOST_ASSERT(lyx_view_ && lyx_view_->buffer()); string format_name; string command = split(argument, format_name, ' '); Format const * format = formats.getFormat(format_name); @@ -873,7 +907,7 @@ void LyXFunc::dispatch(FuncRequest const & cmd) break; } - Buffer * buffer = owner->buffer(); + Buffer * buffer = lyx_view_->buffer(); // The name of the file created by the conversion process string filename; @@ -890,8 +924,7 @@ void LyXFunc::dispatch(FuncRequest const & cmd) break; } else { - Exporter::Export(buffer, format_name, true, - filename); + Exporter::Export(buffer, format_name, true, filename); } // Substitute $$FName for filename @@ -905,7 +938,8 @@ void LyXFunc::dispatch(FuncRequest const & cmd) break; } - case LFUN_PRINT: { + case LFUN_BUFFER_PRINT: { + BOOST_ASSERT(lyx_view_ && lyx_view_->buffer()); string target; string target_name; string command = split(split(argument, target, ' '), @@ -924,7 +958,7 @@ void LyXFunc::dispatch(FuncRequest const & cmd) break; } - Buffer * buffer = owner->buffer(); + Buffer * buffer = lyx_view_->buffer(); if (!Exporter::Export(buffer, "dvi", true)) { showPrintError(buffer->fileName()); @@ -933,7 +967,7 @@ void LyXFunc::dispatch(FuncRequest const & cmd) // Push directory path. string const path = buffer->temppath(); - Path p(path); + support::Path p(path); // there are three cases here: // 1. we print to a file @@ -996,42 +1030,51 @@ void LyXFunc::dispatch(FuncRequest const & cmd) break; } - case LFUN_IMPORT: + case LFUN_BUFFER_IMPORT: doImport(argument); break; - case LFUN_QUIT: - if (view()->available()) { + case LFUN_LYX_QUIT: + if (argument != "force") { + if (!theApp->gui().closeAll()) + break; + lyx_view_ = 0; + } + + // FIXME: this code needs to be transfered somewhere else + // as lyx_view_ will most certainly be null and a same buffer + // might be visible in more than one LyXView. + if (lyx_view_ && lyx_view_->view()->buffer()) { // save cursor Position for opened files to .lyx/session - LyX::ref().session().saveFilePosition(owner->buffer()->fileName(), + LyX::ref().session().lastFilePos().save(lyx_view_->buffer()->fileName(), boost::tie(view()->cursor().pit(), view()->cursor().pos()) ); - // save opened file name to .lyx/session - LyX::ref().session().setLastOpenedFiles( bufferlist.getFileNames()); - // save bookmarks to .lyx/session - view()->saveSavedPositions(); } - quitLyX(argument == "force"); + + LyX::ref().quit(); break; - case LFUN_TOCVIEW: { + case LFUN_TOC_VIEW: { + BOOST_ASSERT(lyx_view_); InsetCommandParams p("tableofcontents"); string const data = InsetCommandMailer::params2string("toc", p); - owner->getDialogs().show("toc", data, 0); + lyx_view_->getDialogs().show("toc", data, 0); break; } - case LFUN_AUTOSAVE: + case LFUN_BUFFER_AUTO_SAVE: autoSave(view()); break; case LFUN_RECONFIGURE: - reconfigure(view()); + BOOST_ASSERT(lyx_view_); + reconfigure(*lyx_view_); break; case LFUN_HELP_OPEN: { + BOOST_ASSERT(lyx_view_); string const arg = argument; if (arg.empty()) { - setErrorMessage(N_("Missing argument")); + setErrorMessage(_("Missing argument")); break; } string const fname = i18nLibFileSearch("doc", arg, "lyx"); @@ -1040,95 +1083,109 @@ void LyXFunc::dispatch(FuncRequest const & cmd) << arg << "'. Bad installation?" << endl; break; } - owner->message(bformat(_("Opening help file %1$s..."), + lyx_view_->message(bformat(_("Opening help file %1$s..."), makeDisplayPath(fname))); - view()->loadLyXFile(fname, false); + lyx_view_->loadLyXFile(fname, false); break; } // --- version control ------------------------------- case LFUN_VC_REGISTER: + BOOST_ASSERT(lyx_view_ && lyx_view_->buffer()); if (!ensureBufferClean(view())) break; - if (!owner->buffer()->lyxvc().inUse()) { - owner->buffer()->lyxvc().registrer(); + if (!lyx_view_->buffer()->lyxvc().inUse()) { + lyx_view_->buffer()->lyxvc().registrer(); view()->reload(); } break; - case LFUN_VC_CHECKIN: + case LFUN_VC_CHECK_IN: + BOOST_ASSERT(lyx_view_ && lyx_view_->buffer()); if (!ensureBufferClean(view())) break; - if (owner->buffer()->lyxvc().inUse() - && !owner->buffer()->isReadonly()) { - owner->buffer()->lyxvc().checkIn(); + if (lyx_view_->buffer()->lyxvc().inUse() + && !lyx_view_->buffer()->isReadonly()) { + lyx_view_->buffer()->lyxvc().checkIn(); view()->reload(); } break; - case LFUN_VC_CHECKOUT: + case LFUN_VC_CHECK_OUT: + BOOST_ASSERT(lyx_view_ && lyx_view_->buffer()); if (!ensureBufferClean(view())) break; - if (owner->buffer()->lyxvc().inUse() - && owner->buffer()->isReadonly()) { - owner->buffer()->lyxvc().checkOut(); + if (lyx_view_->buffer()->lyxvc().inUse() + && lyx_view_->buffer()->isReadonly()) { + lyx_view_->buffer()->lyxvc().checkOut(); view()->reload(); } break; case LFUN_VC_REVERT: - owner->buffer()->lyxvc().revert(); + BOOST_ASSERT(lyx_view_ && lyx_view_->buffer()); + lyx_view_->buffer()->lyxvc().revert(); view()->reload(); break; - case LFUN_VC_UNDO: - owner->buffer()->lyxvc().undoLast(); + case LFUN_VC_UNDO_LAST: + BOOST_ASSERT(lyx_view_ && lyx_view_->buffer()); + lyx_view_->buffer()->lyxvc().undoLast(); view()->reload(); break; // --- buffers ---------------------------------------- - case LFUN_SWITCHBUFFER: - view()->setBuffer(bufferlist.getBuffer(argument)); + case LFUN_BUFFER_SWITCH: + BOOST_ASSERT(lyx_view_); + lyx_view_->setBuffer(theBufferList().getBuffer(argument)); break; - case LFUN_NEXTBUFFER: - view()->setBuffer(bufferlist.next(view()->buffer())); + case LFUN_BUFFER_NEXT: + BOOST_ASSERT(lyx_view_); + lyx_view_->setBuffer(theBufferList().next(view()->buffer())); break; - case LFUN_PREVIOUSBUFFER: - view()->setBuffer(bufferlist.previous(view()->buffer())); + case LFUN_BUFFER_PREVIOUS: + BOOST_ASSERT(lyx_view_); + lyx_view_->setBuffer(theBufferList().previous(view()->buffer())); break; case LFUN_FILE_NEW: + BOOST_ASSERT(lyx_view_); newFile(view(), argument); break; case LFUN_FILE_OPEN: + BOOST_ASSERT(lyx_view_); open(argument); break; case LFUN_DROP_LAYOUTS_CHOICE: - owner->getToolbars().openLayoutList(); + BOOST_ASSERT(lyx_view_); + lyx_view_->getToolbars().openLayoutList(); break; - case LFUN_MENU_OPEN_BY_NAME: - owner->getMenubar().openByName(argument); + case LFUN_MENU_OPEN: + BOOST_ASSERT(lyx_view_); + lyx_view_->getMenubar().openByName(from_utf8(argument)); break; // --- lyxserver commands ---------------------------- - case LFUN_GETNAME: - setMessage(owner->buffer()->fileName()); + case LFUN_SERVER_GET_NAME: + BOOST_ASSERT(lyx_view_ && lyx_view_->buffer()); + setMessage(from_utf8(lyx_view_->buffer()->fileName())); lyxerr[Debug::INFO] << "FNAME[" - << owner->buffer()->fileName() + << lyx_view_->buffer()->fileName() << "] " << endl; break; - case LFUN_NOTIFY: - dispatch_buffer = keyseq.print(); - lyxserver->notifyClient(dispatch_buffer); + case LFUN_SERVER_NOTIFY: + dispatch_buffer = from_utf8(keyseq->print()); + theLyXServer().notifyClient(to_utf8(dispatch_buffer)); break; - case LFUN_GOTOFILEROW: { + case LFUN_SERVER_GOTO_FILE_ROW: { + BOOST_ASSERT(lyx_view_); string file_name; int row; istringstream is(argument); @@ -1136,38 +1193,38 @@ void LyXFunc::dispatch(FuncRequest const & cmd) 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)); + lyx_view_->setBuffer(theBufferList().getBufferFromTmp(file_name)); } else { // Must replace extension of the file to be .lyx // and get full path string const s = changeExtension(file_name, ".lyx"); // Either change buffer or load the file - if (bufferlist.exists(s)) { - view()->setBuffer(bufferlist.getBuffer(s)); + if (theBufferList().exists(s)) { + lyx_view_->setBuffer(theBufferList().getBuffer(s)); } else { - view()->loadLyXFile(s); + lyx_view_->loadLyXFile(s); } } view()->setCursorFromRow(row); view()->center(); - // see BufferView_pimpl::center() - view()->updateScrollbar(); + // see BufferView::center() break; } case LFUN_DIALOG_SHOW: { + BOOST_ASSERT(lyx_view_); string const name = cmd.getArg(0); - string data = trim(cmd.argument.substr(name.size())); + string data = trim(to_utf8(cmd.argument()).substr(name.size())); if (name == "character") { data = freefont2string(); if (!data.empty()) - owner->getDialogs().show("character", data); + lyx_view_->getDialogs().show("character", data); } else if (name == "latexlog") { pair const logfile = - owner->buffer()->getLogName(); + lyx_view_->buffer()->getLogName(); switch (logfile.first) { case Buffer::latexlog: data = "latex "; @@ -1176,24 +1233,26 @@ void LyXFunc::dispatch(FuncRequest const & cmd) data = "literate "; break; } - data += logfile.second; - owner->getDialogs().show("log", data); + data += LyXLex::quoteString(logfile.second); + lyx_view_->getDialogs().show("log", data); } else if (name == "vclog") { string const data = "vc " + - owner->buffer()->lyxvc().getLogFile(); - owner->getDialogs().show("log", data); + LyXLex::quoteString(lyx_view_->buffer()->lyxvc().getLogFile()); + lyx_view_->getDialogs().show("log", data); } else - owner->getDialogs().show(name, data); + lyx_view_->getDialogs().show(name, data); break; } case LFUN_DIALOG_SHOW_NEW_INSET: { + BOOST_ASSERT(lyx_view_); string const name = cmd.getArg(0); - string data = trim(cmd.argument.substr(name.size())); + string data = trim(to_utf8(cmd.argument()).substr(name.size())); if (name == "bibitem" || name == "bibtex" || name == "index" || name == "label" || + name == "nomenclature" || name == "ref" || name == "toc" || name == "url") { @@ -1216,14 +1275,14 @@ void LyXFunc::dispatch(FuncRequest const & cmd) data = InsetERTMailer::params2string(InsetCollapsable::Open); } else if (name == "external") { InsetExternalParams p; - Buffer const & buffer = *owner->buffer(); + Buffer const & buffer = *lyx_view_->buffer(); data = InsetExternalMailer::params2string(p, buffer); } else if (name == "float") { InsetFloatParams p; data = InsetFloatMailer::params2string(p); } else if (name == "graphics") { InsetGraphicsParams p; - Buffer const & buffer = *owner->buffer(); + Buffer const & buffer = *lyx_view_->buffer(); data = InsetGraphicsMailer::params2string(p, buffer); } else if (name == "note") { InsetNoteParams p; @@ -1235,24 +1294,22 @@ void LyXFunc::dispatch(FuncRequest const & cmd) InsetWrapParams p; data = InsetWrapMailer::params2string(p); } - owner->getDialogs().show(name, data, 0); + lyx_view_->getDialogs().show(name, data, 0); break; } - case LFUN_DIALOG_SHOW_NEXT_INSET: - break; - case LFUN_DIALOG_UPDATE: { + BOOST_ASSERT(lyx_view_); string const & name = argument; // Can only update a dialog connected to an existing inset - InsetBase * inset = owner->getDialogs().getOpenInset(name); + InsetBase * inset = lyx_view_->getDialogs().getOpenInset(name); if (inset) { - FuncRequest fr(LFUN_INSET_DIALOG_UPDATE, cmd.argument); + FuncRequest fr(LFUN_INSET_DIALOG_UPDATE, cmd.argument()); inset->dispatch(view()->cursor(), fr); } else if (name == "paragraph") { dispatch(FuncRequest(LFUN_PARAGRAPH_UPDATE)); } else if (name == "prefs") { - owner->getDialogs().update(name, string()); + lyx_view_->getDialogs().update(name, string()); } break; } @@ -1262,11 +1319,13 @@ void LyXFunc::dispatch(FuncRequest const & cmd) break; case LFUN_DIALOG_DISCONNECT_INSET: - owner->getDialogs().disconnect(argument); + BOOST_ASSERT(lyx_view_); + lyx_view_->getDialogs().disconnect(argument); break; - case LFUN_INSERT_CITATION: { + case LFUN_CITATION_INSERT: { + BOOST_ASSERT(lyx_view_); if (!argument.empty()) { // we can have one optional argument, delimited by '|' // citation-insert | @@ -1289,42 +1348,49 @@ void LyXFunc::dispatch(FuncRequest const & cmd) break; } - case LFUN_CHILDOPEN: { + case LFUN_BUFFER_CHILD_OPEN: { + BOOST_ASSERT(lyx_view_); string const filename = - makeAbsPath(argument, owner->buffer()->filePath()); - setMessage(N_("Opening child document ") + + makeAbsPath(argument, lyx_view_->buffer()->filePath()); + // FIXME Should use bformat + setMessage(_("Opening child document ") + makeDisplayPath(filename) + "..."); - view()->savePosition(0); - string const parentfilename = owner->buffer()->fileName(); - if (bufferlist.exists(filename)) - view()->setBuffer(bufferlist.getBuffer(filename)); + view()->saveBookmark(false); + string const parentfilename = lyx_view_->buffer()->fileName(); + if (theBufferList().exists(filename)) + lyx_view_->setBuffer(theBufferList().getBuffer(filename)); else - view()->loadLyXFile(filename); + lyx_view_->loadLyXFile(filename); // Set the parent name of the child document. // This makes insertion of citations and references in the child work, // when the target is in the parent or another child document. - owner->buffer()->setParentName(parentfilename); + lyx_view_->buffer()->setParentName(parentfilename); break; } - case LFUN_TOGGLECURSORFOLLOW: + case LFUN_TOGGLE_CURSOR_FOLLOWS_SCROLLBAR: + BOOST_ASSERT(lyx_view_); lyxrc.cursor_follows_scrollbar = !lyxrc.cursor_follows_scrollbar; break; - case LFUN_KMAP_OFF: - owner->getIntl().keyMapOn(false); + case LFUN_KEYMAP_OFF: + BOOST_ASSERT(lyx_view_); + lyx_view_->view()->getIntl().keyMapOn(false); break; - case LFUN_KMAP_PRIM: - owner->getIntl().keyMapPrim(); + case LFUN_KEYMAP_PRIMARY: + BOOST_ASSERT(lyx_view_); + lyx_view_->view()->getIntl().keyMapPrim(); break; - case LFUN_KMAP_SEC: - owner->getIntl().keyMapSec(); + case LFUN_KEYMAP_SECONDARY: + BOOST_ASSERT(lyx_view_); + lyx_view_->view()->getIntl().keyMapSec(); break; - case LFUN_KMAP_TOGGLE: - owner->getIntl().toggleKeyMap(); + case LFUN_KEYMAP_TOGGLE: + BOOST_ASSERT(lyx_view_); + lyx_view_->view()->getIntl().toggleKeyMap(); break; case LFUN_REPEAT: { @@ -1340,7 +1406,7 @@ void LyXFunc::dispatch(FuncRequest const & cmd) break; } - case LFUN_SEQUENCE: { + case LFUN_COMMAND_SEQUENCE: { // argument contains ';'-terminated commands string arg = argument; while (!arg.empty()) { @@ -1353,16 +1419,17 @@ void LyXFunc::dispatch(FuncRequest const & cmd) break; } - case LFUN_SAVEPREFERENCES: { - Path p(package().user_support()); + case LFUN_PREFERENCES_SAVE: { + support::Path p(package().user_support()); lyxrc.write("preferences", false); break; } case LFUN_SCREEN_FONT_UPDATE: + BOOST_ASSERT(lyx_view_); // handle the screen font changes. lyxrc.set_font_norm_type(); - lyx_gui::update_fonts(); + theFontLoader().update(); // All visible buffers will need resize view()->resize(); break; @@ -1371,7 +1438,7 @@ void LyXFunc::dispatch(FuncRequest const & cmd) string lyx_name; string const x11_name = split(argument, lyx_name, ' '); if (lyx_name.empty() || x11_name.empty()) { - setErrorMessage(N_("Syntax: set-color " + setErrorMessage(_("Syntax: set-color " " ")); break; } @@ -1382,34 +1449,33 @@ void LyXFunc::dispatch(FuncRequest const & cmd) if (!lcolor.setColor(lyx_name, x11_name)) { setErrorMessage( - bformat(_("Set-color \"%1$s\" failed " - "- color is undefined or " - "may not be redefined"), lyx_name)); + bformat(_("Set-color \"%1$s\" failed " + "- color is undefined or " + "may not be redefined"), + from_utf8(lyx_name))); break; } - lyx_gui::update_color(lcolor.getFromLyXName(lyx_name)); + theApp->updateColor(lcolor.getFromLyXName(lyx_name)); if (graphicsbg_changed) { #ifdef WITH_WARNINGS #warning FIXME!! The graphics cache no longer has a changeDisplay method. #endif #if 0 - lyx::graphics::GCache::get().changeDisplay(true); + graphics::GCache::get().changeDisplay(true); #endif } break; } case LFUN_MESSAGE: - owner->message(argument); - break; - - case LFUN_TOOLTIPS_TOGGLE: - owner->getDialogs().toggleTooltips(); + BOOST_ASSERT(lyx_view_); + lyx_view_->message(from_utf8(argument)); break; case LFUN_EXTERNAL_EDIT: { + BOOST_ASSERT(lyx_view_); FuncRequest fr(action, argument); InsetExternal().dispatch(view()->cursor(), fr); break; @@ -1422,8 +1488,9 @@ void LyXFunc::dispatch(FuncRequest const & cmd) } case LFUN_INSET_APPLY: { + BOOST_ASSERT(lyx_view_); string const name = cmd.getArg(0); - InsetBase * inset = owner->getDialogs().getOpenInset(name); + InsetBase * inset = lyx_view_->getDialogs().getOpenInset(name); if (inset) { FuncRequest fr(LFUN_INSET_MODIFY, argument); inset->dispatch(view()->cursor(), fr); @@ -1433,11 +1500,12 @@ void LyXFunc::dispatch(FuncRequest const & cmd) } // ideally, the update flag should be set by the insets, // but this is not possible currently - update = true; + updateFlags = Update::Force | Update::FitCursor; break; } case LFUN_ALL_INSETS_TOGGLE: { + BOOST_ASSERT(lyx_view_); string action; string const name = split(argument, action, ' '); InsetBase::Code const inset_code = @@ -1446,7 +1514,7 @@ void LyXFunc::dispatch(FuncRequest const & cmd) LCursor & cur = view()->cursor(); FuncRequest fr(LFUN_INSET_TOGGLE, action); - InsetBase & inset = owner->buffer()->inset(); + InsetBase & inset = lyx_view_->buffer()->inset(); InsetIterator it = inset_iterator_begin(inset); InsetIterator const end = inset_iterator_end(inset); for (; it != end; ++it) { @@ -1457,12 +1525,13 @@ void LyXFunc::dispatch(FuncRequest const & cmd) it->dispatch(tmpcur, fr); } } - update = true; + updateFlags = Update::Force | Update::FitCursor; break; } - case LFUN_LANGUAGE_BUFFER: { - Buffer & buffer = *owner->buffer(); + case LFUN_BUFFER_LANGUAGE: { + BOOST_ASSERT(lyx_view_); + Buffer & buffer = *lyx_view_->buffer(); Language const * oldL = buffer.params().language; Language const * newL = languages.getLanguage(argument); if (!newL || oldL == newL) @@ -1476,7 +1545,7 @@ void LyXFunc::dispatch(FuncRequest const & cmd) break; } - case LFUN_SAVE_AS_DEFAULT: { + case LFUN_BUFFER_SAVE_AS_DEFAULT: { string const fname = addName(addPath(package().user_support(), "templates/"), "defaults.lyx"); @@ -1488,13 +1557,14 @@ void LyXFunc::dispatch(FuncRequest const & cmd) int const unknown_tokens = defaults.readHeader(lex); if (unknown_tokens != 0) { - lyxerr << "Warning in LFUN_SAVE_AS_DEFAULT!\n" + lyxerr << "Warning in LFUN_BUFFER_SAVE_AS_DEFAULT!\n" << unknown_tokens << " unknown token" << (unknown_tokens == 1 ? "" : "s") << endl; } if (defaults.writeFile(defaults.fileName())) + // FIXME Should use bformat setMessage(_("Document defaults saved in ") + makeDisplayPath(fname)); else @@ -1502,29 +1572,30 @@ void LyXFunc::dispatch(FuncRequest const & cmd) break; } - case LFUN_BUFFERPARAMS_APPLY: { + case LFUN_BUFFER_PARAMS_APPLY: { + BOOST_ASSERT(lyx_view_); biblio::CiteEngine const engine = - owner->buffer()->params().cite_engine; + lyx_view_->buffer()->params().cite_engine; istringstream ss(argument); LyXLex lex(0,0); lex.setStream(ss); int const unknown_tokens = - owner->buffer()->readHeader(lex); + lyx_view_->buffer()->readHeader(lex); if (unknown_tokens != 0) { - lyxerr << "Warning in LFUN_BUFFERPARAMS_APPLY!\n" + lyxerr << "Warning in LFUN_BUFFER_PARAMS_APPLY!\n" << unknown_tokens << " unknown token" << (unknown_tokens == 1 ? "" : "s") << endl; } - if (engine == owner->buffer()->params().cite_engine) + if (engine == lyx_view_->buffer()->params().cite_engine) break; LCursor & cur = view()->cursor(); FuncRequest fr(LFUN_INSET_REFRESH); - InsetBase & inset = owner->buffer()->inset(); + InsetBase & inset = lyx_view_->buffer()->inset(); InsetIterator it = inset_iterator_begin(inset); InsetIterator const end = inset_iterator_end(inset); for (; it != end; ++it) @@ -1534,38 +1605,39 @@ void LyXFunc::dispatch(FuncRequest const & cmd) } case LFUN_TEXTCLASS_APPLY: { - Buffer * buffer = owner->buffer(); + BOOST_ASSERT(lyx_view_); + Buffer * buffer = lyx_view_->buffer(); - lyx::textclass_type const old_class = + textclass_type const old_class = buffer->params().textclass; loadTextclass(argument); - std::pair const tc_pair = + std::pair const tc_pair = textclasslist.numberOfClass(argument); if (!tc_pair.first) break; - lyx::textclass_type const new_class = tc_pair.second; + textclass_type const new_class = tc_pair.second; if (old_class == new_class) // nothing to do break; - owner->message(_("Converting document to new document class...")); + lyx_view_->message(_("Converting document to new document class...")); recordUndoFullDocument(view()); buffer->params().textclass = new_class; StableDocIterator backcur(view()->cursor()); - ErrorList el; - lyx::cap::switchBetweenClasses( + ErrorList & el = buffer->errorList("Class Switch"); + cap::switchBetweenClasses( old_class, new_class, - buffer->paragraphs(), el); + static_cast(buffer->inset()), el); view()->setCursor(backcur.asDocIterator(&(buffer->inset()))); - bufferErrors(*buffer, el); - view()->showErrorList(_("Class switch")); - updateCounters(*buffer); - update = true; + + buffer->errors("Class Switch"); + updateLabels(*buffer); + updateFlags = Update::Force | Update::FitCursor; break; } @@ -1590,62 +1662,99 @@ void LyXFunc::dispatch(FuncRequest const & cmd) break; } + case LFUN_WINDOW_NEW: + LyX::ref().newLyXView(); + break; + + case LFUN_WINDOW_CLOSE: + BOOST_ASSERT(lyx_view_); + BOOST_ASSERT(theApp); + lyx_view_->close(); + // We return here because lyx_view does not exists anymore. + return; + + case LFUN_BOOKMARK_GOTO: { + BOOST_ASSERT(lyx_view_); + unsigned int idx = convert(to_utf8(cmd.argument())); + BookmarksSection::Bookmark const bm = LyX::ref().session().bookmarks().bookmark(idx); + BOOST_ASSERT(!bm.filename.empty()); + // if the file is not opened, open it. + if (!theBufferList().exists(bm.filename)) + dispatch(FuncRequest(LFUN_FILE_OPEN, bm.filename)); + // open may fail, so we need to test it again + if (theBufferList().exists(bm.filename)) { + // if the current buffer is not that one, switch to it. + if (lyx_view_->buffer()->fileName() != bm.filename) + dispatch(FuncRequest(LFUN_BUFFER_SWITCH, bm.filename)); + // BOOST_ASSERT(lyx_view_->buffer()->fileName() != bm.filename); + view()->moveToPosition(bm.par_id, bm.par_pos); + } + break; + } + + case LFUN_BOOKMARK_CLEAR: + LyX::ref().session().bookmarks().clear(); + break; + + case LFUN_TOOLBAR_TOGGLE_STATE: + lyx_view_->toggleToolbarState(argument); + break; + default: { + BOOST_ASSERT(lyx_view_); view()->cursor().dispatch(cmd); - update |= view()->cursor().result().update(); + updateFlags = view()->cursor().result().update(); if (!view()->cursor().result().dispatched()) - update |= view()->dispatch(cmd); + if (view()->dispatch(cmd)) + updateFlags = Update::Force | Update::FitCursor; break; } } - if (view()->available()) { + if (lyx_view_ && view()->buffer()) { // Redraw screen unless explicitly told otherwise. // This also initializes the position cache for all insets // in (at least partially) visible top-level paragraphs. - if (update) - view()->update(Update::FitCursor | Update::Force); - else - view()->update(Update::FitCursor); + std::pair needSecondUpdate = view()->update(updateFlags); + + if (needSecondUpdate.first) + view()->buffer()->changed(needSecondUpdate.second); + + lyx_view_->updateStatusBar(); // if we executed a mutating lfun, mark the buffer as dirty if (flag.enabled() && !lyxaction.funcHasFlag(cmd.action, LyXAction::NoBuffer) && !lyxaction.funcHasFlag(cmd.action, LyXAction::ReadOnly)) view()->buffer()->markDirty(); - } - if (view()->cursor().inTexted()) { - view()->owner()->updateLayoutChoice(); + if (view()->cursor().inTexted()) { + lyx_view_->updateLayoutChoice(); + } } } - sendDispatchMessage(_(getMessage()), cmd); + if (!quitting) { + lyx_view_->updateMenubar(); + lyx_view_->updateToolbars(); + sendDispatchMessage(getMessage(), cmd); + } } -void LyXFunc::sendDispatchMessage(string const & msg, FuncRequest const & cmd) +void LyXFunc::sendDispatchMessage(docstring const & msg, FuncRequest const & cmd) { - /* 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 + const bool verbose = (cmd.origin == FuncRequest::MENU + || cmd.origin == FuncRequest::TOOLBAR || cmd.origin == FuncRequest::COMMANDBUFFER); - if (cmd.action == LFUN_SELFINSERT || !verbose) { - lyxerr[Debug::ACTION] << "dispatch msg is " << msg << endl; + if (cmd.action == LFUN_SELF_INSERT || !verbose) { + lyxerr[Debug::ACTION] << "dispatch msg is " << to_utf8(msg) << endl; if (!msg.empty()) - owner->message(msg); + lyx_view_->message(msg); return; } - string dispatch_msg = msg; + docstring dispatch_msg = msg; if (!dispatch_msg.empty()) dispatch_msg += ' '; @@ -1653,37 +1762,29 @@ void LyXFunc::sendDispatchMessage(string const & msg, FuncRequest const & cmd) bool argsadded = false; - if (!cmd.argument.empty()) { + if (!cmd.argument().empty()) { if (cmd.action != LFUN_UNKNOWN_ACTION) { - comname += ' ' + cmd.argument; + comname += ' ' + to_utf8(cmd.argument()); argsadded = true; } } - string const shortcuts = toplevel_keymap->printbindings(cmd); + string const shortcuts = theTopLevelKeymap().printbindings(cmd); if (!shortcuts.empty()) comname += ": " + shortcuts; - else if (!argsadded && !cmd.argument.empty()) - comname += ' ' + cmd.argument; + else if (!argsadded && !cmd.argument().empty()) + comname += ' ' + to_utf8(cmd.argument()); if (!comname.empty()) { comname = rtrim(comname); - dispatch_msg += '(' + rtrim(comname) + ')'; + dispatch_msg += from_utf8('(' + rtrim(comname) + ')'); } - lyxerr[Debug::ACTION] << "verbose dispatch msg " << dispatch_msg << endl; + lyxerr[Debug::ACTION] << "verbose dispatch msg " + << to_utf8(dispatch_msg) << endl; if (!dispatch_msg.empty()) - owner->message(dispatch_msg); -} - - -void LyXFunc::setupLocalKeymap() -{ - keyseq.stdmap = toplevel_keymap.get(); - keyseq.curmap = toplevel_keymap.get(); - cancel_meta_seq.stdmap = toplevel_keymap.get(); - cancel_meta_seq.curmap = toplevel_keymap.get(); + lyx_view_->message(dispatch_msg); } @@ -1692,8 +1793,8 @@ void LyXFunc::menuNew(string const & name, bool fromTemplate) string initpath = lyxrc.document_path; string filename(name); - if (view()->available()) { - string const trypath = owner->buffer()->filePath(); + if (view()->buffer()) { + string const trypath = lyx_view_->buffer()->filePath(); // If directory is writeable, use this as default. if (isDirWriteable(trypath)) initpath = trypath; @@ -1704,7 +1805,7 @@ void LyXFunc::menuNew(string const & name, bool fromTemplate) if (filename.empty()) { filename = addName(lyxrc.document_path, "newfile" + convert(++newfile_number) + ".lyx"); - while (bufferlist.exists(filename) || fs::is_readable(filename)) { + while (theBufferList().exists(filename) || fs::is_readable(filename)) { ++newfile_number; filename = addName(lyxrc.document_path, "newfile" + convert(newfile_number) + @@ -1717,24 +1818,24 @@ void LyXFunc::menuNew(string const & name, bool fromTemplate) if (fromTemplate) { FileDialog fileDlg(_("Select template file"), LFUN_SELECT_FILE_SYNC, - make_pair(string(_("Documents|#o#O")), - string(lyxrc.document_path)), - make_pair(string(_("Templates|#T#t")), - string(lyxrc.template_path))); + make_pair(_("Documents|#o#O"), from_utf8(lyxrc.document_path)), + make_pair(_("Templates|#T#t"), from_utf8(lyxrc.template_path))); FileDialog::Result result = - fileDlg.open(lyxrc.template_path, + fileDlg.open(from_utf8(lyxrc.template_path), FileFilterList(_("LyX Documents (*.lyx)")), - string()); + docstring()); if (result.first == FileDialog::Later) return; if (result.second.empty()) return; - templname = result.second; + templname = to_utf8(result.second); } - view()->newFile(filename, templname, !name.empty()); + Buffer * const b = newFile(filename, templname, !name.empty()); + if (b) + lyx_view_->setBuffer(b); } @@ -1742,8 +1843,8 @@ void LyXFunc::open(string const & fname) { string initpath = lyxrc.document_path; - if (view()->available()) { - string const trypath = owner->buffer()->filePath(); + if (view()->buffer()) { + string const trypath = lyx_view_->buffer()->filePath(); // If directory is writeable, use this as default. if (isDirWriteable(trypath)) initpath = trypath; @@ -1754,24 +1855,22 @@ void LyXFunc::open(string const & fname) if (fname.empty()) { FileDialog fileDlg(_("Select document to open"), LFUN_FILE_OPEN, - make_pair(string(_("Documents|#o#O")), - string(lyxrc.document_path)), - make_pair(string(_("Examples|#E#e")), - string(addPath(package().system_support(), "examples")))); + make_pair(_("Documents|#o#O"), from_utf8(lyxrc.document_path)), + make_pair(_("Examples|#E#e"), from_utf8(addPath(package().system_support(), "examples")))); FileDialog::Result result = - fileDlg.open(initpath, + fileDlg.open(from_utf8(initpath), FileFilterList(_("LyX Documents (*.lyx)")), - string()); + docstring()); if (result.first == FileDialog::Later) return; - filename = result.second; + filename = to_utf8(result.second); // check selected filename if (filename.empty()) { - owner->message(_("Canceled.")); + lyx_view_->message(_("Canceled.")); return; } } else @@ -1784,24 +1883,26 @@ void LyXFunc::open(string const & fname) filename = fullpath; } - string const disp_fn(makeDisplayPath(filename)); + docstring const disp_fn = makeDisplayPath(filename); // if the file doesn't exist, let the user create one if (!fs::exists(filename)) { - // the user specifically chose this name. Believe them. - view()->newFile(filename, "", true); + // the user specifically chose this name. Believe him. + Buffer * const b = newFile(filename, string(), true); + if (b) + lyx_view_->setBuffer(b); return; } - owner->message(bformat(_("Opening document %1$s..."), disp_fn)); + lyx_view_->message(bformat(_("Opening document %1$s..."), disp_fn)); - string str2; - if (view()->loadLyXFile(filename)) { + docstring str2; + if (lyx_view_->loadLyXFile(filename)) { str2 = bformat(_("Document %1$s opened."), disp_fn); } else { str2 = bformat(_("Could not open document %1$s"), disp_fn); } - owner->message(str2); + lyx_view_->message(str2); } @@ -1817,39 +1918,41 @@ void LyXFunc::doImport(string const & argument) if (filename.empty()) { string initpath = lyxrc.document_path; - if (view()->available()) { - string const trypath = owner->buffer()->filePath(); + if (view()->buffer()) { + string const trypath = lyx_view_->buffer()->filePath(); // If directory is writeable, use this as default. if (isDirWriteable(trypath)) initpath = trypath; } - string const text = bformat(_("Select %1$s file to import"), + docstring const text = bformat(_("Select %1$s file to import"), formats.prettyName(format)); FileDialog fileDlg(text, - LFUN_IMPORT, - make_pair(string(_("Documents|#o#O")), - string(lyxrc.document_path)), - make_pair(string(_("Examples|#E#e")), - string(addPath(package().system_support(), "examples")))); + LFUN_BUFFER_IMPORT, + make_pair(_("Documents|#o#O"), from_utf8(lyxrc.document_path)), + make_pair(_("Examples|#E#e"), + from_utf8(addPath(package().system_support(), "examples")))); - string const filter = formats.prettyName(format) - + " (*." + formats.extension(format) + ')'; + docstring filter = formats.prettyName(format); + filter += " (*."; + // FIXME UNICODE + filter += from_utf8(formats.extension(format)); + filter += ')'; FileDialog::Result result = - fileDlg.open(initpath, + fileDlg.open(from_utf8(initpath), FileFilterList(filter), - string()); + docstring()); if (result.first == FileDialog::Later) return; - filename = result.second; + filename = to_utf8(result.second); // check selected filename if (filename.empty()) - owner->message(_("Canceled.")); + lyx_view_->message(_("Canceled.")); } if (filename.empty()) @@ -1861,9 +1964,9 @@ void LyXFunc::doImport(string const & argument) string const lyxfile = changeExtension(filename, ".lyx"); // Check if the document already is open - if (lyx_gui::use_gui && bufferlist.exists(lyxfile)) { - if (!bufferlist.close(bufferlist.getBuffer(lyxfile), true)) { - owner->message(_("Canceled.")); + if (use_gui && theBufferList().exists(lyxfile)) { + if (!theBufferList().close(theBufferList().getBuffer(lyxfile), true)) { + lyx_view_->message(_("Canceled.")); return; } } @@ -1871,55 +1974,57 @@ void LyXFunc::doImport(string const & argument) // if the file exists already, and we didn't do // -i lyx thefile.lyx, warn if (fs::exists(lyxfile) && filename != lyxfile) { - string const file = makeDisplayPath(lyxfile, 30); + docstring const file = makeDisplayPath(lyxfile, 30); - string text = bformat(_("The document %1$s already exists.\n\n" - "Do you want to over-write that document?"), file); + docstring text = bformat(_("The document %1$s already exists.\n\n" + "Do you want to over-write that document?"), file); int const ret = Alert::prompt(_("Over-write document?"), text, 0, 1, _("&Over-write"), _("&Cancel")); if (ret == 1) { - owner->message(_("Canceled.")); + lyx_view_->message(_("Canceled.")); return; } } - Importer::Import(owner, filename, format); + ErrorList errorList; + Importer::Import(lyx_view_, filename, format, errorList); + // FIXME (Abdel 12/08/06): Is there a need to display the error list here? } void LyXFunc::closeBuffer() { // save current cursor position - LyX::ref().session().saveFilePosition(owner->buffer()->fileName(), + LyX::ref().session().lastFilePos().save(lyx_view_->buffer()->fileName(), boost::tie(view()->cursor().pit(), view()->cursor().pos()) ); - if (bufferlist.close(owner->buffer(), true) && !quitting) { - if (bufferlist.empty()) { + if (theBufferList().close(lyx_view_->buffer(), true) && !quitting) { + if (theBufferList().empty()) { // need this otherwise SEGV may occur while // trying to set variables that don't exist // since there's no current buffer - owner->getDialogs().hideBufferDependent(); + lyx_view_->getDialogs().hideBufferDependent(); } else { - view()->setBuffer(bufferlist.first()); + lyx_view_->setBuffer(theBufferList().first()); } } } -// Each "owner" should have it's own message method. lyxview and +// Each "lyx_view_" should have it's own message method. lyxview and // the minibuffer would use the minibuffer, but lyxserver would // send an ERROR signal to its client. Alejandro 970603 // This function is bit problematic when it comes to NLS, to make the // lyx servers client be language indepenent we must not translate // strings sent to this func. -void LyXFunc::setErrorMessage(string const & m) const +void LyXFunc::setErrorMessage(docstring const & m) const { dispatch_buffer = m; errorstat = true; } -void LyXFunc::setMessage(string const & m) const +void LyXFunc::setMessage(docstring const & m) const { dispatch_buffer = m; } @@ -1929,15 +2034,15 @@ string const LyXFunc::viewStatusMessage() { // When meta-fake key is pressed, show the key sequence so far + "M-". if (wasMetaKey()) - return keyseq.print() + "M-"; + return keyseq->print() + "M-"; // Else, when a non-complete key sequence is pressed, // show the available options. - if (keyseq.length() > 0 && !keyseq.deleted()) - return keyseq.printOptions(); + if (keyseq->length() > 0 && !keyseq->deleted()) + return keyseq->printOptions(); - if (!view()->available()) - return _("Welcome to LyX!"); + if (!view()->buffer()) + return to_utf8(_("Welcome to LyX!")); return view()->cursor().currentState(); } @@ -1945,8 +2050,8 @@ string const LyXFunc::viewStatusMessage() BufferView * LyXFunc::view() const { - BOOST_ASSERT(owner); - return owner->view().get(); + BOOST_ASSERT(lyx_view_); + return lyx_view_->view(); } @@ -1983,15 +2088,11 @@ void actOnUpdatedPrefs(LyXRC const & lyxrc_orig, LyXRC const & lyxrc_new) case LyXRC::RC_LOADSESSION: case LyXRC::RC_CHKTEX_COMMAND: case LyXRC::RC_CONVERTER: + case LyXRC::RC_CONVERTER_CACHE_MAXAGE: 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: @@ -2001,8 +2102,7 @@ void actOnUpdatedPrefs(LyXRC const & lyxrc_orig, LyXRC const & lyxrc_new) 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; + support::package().document_dir() = lyxrc.document_path; } } case LyXRC::RC_ESC_CHARS: @@ -2027,8 +2127,7 @@ void actOnUpdatedPrefs(LyXRC const & lyxrc_orig, LyXRC const & lyxrc_new) 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); + support::prependEnvPath("PATH", lyxrc.path_prefix); } case LyXRC::RC_PERS_DICT: case LyXRC::RC_POPUP_BOLD_FONT: @@ -2077,21 +2176,28 @@ void actOnUpdatedPrefs(LyXRC const & lyxrc_orig, LyXRC const & lyxrc_new) case LyXRC::RC_TEMPDIRPATH: case LyXRC::RC_TEMPLATEPATH: case LyXRC::RC_TEX_ALLOWS_SPACES: + case LyXRC::RC_TEX_EXPECTS_WINDOWS_PATHS: + if (lyxrc_orig.windows_style_tex_paths != lyxrc_new.windows_style_tex_paths) { + support::os::windows_style_tex_paths(lyxrc_new.windows_style_tex_paths); + } 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_CONVERTER_CACHE: 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 + + +} // namespace lyx