X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Flyxfunc.C;h=750d2c210026a8141f171e64645863c7ff3902b0;hb=c544107e324090c6eafb4c56749da2624b9b1122;hp=319f418e4a9209c63230ce1e84ad720e513978e2;hpb=00efea79702404ee13d1dd593aabeb72897cfb61;p=lyx.git diff --git a/src/lyxfunc.C b/src/lyxfunc.C index 319f418e4a..750d2c2100 100644 --- a/src/lyxfunc.C +++ b/src/lyxfunc.C @@ -10,15 +10,13 @@ #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 "buffer_funcs.h" #include "BufferView.h" #include "lyxserver.h" #include "intl.h" @@ -31,13 +29,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" @@ -46,6 +45,7 @@ #include "ParagraphParameters.h" #include "insets/insetcommand.h" +#include "insets/insetexternal.h" #include "insets/insettabular.h" #include "mathed/formulamacro.h" @@ -66,11 +66,11 @@ #include "support/FileInfo.h" #include "support/forkedcontr.h" #include "support/lstrings.h" +#include "support/tostr.h" #include "support/path.h" +#include "support/path_defines.h" #include "support/lyxfunctional.h" -#include "BoostFormat.h" - #include #include #include @@ -79,6 +79,8 @@ #include #include +using namespace lyx::support; + using std::pair; using std::make_pair; using std::endl; @@ -86,6 +88,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; @@ -101,6 +104,7 @@ extern void ShowLatexLog(); 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()), meta_fake_bit(key_modifier::none) @@ -108,47 +112,32 @@ LyXFunc::LyXFunc(LyXView * o) } -inline -LyXText * LyXFunc::TEXT(bool flag = true) const -{ - if (flag) - return view()->text; - return view()->getLyXText(); -} - - -inline -void LyXFunc::moveCursorUpdate(bool flag, bool selecting) +void LyXFunc::moveCursorUpdate() { - if (selecting || TEXT(flag)->selection.mark()) { - TEXT(flag)->setSelection(view()); - if (TEXT(flag)->bv_owner) - view()->toggleToggle(); - } - view()->update(TEXT(flag), BufferView::SELECT|BufferView::FITCUR); - view()->showCursor(); - + LyXText * lt = view()->text; + if (lt->selection.mark()) + lt->setSelection(); + view()->update(); 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() - .deadkey(c, get_accent(action).accent, TEXT(false)); + .deadkey(c, get_accent(action).accent, view()->getLyXText()); // Need to clear, in case the minibuffer calls these // actions keyseq.clear(); // copied verbatim from do_accent_char - view()->update(TEXT(false), - BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE); - TEXT(false)->selection.cursor = TEXT(false)->cursor; + view()->update(); + view()->getLyXText()->selection.cursor = view()->getLyXText()->cursor; } @@ -171,15 +160,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); - lyxerr[Debug::KEY] << "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. @@ -188,7 +182,7 @@ 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. @@ -202,7 +196,7 @@ void LyXFunc::processKeySym(LyXKeySymPtr keysym, if (lyxerr.debugging(Debug::KEY)) { lyxerr << "Key [action=" << action << "][" - << keyseq.print() << "]" + << keyseq.print() << ']' << endl; } @@ -214,31 +208,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) - action = keyseq.addkey(keysym, key_modifier::none); - lyxerr[Debug::KEY] << "Removing modifiers...\n" - << "Action now set to [" - << action << "]" << endl; + // 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; + } - 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(view(), LFUN_SELFINSERT, argument)); - lyxerr[Debug::KEY] << "SelfInsert arg[`" + lyxerr[Debug::KEY] << "SelfInsert arg[`" << argument << "']" << endl; + } } else { dispatch(action); } @@ -261,9 +263,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 @@ -296,13 +309,9 @@ FuncStatus LyXFunc::getStatus(FuncRequest const & ev) const // encode this in the function itself. bool disable = false; switch (ev.action) { - case LFUN_MENUPRINT: - disable = !Exporter::IsExportable(buf, "dvi") - || 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(); @@ -312,46 +321,48 @@ FuncStatus LyXFunc::getStatus(FuncRequest const & ev) const break; case LFUN_CUT: case LFUN_COPY: - if (tli && tli->lyxCode() == Inset::TABULAR_CODE) { - InsetTabular * t(static_cast(tli)); - if (t->hasSelection()) { + if (tli) { + UpdatableInset * in = tli; + if (in->lyxCode() != InsetOld::TABULAR_CODE) { + in = tli->getFirstLockingInsetOfType(InsetOld::TABULAR_CODE); + } + if (in && static_cast(in)->hasSelection()) { disable = false; break; } } disable = !mathcursor && !view()->getLyXText()->selection.set(); break; -#ifndef HAVE_LIBAIKSAURUS - case LFUN_THESAURUS_ENTRY: - disable = true; - 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"); break; - case LFUN_LAYOUT_CHARACTER: - disable = tli && tli->lyxCode() == Inset::ERT_CODE; - break; - case LFUN_LAYOUT_TABULAR: disable = !tli - || (tli->lyxCode() != Inset::TABULAR_CODE - && !tli->getFirstLockingInsetOfType(Inset::TABULAR_CODE)); + || (tli->lyxCode() != InsetOld::TABULAR_CODE + && !tli->getFirstLockingInsetOfType(InsetOld::TABULAR_CODE)); + break; + + case LFUN_DEPTH_MIN: + disable = !changeDepth(view(), view()->getLyXText(), DEC_DEPTH, true); + break; + + case LFUN_DEPTH_PLUS: + disable = !changeDepth(view(), view()->getLyXText(), INC_DEPTH, true); break; case LFUN_LAYOUT: case LFUN_LAYOUT_PARAGRAPH: { - Inset * inset = TEXT(false)->cursor.par()->inInset(); + InsetOld * inset = view()->getLyXText()->cursor.par()->inInset(); disable = inset && inset->forceDefaultParagraphs(inset); break; } case LFUN_INSET_OPTARG: - disable = (TEXT(false)->cursor.par()->layout()->optionalargs == 0); + disable = (view()->getLyXText()->cursor.par()->layout()->optionalargs == 0); break; case LFUN_TABULAR_FEATURE: @@ -399,16 +410,20 @@ FuncStatus LyXFunc::getStatus(FuncRequest const & ev) const if (tli) { FuncStatus ret; //ret.disabled(true); - if (tli->lyxCode() == Inset::TABULAR_CODE) { + if (tli->lyxCode() == InsetOld::TABULAR_CODE) { ret = static_cast(tli) ->getStatus(ev.argument); - } else if (tli->getFirstLockingInsetOfType(Inset::TABULAR_CODE)) { + flag |= ret; + disable = false; + } else if (tli->getFirstLockingInsetOfType(InsetOld::TABULAR_CODE)) { ret = static_cast - (tli->getFirstLockingInsetOfType(Inset::TABULAR_CODE)) + (tli->getFirstLockingInsetOfType(InsetOld::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; @@ -431,13 +446,22 @@ FuncStatus LyXFunc::getStatus(FuncRequest const & ev) const break; case LFUN_VC_REVERT: case LFUN_VC_UNDO: - case LFUN_VC_HISTORY: disable = !buf->lyxvc.inUse(); break; + case LFUN_MENURELOAD: + disable = buf->isUnnamed() || buf->isClean(); + break; case LFUN_BOOKMARK_GOTO: 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 = view()->getLyXText(); disable = !(isEditableInset(lt->getInset()) @@ -446,9 +470,47 @@ FuncStatus LyXFunc::getStatus(FuncRequest const & ev) const && lt->inset_owner->owner()->isOpen())); break; } - case LFUN_LATEX_LOG: - disable = !IsFileReadable(buf->getLogName().second); + + 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() == InsetOld::TEXT_CODE) + inset = inset->owner(); + + InsetOld::Code code = inset->lyxCode(); + switch (code) { + case InsetOld::TABULAR_CODE: + disable = ev.argument != "tabular"; + break; + case InsetOld::ERT_CODE: + disable = ev.argument != "ert"; + break; + case InsetOld::FLOAT_CODE: + disable = ev.argument != "float"; + break; + case InsetOld::MINIPAGE_CODE: + disable = ev.argument != "minipage"; + break; + case InsetOld::WRAP_CODE: + disable = ev.argument != "wrap"; + break; + case InsetOld::NOTE_CODE: + disable = ev.argument != "note"; + break; + default: + break; + } break; + } case LFUN_MATH_MUTATE: if (mathcursor) @@ -468,93 +530,131 @@ FuncStatus LyXFunc::getStatus(FuncRequest const & ev) const disable = !mathcursor; break; + case LFUN_DIALOG_SHOW: { + string const name = ev.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") { + UpdatableInset * tli = view()->theLockingInset(); + disable = tli && tli->lyxCode() == InsetOld::ERT_CODE; + } else if (name == "vclog") { + disable = !buf->lyxvc.inUse(); + } else if (name == "latexlog") { + disable = !IsFileReadable(buf->getLogName().second); + } + break; + } + default: break; } // the functions which insert insets - Inset::Code code = Inset::NO_CODE; + InsetOld::Code code = InsetOld::NO_CODE; switch (ev.action) { - case LFUN_INSET_ERT: - code = Inset::ERT_CODE; + case LFUN_DIALOG_SHOW_NEW_INSET: + if (ev.argument == "bibitem") + code = InsetOld::BIBITEM_CODE; + else if (ev.argument == "bibtex") + code = InsetOld::BIBTEX_CODE; + else if (ev.argument == "citation") + code = InsetOld::CITE_CODE; + else if (ev.argument == "ert") + code = InsetOld::ERT_CODE; + else if (ev.argument == "external") + code = InsetOld::EXTERNAL_CODE; + else if (ev.argument == "float") + code = InsetOld::FLOAT_CODE; + else if (ev.argument == "graphics") + code = InsetOld::GRAPHICS_CODE; + else if (ev.argument == "include") + code = InsetOld::INCLUDE_CODE; + else if (ev.argument == "index") + code = InsetOld::INDEX_CODE; + else if (ev.argument == "label") + code = InsetOld::LABEL_CODE; + else if (ev.argument == "minipage") + code = InsetOld::MINIPAGE_CODE; + else if (ev.argument == "ref") + code = InsetOld::REF_CODE; + else if (ev.argument == "toc") + code = InsetOld::TOC_CODE; + else if (ev.argument == "url") + code = InsetOld::URL_CODE; + else if (ev.argument == "wrap") + code = InsetOld::WRAP_CODE; break; - case LFUN_INSET_GRAPHICS: - code = Inset::GRAPHICS_CODE; + + case LFUN_INSET_ERT: + code = InsetOld::ERT_CODE; break; case LFUN_INSET_FOOTNOTE: - code = Inset::FOOT_CODE; + code = InsetOld::FOOT_CODE; break; case LFUN_TABULAR_INSERT: - code = Inset::TABULAR_CODE; - break; - case LFUN_INSET_EXTERNAL: - code = Inset::EXTERNAL_CODE; + code = InsetOld::TABULAR_CODE; break; case LFUN_INSET_MARGINAL: - code = Inset::MARGIN_CODE; + code = InsetOld::MARGIN_CODE; break; case LFUN_INSET_MINIPAGE: - code = Inset::MINIPAGE_CODE; + code = InsetOld::MINIPAGE_CODE; break; case LFUN_INSET_FLOAT: case LFUN_INSET_WIDE_FLOAT: - code = Inset::FLOAT_CODE; + code = InsetOld::FLOAT_CODE; break; case LFUN_INSET_WRAP: - code = Inset::WRAP_CODE; + code = InsetOld::WRAP_CODE; break; case LFUN_FLOAT_LIST: - code = Inset::FLOAT_LIST_CODE; + code = InsetOld::FLOAT_LIST_CODE; break; #if 0 case LFUN_INSET_LIST: - code = Inset::LIST_CODE; + code = InsetOld::LIST_CODE; break; case LFUN_INSET_THEOREM: - code = Inset::THEOREM_CODE; + code = InsetOld::THEOREM_CODE; break; #endif case LFUN_INSET_CAPTION: - code = Inset::CAPTION_CODE; + code = InsetOld::CAPTION_CODE; break; case LFUN_INSERT_NOTE: - code = Inset::NOTE_CODE; + code = InsetOld::NOTE_CODE; break; case LFUN_INSERT_LABEL: - code = Inset::LABEL_CODE; + code = InsetOld::LABEL_CODE; break; case LFUN_INSET_OPTARG: - code = Inset::OPTARG_CODE; - break; - case LFUN_REF_INSERT: - code = Inset::REF_CODE; + code = InsetOld::OPTARG_CODE; break; - case LFUN_CITATION_CREATE: - case LFUN_CITATION_INSERT: - code = Inset::CITE_CODE; - break; - case LFUN_INSERT_BIBTEX: - code = Inset::BIBTEX_CODE; + case LFUN_ENVIRONMENT_INSERT: + code = InsetOld::MINIPAGE_CODE; break; case LFUN_INDEX_INSERT: - code = Inset::INDEX_CODE; + code = InsetOld::INDEX_CODE; break; case LFUN_INDEX_PRINT: - code = Inset::INDEX_PRINT_CODE; - break; - case LFUN_CHILD_INSERT: - code = Inset::INCLUDE_CODE; + code = InsetOld::INDEX_PRINT_CODE; break; case LFUN_TOC_INSERT: - code = Inset::TOC_CODE; - break; - case LFUN_PARENTINSERT: - code = Inset::PARENT_CODE; + code = InsetOld::TOC_CODE; break; case LFUN_HTMLURL: case LFUN_URL: - case LFUN_INSERT_URL: - code = Inset::URL_CODE; + code = InsetOld::URL_CODE; break; case LFUN_QUOTE: // always allow this, since we will inset a raw quote @@ -566,17 +666,17 @@ FuncStatus LyXFunc::getStatus(FuncRequest const & ev) const case LFUN_MENU_SEPARATOR: case LFUN_LDOTS: case LFUN_END_OF_SENTENCE: - code = Inset::SPECIALCHAR_CODE; + code = InsetOld::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 = InsetOld::SPACE_CODE; break; default: break; } - if (code != Inset::NO_CODE && tli && !tli->insetAllowed(code)) + if (code != InsetOld::NO_CODE && tli && !tli->insetAllowed(code)) disable = true; if (disable) @@ -592,7 +692,7 @@ FuncStatus LyXFunc::getStatus(FuncRequest const & ev) const flag.setOnOff(buf->isReadonly()); break; case LFUN_APPENDIX: - flag.setOnOff(TEXT(false)->cursor.par()->params().startOfAppendix()); + flag.setOnOff(view()->getLyXText()->cursor.par()->params().startOfAppendix()); break; case LFUN_SWITCHBUFFER: // toggle on the current buffer, but do not toggle off @@ -600,13 +700,16 @@ 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; } // the font related toggles if (!mathcursor) { - LyXFont const & font = TEXT(false)->real_current_font; + LyXFont const & font = view()->getLyXText()->real_current_font; switch (ev.action) { case LFUN_EMPH: flag.setOnOff(font.emph() == LyXFont::ON); @@ -674,9 +777,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; } @@ -689,12 +790,34 @@ void LyXFunc::dispatch(int ac, bool verbose) dispatch(lyxaction.retrieveActionArg(ac), verbose); } +namespace { + bool 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); + int const ret = Alert::prompt(_("Save changed document?"), + text, 0, 1, _("&Save"), + _("&Cancel")); + + if (ret == 0) + bv->owner()->dispatch(FuncRequest(LFUN_MENUWRITE)); + + return buf.isClean(); + } + +} //namespace anon 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; @@ -709,9 +832,6 @@ void LyXFunc::dispatch(FuncRequest const & ev, bool verbose) selection_possible = false; - if (view()->available()) - view()->hideCursor(); - string argument = ev.argument; kb_action action = ev.action; @@ -725,10 +845,13 @@ void LyXFunc::dispatch(FuncRequest const & ev, bool verbose) goto exit_with_message; } + if (view()->available()) + view()->hideCursor(); + if (view()->available() && view()->theLockingInset()) { - Inset::RESULT result; - if ((action > 1) || ((action == LFUN_UNKNOWN_ACTION) && - (!keyseq.deleted()))) + InsetOld::RESULT result; + if (action > 1 || (action == LFUN_UNKNOWN_ACTION && + !keyseq.deleted())) { UpdatableInset * inset = view()->theLockingInset(); #if 1 @@ -738,8 +861,21 @@ void LyXFunc::dispatch(FuncRequest const & ev, bool verbose) #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) { view()->undo(); @@ -750,54 +886,57 @@ void LyXFunc::dispatch(FuncRequest const & ev, bool verbose) } else if (((result=inset-> // Hand-over to inset's own dispatch: localDispatch(FuncRequest(view(), action, argument))) == - UpdatableInset::DISPATCHED) || - (result == UpdatableInset::DISPATCHED_NOUPDATE)) + 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(view()); - moveCursorUpdate(true, false); - owner->view_state_changed(); + } else if (result == FINISHED_RIGHT) { + view()->text->cursorRight(view()); + moveCursorUpdate(); + owner->clearMessage(); goto exit_with_message; - } else if (result == UpdatableInset::FINISHED_UP) { - if (TEXT()->cursor.irow()->previous()) { + } else if (result == FINISHED_UP) { + RowList::iterator const irow = view()->text->cursorIRow(); + if (irow != view()->text->rows().begin()) { #if 1 - TEXT()->setCursorFromCoordinates( - view(), TEXT()->cursor.ix() + inset_x, - TEXT()->cursor.iy() - - TEXT()->cursor.irow()->baseline() - 1); - TEXT()->cursor.x_fix(TEXT()->cursor.x()); + view()->text->setCursorFromCoordinates( + view()->text->cursor.ix() + inset_x, + view()->text->cursor.iy() - + irow->baseline() - 1); + view()->text->cursor.x_fix(view()->text->cursor.x()); #else - TEXT()->cursorUp(view()); + view()->text->cursorUp(view()); #endif - moveCursorUpdate(true, false); - owner->view_state_changed(); + moveCursorUpdate(); } else { - view()->update(TEXT(), BufferView::SELECT|BufferView::FITCUR); + view()->update(); } + owner->clearMessage(); goto exit_with_message; - } else if (result == UpdatableInset::FINISHED_DOWN) { - if (TEXT()->cursor.irow()->next()) { + } else if (result == FINISHED_DOWN) { + RowList::iterator const irow = view()->text->cursorIRow(); + if (boost::next(irow) != view()->text->rows().end()) { #if 1 - TEXT()->setCursorFromCoordinates( - view(), TEXT()->cursor.ix() + inset_x, - TEXT()->cursor.iy() - - TEXT()->cursor.irow()->baseline() + - TEXT()->cursor.irow()->height() + 1); - TEXT()->cursor.x_fix(TEXT()->cursor.x()); + view()->text->setCursorFromCoordinates( + view()->text->cursor.ix() + inset_x, + view()->text->cursor.iy() - + irow->baseline() + + irow->height() + 1); + view()->text->cursor.x_fix(view()->text->cursor.x()); #else - TEXT()->cursorDown(view()); + view()->text->cursorDown(view()); #endif } else { - TEXT()->cursorRight(view()); + view()->text->cursorRight(view()); } - moveCursorUpdate(true, false); - owner->view_state_changed(); + moveCursorUpdate(); + owner->clearMessage(); goto exit_with_message; } #warning I am not sure this is still right, please have a look! (Jug 20020417) @@ -807,30 +946,30 @@ void LyXFunc::dispatch(FuncRequest const & ev, bool verbose) case LFUN_UNKNOWN_ACTION: case LFUN_BREAKPARAGRAPH: case LFUN_BREAKLINE: - TEXT()->cursorRight(view()); + view()->text->cursorRight(view()); view()->switchKeyMap(); owner->view_state_changed(); break; case LFUN_RIGHT: - if (!TEXT()->cursor.par()->isRightToLeftPar(owner->buffer()->params)) { - TEXT()->cursorRight(view()); - moveCursorUpdate(true, false); + if (!view()->text->cursor.par()->isRightToLeftPar(owner->buffer()->params)) { + view()->text->cursorRight(view()); + moveCursorUpdate(); owner->view_state_changed(); } goto exit_with_message; case LFUN_LEFT: - if (TEXT()->cursor.par()->isRightToLeftPar(owner->buffer()->params)) { - TEXT()->cursorRight(view()); - moveCursorUpdate(true, false); + if (view()->text->cursor.par()->isRightToLeftPar(owner->buffer()->params)) { + view()->text->cursorRight(view()); + moveCursorUpdate(); owner->view_state_changed(); } goto exit_with_message; case LFUN_DOWN: - if (TEXT()->cursor.row()->next()) - TEXT()->cursorDown(view()); + if (boost::next(view()->text->cursorRow()) != view()->text->rows().end()) + view()->text->cursorDown(view()); else - TEXT()->cursorRight(view()); - moveCursorUpdate(true, false); + view()->text->cursorRight(view()); + moveCursorUpdate(); owner->view_state_changed(); goto exit_with_message; default: @@ -842,35 +981,31 @@ void LyXFunc::dispatch(FuncRequest const & ev, bool verbose) switch (action) { - case LFUN_ESCAPE: - { - if (!view()->available()) break; + case LFUN_ESCAPE: { + if (!view()->available()) + break; // this function should be used always [asierra060396] - UpdatableInset * tli = - view()->theLockingInset(); + UpdatableInset * tli = view()->theLockingInset(); if (tli) { UpdatableInset * lock = tli->getLockingInset(); if (tli == lock) { view()->unlockInset(tli); - TEXT()->cursorRight(view()); - moveCursorUpdate(true, false); + view()->text->cursorRight(view()); + moveCursorUpdate(); owner->view_state_changed(); } else { - tli->unlockInsetInInset(view(), - lock, - true); + tli->unlockInsetInInset(view(), lock, true); } finishUndo(); // Tell the paragraph dialog that we changed paragraph - owner->getDialogs().updateParagraph(); + dispatch(FuncRequest(LFUN_PARAGRAPH_UPDATE)); } + break; } - break; - // --- Misc ------------------------------------------- - case LFUN_WORDFINDFORWARD : - case LFUN_WORDFINDBACKWARD : { + case LFUN_WORDFINDFORWARD: + case LFUN_WORDFINDBACKWARD: { static string last_search; string searched_string; @@ -880,30 +1015,24 @@ void LyXFunc::dispatch(FuncRequest const & ev, bool verbose) } else { searched_string = last_search; } - bool fw = (action == LFUN_WORDFINDBACKWARD); - if (!searched_string.empty()) { - lyxfind::LyXFind(view(), searched_string, fw); - } -// view()->showCursor(); + bool fw = (action == LFUN_WORDFINDFORWARD); + if (!searched_string.empty()) + lyx::find::find(view(), searched_string, fw); + break; } - break; case LFUN_PREFIX: - { - if (view()->available() && !view()->theLockingInset()) { - view()->update(TEXT(), - BufferView::SELECT|BufferView::FITCUR); - } + if (view()->available() && !view()->theLockingInset()) + view()->update(); owner->message(keyseq.printOptions()); - } - break; + break; // --- Misc ------------------------------------------- case LFUN_EXEC_COMMAND: owner->focus_command_buffer(); break; - case LFUN_CANCEL: // RVDK_PATCH_5 + case LFUN_CANCEL: keyseq.reset(); meta_fake_bit = key_modifier::none; if (view()->available()) @@ -912,20 +1041,17 @@ void LyXFunc::dispatch(FuncRequest const & ev, bool verbose) setMessage(N_("Cancel")); break; - case LFUN_META_FAKE: // RVDK_PATCH_5 - { + case LFUN_META_FAKE: meta_fake_bit = key_modifier::alt; setMessage(keyseq.print()); - } - break; + break; case LFUN_READ_ONLY_TOGGLE: - if (owner->buffer()->lyxvc.inUse()) { + if (owner->buffer()->lyxvc.inUse()) owner->buffer()->lyxvc.toggleReadOnly(); - } else { + else owner->buffer()->setReadonly( !owner->buffer()->isReadonly()); - } break; case LFUN_CENTER: // this is center and redraw. @@ -947,56 +1073,58 @@ void LyXFunc::dispatch(FuncRequest const & ev, bool verbose) case LFUN_MENUWRITE: if (!owner->buffer()->isUnnamed()) { - ostringstream s1; -#if USE_BOOST_FORMAT - s1 << boost::format(_("Saving document %1$s...")) - % MakeDisplayPath(owner->buffer()->fileName()); -#else - s1 << _("Saving document ") - << MakeDisplayPath(owner->buffer()->fileName()) - << _("..."); -#endif - owner->message(STRCONV(s1.str())); - MenuWrite(view(), owner->buffer()); - s1 << _(" done."); - owner->message(STRCONV(s1.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(view(), owner->buffer()); + WriteAs(owner->buffer()); break; case LFUN_WRITEAS: - WriteAs(view(), 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); + view()->showErrorList(BufferFormat(*owner->buffer())); break; case LFUN_PREVIEW: Exporter::Preview(owner->buffer(), argument); + view()->showErrorList(BufferFormat(*owner->buffer())); break; case LFUN_BUILDPROG: Exporter::Export(owner->buffer(), "program", true); + view()->showErrorList(_("Build")); break; case LFUN_RUNCHKTEX: - MenuRunChktex(owner->buffer()); - break; - - case LFUN_MENUPRINT: - owner->getDialogs().showPrint(); + owner->buffer()->runChktex(); + view()->showErrorList(_("ChkTeX")); break; case LFUN_EXPORT: if (argument == "custom") owner->getDialogs().showSendto(); - else + else { Exporter::Export(owner->buffer(), argument, false); + view()->showErrorList(BufferFormat(*owner->buffer())); + } break; case LFUN_IMPORT: @@ -1008,27 +1136,10 @@ 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; } @@ -1044,28 +1155,22 @@ void LyXFunc::dispatch(FuncRequest const & ev, bool verbose) view()->redo(); break; - case LFUN_MENUSEARCH: - owner->getDialogs().showSearch(); - break; - - case LFUN_REMOVEERRORS: - if (view()->removeAutoInsets()) { -#warning repaint() or update() or nothing ? - view()->repaint(); - view()->fitCursor(); - } - break; - case LFUN_DEPTH_MIN: - changeDepth(view(), TEXT(false), -1); + changeDepth(view(), view()->getLyXText(), DEC_DEPTH, false); + owner->view_state_changed(); break; case LFUN_DEPTH_PLUS: - changeDepth(view(), TEXT(false), 1); + changeDepth(view(), view()->getLyXText(), INC_DEPTH, false); + owner->view_state_changed(); break; - case LFUN_FREE: - owner->getDialogs().setUserFreeFont(); + case LFUN_FREEFONT_APPLY: + apply_freefont(view()); + break; + + case LFUN_FREEFONT_UPDATE: + update_and_apply_freefont(view(), argument); break; case LFUN_RECONFIGURE: @@ -1088,14 +1193,6 @@ void LyXFunc::dispatch(FuncRequest const & ev, bool verbose) //#warning Find another implementation here (or another lyxfunc)! #endif #endif - case LFUN_HELP_ABOUTLYX: - owner->getDialogs().showAboutlyx(); - break; - - case LFUN_HELP_TEXINFO: - owner->getDialogs().showTexinfo(); - break; - case LFUN_HELP_OPEN: { string const arg = argument; @@ -1103,70 +1200,68 @@ 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; -#if USE_BOOST_FORMAT - str << boost::format(_("Opening help file %1$s...")) - % MakeDisplayPath(fname); -#else - str << _("Opening help file ") - << MakeDisplayPath(fname) << _("..."); -#endif - owner->message(STRCONV(str.str())); - view()->buffer(bufferlist.loadLyXFile(fname, false)); - owner->allowInput(); + owner->message(bformat(_("Opening help file %1$s..."), + MakeDisplayPath(fname))); + view()->loadLyXFile(fname, false); break; } // --- version control ------------------------------- case LFUN_VC_REGISTER: { - if (!owner->buffer()->lyxvc.inUse()) + if (!ensureBufferClean(view())) + break; + if (!owner->buffer()->lyxvc.inUse()) { owner->buffer()->lyxvc.registrer(); + view()->reload(); + } } break; case LFUN_VC_CHECKIN: { + if (!ensureBufferClean(view())) + break; if (owner->buffer()->lyxvc.inUse() - && !owner->buffer()->isReadonly()) + && !owner->buffer()->isReadonly()) { owner->buffer()->lyxvc.checkIn(); + view()->reload(); + } } break; case LFUN_VC_CHECKOUT: { + if (!ensureBufferClean(view())) + break; if (owner->buffer()->lyxvc.inUse() - && owner->buffer()->isReadonly()) + && owner->buffer()->isReadonly()) { owner->buffer()->lyxvc.checkOut(); + view()->reload(); + } } break; case LFUN_VC_REVERT: { owner->buffer()->lyxvc.revert(); + view()->reload(); } break; case LFUN_VC_UNDO: { owner->buffer()->lyxvc.undoLast(); + view()->reload(); } break; - case LFUN_VC_HISTORY: - { - owner->getDialogs().showVCLogFile(); - break; - } - // --- buffers ---------------------------------------- case LFUN_SWITCHBUFFER: @@ -1174,53 +1269,28 @@ void LyXFunc::dispatch(FuncRequest const & ev, bool verbose) break; case LFUN_FILE_NEW: - { - // servercmd: argument must be :