X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Flyxfunc.C;h=bf551cd8b55ba52548abb52d28b459770eb39c6b;hb=a9713c5563c924f4ab98bde3d9f24a5c1e4dd50e;hp=56464ec535f7a21d1ab8735e9fe00bef168f5abf;hpb=b8198905dc65d62ec43f835a42dc219455f881a0;p=lyx.git diff --git a/src/lyxfunc.C b/src/lyxfunc.C index 56464ec535..bf551cd8b5 100644 --- a/src/lyxfunc.C +++ b/src/lyxfunc.C @@ -10,15 +10,12 @@ #include -#ifdef __GNUG__ -#pragma implementation -#endif - #include "lyxfunc.h" #include "version.h" #include "kbmap.h" #include "lyxrow.h" #include "bufferlist.h" +#include "buffer.h" #include "BufferView.h" #include "lyxserver.h" #include "intl.h" @@ -31,13 +28,14 @@ #include "gettext.h" #include "Lsstream.h" #include "trans_mgr.h" +#include "encoding.h" #include "layout.h" #include "bufferview_funcs.h" #include "frontends/LyXView.h" #include "frontends/lyx_gui.h" #include "vspace.h" #include "FloatList.h" -#include "converter.h" +#include "format.h" #include "exporter.h" #include "importer.h" #include "TextCache.h" @@ -45,29 +43,9 @@ #include "undo_funcs.h" #include "ParagraphParameters.h" -#include "insets/inseturl.h" -#include "insets/insetlatexaccent.h" -#include "insets/insettoc.h" -#include "insets/insetref.h" -#include "insets/insetparent.h" -#include "insets/insetindex.h" -#include "insets/insetinclude.h" -#include "insets/insetbib.h" -#include "insets/insetcite.h" -#include "insets/insettext.h" -#include "insets/insetert.h" +#include "insets/insetcommand.h" #include "insets/insetexternal.h" -#include "insets/insetgraphics.h" -#include "insets/insetfoot.h" -#include "insets/insetmarginal.h" -#include "insets/insetminipage.h" -#include "insets/insetfloat.h" -#if 0 -#include "insets/insetlist.h" -#include "insets/insettheorem.h" -#endif #include "insets/insettabular.h" -#include "insets/insetcaption.h" #include "mathed/formulamacro.h" #include "mathed/math_cursor.h" @@ -87,6 +65,7 @@ #include "support/FileInfo.h" #include "support/forkedcontr.h" #include "support/lstrings.h" +#include "support/tostr.h" #include "support/path.h" #include "support/lyxfunctional.h" @@ -105,6 +84,7 @@ using std::find_if; using std::vector; using std::transform; using std::back_inserter; +using namespace bv_funcs; extern BufferList bufferlist; extern LyXServer * lyxserver; @@ -112,26 +92,19 @@ extern bool selection_possible; extern boost::scoped_ptr toplevel_keymap; -extern void show_symbols_form(LyXFunc *); - -extern LyXAction lyxaction; // (alkis) extern tex_accent_struct get_accent(kb_action action); extern void ShowLatexLog(); -/* === globals =========================================================== */ - - LyXFunc::LyXFunc(LyXView * o) : owner(o), + encoded_last_key(0), keyseq(toplevel_keymap.get(), toplevel_keymap.get()), - cancel_meta_seq(toplevel_keymap.get(), toplevel_keymap.get()) + cancel_meta_seq(toplevel_keymap.get(), toplevel_keymap.get()), + meta_fake_bit(key_modifier::none) { - meta_fake_bit = key_modifier::none; - lyx_dead_action = LFUN_NOACTION; - lyx_calling_dead_action = LFUN_NOACTION; } @@ -139,8 +112,8 @@ inline LyXText * LyXFunc::TEXT(bool flag = true) const { if (flag) - return owner->view()->text; - return owner->view()->getLyXText(); + return view()->text; + return view()->getLyXText(); } @@ -148,33 +121,31 @@ inline void LyXFunc::moveCursorUpdate(bool flag, bool selecting) { if (selecting || TEXT(flag)->selection.mark()) { - TEXT(flag)->setSelection(owner->view().get()); - if (TEXT(flag)->bv_owner) - owner->view()->toggleToggle(); + TEXT(flag)->setSelection(); + if (!TEXT(flag)->isInInset()) + view()->toggleToggle(); } - owner->view()->update(TEXT(flag), BufferView::SELECT|BufferView::FITCUR); - owner->view()->showCursor(); + view()->update(TEXT(flag), BufferView::SELECT); - owner->view()->switchKeyMap(); + view()->switchKeyMap(); } void LyXFunc::handleKeyFunc(kb_action action) { - char c = keyseq.getLastKeyEncoded(); + char c = encoded_last_key; - if (keyseq.length() > 1) { + if (keyseq.length()) { c = 0; } - owner->getIntl()->getTransManager() + owner->getIntl().getTransManager() .deadkey(c, get_accent(action).accent, TEXT(false)); // Need to clear, in case the minibuffer calls these // actions keyseq.clear(); // copied verbatim from do_accent_char - owner->view()->update(TEXT(false), - BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE); + view()->update(TEXT(false), BufferView::SELECT); TEXT(false)->selection.cursor = TEXT(false)->cursor; } @@ -189,6 +160,7 @@ void LyXFunc::processKeySym(LyXKeySymPtr keysym, << keysym->getSymbolName() << endl; } + // Do nothing if we have nothing (JMarc) if (!keysym->isOK()) { lyxerr[Debug::KEY] << "Empty kbd action (probably composing)" @@ -197,17 +169,20 @@ void LyXFunc::processKeySym(LyXKeySymPtr keysym, } if (keysym->isModifier()) { + lyxerr[Debug::KEY] << "isModifier true" << endl; return; } + Encoding const * encoding = view()->getEncoding(); + + encoded_last_key = keysym->getISOEncoded(encoding ? encoding->Name() : ""); + // Do a one-deep top-level lookup for // cancel and meta-fake keys. RVDK_PATCH_5 cancel_meta_seq.reset(); int action = cancel_meta_seq.addkey(keysym, state); - if (lyxerr.debugging(Debug::KEY)) { - lyxerr << "action first set to [" << action << "]" << endl; - } + lyxerr[Debug::KEY] << "action first set to [" << 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. @@ -216,9 +191,9 @@ void LyXFunc::processKeySym(LyXKeySymPtr keysym, // remove Caps Lock and Mod2 as a modifiers action = keyseq.addkey(keysym, (state | meta_fake_bit)); lyxerr[Debug::KEY] << "action now set to [" - << action << "]" << endl; + << action << ']' << endl; } - + // Dont remove this unless you know what you are doing. meta_fake_bit = key_modifier::none; @@ -230,7 +205,7 @@ void LyXFunc::processKeySym(LyXKeySymPtr keysym, if (lyxerr.debugging(Debug::KEY)) { lyxerr << "Key [action=" << action << "][" - << keyseq.print() << "]" + << keyseq.print() << ']' << endl; } @@ -242,31 +217,39 @@ void LyXFunc::processKeySym(LyXKeySymPtr keysym, owner->message(keyseq.print()); } - if (action == LFUN_UNKNOWN_ACTION) { - // It is unknown, but what if we remove all - // the modifiers? (Lgb) + + // Maybe user can only reach the key via holding down shift. + // Let's see. But only if shift is the only modifier + if (action == LFUN_UNKNOWN_ACTION && state == key_modifier::shift) { + lyxerr[Debug::KEY] << "Trying without shift" << endl; action = keyseq.addkey(keysym, key_modifier::none); + lyxerr[Debug::KEY] << "Action now " << action << endl; + } - lyxerr[Debug::KEY] << "Removing modifiers...\n" - << "Action now set to [" - << action << "]" << endl; - - if (action == LFUN_UNKNOWN_ACTION) { + if (action == LFUN_UNKNOWN_ACTION) { + // 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) { + lyxerr[Debug::KEY] << "isText() is true, inserting." << endl; + action = LFUN_SELFINSERT; + } else { + lyxerr[Debug::KEY] << "Unknown, !isText() - giving up" << endl; owner->message(_("Unknown function.")); return; } } if (action == LFUN_SELFINSERT) { - char c = keysym->getISOEncoded(); - string argument; + if (encoded_last_key != 0) { + string arg; + arg += encoded_last_key; - if (c != 0) - argument = c; + dispatch(FuncRequest(view(), LFUN_SELFINSERT, arg)); - dispatch(FuncRequest(LFUN_SELFINSERT, argument)); - lyxerr[Debug::KEY] << "SelfInsert arg[`" + lyxerr[Debug::KEY] << "SelfInsert arg[`" << argument << "']" << endl; + } } else { dispatch(action); } @@ -275,9 +258,7 @@ void LyXFunc::processKeySym(LyXKeySymPtr keysym, FuncStatus LyXFunc::getStatus(int ac) const { - string argument; - kb_action action = lyxaction.retrieveActionArg(ac, argument); - return getStatus(FuncRequest(action, argument)); + return getStatus(lyxaction.retrieveActionArg(ac)); } @@ -291,9 +272,20 @@ FuncStatus LyXFunc::getStatus(FuncRequest const & ev) const return flag.disabled(true); } - if (ev.action == LFUN_UNKNOWN_ACTION) { + switch (ev.action) { + case LFUN_UNKNOWN_ACTION: +#ifndef HAVE_LIBAIKSAURUS + case LFUN_THESAURUS_ENTRY: +#endif + flag.unknown(true); + break; + default: + flag |= lyx_gui::getStatus(ev); + } + + if (flag.unknown()) { setStatusMessage(N_("Unknown action")); - return flag.unknown(true); + return flag; } // the default error message if we disable the command @@ -320,7 +312,7 @@ FuncStatus LyXFunc::getStatus(FuncRequest const & ev) const } } - UpdatableInset * tli = owner->view()->theLockingInset(); + UpdatableInset * tli = view()->theLockingInset(); // I would really like to avoid having this switch and rather try to // encode this in the function itself. @@ -331,8 +323,8 @@ FuncStatus LyXFunc::getStatus(FuncRequest const & ev) const || lyxrc.print_command == "none"; break; case LFUN_EXPORT: - disable = ev.argument == "fax" && - !Exporter::IsExportable(buf, ev.argument); + disable = ev.argument != "custom" + && !Exporter::IsExportable(buf, ev.argument); break; case LFUN_UNDO: disable = buf->undostack.empty(); @@ -340,13 +332,22 @@ FuncStatus LyXFunc::getStatus(FuncRequest const & ev) const case LFUN_REDO: disable = buf->redostack.empty(); break; -#ifndef HAVE_LIBAIKSAURUS - case LFUN_THESAURUS_ENTRY: - disable = true; + case LFUN_CUT: + case LFUN_COPY: + if (tli) { + UpdatableInset * in = tli; + if (in->lyxCode() != Inset::TABULAR_CODE) { + in = tli->getFirstLockingInsetOfType(Inset::TABULAR_CODE); + } + if (in && static_cast(in)->hasSelection()) { + disable = false; + break; + } + } + disable = !mathcursor && !view()->getLyXText()->selection.set(); break; -#endif case LFUN_RUNCHKTEX: - disable = lyxrc.chktex_command == "none"; + disable = !buf->isLatex() || lyxrc.chktex_command == "none"; break; case LFUN_BUILDPROG: disable = !Exporter::IsExportable(buf, "program"); @@ -362,6 +363,14 @@ FuncStatus LyXFunc::getStatus(FuncRequest const & ev) const && !tli->getFirstLockingInsetOfType(Inset::TABULAR_CODE)); break; + case LFUN_DEPTH_MIN: + disable = !changeDepth(view(), TEXT(false), DEC_DEPTH, true); + break; + + case LFUN_DEPTH_PLUS: + disable = !changeDepth(view(), TEXT(false), INC_DEPTH, true); + break; + case LFUN_LAYOUT: case LFUN_LAYOUT_PARAGRAPH: { Inset * inset = TEXT(false)->cursor.par()->inInset(); @@ -369,21 +378,69 @@ FuncStatus LyXFunc::getStatus(FuncRequest const & ev) const break; } + case LFUN_INSET_OPTARG: + disable = (TEXT(false)->cursor.par()->layout()->optionalargs == 0); + break; + case LFUN_TABULAR_FEATURE: - disable = true; + if (mathcursor) { +#if 0 + // FIXME: check temporarily disabled + // valign code + char align = mathcursor->valign(); + if (align == '\0') { + disable = true; + break; + } + if (ev.argument.empty()) { + flag.clear(); + break; + } + if (!contains("tcb", ev.argument[0])) { + disable = true; + break; + } + flag.setOnOff(ev.argument[0] == align); + } else + disable = true; + + char align = mathcursor->halign(); + if (align == '\0') { + disable = true; + break; + } + if (ev.argument.empty()) { + flag.clear(); + break; + } + if (!contains("lcr", ev.argument[0])) { + disable = true; + break; + } + flag.setOnOff(ev.argument[0] == align); +#endif + + disable = !mathcursor->halign(); + break; + } + if (tli) { FuncStatus ret; //ret.disabled(true); if (tli->lyxCode() == Inset::TABULAR_CODE) { ret = static_cast(tli) ->getStatus(ev.argument); + flag |= ret; + disable = false; } else if (tli->getFirstLockingInsetOfType(Inset::TABULAR_CODE)) { ret = static_cast (tli->getFirstLockingInsetOfType(Inset::TABULAR_CODE)) ->getStatus(ev.argument); + flag |= ret; + disable = false; + } else { + disable = true; } - flag |= ret; - disable = false; } else { static InsetTabular inset(*owner->buffer(), 1, 1); FuncStatus ret; @@ -409,64 +466,75 @@ FuncStatus LyXFunc::getStatus(FuncRequest const & ev) const case LFUN_VC_HISTORY: disable = !buf->lyxvc.inUse(); break; + case LFUN_MENURELOAD: + disable = buf->isUnnamed() || buf->isClean(); + break; case LFUN_BOOKMARK_GOTO: - disable = !owner->view()-> + disable = !view()-> isSavedPosition(strToUnsignedInt(ev.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; + break; case LFUN_INSET_TOGGLE: { - LyXText * lt = owner->view()->getLyXText(); + LyXText * lt = view()->getLyXText(); disable = !(isEditableInset(lt->getInset()) || (lt->inset_owner && lt->inset_owner->owner() && lt->inset_owner->owner()->isOpen())); break; } - case LFUN_LATEX_LOG: - disable = !IsFileReadable(buf->getLogName().second); - break; - case LFUN_MATH_VALIGN: - if (mathcursor && mathcursor->formula()->hullType() != "simple") { - char align = mathcursor->valign(); - if (align == '\0') { - disable = true; + + case LFUN_INSET_SETTINGS: { + disable = true; + UpdatableInset * inset = view()->theLockingInset(); + + if (!inset) + break; + + // get the innermost inset + inset = inset->getLockingInset(); + + // jump back to owner if an InsetText, so + // we get back to the InsetTabular or whatever + if (inset->lyxCode() == Inset::TEXT_CODE) + inset = inset->owner(); + + Inset::Code code = inset->lyxCode(); + switch (code) { + case Inset::TABULAR_CODE: + disable = ev.argument != "tabular"; break; - } - if (ev.argument.empty()) { - flag.clear(); + case Inset::ERT_CODE: + disable = ev.argument != "ert"; break; - } - if (!contains("tcb", ev.argument[0])) { - disable = true; + case Inset::FLOAT_CODE: + disable = ev.argument != "float"; break; - } - flag.setOnOff(ev.argument[0] == align); - } else - disable = true; - break; - - case LFUN_MATH_HALIGN: - if (mathcursor && mathcursor->formula()->hullType() != "simple") { - char align = mathcursor->halign(); - if (align == '\0') { - disable = true; + case Inset::MINIPAGE_CODE: + disable = ev.argument != "minipage"; break; - } - if (ev.argument.empty()) { - flag.clear(); + case Inset::WRAP_CODE: + disable = ev.argument != "wrap"; break; - } - if (!contains("lcr", ev.argument[0])) { - disable = true; + default: break; - } - flag.setOnOff(ev.argument[0] == align); - } else - disable = true; + } + break; + } + + case LFUN_LATEX_LOG: + disable = !IsFileReadable(buf->getLogName().second); break; case LFUN_MATH_MUTATE: - if (tli && (tli->lyxCode() == Inset::MATH_CODE)) - flag.setOnOff(mathcursor->formula()->hullType() == ev.argument); + if (mathcursor) + //flag.setOnOff(mathcursor->formula()->hullType() == ev.argument); + flag.setOnOff(false); else disable = true; break; @@ -477,19 +545,10 @@ FuncStatus LyXFunc::getStatus(FuncRequest const & ev) const case LFUN_MATH_LIMITS: case LFUN_MATH_NONUMBER: case LFUN_MATH_NUMBER: + case LFUN_MATH_EXTERN: disable = !mathcursor; break; - // we need to be math mode and a math array for that - // Hack: halign produces non-zero result iff we are in a math array - case LFUN_MATH_ROW_INSERT: - case LFUN_MATH_ROW_DELETE: - case LFUN_MATH_COLUMN_INSERT: - case LFUN_MATH_COLUMN_DELETE: - disable = !mathcursor || !mathcursor->halign() || - mathcursor->formula()->hullType() == "simple"; - break; - default: break; } @@ -497,21 +556,48 @@ FuncStatus LyXFunc::getStatus(FuncRequest const & ev) const // the functions which insert insets Inset::Code code = Inset::NO_CODE; switch (ev.action) { + case LFUN_DIALOG_SHOW_NEW_INSET: + if (ev.argument == "bibitem") + code = Inset::BIBITEM_CODE; + else if (ev.argument == "bibtex") + code = Inset::BIBTEX_CODE; + else if (ev.argument == "citation") + code = Inset::CITE_CODE; + else if (ev.argument == "ert") + code = Inset::ERT_CODE; + else if (ev.argument == "external") + code = Inset::EXTERNAL_CODE; + else if (ev.argument == "float") + code = Inset::FLOAT_CODE; + else if (ev.argument == "graphics") + code = Inset::GRAPHICS_CODE; + else if (ev.argument == "include") + code = Inset::INCLUDE_CODE; + else if (ev.argument == "index") + code = Inset::INDEX_CODE; + else if (ev.argument == "label") + code = Inset::LABEL_CODE; + else if (ev.argument == "minipage") + code = Inset::MINIPAGE_CODE; + else if (ev.argument == "ref") + code = Inset::REF_CODE; + else if (ev.argument == "toc") + code = Inset::TOC_CODE; + else if (ev.argument == "url") + code = Inset::URL_CODE; + else if (ev.argument == "wrap") + code = Inset::WRAP_CODE; + break; + case LFUN_INSET_ERT: code = Inset::ERT_CODE; break; - case LFUN_INSET_GRAPHICS: - code = Inset::GRAPHICS_CODE; - break; case LFUN_INSET_FOOTNOTE: code = Inset::FOOT_CODE; break; case LFUN_TABULAR_INSERT: code = Inset::TABULAR_CODE; break; - case LFUN_INSET_EXTERNAL: - code = Inset::EXTERNAL_CODE; - break; case LFUN_INSET_MARGINAL: code = Inset::MARGIN_CODE; break; @@ -522,6 +608,9 @@ FuncStatus LyXFunc::getStatus(FuncRequest const & ev) const case LFUN_INSET_WIDE_FLOAT: code = Inset::FLOAT_CODE; break; + case LFUN_INSET_WRAP: + code = Inset::WRAP_CODE; + break; case LFUN_FLOAT_LIST: code = Inset::FLOAT_LIST_CODE; break; @@ -542,15 +631,11 @@ FuncStatus LyXFunc::getStatus(FuncRequest const & ev) const case LFUN_INSERT_LABEL: code = Inset::LABEL_CODE; break; - case LFUN_REF_INSERT: - code = Inset::REF_CODE; - break; - case LFUN_CITATION_CREATE: - case LFUN_CITATION_INSERT: - code = Inset::CITE_CODE; + case LFUN_INSET_OPTARG: + code = Inset::OPTARG_CODE; break; - case LFUN_INSERT_BIBTEX: - code = Inset::BIBTEX_CODE; + case LFUN_ENVIRONMENT_INSERT: + code = Inset::MINIPAGE_CODE; break; case LFUN_INDEX_INSERT: code = Inset::INDEX_CODE; @@ -558,18 +643,11 @@ FuncStatus LyXFunc::getStatus(FuncRequest const & ev) const case LFUN_INDEX_PRINT: code = Inset::INDEX_PRINT_CODE; break; - case LFUN_CHILD_INSERT: - code = Inset::INCLUDE_CODE; - break; case LFUN_TOC_INSERT: code = Inset::TOC_CODE; break; - case LFUN_PARENTINSERT: - code = Inset::PARENT_CODE; - break; case LFUN_HTMLURL: case LFUN_URL: - case LFUN_INSERT_URL: code = Inset::URL_CODE; break; case LFUN_QUOTE: @@ -584,17 +662,16 @@ FuncStatus LyXFunc::getStatus(FuncRequest const & ev) const case LFUN_END_OF_SENTENCE: code = Inset::SPECIALCHAR_CODE; break; - case LFUN_PROTECTEDSPACE: + case LFUN_SPACE_INSERT: // slight hack: we know this is allowed in math mode if (!mathcursor) - code = Inset::SPECIALCHAR_CODE; + code = Inset::SPACE_CODE; break; default: break; } - if (code != Inset::NO_CODE && tli && !tli->insetAllowed(code)) { + if (code != Inset::NO_CODE && tli && !tli->insetAllowed(code)) disable = true; - } if (disable) flag.disabled(true); @@ -602,7 +679,7 @@ FuncStatus LyXFunc::getStatus(FuncRequest const & ev) const // A few general toggles switch (ev.action) { case LFUN_TOOLTIPS_TOGGLE: - flag.setOnOff(owner->getDialogs()->tooltipsEnabled()); + flag.setOnOff(owner->getDialogs().tooltipsEnabled()); break; case LFUN_READ_ONLY_TOGGLE: @@ -617,6 +694,9 @@ FuncStatus LyXFunc::getStatus(FuncRequest const & ev) const if (ev.argument == buf->fileName()) flag.setOnOff(true); break; + case LFUN_TRACK_CHANGES: + flag.setOnOff(buf->params.tracking_changes); + break; default: break; } @@ -691,9 +771,7 @@ void LyXFunc::dispatch(string const & s, bool verbose) int const action = lyxaction.LookupFunc(s); if (action == LFUN_UNKNOWN_ACTION) { - string const msg = string(_("Unknown function (")) - + s + ")"; - owner->message(msg); + owner->message(bformat(_("Unknown function (%1$s)"), s)); return; } @@ -703,9 +781,7 @@ void LyXFunc::dispatch(string const & s, bool verbose) void LyXFunc::dispatch(int ac, bool verbose) { - string argument; - kb_action const action = lyxaction.retrieveActionArg(ac, argument); - dispatch(FuncRequest(action, argument), verbose); + dispatch(lyxaction.retrieveActionArg(ac), verbose); } @@ -713,7 +789,7 @@ void LyXFunc::dispatch(int ac, bool verbose) void LyXFunc::dispatch(FuncRequest const & ev, bool verbose) { lyxerr[Debug::ACTION] << "LyXFunc::dispatch: action[" << ev.action - <<"] arg[" << ev.argument << "]" << endl; + <<"] arg[" << ev.argument << ']' << endl; // we have not done anything wrong yet. errorstat = false; @@ -728,9 +804,6 @@ void LyXFunc::dispatch(FuncRequest const & ev, bool verbose) selection_possible = false; - if (owner->view()->available()) - owner->view()->hideCursor(); - string argument = ev.argument; kb_action action = ev.action; @@ -744,79 +817,96 @@ void LyXFunc::dispatch(FuncRequest const & ev, bool verbose) goto exit_with_message; } - if (owner->view()->available() && owner->view()->theLockingInset()) { - UpdatableInset::RESULT result; + if (view()->available()) + view()->hideCursor(); + + if (view()->available() && view()->theLockingInset()) { + Inset::RESULT result; if ((action > 1) || ((action == LFUN_UNKNOWN_ACTION) && (!keyseq.deleted()))) { - UpdatableInset * inset = owner->view()->theLockingInset(); + UpdatableInset * inset = view()->theLockingInset(); #if 1 int inset_x; int dummy_y; - inset->getCursorPos(owner->view().get(), inset_x, dummy_y); + inset->getCursorPos(view(), inset_x, dummy_y); #endif if ((action == LFUN_UNKNOWN_ACTION) && argument.empty()) { - argument = keyseq.getLastKeyEncoded(); + argument = encoded_last_key; + } + + // the insets can't try to handle this, + // a table cell in the dummy position will + // lock its insettext, the insettext will + // pass it the bufferview, and succeed, + // so it will stay not locked. Not good + // if we've just done LFUN_ESCAPE (which + // injects an LFUN_PARAGRAPH_UPDATE) + if (action == LFUN_PARAGRAPH_UPDATE) { + view()->dispatch(ev); + goto exit_with_message; } + // Undo/Redo is a bit tricky for insets. if (action == LFUN_UNDO) { - owner->view()->menuUndo(); + view()->undo(); goto exit_with_message; } else if (action == LFUN_REDO) { - owner->view()->menuRedo(); + view()->redo(); goto exit_with_message; } else if (((result=inset-> // Hand-over to inset's own dispatch: - localDispatch(owner->view().get(), FuncRequest(action, argument))) == - UpdatableInset::DISPATCHED) || - (result == UpdatableInset::DISPATCHED_NOUPDATE)) + localDispatch(FuncRequest(view(), action, argument))) == + DISPATCHED) || + (result == DISPATCHED_NOUPDATE)) goto exit_with_message; // If UNDISPATCHED, just soldier on - else if (result == UpdatableInset::FINISHED) { + else if (result == FINISHED) { + owner->clearMessage(); goto exit_with_message; // We do not need special RTL handling here: // FINISHED means that the cursor should be // one position after the inset. - } else if (result == UpdatableInset::FINISHED_RIGHT) { - TEXT()->cursorRight(owner->view().get()); + } else if (result == FINISHED_RIGHT) { + TEXT()->cursorRight(view()); moveCursorUpdate(true, false); - owner->view_state_changed(); + owner->clearMessage(); goto exit_with_message; - } else if (result == UpdatableInset::FINISHED_UP) { - if (TEXT()->cursor.irow()->previous()) { + } else if (result == FINISHED_UP) { + if (TEXT()->cursor.irow() != TEXT()->rows().begin()) { #if 1 TEXT()->setCursorFromCoordinates( - owner->view().get(), TEXT()->cursor.ix() + inset_x, + TEXT()->cursor.ix() + inset_x, TEXT()->cursor.iy() - TEXT()->cursor.irow()->baseline() - 1); TEXT()->cursor.x_fix(TEXT()->cursor.x()); #else - TEXT()->cursorUp(owner->view().get()); + TEXT()->cursorUp(view()); #endif moveCursorUpdate(true, false); - owner->view_state_changed(); } else { - owner->view()->update(TEXT(), BufferView::SELECT|BufferView::FITCUR); + view()->update(TEXT(), BufferView::SELECT); } + owner->clearMessage(); goto exit_with_message; - } else if (result == UpdatableInset::FINISHED_DOWN) { - if (TEXT()->cursor.irow()->next()) { + } else if (result == FINISHED_DOWN) { + if (boost::next(TEXT()->cursor.irow()) != TEXT()->rows().end()) { #if 1 TEXT()->setCursorFromCoordinates( - owner->view().get(), TEXT()->cursor.ix() + inset_x, + TEXT()->cursor.ix() + inset_x, TEXT()->cursor.iy() - TEXT()->cursor.irow()->baseline() + TEXT()->cursor.irow()->height() + 1); TEXT()->cursor.x_fix(TEXT()->cursor.x()); #else - TEXT()->cursorDown(owner->view().get()); + TEXT()->cursorDown(view()); #endif } else { - TEXT()->cursorRight(owner->view().get()); + TEXT()->cursorRight(view()); } moveCursorUpdate(true, false); - owner->view_state_changed(); + owner->clearMessage(); goto exit_with_message; } #warning I am not sure this is still right, please have a look! (Jug 20020417) @@ -826,29 +916,29 @@ void LyXFunc::dispatch(FuncRequest const & ev, bool verbose) case LFUN_UNKNOWN_ACTION: case LFUN_BREAKPARAGRAPH: case LFUN_BREAKLINE: - TEXT()->cursorRight(owner->view().get()); - owner->view()->switchKeyMap(); + TEXT()->cursorRight(view()); + view()->switchKeyMap(); owner->view_state_changed(); break; case LFUN_RIGHT: if (!TEXT()->cursor.par()->isRightToLeftPar(owner->buffer()->params)) { - TEXT()->cursorRight(owner->view().get()); + TEXT()->cursorRight(view()); moveCursorUpdate(true, false); owner->view_state_changed(); } goto exit_with_message; case LFUN_LEFT: if (TEXT()->cursor.par()->isRightToLeftPar(owner->buffer()->params)) { - TEXT()->cursorRight(owner->view().get()); + TEXT()->cursorRight(view()); moveCursorUpdate(true, false); owner->view_state_changed(); } goto exit_with_message; case LFUN_DOWN: - if (TEXT()->cursor.row()->next()) - TEXT()->cursorDown(owner->view().get()); + if (boost::next(TEXT()->cursor.row()) != TEXT()->rows().end()) + TEXT()->cursorDown(view()); else - TEXT()->cursorRight(owner->view().get()); + TEXT()->cursorRight(view()); moveCursorUpdate(true, false); owner->view_state_changed(); goto exit_with_message; @@ -863,26 +953,26 @@ void LyXFunc::dispatch(FuncRequest const & ev, bool verbose) case LFUN_ESCAPE: { - if (!owner->view()->available()) break; + if (!view()->available()) break; // this function should be used always [asierra060396] UpdatableInset * tli = - owner->view()->theLockingInset(); + view()->theLockingInset(); if (tli) { UpdatableInset * lock = tli->getLockingInset(); if (tli == lock) { - owner->view()->unlockInset(tli); - TEXT()->cursorRight(owner->view().get()); + view()->unlockInset(tli); + TEXT()->cursorRight(view()); moveCursorUpdate(true, false); owner->view_state_changed(); } else { - tli->unlockInsetInInset(owner->view().get(), + tli->unlockInsetInInset(view(), lock, true); } finishUndo(); // Tell the paragraph dialog that we changed paragraph - owner->getDialogs()->updateParagraph(); + dispatch(FuncRequest(LFUN_PARAGRAPH_UPDATE)); } } break; @@ -899,19 +989,17 @@ void LyXFunc::dispatch(FuncRequest const & ev, bool verbose) } else { searched_string = last_search; } - bool fw = (action == LFUN_WORDFINDBACKWARD); + bool fw = (action == LFUN_WORDFINDFORWARD); if (!searched_string.empty()) { - lyxfind::LyXFind(owner->view().get(), searched_string, fw); + lyxfind::LyXFind(view(), searched_string, fw); } -// owner->view()->showCursor(); } break; case LFUN_PREFIX: { - if (owner->view()->available() && !owner->view()->theLockingInset()) { - owner->view()->update(TEXT(), - BufferView::SELECT|BufferView::FITCUR); + if (view()->available() && !view()->theLockingInset()) { + view()->update(TEXT(), BufferView::SELECT); } owner->message(keyseq.printOptions()); } @@ -925,7 +1013,7 @@ void LyXFunc::dispatch(FuncRequest const & ev, bool verbose) case LFUN_CANCEL: // RVDK_PATCH_5 keyseq.reset(); meta_fake_bit = key_modifier::none; - if (owner->view()->available()) + if (view()->available()) // cancel any selection dispatch(LFUN_MARK_OFF); setMessage(N_("Cancel")); @@ -948,7 +1036,7 @@ void LyXFunc::dispatch(FuncRequest const & ev, bool verbose) break; case LFUN_CENTER: // this is center and redraw. - owner->view()->center(); + view()->center(); break; // --- Menus ----------------------------------------------- @@ -966,24 +1054,30 @@ void LyXFunc::dispatch(FuncRequest const & ev, bool verbose) case LFUN_MENUWRITE: if (!owner->buffer()->isUnnamed()) { - ostringstream s1; - s1 << _("Saving document") << ' ' - << MakeDisplayPath(owner->buffer()->fileName() + "..."); - owner->message(s1.str().c_str()); - MenuWrite(owner->view().get(), owner->buffer()); - s1 << _(" done."); - owner->message(s1.str().c_str()); + string const str = bformat(_("Saving document %1$s..."), + MakeDisplayPath(owner->buffer()->fileName())); + owner->message(str); + MenuWrite(owner->buffer()); + owner->message(str + _(" done.")); } else - WriteAs(owner->view().get(), owner->buffer()); + WriteAs(owner->buffer()); break; case LFUN_WRITEAS: - WriteAs(owner->view().get(), owner->buffer(), argument); + WriteAs(owner->buffer(), argument); break; - case LFUN_MENURELOAD: - reloadBuffer(); + 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); + int const ret = Alert::prompt(_("Revert to saved document?"), + text, 0, 1, _("&Revert"), _("&Cancel")); + + if (ret == 0) + view()->reload(); break; + } case LFUN_UPDATE: Exporter::Export(owner->buffer(), argument, true); @@ -998,16 +1092,16 @@ void LyXFunc::dispatch(FuncRequest const & ev, bool verbose) break; case LFUN_RUNCHKTEX: - MenuRunChktex(owner->buffer()); + owner->buffer()->runChktex(); break; case LFUN_MENUPRINT: - owner->getDialogs()->showPrint(); + owner->getDialogs().showPrint(); break; case LFUN_EXPORT: if (argument == "custom") - owner->getDialogs()->showSendto(); + owner->getDialogs().showSendto(); else Exporter::Export(owner->buffer(), argument, false); break; @@ -1021,80 +1115,61 @@ void LyXFunc::dispatch(FuncRequest const & ev, bool verbose) break; case LFUN_TOCVIEW: -#if 0 - case LFUN_LOFVIEW: - case LFUN_LOTVIEW: - case LFUN_LOAVIEW: -#endif { - InsetCommandParams p; - -#if 0 - if (action == LFUN_TOCVIEW) -#endif - p.setCmdName("tableofcontents"); -#if 0 - else if (action == LFUN_LOAVIEW) - p.setCmdName("listof{algorithm}{List of Algorithms}"); - else if (action == LFUN_LOFVIEW) - p.setCmdName("listoffigures"); - else - p.setCmdName("listoftables"); -#endif - owner->getDialogs()->createTOC(p.getAsString()); + InsetCommandParams p("tableofcontents"); + string const data = InsetCommandMailer::params2string("toc", p); + owner->getDialogs().show("toc", data, 0); break; } case LFUN_AUTOSAVE: - AutoSave(owner->view().get()); + AutoSave(view()); break; case LFUN_UNDO: - owner->view()->menuUndo(); + view()->undo(); break; case LFUN_REDO: - owner->view()->menuRedo(); + view()->redo(); break; case LFUN_MENUSEARCH: - owner->getDialogs()->showSearch(); - break; - - case LFUN_REMOVEERRORS: - if (owner->view()->removeAutoInsets()) { -#warning repaint() or update() or nothing ? - owner->view()->repaint(); - owner->view()->fitCursor(); - } + owner->getDialogs().showSearch(); break; case LFUN_DEPTH_MIN: - changeDepth(owner->view().get(), TEXT(false), -1); + changeDepth(view(), TEXT(false), DEC_DEPTH, false); + owner->view_state_changed(); break; case LFUN_DEPTH_PLUS: - changeDepth(owner->view().get(), TEXT(false), 1); + changeDepth(view(), TEXT(false), INC_DEPTH, false); + owner->view_state_changed(); + break; + + case LFUN_FREEFONT_APPLY: + apply_freefont(view()); break; - case LFUN_FREE: - owner->getDialogs()->setUserFreeFont(); + case LFUN_FREEFONT_UPDATE: + update_and_apply_freefont(view(), argument); break; case LFUN_RECONFIGURE: - Reconfigure(owner->view().get()); + Reconfigure(view()); break; #if 0 case LFUN_FLOATSOPERATE: if (argument == "openfoot") - owner->view()->allFloats(1,0); + view()->allFloats(1,0); else if (argument == "closefoot") - owner->view()->allFloats(0,0); + view()->allFloats(0,0); else if (argument == "openfig") - owner->view()->allFloats(1,1); + view()->allFloats(1,1); else if (argument == "closefig") - owner->view()->allFloats(0,1); + view()->allFloats(0,1); break; #else #ifdef WITH_WARNINGS @@ -1102,11 +1177,11 @@ void LyXFunc::dispatch(FuncRequest const & ev, bool verbose) #endif #endif case LFUN_HELP_ABOUTLYX: - owner->getDialogs()->showAboutlyx(); + owner->getDialogs().show("about"); break; case LFUN_HELP_TEXINFO: - owner->getDialogs()->showTexinfo(); + owner->getDialogs().showTexinfo(); break; case LFUN_HELP_OPEN: @@ -1116,20 +1191,15 @@ void LyXFunc::dispatch(FuncRequest const & ev, bool verbose) setErrorMessage(N_("Missing argument")); break; } - owner->prohibitInput(); string const fname = i18nLibFileSearch("doc", arg, "lyx"); if (fname.empty()) { lyxerr << "LyX: unable to find documentation file `" << arg << "'. Bad installation?" << endl; - owner->allowInput(); break; } - ostringstream str; - str << _("Opening help file") << ' ' - << MakeDisplayPath(fname) << "..."; - owner->message(str.str().c_str()); - owner->view()->buffer(bufferlist.loadLyXFile(fname, false)); - owner->allowInput(); + owner->message(bformat(_("Opening help file %1$s..."), + MakeDisplayPath(fname))); + view()->buffer(bufferlist.loadLyXFile(fname, false)); break; } @@ -1171,14 +1241,14 @@ void LyXFunc::dispatch(FuncRequest const & ev, bool verbose) case LFUN_VC_HISTORY: { - owner->getDialogs()->showVCLogFile(); + owner->getDialogs().show("vclog"); break; } // --- buffers ---------------------------------------- case LFUN_SWITCHBUFFER: - owner->view()->buffer(bufferlist.getBuffer(argument)); + view()->buffer(bufferlist.getBuffer(argument)); break; case LFUN_FILE_NEW: @@ -1186,7 +1256,7 @@ void LyXFunc::dispatch(FuncRequest const & ev, bool verbose) // servercmd: argument must be :