X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Flyxfunc.C;h=f6e54aa3faf682d4d37af6ac964aedb5cdc7c024;hb=3c851f1f7951f3a24b57826f3e580e4318b5e6c4;hp=63cda7cf37d6f123811d4eeeaa5666d7204a770d;hpb=4c8d536692beabcec88771a53b40eaf6acd76f49;p=lyx.git diff --git a/src/lyxfunc.C b/src/lyxfunc.C index 63cda7cf37..f6e54aa3fa 100644 --- a/src/lyxfunc.C +++ b/src/lyxfunc.C @@ -28,26 +28,32 @@ #include "bufferparams.h" #include "BufferView.h" #include "cursor.h" +#include "CutAndPaste.h" #include "debug.h" #include "dispatchresult.h" #include "encoding.h" +#include "errorlist.h" #include "exporter.h" #include "format.h" #include "funcrequest.h" #include "gettext.h" #include "importer.h" +#include "insetiterator.h" #include "intl.h" -#include "iterators.h" #include "kbmap.h" +#include "language.h" #include "LColor.h" #include "lyx_cb.h" #include "LyXAction.h" #include "lyxfind.h" +#include "lyxlex.h" #include "lyxrc.h" #include "lyxrow.h" #include "lyxserver.h" +#include "lyxtextclasslist.h" #include "lyxvc.h" #include "paragraph.h" +#include "pariterator.h" #include "ParagraphParameters.h" #include "undo.h" @@ -70,28 +76,33 @@ #include "frontends/LyXKeySym.h" #include "frontends/LyXView.h" #include "frontends/Menubar.h" -#include "frontends/Toolbar.h" +#include "frontends/Toolbars.h" -#include "support/FileInfo.h" +#include "support/environment.h" +#include "support/filefilterlist.h" #include "support/filetools.h" #include "support/forkedcontr.h" -#include "support/globbing.h" +#include "support/fs_extras.h" +#include "support/lstrings.h" #include "support/path.h" -#include "support/path_defines.h" -#include "support/tostr.h" -#include "support/std_sstream.h" +#include "support/package.h" +#include "support/systemcall.h" +#include "support/convert.h" #include "support/os.h" -using bv_funcs::DEC_DEPTH; +#include + +#include + using bv_funcs::freefont2string; -using bv_funcs::INC_DEPTH; +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; @@ -100,17 +111,16 @@ 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::strToInt; -using lyx::support::strToUnsignedInt; -using lyx::support::system_lyxdir; +using lyx::support::subst; +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; @@ -118,10 +128,12 @@ using std::pair; using std::string; using std::istringstream; +namespace biblio = lyx::biblio; +namespace fs = boost::filesystem; + extern BufferList bufferlist; extern LyXServer * lyxserver; -extern bool selection_possible; extern boost::scoped_ptr toplevel_keymap; @@ -129,6 +141,47 @@ extern boost::scoped_ptr toplevel_keymap; extern tex_accent_struct get_accent(kb_action action); +namespace { + +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.depth(); cursor.pop()) { + //lyxerr << "\nLCursor::getStatus: cmd: " << cmd << endl << *this << endl; + DocIterator::idx_type & idx = cursor.idx(); + DocIterator::idx_type const lastidx = cursor.lastidx(); + BOOST_ASSERT(idx <= lastidx); + + DocIterator::pit_type & pit = cursor.pit(); + DocIterator::pit_type const lastpit = cursor.lastpit(); + BOOST_ASSERT(pit <= lastpit); + + DocIterator::pos_type & pos = cursor.pos(); + DocIterator::pos_type const lastpos = cursor.lastpos(); + BOOST_ASSERT(pos <= lastpos); + + // The inset's getStatus() will return 'true' if it made + // a definitive decision on whether it want to handle the + // request or not. The result of this decision is put into + // the 'status' parameter. + if (cursor.inset().getStatus(cursor, cmd, status)) { + res = true; + break; + } + } + return res; +} + +} + LyXFunc::LyXFunc(LyXView * lv) : owner(lv), encoded_last_key(0), @@ -174,7 +227,7 @@ void LyXFunc::processKeySym(LyXKeySymPtr keysym, key_modifier::state state) return; } - Encoding const * encoding = view()->getEncoding(); + Encoding const * encoding = view()->cursor().getEncoding(); encoded_last_key = keysym->getISOEncoded(encoding ? encoding->Name() : ""); @@ -183,7 +236,9 @@ void LyXFunc::processKeySym(LyXKeySymPtr keysym, key_modifier::state state) 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. @@ -191,20 +246,22 @@ void LyXFunc::processKeySym(LyXKeySymPtr keysym, key_modifier::state state) 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; @@ -244,7 +301,7 @@ void LyXFunc::processKeySym(LyXKeySymPtr keysym, key_modifier::state state) if (func.action == LFUN_SELFINSERT) { if (encoded_last_key != 0) { - string arg(1, encoded_last_key); + string const arg(1, encoded_last_key); dispatch(FuncRequest(LFUN_SELFINSERT, arg)); lyxerr[Debug::KEY] << "SelfInsert arg[`" << arg << "']" << endl; @@ -257,13 +314,24 @@ void LyXFunc::processKeySym(LyXKeySymPtr keysym, key_modifier::state state) FuncStatus LyXFunc::getStatus(FuncRequest const & cmd) const { + //lyxerr << "LyXFunc::getStatus: cmd: " << cmd << endl; FuncStatus flag; - Buffer * buf = owner->buffer(); LCursor & cur = view()->cursor(); + /* In LyX/Mac, when a dialog is open, the menus of the + 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. + */ + Buffer * buf; + if (cmd.origin == FuncRequest::UI && !owner->hasFocus()) + buf = 0; + else + buf = owner->buffer(); + if (cmd.action == LFUN_NOACTION) { - setStatusMessage(N_("Nothing to do")); - flag.disabled(true); + flag.message(N_("Nothing to do")); + flag.enabled(false); return flag; } @@ -273,221 +341,127 @@ FuncStatus LyXFunc::getStatus(FuncRequest const & cmd) const case LFUN_THESAURUS_ENTRY: #endif flag.unknown(true); - flag.disabled(true); + flag.enabled(false); break; default: flag |= lyx_gui::getStatus(cmd); } if (flag.unknown()) { - setStatusMessage(N_("Unknown action")); + flag.message(N_("Unknown action")); return flag; } - // the default error message if we disable the command - setStatusMessage(N_("Command disabled")); + if (!flag.enabled()) { + if (flag.message().empty()) + flag.message(N_("Command disabled")); + return flag; + } // Check whether we need a buffer - if (!lyxaction.funcHasFlag(cmd.action, LyXAction::NoBuffer)) { - // Yes we need a buffer, do we have one? - if (buf) { - // yes - // Can we use a readonly buffer? - if (buf->isReadonly() && - !lyxaction.funcHasFlag(cmd.action, - LyXAction::ReadOnly)) { - // no - setStatusMessage(N_("Document is read-only")); - flag.disabled(true); - } - } else { - // no - setStatusMessage(N_("Command not allowed with" - "out any document open")); - flag.disabled(true); - return flag; - } + if (!lyxaction.funcHasFlag(cmd.action, LyXAction::NoBuffer) && !buf) { + // no, exit directly + flag.message(N_("Command not allowed with" + "out any document open")); + flag.enabled(false); + return flag; } - UpdatableInset * tli = cur.inset() ? cur.inset()->asUpdatableInset() : 0; - // I would really like to avoid having this switch and rather try to // encode this in the function itself. - bool disable = false; + // -- And I'd rather let an inset decide which LFUNs it is willing + // to handle (Andre') + bool enable = true; switch (cmd.action) { - case LFUN_EXPORT: - disable = cmd.argument != "custom" - && !Exporter::IsExportable(*buf, cmd.argument); + case LFUN_TOOLTIPS_TOGGLE: + flag.setOnOff(owner->getDialogs().tooltipsEnabled()); break; - case LFUN_UNDO: - disable = buf->undostack().empty(); + + case LFUN_READ_ONLY_TOGGLE: + flag.setOnOff(buf->isReadonly()); + break; + + case LFUN_SWITCHBUFFER: + // toggle on the current buffer, but do not toggle off + // the other ones (is that a good idea?) + if (cmd.argument == buf->fileName()) + flag.setOnOff(true); break; - case LFUN_REDO: - disable = buf->redostack().empty(); + + case LFUN_EXPORT: + enable = cmd.argument == "custom" + || Exporter::IsExportable(*buf, cmd.argument); break; case LFUN_CUT: case LFUN_COPY: - disable = !cur.selection(); + enable = cur.selection(); break; case LFUN_RUNCHKTEX: - disable = !buf->isLatex() || lyxrc.chktex_command == "none"; + enable = buf->isLatex() && lyxrc.chktex_command != "none"; break; case LFUN_BUILDPROG: - disable = !Exporter::IsExportable(*buf, "program"); + enable = Exporter::IsExportable(*buf, "program"); break; case LFUN_LAYOUT_TABULAR: - disable = !cur.innerInsetOfType(InsetBase::TABULAR_CODE); - break; - - case LFUN_DEPTH_MIN: - disable = !changeDepthAllowed(cur, view()->getLyXText(), DEC_DEPTH); - break; - - case LFUN_DEPTH_PLUS: - disable = !changeDepthAllowed(cur, view()->getLyXText(), INC_DEPTH); + enable = cur.innerInsetOfType(InsetBase::TABULAR_CODE); break; case LFUN_LAYOUT: case LFUN_LAYOUT_PARAGRAPH: - disable = cur.inset() - && cur.inset()->forceDefaultParagraphs(cur.inset()); - break; - - case LFUN_INSET_OPTARG: - disable = cur.inMathed() - || cur.paragraph().layout()->optionalargs == 0; - break; - - case LFUN_TABULAR_FEATURE: -#if 0 - if (cur.inMathed()) { - // FIXME: check temporarily disabled - // valign code - char align = mathcursor::valign(); - if (align == '\0') { - disable = true; - break; - } - if (cmd.argument.empty()) { - flag.clear(); - break; - } - if (!contains("tcb", cmd.argument[0])) { - disable = true; - break; - } - flag.setOnOff(cmd.argument[0] == align); - } else { - disable = true; - - char align = mathcursor::halign(); - if (align == '\0') { - disable = true; - break; - } - if (cmd.argument.empty()) { - flag.clear(); - break; - } - if (!contains("lcr", cmd.argument[0])) { - disable = true; - break; - } - flag.setOnOff(cmd.argument[0] == align); - - disable = !mathcursor::halign(); - break; - } - - if (tli) { - FuncStatus ret; - //ret.disabled(true); - InsetTabular * tab = static_cast - (cur.innerInsetOfType(InsetBase::TABULAR_CODE)); - if (tab) { - ret = tab->getStatus(cmd.argument); - flag |= ret; - disable = false; - } else { - disable = true; - } - } else { - static InsetTabular inset(*buf, 1, 1); - disable = true; - FuncStatus ret = inset.getStatus(cmd.argument); - if (ret.onoff(true) || ret.onoff(false)) - flag.setOnOff(false); - } -#endif + enable = !cur.inset().forceDefaultParagraphs(&cur.inset()); break; case LFUN_VC_REGISTER: - disable = buf->lyxvc().inUse(); + enable = !buf->lyxvc().inUse(); break; case LFUN_VC_CHECKIN: - disable = !buf->lyxvc().inUse() || buf->isReadonly(); + enable = buf->lyxvc().inUse() && !buf->isReadonly(); break; case LFUN_VC_CHECKOUT: - disable = !buf->lyxvc().inUse() || !buf->isReadonly(); + enable = buf->lyxvc().inUse() && buf->isReadonly(); break; case LFUN_VC_REVERT: case LFUN_VC_UNDO: - disable = !buf->lyxvc().inUse(); + enable = buf->lyxvc().inUse(); break; case LFUN_MENURELOAD: - disable = buf->isUnnamed() || buf->isClean(); - break; - case LFUN_BOOKMARK_GOTO: - disable = !view()-> - isSavedPosition(strToUnsignedInt(cmd.argument)); - break; - - case LFUN_MERGE_CHANGES: - case LFUN_ACCEPT_CHANGE: - case LFUN_REJECT_CHANGE: - case LFUN_ACCEPT_ALL_CHANGES: - case LFUN_REJECT_ALL_CHANGES: - disable = !buf->params().tracking_changes; + enable = !buf->isUnnamed() && !buf->isClean(); break; case LFUN_INSET_SETTINGS: { - disable = true; - if (!cur.inset()) + enable = false; + if (!cur) break; - UpdatableInset * inset = cur.inset()->asUpdatableInset(); + UpdatableInset * inset = cur.inset().asUpdatableInset(); + lyxerr << "inset: " << inset << endl; if (!inset) break; - // jump back to owner if an InsetText, so - // we get back to the InsetTabular or whatever - if (inset->lyxCode() == InsetOld::TEXT_CODE) - inset = inset->owner(); - - InsetOld::Code code = inset->lyxCode(); + InsetBase::Code code = inset->lyxCode(); switch (code) { - case InsetOld::TABULAR_CODE: - disable = cmd.argument != "tabular"; + case InsetBase::TABULAR_CODE: + enable = cmd.argument == "tabular"; break; - case InsetOld::ERT_CODE: - disable = cmd.argument != "ert"; + case InsetBase::ERT_CODE: + enable = cmd.argument == "ert"; break; - case InsetOld::FLOAT_CODE: - disable = cmd.argument != "float"; + case InsetBase::FLOAT_CODE: + enable = cmd.argument == "float"; break; - case InsetOld::WRAP_CODE: - disable = cmd.argument != "wrap"; + case InsetBase::WRAP_CODE: + enable = cmd.argument == "wrap"; break; - case InsetOld::NOTE_CODE: - disable = cmd.argument != "note"; + case InsetBase::NOTE_CODE: + enable = cmd.argument == "note"; break; - case InsetOld::BRANCH_CODE: - disable = cmd.argument != "branch"; + case InsetBase::BRANCH_CODE: + enable = cmd.argument == "branch"; break; - case InsetOld::BOX_CODE: - disable = cmd.argument != "box"; + case InsetBase::BOX_CODE: + enable = cmd.argument == "box"; break; default: break; @@ -495,296 +469,124 @@ FuncStatus LyXFunc::getStatus(FuncRequest const & cmd) const break; } - case LFUN_MATH_MUTATE: - if (cur.inMathed()) - //flag.setOnOff(mathcursor::formula()->hullType() == cmd.argument); - flag.setOnOff(false); - else - disable = true; - break; - - // we just need to be in math mode to enable that - case LFUN_MATH_SIZE: - case LFUN_MATH_SPACE: - case LFUN_MATH_LIMITS: - case LFUN_MATH_NONUMBER: - case LFUN_MATH_NUMBER: - case LFUN_MATH_EXTERN: - disable = cur.inTexted(); - break; - case LFUN_DIALOG_SHOW: { string const name = cmd.getArg(0); - if (!buf) { - disable = !(name == "aboutlyx" || - name == "file" || - name == "forks" || - name == "preferences" || - name == "texinfo"); - break; - } - - if (name == "print") { - disable = !Exporter::IsExportable(*buf, "dvi") || - lyxrc.print_command == "none"; - } else if (name == "character") { - InsetBase * inset = cur.inset(); - disable = inset && inset->lyxCode() == InsetOld::ERT_CODE; - } else if (name == "vclog") { - disable = !buf->lyxvc().inUse(); - } else if (name == "latexlog") { - disable = !IsFileReadable(buf->getLogName().second); - } - break; - } - - default: + if (!buf) + enable = name == "aboutlyx" + || name == "file" + || name == "forks" + || name == "prefs" + || name == "texinfo"; + else if (name == "print") + enable = Exporter::IsExportable(*buf, "dvi") + && lyxrc.print_command != "none"; + 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); break; } - // the functions which insert insets - InsetOld::Code code = InsetOld::NO_CODE; - switch (cmd.action) { case LFUN_DIALOG_SHOW_NEW_INSET: - if (cmd.argument == "bibitem") - code = InsetOld::BIBITEM_CODE; - else if (cmd.argument == "bibtex") - code = InsetOld::BIBTEX_CODE; - else if (cmd.argument == "box") - code = InsetOld::BOX_CODE; - else if (cmd.argument == "branch") - code = InsetOld::BRANCH_CODE; - else if (cmd.argument == "citation") - code = InsetOld::CITE_CODE; - else if (cmd.argument == "ert") - code = InsetOld::ERT_CODE; - else if (cmd.argument == "external") - code = InsetOld::EXTERNAL_CODE; - else if (cmd.argument == "float") - code = InsetOld::FLOAT_CODE; - else if (cmd.argument == "graphics") - code = InsetOld::GRAPHICS_CODE; - else if (cmd.argument == "include") - code = InsetOld::INCLUDE_CODE; - else if (cmd.argument == "index") - code = InsetOld::INDEX_CODE; - else if (cmd.argument == "label") - code = InsetOld::LABEL_CODE; - else if (cmd.argument == "note") - code = InsetOld::NOTE_CODE; - else if (cmd.argument == "ref") - code = InsetOld::REF_CODE; - else if (cmd.argument == "toc") - code = InsetOld::TOC_CODE; - else if (cmd.argument == "url") - code = InsetOld::URL_CODE; - else if (cmd.argument == "vspace") - code = InsetOld::VSPACE_CODE; - else if (cmd.argument == "wrap") - code = InsetOld::WRAP_CODE; + enable = cur.inset().lyxCode() != InsetBase::ERT_CODE; break; - case LFUN_INSET_ERT: - code = InsetOld::ERT_CODE; - break; - case LFUN_INSET_FOOTNOTE: - code = InsetOld::FOOT_CODE; - break; - case LFUN_TABULAR_INSERT: - code = InsetOld::TABULAR_CODE; - break; - case LFUN_INSET_MARGINAL: - code = InsetOld::MARGIN_CODE; - break; - case LFUN_INSET_FLOAT: - case LFUN_INSET_WIDE_FLOAT: - code = InsetOld::FLOAT_CODE; - break; - case LFUN_INSET_WRAP: - code = InsetOld::WRAP_CODE; - break; - case LFUN_FLOAT_LIST: - code = InsetOld::FLOAT_LIST_CODE; - break; -#if 0 - case LFUN_INSET_LIST: - code = InsetOld::LIST_CODE; - break; - case LFUN_INSET_THEOREM: - code = InsetOld::THEOREM_CODE; - break; -#endif - case LFUN_INSET_CAPTION: - code = InsetOld::CAPTION_CODE; - break; - case LFUN_INSERT_NOTE: - code = InsetOld::NOTE_CODE; - break; - case LFUN_INSERT_CHARSTYLE: - code = InsetOld::CHARSTYLE_CODE; - if (buf->params().getLyXTextClass().charstyles().empty()) - disable = true; - break; - case LFUN_INSERT_BOX: - code = InsetOld::BOX_CODE; - break; - case LFUN_INSERT_BRANCH: - code = InsetOld::BRANCH_CODE; - if (buf->params().branchlist().empty()) - disable = true; - break; - case LFUN_INSERT_LABEL: - code = InsetOld::LABEL_CODE; - break; - case LFUN_INSET_OPTARG: - code = InsetOld::OPTARG_CODE; - break; - case LFUN_ENVIRONMENT_INSERT: - code = InsetOld::BOX_CODE; - break; - case LFUN_INDEX_INSERT: - code = InsetOld::INDEX_CODE; - break; - case LFUN_INDEX_PRINT: - code = InsetOld::INDEX_PRINT_CODE; - break; - case LFUN_TOC_INSERT: - code = InsetOld::TOC_CODE; - break; - case LFUN_HTMLURL: - case LFUN_URL: - code = InsetOld::URL_CODE; - break; - case LFUN_QUOTE: - // always allow this, since we will inset a raw quote - // if an inset is not allowed. - break; - case LFUN_HYPHENATION: - case LFUN_LIGATURE_BREAK: - case LFUN_HFILL: - case LFUN_MENU_SEPARATOR: - case LFUN_LDOTS: - case LFUN_END_OF_SENTENCE: - code = InsetOld::SPECIALCHAR_CODE; - break; - case LFUN_SPACE_INSERT: - // slight hack: we know this is allowed in math mode - if (cur.inTexted()) - code = InsetOld::SPACE_CODE; - break; - case LFUN_INSET_DIALOG_SHOW: { - InsetBase * inset = cur.nextInset(); - disable = !inset; - if (inset) { - code = inset->lyxCode(); - if (!(code == InsetOld::INCLUDE_CODE - || code == InsetOld::BIBTEX_CODE - || code == InsetOld::FLOAT_LIST_CODE - || code == InsetOld::TOC_CODE)) - disable = true; - } - break; - } - default: + case LFUN_DIALOG_UPDATE: { + string const name = cmd.getArg(0); + if (!buf) + enable = name == "prefs"; break; } - if (code != InsetOld::NO_CODE && tli && !tli->insetAllowed(code)) - disable = true; - if (disable) - flag.disabled(true); + // this one is difficult to get right. As a half-baked + // solution, we consider only the first action of the sequence + case LFUN_SEQUENCE: { + // argument contains ';'-terminated commands + string const firstcmd = token(cmd.argument, ';', 0); + FuncRequest func(lyxaction.lookupFunc(firstcmd)); + func.origin = cmd.origin; + flag = getStatus(func); + } - // A few general toggles - switch (cmd.action) { - case LFUN_TOOLTIPS_TOGGLE: - flag.setOnOff(owner->getDialogs().tooltipsEnabled()); + case LFUN_MENUNEW: + case LFUN_MENUNEWTMPLT: + case LFUN_WORDFINDFORWARD: + case LFUN_WORDFINDBACKWARD: + case LFUN_PREFIX: + case LFUN_EXEC_COMMAND: + case LFUN_CANCEL: + case LFUN_META_FAKE: + case LFUN_CLOSEBUFFER: + case LFUN_MENUWRITE: + case LFUN_WRITEAS: + case LFUN_UPDATE: + case LFUN_PREVIEW: + case LFUN_IMPORT: + case LFUN_QUIT: + case LFUN_TOCVIEW: + case LFUN_AUTOSAVE: + 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_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_REPEAT: + case LFUN_EXPORT_CUSTOM: + case LFUN_PRINT: + case LFUN_SAVEPREFERENCES: + 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_TEXTCLASS_APPLY: + case LFUN_TEXTCLASS_LOAD: + case LFUN_SAVE_AS_DEFAULT: + case LFUN_BUFFERPARAMS_APPLY: + case LFUN_LYXRC_APPLY: + case LFUN_NEXTBUFFER: + case LFUN_PREVIOUSBUFFER: + // these are handled in our dispatch() break; - case LFUN_READ_ONLY_TOGGLE: - flag.setOnOff(buf->isReadonly()); - break; - case LFUN_APPENDIX: - flag.setOnOff(cur.inTexted() - && cur.paragraph().params().startOfAppendix()); - break; - case LFUN_SWITCHBUFFER: - // toggle on the current buffer, but do not toggle off - // the other ones (is that a good idea?) - if (cmd.argument == buf->fileName()) - flag.setOnOff(true); - break; - case LFUN_TRACK_CHANGES: - flag.setOnOff(buf->params().tracking_changes); - break; default: - break; - } -#ifdef LOCK - // the font related toggles - if (cur.inTexted()) { - LyXFont const & font = cur.text()->real_current_font; - switch (cmd.action) { - case LFUN_EMPH: - flag.setOnOff(font.emph() == LyXFont::ON); - break; - case LFUN_NOUN: - flag.setOnOff(font.noun() == LyXFont::ON); - break; - case LFUN_BOLD: - flag.setOnOff(font.series() == LyXFont::BOLD_SERIES); - break; - case LFUN_SANS: - flag.setOnOff(font.family() == LyXFont::SANS_FAMILY); - break; - case LFUN_ROMAN: - flag.setOnOff(font.family() == LyXFont::ROMAN_FAMILY); - break; - case LFUN_CODE: - flag.setOnOff(font.family() == LyXFont::TYPEWRITER_FAMILY); - break; - default: - break; - } - } else { - string tc = mathcursor::getLastCode(); - switch (cmd.action) { - case LFUN_BOLD: - flag.setOnOff(tc == "mathbf"); - break; - case LFUN_SANS: - flag.setOnOff(tc == "mathsf"); - break; - case LFUN_EMPH: - flag.setOnOff(tc == "mathcal"); - break; - case LFUN_ROMAN: - flag.setOnOff(tc == "mathrm"); - break; - case LFUN_CODE: - flag.setOnOff(tc == "mathtt"); - break; - case LFUN_NOUN: - flag.setOnOff(tc == "mathbb"); - break; - case LFUN_DEFAULT: - flag.setOnOff(tc == "mathnormal"); - break; - default: - break; - } + if (!::getStatus(cur, cmd, flag)) + flag = view()->getStatus(cmd); } -#endif - // this one is difficult to get right. As a half-baked - // solution, we consider only the first action of the sequence - if (cmd.action == LFUN_SEQUENCE) { - // argument contains ';'-terminated commands -#warning LyXAction arguments not handled here. - flag = getStatus(FuncRequest( - lyxaction.lookupFunc(token(cmd.argument, ';', 0)))); + if (!enable) + flag.enabled(false); + + // Can we use a readonly buffer? + if (buf && buf->isReadonly() + && !lyxaction.funcHasFlag(cmd.action, LyXAction::ReadOnly) + && !lyxaction.funcHasFlag(cmd.action, LyXAction::NoBuffer)) { + flag.message(N_("Document is read-only")); + flag.enabled(false); } + // the default error message if we disable the command + if (!flag.enabled() && flag.message().empty()) + flag.message(N_("Command disabled")); + return flag; } @@ -811,13 +613,49 @@ bool ensureBufferClean(BufferView * bv) return buf.isClean(); } + +void showPrintError(string const & name) +{ + string 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); +} + + +void loadTextclass(string const & name) +{ + std::pair const tc_pair = + textclasslist.NumberOfClass(name); + + if (!tc_pair.first) { + lyxerr << "Document class \"" << name + << "\" does not exist." + << std::endl; + return; + } + + lyx::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()); + Alert::error(_("Could not change class"), s); + } +} + + +void actOnUpdatedPrefs(LyXRC const & lyxrc_orig, LyXRC const & lyxrc_new); + } //namespace anon -void LyXFunc::dispatch(FuncRequest const & cmd, bool verbose) +void LyXFunc::dispatch(FuncRequest const & cmd) { - string argument = cmd.argument; - kb_action action = cmd.action; + BOOST_ASSERT(view()); + string const argument = cmd.argument; + kb_action const action = cmd.action; lyxerr[Debug::ACTION] << "LyXFunc::dispatch: cmd: " << cmd << endl; //lyxerr << "LyXFunc::dispatch: cmd: " << cmd << endl; @@ -825,16 +663,17 @@ void LyXFunc::dispatch(FuncRequest const & cmd, bool verbose) // we have not done anything wrong yet. errorstat = false; dispatch_buffer.erase(); - selection_possible = false; - // We cannot use this function here - if (getStatus(cmd).disabled()) { + bool update = false; + + FuncStatus const flag = getStatus(cmd); + if (!flag.enabled()) { + // We cannot use this function here lyxerr[Debug::ACTION] << "LyXFunc::dispatch: " << lyxaction.getActionName(action) << " [" << action << "] is disabled at this location" << endl; - setErrorMessage(getStatusMessage()); - + setErrorMessage(flag.message()); } else { if (view()->available()) @@ -850,8 +689,9 @@ void LyXFunc::dispatch(FuncRequest const & cmd, bool verbose) if (!argument.empty()) { last_search = argument; searched_string = argument; - } else + } else { searched_string = last_search; + } if (searched_string.empty()) break; @@ -859,7 +699,7 @@ void LyXFunc::dispatch(FuncRequest const & cmd, bool verbose) bool const fw = action == LFUN_WORDFINDFORWARD; string const data = lyx::find::find2string(searched_string, true, false, fw); - view()->dispatch(FuncRequest(LFUN_WORD_FIND, data)); + lyx::find::find(view(), FuncRequest(LFUN_WORD_FIND, data)); break; } @@ -868,6 +708,7 @@ void LyXFunc::dispatch(FuncRequest const & cmd, bool verbose) break; case LFUN_EXEC_COMMAND: + owner->getToolbars().display("minibuffer", true); owner->focus_command_buffer(); break; @@ -955,13 +796,147 @@ void LyXFunc::dispatch(FuncRequest const & cmd, bool verbose) case LFUN_EXPORT: if (argument == "custom") - owner->getDialogs().showSendto(); + owner->getDialogs().show("sendto"); else { Exporter::Export(owner->buffer(), argument, false); view()->showErrorList(BufferFormat(*owner->buffer())); } break; + case LFUN_EXPORT_CUSTOM: { + string format_name; + string command = split(argument, format_name, ' '); + Format const * format = formats.getFormat(format_name); + if (!format) { + lyxerr << "Format \"" << format_name + << "\" not recognized!" + << std::endl; + break; + } + + Buffer * buffer = owner->buffer(); + + // The name of the file created by the conversion process + string filename; + + // Output to filename + if (format->name() == "lyx") { + string const latexname = + buffer->getLatexName(false); + filename = ChangeExtension(latexname, + format->extension()); + filename = AddName(buffer->temppath(), filename); + + if (!buffer->writeFile(filename)) + break; + + } else { + Exporter::Export(buffer, format_name, true, + filename); + } + + // Substitute $$FName for filename + if (!contains(command, "$$FName")) + command = "( " + command + " ) < $$FName"; + command = subst(command, "$$FName", filename); + + // Execute the command in the background + Systemcall call; + call.startscript(Systemcall::DontWait, command); + break; + } + + case LFUN_PRINT: { + string target; + string target_name; + string command = split(split(argument, target, ' '), + target_name, ' '); + + if (target.empty() + || target_name.empty() + || command.empty()) { + lyxerr << "Unable to parse \"" + << argument << '"' << std::endl; + break; + } + if (target != "printer" && target != "file") { + lyxerr << "Unrecognized target \"" + << target << '"' << std::endl; + break; + } + + Buffer * buffer = owner->buffer(); + + if (!Exporter::Export(buffer, "dvi", true)) { + showPrintError(buffer->fileName()); + break; + } + + // Push directory path. + string const path = buffer->temppath(); + Path p(path); + + // there are three cases here: + // 1. we print to a file + // 2. we print directly to a printer + // 3. we print using a spool command (print to file first) + Systemcall one; + int res = 0; + string const dviname = + ChangeExtension(buffer->getLatexName(true), + "dvi"); + + if (target == "printer") { + if (!lyxrc.print_spool_command.empty()) { + // case 3: print using a spool + string const psname = + ChangeExtension(dviname,".ps"); + command += lyxrc.print_to_file + + QuoteName(psname) + + ' ' + + QuoteName(dviname); + + string command2 = + lyxrc.print_spool_command +' '; + if (target_name != "default") { + command2 += lyxrc.print_spool_printerprefix + + target_name + + ' '; + } + command2 += QuoteName(psname); + // First run dvips. + // If successful, then spool command + res = one.startscript( + Systemcall::Wait, + command); + + if (res == 0) + res = one.startscript( + Systemcall::DontWait, + command2); + } else { + // case 2: print directly to a printer + res = one.startscript( + Systemcall::DontWait, + command + QuoteName(dviname)); + } + + } else { + // case 1: print to a file + command += lyxrc.print_to_file + + QuoteName(MakeAbsPath(target_name, + path)) + + ' ' + + QuoteName(dviname); + res = one.startscript(Systemcall::DontWait, + command); + } + + if (res != 0) + showPrintError(buffer->fileName()); + break; + } + case LFUN_IMPORT: doImport(argument); break; @@ -1045,7 +1020,15 @@ void LyXFunc::dispatch(FuncRequest const & cmd, bool verbose) // --- buffers ---------------------------------------- case LFUN_SWITCHBUFFER: - view()->buffer(bufferlist.getBuffer(argument)); + view()->setBuffer(bufferlist.getBuffer(argument)); + break; + + case LFUN_NEXTBUFFER: + view()->setBuffer(bufferlist.next(view()->buffer())); + break; + + case LFUN_PREVIOUSBUFFER: + view()->setBuffer(bufferlist.previous(view()->buffer())); break; case LFUN_FILE_NEW: @@ -1057,7 +1040,7 @@ void LyXFunc::dispatch(FuncRequest const & cmd, bool verbose) break; case LFUN_DROP_LAYOUTS_CHOICE: - owner->getToolbar().openLayoutList(); + owner->getToolbars().openLayoutList(); break; case LFUN_MENU_OPEN_BY_NAME: @@ -1082,17 +1065,17 @@ void LyXFunc::dispatch(FuncRequest const & cmd, bool verbose) 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()->buffer(bufferlist.getBufferFromTmp(file_name)); + view()->setBuffer(bufferlist.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()->buffer(bufferlist.getBuffer(s)); + view()->setBuffer(bufferlist.getBuffer(s)); } else { view()->loadLyXFile(s); } @@ -1106,32 +1089,6 @@ void LyXFunc::dispatch(FuncRequest const & cmd, bool verbose) 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())); @@ -1141,18 +1098,6 @@ void LyXFunc::dispatch(FuncRequest const & cmd, bool verbose) if (!data.empty()) owner->getDialogs().show("character", data); } - else if (name == "document") - owner->getDialogs().showDocument(); - else if (name == "forks") - owner->getDialogs().showForks(); - else if (name == "preamble") - owner->getDialogs().showPreamble(); - else if (name == "preferences") - owner->getDialogs().showPreferences(); - else if (name == "print") - owner->getDialogs().showPrint(); - else if (name == "spellchecker") - owner->getDialogs().showSpellchecker(); else if (name == "latexlog") { pair const logfile = @@ -1231,13 +1176,6 @@ void LyXFunc::dispatch(FuncRequest const & cmd, bool verbose) case LFUN_DIALOG_SHOW_NEXT_INSET: break; - case LFUN_INSET_DIALOG_SHOW: { - InsetBase * inset = view()->cursor().nextInset(); - if (inset) - inset->dispatch(view()->cursor(), FuncRequest(LFUN_INSET_DIALOG_SHOW)); - break; - } - case LFUN_DIALOG_UPDATE: { string const & name = argument; // Can only update a dialog connected to an existing inset @@ -1247,6 +1185,8 @@ void LyXFunc::dispatch(FuncRequest const & cmd, bool verbose) inset->dispatch(view()->cursor(), fr); } else if (name == "paragraph") { dispatch(FuncRequest(LFUN_PARAGRAPH_UPDATE)); + } else if (name == "prefs") { + owner->getDialogs().update(name, string()); } break; } @@ -1267,7 +1207,7 @@ void LyXFunc::dispatch(FuncRequest const & cmd, bool verbose) view()->savePosition(0); string const parentfilename = owner->buffer()->fileName(); if (bufferlist.exists(filename)) - view()->buffer(bufferlist.getBuffer(filename)); + view()->setBuffer(bufferlist.getBuffer(filename)); else view()->loadLyXFile(filename); // Set the parent name of the child document. @@ -1300,28 +1240,32 @@ void LyXFunc::dispatch(FuncRequest const & cmd, bool verbose) case LFUN_REPEAT: { // repeat command string countstr; - argument = split(argument, countstr, ' '); + string rest = split(argument, countstr, ' '); istringstream is(countstr); int count = 0; is >> count; - lyxerr << "repeat: count: " << count << " cmd: " << argument << endl; + lyxerr << "repeat: count: " << count << " cmd: " << rest << endl; for (int i = 0; i < count; ++i) - dispatch(lyxaction.lookupFunc(argument)); + dispatch(lyxaction.lookupFunc(rest)); break; } - case LFUN_SEQUENCE: + case LFUN_SEQUENCE: { // argument contains ';'-terminated commands - while (!argument.empty()) { + string arg = argument; + while (!arg.empty()) { string first; - argument = split(argument, first, ';'); - dispatch(lyxaction.lookupFunc(first)); + arg = split(arg, first, ';'); + FuncRequest func(lyxaction.lookupFunc(first)); + func.origin = cmd.origin; + dispatch(func); } break; + } case LFUN_SAVEPREFERENCES: { - Path p(user_lyxdir()); - lyxrc.write("preferences"); + Path p(package().user_support()); + lyxrc.write("preferences", false); break; } @@ -1346,8 +1290,7 @@ void LyXFunc::dispatch(FuncRequest const & cmd, bool verbose) (lyx_name == lcolor.getLyXName(LColor::graphicsbg) && x11_name != lcolor.getX11Name(LColor::graphicsbg)); - LColor::color col = lcolor.getFromLyXName(lyx_name); - if (!lcolor.setColor(col, x11_name)) { + if (!lcolor.setColor(lyx_name, x11_name)) { setErrorMessage( bformat(_("Set-color \"%1$s\" failed " "- color is undefined or " @@ -1372,51 +1315,204 @@ void LyXFunc::dispatch(FuncRequest const & cmd, bool verbose) owner->message(argument); break; - case LFUN_FORKS_KILL: - if (isStrInt(argument)) - ForkedcallsController::get().kill(strToInt(argument)); - break; - case LFUN_TOOLTIPS_TOGGLE: owner->getDialogs().toggleTooltips(); break; - case LFUN_EXTERNAL_EDIT: - InsetExternal().dispatch(view()->cursor(), FuncRequest(action, argument)); + case LFUN_EXTERNAL_EDIT: { + FuncRequest fr(action, argument); + InsetExternal().dispatch(view()->cursor(), fr); break; + } - default: - DispatchResult res = view()->cursor().dispatch(cmd); - if (!res.dispatched()); - view()->dispatch(cmd); + case LFUN_GRAPHICS_EDIT: { + FuncRequest fr(action, argument); + InsetGraphics().dispatch(view()->cursor(), fr); break; } - } - if (view()->cursor().inTexted()) - view()->owner()->updateLayoutChoice(); + case LFUN_ALL_INSETS_TOGGLE: { + string action; + string const name = split(argument, action, ' '); + InsetBase::Code const inset_code = + InsetBase::translate(name); + + LCursor & cur = view()->cursor(); + FuncRequest fr(LFUN_INSET_TOGGLE, action); + + InsetBase & inset = owner->buffer()->inset(); + InsetIterator it = inset_iterator_begin(inset); + 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); + } + break; + } - if (view()->available()) { - view()->fitCursor(); - view()->update(); - view()->cursor().updatePos(); - // if we executed a mutating lfun, mark the buffer as dirty - if (!getStatus(cmd).disabled() - && !lyxaction.funcHasFlag(cmd.action, LyXAction::NoBuffer) - && !lyxaction.funcHasFlag(cmd.action, LyXAction::ReadOnly)) - view()->buffer()->markDirty(); - } + case LFUN_LANGUAGE_BUFFER: { + Buffer & buffer = *owner->buffer(); + Language const * oldL = buffer.params().language; + Language const * newL = languages.getLanguage(argument); + if (!newL || oldL == newL) + break; + + if (oldL->RightToLeft() == newL->RightToLeft() + && !buffer.isMultiLingual()) + buffer.changeLanguage(oldL, newL); + else + buffer.updateDocLang(newL); + break; + } + + case LFUN_SAVE_AS_DEFAULT: { + string const fname = + AddName(AddPath(package().user_support(), "templates/"), + "defaults.lyx"); + Buffer defaults(fname); + + istringstream ss(argument); + LyXLex lex(0,0); + lex.setStream(ss); + int const unknown_tokens = defaults.readHeader(lex); + + if (unknown_tokens != 0) { + lyxerr << "Warning in LFUN_SAVE_AS_DEFAULT!\n" + << unknown_tokens << " unknown token" + << (unknown_tokens == 1 ? "" : "s") + << endl; + } + + if (defaults.writeFile(defaults.fileName())) + setMessage(_("Document defaults saved in ") + + MakeDisplayPath(fname)); + else + setErrorMessage(_("Unable to save document defaults")); + break; + } + + case LFUN_BUFFERPARAMS_APPLY: { + biblio::CiteEngine const engine = + owner->buffer()->params().cite_engine; + + istringstream ss(argument); + LyXLex lex(0,0); + lex.setStream(ss); + int const unknown_tokens = + owner->buffer()->readHeader(lex); + + if (unknown_tokens != 0) { + lyxerr << "Warning in LFUN_BUFFERPARAMS_APPLY!\n" + << unknown_tokens << " unknown token" + << (unknown_tokens == 1 ? "" : "s") + << endl; + } + if (engine == owner->buffer()->params().cite_engine) + break; + + LCursor & cur = view()->cursor(); + FuncRequest fr(LFUN_INSET_REFRESH); + + InsetBase & inset = owner->buffer()->inset(); + InsetIterator it = inset_iterator_begin(inset); + InsetIterator const end = inset_iterator_end(inset); + for (; it != end; ++it) + if (it->lyxCode() == InsetBase::CITE_CODE) + it->dispatch(cur, fr); + break; + } + + case LFUN_TEXTCLASS_APPLY: { + Buffer * buffer = owner->buffer(); + + lyx::textclass_type const old_class = + buffer->params().textclass; + + loadTextclass(argument); + + std::pair const tc_pair = + textclasslist.NumberOfClass(argument); + + if (!tc_pair.first) + break; + + lyx::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...")); + ErrorList el; + lyx::cap::SwitchLayoutsBetweenClasses( + old_class, new_class, + buffer->paragraphs(), el); + + bufferErrors(*buffer, el); + view()->showErrorList(_("Class switch")); + break; + } - if (view()->cursor().inTexted()) - sendDispatchMessage(getMessage(), cmd, verbose); + case LFUN_TEXTCLASS_LOAD: + loadTextclass(argument); + break; + + case LFUN_LYXRC_APPLY: { + LyXRC const lyxrc_orig = lyxrc; + + istringstream ss(argument); + bool const success = lyxrc.read(ss) == 0; + + if (!success) { + lyxerr << "Warning in LFUN_LYXRC_APPLY!\n" + << "Unable to read lyxrc data" + << endl; + break; + } + + actOnUpdatedPrefs(lyxrc_orig, lyxrc); + break; + } + + default: { + view()->cursor().dispatch(cmd); + update |= view()->cursor().result().update(); + if (!view()->cursor().result().dispatched()) { + update |= view()->dispatch(cmd); + } + + break; + } + } + + if (view()->available()) { + // 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 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)) + view()->buffer()->markDirty(); + } + + if (view()->cursor().inTexted()) { + view()->owner()->updateLayoutChoice(); + } + } + sendDispatchMessage(getMessage(), cmd); } -void LyXFunc::sendDispatchMessage(string const & msg, - FuncRequest const & cmd, bool verbose) +void LyXFunc::sendDispatchMessage(string const & msg, FuncRequest const & cmd) { owner->updateMenubar(); - owner->updateToolbar(); + owner->updateToolbars(); + + const bool verbose = (cmd.origin == FuncRequest::UI + || cmd.origin == FuncRequest::COMMANDBUFFER); if (cmd.action == LFUN_SELFINSERT || !verbose) { lyxerr[Debug::ACTION] << "dispatch msg is " << msg << endl; @@ -1440,7 +1536,7 @@ void LyXFunc::sendDispatchMessage(string const & msg, } } - string const shortcuts = toplevel_keymap->findbinding(cmd); + string const shortcuts = toplevel_keymap->printbindings(cmd); if (!shortcuts.empty()) { comname += ": " + shortcuts; @@ -1484,14 +1580,12 @@ void LyXFunc::menuNew(string const & name, bool fromTemplate) if (filename.empty()) { filename = AddName(lyxrc.document_path, - "newfile" + tostr(++newfile_number) + ".lyx"); - FileInfo fi(filename); - while (bufferlist.exists(filename) || fi.readable()) { + "newfile" + convert(++newfile_number) + ".lyx"); + while (bufferlist.exists(filename) || fs::is_readable(filename)) { ++newfile_number; filename = AddName(lyxrc.document_path, - "newfile" + tostr(newfile_number) + + "newfile" + convert(newfile_number) + ".lyx"); - fi.newFile(filename); } } @@ -1540,7 +1634,7 @@ void LyXFunc::open(string const & fname) 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, @@ -1570,8 +1664,7 @@ void LyXFunc::open(string const & fname) 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; @@ -1616,7 +1709,7 @@ void LyXFunc::doImport(string const & argument) 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) + ')'; @@ -1654,7 +1747,7 @@ void LyXFunc::doImport(string const & argument) // 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" @@ -1681,7 +1774,7 @@ void LyXFunc::closeBuffer() // since there's no current buffer owner->getDialogs().hideBufferDependent(); } else { - view()->buffer(bufferlist.first()); + view()->setBuffer(bufferlist.first()); } } } @@ -1706,12 +1799,6 @@ void LyXFunc::setMessage(string const & m) const } -void LyXFunc::setStatusMessage(string const & m) const -{ - status_buffer = m; -} - - string const LyXFunc::viewStatusMessage() { // When meta-fake key is pressed, show the key sequence so far + "M-". @@ -1741,3 +1828,139 @@ bool LyXFunc::wasMetaKey() const { 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_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