X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FText3.cpp;h=adeb80b88f15ec737c699a0d305d6cd71683f8b2;hb=ce2e1554908785d7accba292985017fb961b1450;hp=af69c654e79311a7cce1254a5862a778ac506cb5;hpb=2a257eca856b107d814543f5fa9905b791ed6805;p=lyx.git diff --git a/src/Text3.cpp b/src/Text3.cpp index af69c654e7..adeb80b88f 100644 --- a/src/Text3.cpp +++ b/src/Text3.cpp @@ -17,7 +17,6 @@ #include "Text.h" -#include "Bidi.h" #include "BranchList.h" #include "FloatList.h" #include "FuncStatus.h" @@ -37,26 +36,31 @@ #include "Language.h" #include "Layout.h" #include "LyXAction.h" -#include "LyXFunc.h" +#include "LyX.h" #include "Lexer.h" #include "LyXRC.h" #include "Paragraph.h" #include "ParagraphParameters.h" +#include "SpellChecker.h" #include "TextClass.h" #include "TextMetrics.h" -#include "VSpace.h" +#include "Thesaurus.h" +#include "WordLangTuple.h" +#include "frontends/alert.h" #include "frontends/Application.h" #include "frontends/Clipboard.h" #include "frontends/Selection.h" -#include "insets/InsetCollapsable.h" +#include "insets/InsetArgument.h" +#include "insets/InsetCollapsible.h" #include "insets/InsetCommand.h" #include "insets/InsetExternal.h" #include "insets/InsetFloat.h" #include "insets/InsetFloatList.h" #include "insets/InsetGraphics.h" #include "insets/InsetGraphicsParams.h" +#include "insets/InsetIPAMacro.h" #include "insets/InsetNewline.h" #include "insets/InsetQuotes.h" #include "insets/InsetSpecialChar.h" @@ -66,14 +70,15 @@ #include "support/convert.h" #include "support/debug.h" #include "support/gettext.h" +#include "support/lassert.h" #include "support/lstrings.h" +#include "support/lyxalgo.h" #include "support/lyxtime.h" #include "support/os.h" +#include "support/regex.h" #include "mathed/InsetMathHull.h" -#include "mathed/MathMacroTemplate.h" - -#include +#include "mathed/InsetMathMacroTemplate.h" #include #include @@ -85,12 +90,16 @@ namespace lyx { using cap::copySelection; using cap::cutSelection; +using cap::cutSelectionToTemp; using cap::pasteFromStack; +using cap::pasteFromTemp; using cap::pasteClipboardText; using cap::pasteClipboardGraphics; using cap::replaceSelection; using cap::grabAndEraseSelection; using cap::selClearOrDel; +using cap::pasteSimpleText; +using frontend::Clipboard; // globals... static Font freefont(ignore_font, ignore_language); @@ -126,7 +135,7 @@ static void finishChange(Cursor & cur, bool selecting) } -static void mathDispatch(Cursor & cur, FuncRequest const & cmd, bool display) +static void mathDispatch(Cursor & cur, FuncRequest const & cmd) { cur.recordUndo(); docstring sel = cur.selectionAsString(false); @@ -143,48 +152,42 @@ static void mathDispatch(Cursor & cur, FuncRequest const & cmd, bool display) #endif cur.insert(new InsetMathHull(cur.buffer(), hullSimple)); #ifdef ENABLE_ASSERTIONS - LASSERT(old_pos == cur.pos(), /**/); + LATTEST(old_pos == cur.pos()); #endif cur.nextInset()->edit(cur, true); - // don't do that also for LFUN_MATH_MODE - // unless you want end up with always changing - // to mathrm when opening an inlined inset -- - // I really hate "LyXfunc overloading"... - if (display) - cur.dispatch(FuncRequest(LFUN_MATH_DISPLAY)); - // Avoid an unnecessary undo step if cmd.argument - // is empty - if (!cmd.argument().empty()) - cur.dispatch(FuncRequest(LFUN_MATH_INSERT, - cmd.argument())); + if (cmd.action() != LFUN_MATH_MODE) + // LFUN_MATH_MODE has a different meaning in math mode + cur.dispatch(cmd); } else { - // create a macro if we see "\\newcommand" - // somewhere, and an ordinary formula - // otherwise - if (sel.find(from_ascii("\\newcommand")) == string::npos - && sel.find(from_ascii("\\newlyxcommand")) == string::npos - && sel.find(from_ascii("\\def")) == string::npos) - { - InsetMathHull * formula = new InsetMathHull(cur.buffer()); - string const selstr = to_utf8(sel); - istringstream is(selstr); - Lexer lex; + InsetMathHull * formula = new InsetMathHull(cur.buffer()); + string const selstr = to_utf8(sel); + istringstream is(selstr); + Lexer lex; + lex.setStream(is); + if (!formula->readQuiet(lex)) { + // No valid formula, let's try with delims + is.str("$" + selstr + "$"); lex.setStream(is); if (!formula->readQuiet(lex)) { - // No valid formula, let's try with delims - is.str("$" + selstr + "$"); - lex.setStream(is); - if (!formula->readQuiet(lex)) { - // Still not valid, leave it as is - valid = false; - delete formula; - cur.insert(sel); - } else - cur.insert(formula); - } else - cur.insert(formula); - } else { - cur.insert(new MathMacroTemplate(cur.buffer(), sel)); + // Still not valid, leave it as is + valid = false; + delete formula; + cur.insert(sel); + } + } + if (valid) { + cur.insert(formula); + cur.nextInset()->edit(cur, true); + LASSERT(cur.inMathed(), return); + cur.pos() = 0; + cur.resetAnchor(); + cur.selection(true); + cur.pos() = cur.lastpos(); + if (cmd.action() != LFUN_MATH_MODE) + // LFUN_MATH_MODE has a different meaning in math mode + cur.dispatch(cmd); + cur.clearSelection(); + cur.pos() = cur.lastpos(); } } if (valid) @@ -196,9 +199,9 @@ static void mathDispatch(Cursor & cur, FuncRequest const & cmd, bool display) void regexpDispatch(Cursor & cur, FuncRequest const & cmd) { - BOOST_ASSERT(cmd.action == LFUN_REGEXP_MODE); + LASSERT(cmd.action() == LFUN_REGEXP_MODE, return); if (cur.inRegexped()) { - cur.message(_("Already in regexp mode")); + cur.message(_("Already in regular expression mode")); return; } cur.recordUndo(); @@ -224,6 +227,15 @@ static void specialChar(Cursor & cur, InsetSpecialChar::Kind kind) } +static void ipaChar(Cursor & cur, InsetIPAChar::Kind kind) +{ + cur.recordUndo(); + cap::replaceSelection(cur); + cur.insert(new InsetIPAChar(kind)); + cur.posForward(); +} + + static bool doInsertInset(Cursor & cur, Text * text, FuncRequest const & cmd, bool edit, bool pastesel) { @@ -233,24 +245,63 @@ static bool doInsertInset(Cursor & cur, Text * text, if (!inset) return false; - if (InsetCollapsable * ci = inset->asInsetCollapsable()) + if (InsetCollapsible * ci = inset->asInsetCollapsible()) ci->setButtonLabel(); cur.recordUndo(); - if (cmd.action == LFUN_INDEX_INSERT) { + if (cmd.action() == LFUN_INDEX_INSERT) { docstring ds = subst(text->getStringToIndex(cur), '\n', ' '); text->insertInset(cur, inset); if (edit) inset->edit(cur, true); // Now put this into inset - cur.text()->insertStringAsLines(cur, ds, cur.current_font); - cur.leaveInset(*inset); + Font const f(inherit_font, cur.current_font.language()); + if (!ds.empty()) { + cur.text()->insertStringAsLines(cur, ds, f); + cur.leaveInset(*inset); + } return true; } + else if (cmd.action() == LFUN_ARGUMENT_INSERT) { + bool cotextinsert = false; + InsetArgument const * const ia = static_cast(inset); + Layout const & lay = cur.paragraph().layout(); + Layout::LaTeXArgMap args = lay.args(); + Layout::LaTeXArgMap::const_iterator const lait = args.find(ia->name()); + if (lait != args.end()) + cotextinsert = (*lait).second.insertcotext; + else { + InsetLayout const & il = cur.inset().getLayout(); + args = il.args(); + Layout::LaTeXArgMap::const_iterator const ilait = args.find(ia->name()); + if (ilait != args.end()) + cotextinsert = (*ilait).second.insertcotext; + } + // The argument requests to insert a copy of the co-text to the inset + if (cotextinsert) { + docstring ds; + // If we have a selection within a paragraph, use this + if (cur.selection() && cur.selBegin().pit() == cur.selEnd().pit()) + ds = cur.selectionAsString(false); + // else use the whole paragraph + else + ds = cur.paragraph().asString(); + text->insertInset(cur, inset); + if (edit) + inset->edit(cur, true); + // Now put co-text into inset + Font const f(inherit_font, cur.current_font.language()); + if (!ds.empty()) { + cur.text()->insertStringAsLines(cur, ds, f); + cur.leaveInset(*inset); + } + return true; + } + } bool gotsel = false; if (cur.selection()) { - cutSelection(cur, false, pastesel); + cutSelectionToTemp(cur, false, pastesel); cur.clearSelection(); gotsel = true; } @@ -262,14 +313,14 @@ static bool doInsertInset(Cursor & cur, Text * text, if (!gotsel || !pastesel) return true; - pasteFromStack(cur, cur.buffer()->errorList("Paste"), 0); + pasteFromTemp(cur, cur.buffer()->errorList("Paste")); cur.buffer()->errors("Paste"); cur.clearSelection(); // bug 393 cur.finishUndo(); - InsetText * insetText = dynamic_cast(inset); - if (insetText) { - insetText->fixParagraphsFont(); - if (!insetText->allowMultiPar() || cur.lastpit() == 0) { + InsetText * inset_text = inset->asInsetText(); + if (inset_text) { + inset_text->fixParagraphsFont(); + if (!inset_text->allowMultiPar() || cur.lastpit() == 0) { // reset first par to default cur.text()->paragraphs().begin() ->setPlainOrDefaultLayout(bparams.documentClass()); @@ -278,7 +329,14 @@ static bool doInsertInset(Cursor & cur, Text * text, // Merge multiple paragraphs -- hack while (cur.lastpit() > 0) mergeParagraph(bparams, cur.text()->paragraphs(), 0); + if (cmd.action() == LFUN_FLEX_INSERT) + return true; + Cursor old = cur; cur.leaveInset(*inset); + if (cmd.action() == LFUN_PREVIEW_INSERT + || cmd.action() == LFUN_IPA_INSERT) + // trigger preview + notifyCursorLeavesOrEnters(old, cur); } } else { cur.leaveInset(*inset); @@ -299,59 +357,6 @@ string const freefont2string() } -static void dragMove(Cursor & cur, int moveid, int movetoid) -{ - // Create pointers to buffers - Buffer & buf_move = *cur.buffer(); - DocIterator dit_move = buf_move.getParFromID(moveid); - DocIterator dit_dest = buf_move.getParFromID(movetoid); - - pit_type & pit_move = dit_move.pit(); - pit_type & pit_dest = dit_dest.pit(); - ParagraphList & pars = dit_move.text()->paragraphs(); - - // Create references to the paragraphs to be moved - ParagraphList::iterator const bgn = pars.begin(); - ParagraphList::iterator dest_start = boost::next(bgn, pit_dest); - - // The first paragraph of the area to be copied: - ParagraphList::iterator start = boost::next(bgn, pit_move); - // The final paragraph of area to be copied: - ParagraphList::iterator finish = start; - ParagraphList::iterator const end = pars.end(); - - // Move out (down) from this section header - if (finish != end) - ++finish; - - // Seek the one (on same level) below - int const thistoclevel = start->layout().toclevel; - for (; finish != end; ++finish) { - int const toclevel = finish->layout().toclevel; - if (toclevel != Layout::NOT_IN_TOC - && toclevel <= thistoclevel) - break; - } - - if (start == pars.begin() || start == dest_start) - // Nothing to move - return; - - pars.insert(dest_start, start, finish); - pars.erase(start, finish); - - // FIXME: This only really needs doing for the newly - // introduced paragraphs. Something like: - // pit_type const numpars = distance(start, finish); - // start = boost::next(bgn, pit); - // finish = boost::next(start, numpars); - // for (; start != finish; ++start) - // start->setBuffer(buf); - // But while this seems to work, it is kind of fragile. - buf_move.inset().setBuffer(buf_move); -} - - /// the type of outline operation enum OutlineOp { OutlineUp, // Move this header with text down @@ -361,21 +366,36 @@ enum OutlineOp { }; -static void outline(OutlineOp mode, Cursor & cur) +static void insertSeparator(Cursor & cur, depth_type const depth) +{ + Buffer & buf = *cur.buffer(); + lyx::dispatch(FuncRequest(LFUN_PARAGRAPH_BREAK)); + DocumentClass const & tc = buf.params().documentClass(); + lyx::dispatch(FuncRequest(LFUN_LAYOUT, from_ascii("\"") + tc.plainLayout().name() + + from_ascii("\" ignoreautonests"))); + // FIXME: Bibitem mess! + if (cur.prevInset() && cur.prevInset()->lyxCode() == BIBITEM_CODE) + lyx::dispatch(FuncRequest(LFUN_CHAR_DELETE_BACKWARD)); + lyx::dispatch(FuncRequest(LFUN_SEPARATOR_INSERT, "plain")); + while (cur.paragraph().params().depth() > depth) + lyx::dispatch(FuncRequest(LFUN_DEPTH_DECREMENT)); +} + + +static void outline(OutlineOp mode, Cursor & cur, Text * text) { Buffer & buf = *cur.buffer(); pit_type & pit = cur.pit(); ParagraphList & pars = buf.text().paragraphs(); ParagraphList::iterator const bgn = pars.begin(); // The first paragraph of the area to be copied: - ParagraphList::iterator start = boost::next(bgn, pit); + ParagraphList::iterator start = lyx::next(bgn, pit); // The final paragraph of area to be copied: ParagraphList::iterator finish = start; ParagraphList::iterator const end = pars.end(); + depth_type const current_depth = cur.paragraph().params().depth(); - DocumentClass const & tc = buf.params().documentClass(); - - int const thistoclevel = start->layout().toclevel; + int const thistoclevel = buf.text().getTocLevel(distance(bgn, start)); int toclevel; // Move out (down) from this section header @@ -384,7 +404,7 @@ static void outline(OutlineOp mode, Cursor & cur) // Seek the one (on same level) below for (; finish != end; ++finish) { - toclevel = finish->layout().toclevel; + toclevel = buf.text().getTocLevel(distance(bgn, finish)); if (toclevel != Layout::NOT_IN_TOC && toclevel <= thistoclevel) break; } @@ -401,17 +421,54 @@ static void outline(OutlineOp mode, Cursor & cur) // Search previous same-level header above do { --dest; - toclevel = dest->layout().toclevel; + toclevel = buf.text().getTocLevel(distance(bgn, dest)); } while(dest != bgn && (toclevel == Layout::NOT_IN_TOC || toclevel > thistoclevel)); // Not found; do nothing if (toclevel == Layout::NOT_IN_TOC || toclevel > thistoclevel) return; - pit_type const newpit = distance(bgn, dest); + pit_type newpit = distance(bgn, dest); pit_type const len = distance(start, finish); pit_type const deletepit = pit + len; - buf.undo().recordUndo(cur, ATOMIC_UNDO, newpit, deletepit - 1); + buf.undo().recordUndo(cur, newpit, deletepit - 1); + // If we move an environment upwards, make sure it is + // separated from its new neighbour below: + // If an environment of the same layout follows, and the moved + // paragraph sequence does not end with a separator, insert one. + ParagraphList::iterator lastmoved = finish; + --lastmoved; + if (start->layout().isEnvironment() + && dest->layout() == start->layout() + && !lastmoved->isEnvSeparator(lastmoved->beginOfBody())) { + cur.pit() = distance(bgn, lastmoved); + cur.pos() = cur.lastpos(); + insertSeparator(cur, current_depth); + cur.pit() = pit; + } + // Likewise, if we moved an environment upwards, make sure it + // is separated from its new neighbour above. + // The paragraph before the target of movement + if (dest != bgn) { + ParagraphList::iterator before = dest; + --before; + // Get the parent paragraph (outer in nested context) + pit_type const parent = + before->params().depth() > current_depth + ? text->depthHook(distance(bgn, before), current_depth) + : distance(bgn, before); + // If a environment with same layout preceeds the moved one in the new + // position, and there is no separator yet, insert one. + if (start->layout().isEnvironment() + && pars[parent].layout() == start->layout() + && !before->isEnvSeparator(before->beginOfBody())) { + cur.pit() = distance(bgn, before); + cur.pos() = cur.lastpos(); + insertSeparator(cur, current_depth); + cur.pit() = pit; + } + } + newpit = distance(bgn, dest); pars.splice(dest, start, finish); cur.pit() = newpit; break; @@ -421,34 +478,77 @@ static void outline(OutlineOp mode, Cursor & cur) // Nothing to move. return; // Go one down from *this* header: - ParagraphList::iterator dest = boost::next(finish, 1); + ParagraphList::iterator dest = next(finish, 1); // Go further down to find header to insert in front of: for (; dest != end; ++dest) { - toclevel = dest->layout().toclevel; + toclevel = buf.text().getTocLevel(distance(bgn, dest)); if (toclevel != Layout::NOT_IN_TOC && toclevel <= thistoclevel) break; } - // One such was found: + // One such was found, so go on... + // If we move an environment downwards, make sure it is + // separated from its new neighbour above. pit_type newpit = distance(bgn, dest); - buf.undo().recordUndo(cur, ATOMIC_UNDO, pit, newpit - 1); + buf.undo().recordUndo(cur, pit, newpit - 1); + // The paragraph before the target of movement + ParagraphList::iterator before = dest; + --before; + // Get the parent paragraph (outer in nested context) + pit_type const parent = + before->params().depth() > current_depth + ? text->depthHook(distance(bgn, before), current_depth) + : distance(bgn, before); + // If a environment with same layout preceeds the moved one in the new + // position, and there is no separator yet, insert one. + if (start->layout().isEnvironment() + && pars[parent].layout() == start->layout() + && !before->isEnvSeparator(before->beginOfBody())) { + cur.pit() = distance(bgn, before); + cur.pos() = cur.lastpos(); + insertSeparator(cur, current_depth); + cur.pit() = pit; + } + // Likewise, make sure moved environments are separated + // from their new neighbour below: + // If an environment of the same layout follows, and the moved + // paragraph sequence does not end with a separator, insert one. + ParagraphList::iterator lastmoved = finish; + --lastmoved; + if (dest != end + && start->layout().isEnvironment() + && dest->layout() == start->layout() + && !lastmoved->isEnvSeparator(lastmoved->beginOfBody())) { + cur.pit() = distance(bgn, lastmoved); + cur.pos() = cur.lastpos(); + insertSeparator(cur, current_depth); + cur.pit() = pit; + } + newpit = distance(bgn, dest); pit_type const len = distance(start, finish); pars.splice(dest, start, finish); cur.pit() = newpit - len; break; } - case OutlineIn: { + case OutlineIn: + case OutlineOut: { pit_type const len = distance(start, finish); - buf.undo().recordUndo(cur, ATOMIC_UNDO, pit, pit + len - 1); + buf.undo().recordUndo(cur, pit, pit + len - 1); for (; start != finish; ++start) { - toclevel = start->layout().toclevel; + toclevel = buf.text().getTocLevel(distance(bgn, start)); if (toclevel == Layout::NOT_IN_TOC) continue; + + DocumentClass const & tc = buf.params().documentClass(); DocumentClass::const_iterator lit = tc.begin(); DocumentClass::const_iterator len = tc.end(); + int const newtoclevel = + (mode == OutlineIn ? toclevel + 1 : toclevel - 1); + LabelType const oldlabeltype = start->layout().labeltype; + for (; lit != len; ++lit) { - if (lit->toclevel == toclevel + 1 && - start->layout().labeltype == lit->labeltype) { + if (lit->toclevel == newtoclevel && + lit->labeltype == oldlabeltype) { start->setLayout(*lit); break; } @@ -456,25 +556,6 @@ static void outline(OutlineOp mode, Cursor & cur) } break; } - case OutlineOut: { - pit_type const len = distance(start, finish); - buf.undo().recordUndo(cur, ATOMIC_UNDO, pit, pit + len - 1); - for (; start != finish; ++start) { - toclevel = start->layout().toclevel; - if (toclevel == Layout::NOT_IN_TOC) - continue; - DocumentClass::const_iterator lit = tc.begin(); - DocumentClass::const_iterator len = tc.end(); - for (; lit != len; ++lit) { - if (lit->toclevel == toclevel - 1 && - start->layout().labeltype == lit->labeltype) { - start->setLayout(*lit); - break; - } - } - } - break; - } } } @@ -494,6 +575,15 @@ bool Text::isRTL(Paragraph const & par) const } +namespace { + + Language const * getLanguage(Cursor const & cur, string const & lang) { + return lang.empty() ? cur.getFont().language() : languages.getLanguage(lang); + } + +} // namespace + + void Text::dispatch(Cursor & cur, FuncRequest & cmd) { LYXERR(Debug::ACTION, "Text::dispatch: cmd: " << cmd); @@ -515,41 +605,46 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) // FIXME: We use the update flag to indicates wether a singlePar or a // full screen update is needed. We reset it here but shall we restore it // at the end? - cur.noUpdate(); + cur.noScreenUpdate(); + + LBUFERR(this == cur.text()); - LASSERT(cur.text() == this, /**/); - CursorSlice oldTopSlice = cur.top(); - bool oldBoundary = cur.boundary(); - bool sel = cur.selection(); + // NOTE: This should NOT be a reference. See commit 94a5481a. + CursorSlice const oldTopSlice = cur.top(); + bool const oldBoundary = cur.boundary(); + bool const oldSelection = cur.selection(); // Signals that, even if needsUpdate == false, an update of the // cursor paragraph is required - bool singleParUpdate = lyxaction.funcHasFlag(cmd.action, + bool singleParUpdate = lyxaction.funcHasFlag(cmd.action(), LyXAction::SingleParUpdate); // Signals that a full-screen update is required - bool needsUpdate = !(lyxaction.funcHasFlag(cmd.action, + bool needsUpdate = !(lyxaction.funcHasFlag(cmd.action(), LyXAction::NoUpdate) || singleParUpdate); + bool const last_misspelled = lyxrc.spellcheck_continuously + && cur.paragraph().isMisspelled(cur.pos(), true); - switch (cmd.action) { + FuncCode const act = cmd.action(); + switch (act) { case LFUN_PARAGRAPH_MOVE_DOWN: { pit_type const pit = cur.pit(); - recUndo(cur, pit, pit + 1); + cur.recordUndo(pit, pit + 1); cur.finishUndo(); pars_.swap(pit, pit + 1); - cur.buffer()->updateLabels(); needsUpdate = true; + cur.forceBufferUpdate(); ++cur.pit(); break; } case LFUN_PARAGRAPH_MOVE_UP: { pit_type const pit = cur.pit(); - recUndo(cur, pit - 1, pit); + cur.recordUndo(pit - 1, pit); cur.finishUndo(); pars_.swap(pit, pit - 1); - cur.buffer()->updateLabels(); --cur.pit(); needsUpdate = true; + cur.forceBufferUpdate(); break; } @@ -563,7 +658,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) // FIXME: this don't work for multipart document! for (pit_type tmp = 0, end = pars_.size(); tmp != end; ++tmp) { if (pars_[tmp].params().startOfAppendix()) { - recUndo(cur, tmp); + cur.recordUndo(tmp, tmp); pars_[tmp].params().startOfAppendix(false); break; } @@ -573,7 +668,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) par.params().startOfAppendix(start); // we can set the refreshing parameters now - cur.buffer()->updateLabels(); + cur.forceBufferUpdate(); break; } @@ -581,7 +676,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) if (cur.selection()) cutSelection(cur, true, false); else - deleteWordForward(cur); + deleteWordForward(cur, cmd.getArg(0) == "force"); finishChange(cur, false); break; @@ -589,11 +684,11 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) if (cur.selection()) cutSelection(cur, true, false); else - deleteWordBackward(cur); + deleteWordBackward(cur, cmd.getArg(0) == "force"); finishChange(cur, false); break; - case LFUN_LINE_DELETE: + case LFUN_LINE_DELETE_FORWARD: if (cur.selection()) cutSelection(cur, true, false); else @@ -603,125 +698,120 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) case LFUN_BUFFER_BEGIN: case LFUN_BUFFER_BEGIN_SELECT: - needsUpdate |= cur.selHandle(cmd.action == LFUN_BUFFER_BEGIN_SELECT); + needsUpdate |= cur.selHandle(act == LFUN_BUFFER_BEGIN_SELECT); if (cur.depth() == 1) needsUpdate |= cursorTop(cur); else cur.undispatched(); - cur.updateFlags(Update::FitCursor); + cur.screenUpdateFlags(Update::FitCursor); break; case LFUN_BUFFER_END: case LFUN_BUFFER_END_SELECT: - needsUpdate |= cur.selHandle(cmd.action == LFUN_BUFFER_END_SELECT); + needsUpdate |= cur.selHandle(act == LFUN_BUFFER_END_SELECT); if (cur.depth() == 1) needsUpdate |= cursorBottom(cur); else cur.undispatched(); - cur.updateFlags(Update::FitCursor); + cur.screenUpdateFlags(Update::FitCursor); break; case LFUN_INSET_BEGIN: case LFUN_INSET_BEGIN_SELECT: - needsUpdate |= cur.selHandle(cmd.action == LFUN_INSET_BEGIN_SELECT); + needsUpdate |= cur.selHandle(act == LFUN_INSET_BEGIN_SELECT); if (cur.depth() == 1 || !cur.top().at_begin()) needsUpdate |= cursorTop(cur); else cur.undispatched(); - cur.updateFlags(Update::FitCursor); + cur.screenUpdateFlags(Update::FitCursor); break; case LFUN_INSET_END: case LFUN_INSET_END_SELECT: - needsUpdate |= cur.selHandle(cmd.action == LFUN_INSET_END_SELECT); + needsUpdate |= cur.selHandle(act == LFUN_INSET_END_SELECT); if (cur.depth() == 1 || !cur.top().at_end()) needsUpdate |= cursorBottom(cur); else cur.undispatched(); - cur.updateFlags(Update::FitCursor); - break; - - case LFUN_INSET_SELECT_ALL: - if (cur.depth() == 1 || !cur.selection() || !cur.selBegin().at_begin() - || !cur.selEnd().at_end()) { - needsUpdate |= cur.selHandle(false); - needsUpdate |= cursorTop(cur); - needsUpdate |= cur.selHandle(true); - needsUpdate |= cursorBottom(cur); - } else - cur.undispatched(); - cur.updateFlags(Update::FitCursor); + cur.screenUpdateFlags(Update::FitCursor); break; case LFUN_CHAR_FORWARD: - case LFUN_CHAR_FORWARD_SELECT: + case LFUN_CHAR_FORWARD_SELECT: { //LYXERR0(" LFUN_CHAR_FORWARD[SEL]:\n" << cur); - needsUpdate |= cur.selHandle(cmd.action == LFUN_CHAR_FORWARD_SELECT); - needsUpdate |= cursorForward(cur); + needsUpdate |= cur.selHandle(act == LFUN_CHAR_FORWARD_SELECT); + bool const cur_moved = cursorForward(cur); + needsUpdate |= cur_moved; - if (!needsUpdate && oldTopSlice == cur.top() - && cur.boundary() == oldBoundary) { + if (!cur_moved && oldTopSlice == cur.top() + && cur.boundary() == oldBoundary) { cur.undispatched(); cmd = FuncRequest(LFUN_FINISHED_FORWARD); - + // we will probably be moving out the inset, so we should execute - // the depm-mechanism, but only when the cursor has a place to + // the depm-mechanism, but only when the cursor has a place to // go outside this inset, i.e. in a slice above. - if (cur.depth() > 1 && cur.pos() == cur.lastpos() + if (cur.depth() > 1 && cur.pos() == cur.lastpos() && cur.pit() == cur.lastpit()) { - // The cursor hasn't changed yet. To give the + // The cursor hasn't changed yet. To give the // DEPM the possibility of doing something we must // provide it with two different cursors. Cursor dummy = cur; dummy.pos() = dummy.pit() = 0; - cur.bv().checkDepm(dummy, cur); + if (cur.bv().checkDepm(dummy, cur)) + cur.forceBufferUpdate(); } } break; + } case LFUN_CHAR_BACKWARD: - case LFUN_CHAR_BACKWARD_SELECT: + case LFUN_CHAR_BACKWARD_SELECT: { //lyxerr << "handle LFUN_CHAR_BACKWARD[_SELECT]:\n" << cur << endl; - needsUpdate |= cur.selHandle(cmd.action == LFUN_CHAR_BACKWARD_SELECT); - needsUpdate |= cursorBackward(cur); + needsUpdate |= cur.selHandle(act == LFUN_CHAR_BACKWARD_SELECT); + bool const cur_moved = cursorBackward(cur); + needsUpdate |= cur_moved; - if (!needsUpdate && oldTopSlice == cur.top() - && cur.boundary() == oldBoundary) { + if (!cur_moved && oldTopSlice == cur.top() + && cur.boundary() == oldBoundary) { cur.undispatched(); cmd = FuncRequest(LFUN_FINISHED_BACKWARD); // we will probably be moving out the inset, so we should execute - // the depm-mechanism, but only when the cursor has a place to + // the depm-mechanism, but only when the cursor has a place to // go outside this inset, i.e. in a slice above. if (cur.depth() > 1 && cur.pos() == 0 && cur.pit() == 0) { - // The cursor hasn't changed yet. To give the + // The cursor hasn't changed yet. To give the // DEPM the possibility of doing something we must // provide it with two different cursors. Cursor dummy = cur; dummy.pos() = cur.lastpos(); dummy.pit() = cur.lastpit(); - cur.bv().checkDepm(dummy, cur); + if (cur.bv().checkDepm(dummy, cur)) + cur.forceBufferUpdate(); } } break; + } case LFUN_CHAR_LEFT: case LFUN_CHAR_LEFT_SELECT: if (lyxrc.visual_cursor) { - needsUpdate |= cur.selHandle(cmd.action == LFUN_CHAR_LEFT_SELECT); - needsUpdate |= cursorVisLeft(cur); - if (!needsUpdate && oldTopSlice == cur.top() - && cur.boundary() == oldBoundary) { + needsUpdate |= cur.selHandle(act == LFUN_CHAR_LEFT_SELECT); + bool const cur_moved = cursorVisLeft(cur); + needsUpdate |= cur_moved; + if (!cur_moved && oldTopSlice == cur.top() + && cur.boundary() == oldBoundary) { cur.undispatched(); cmd = FuncRequest(LFUN_FINISHED_LEFT); } } else { - if (reverseDirectionNeeded(cur)) { - cmd.action = cmd.action == LFUN_CHAR_LEFT_SELECT ? - LFUN_CHAR_FORWARD_SELECT : LFUN_CHAR_FORWARD; + if (cur.reverseDirectionNeeded()) { + cmd.setAction(cmd.action() == LFUN_CHAR_LEFT_SELECT ? + LFUN_CHAR_FORWARD_SELECT : LFUN_CHAR_FORWARD); } else { - cmd.action = cmd.action == LFUN_CHAR_LEFT_SELECT ? - LFUN_CHAR_BACKWARD_SELECT : LFUN_CHAR_BACKWARD; + cmd.setAction(cmd.action() == LFUN_CHAR_LEFT_SELECT ? + LFUN_CHAR_BACKWARD_SELECT : LFUN_CHAR_BACKWARD); } dispatch(cur, cmd); return; @@ -731,20 +821,21 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) case LFUN_CHAR_RIGHT: case LFUN_CHAR_RIGHT_SELECT: if (lyxrc.visual_cursor) { - needsUpdate |= cur.selHandle(cmd.action == LFUN_CHAR_RIGHT_SELECT); - needsUpdate |= cursorVisRight(cur); - if (!needsUpdate && oldTopSlice == cur.top() - && cur.boundary() == oldBoundary) { + needsUpdate |= cur.selHandle(cmd.action() == LFUN_CHAR_RIGHT_SELECT); + bool const cur_moved = cursorVisRight(cur); + needsUpdate |= cur_moved; + if (!cur_moved && oldTopSlice == cur.top() + && cur.boundary() == oldBoundary) { cur.undispatched(); cmd = FuncRequest(LFUN_FINISHED_RIGHT); } } else { - if (reverseDirectionNeeded(cur)) { - cmd.action = cmd.action == LFUN_CHAR_RIGHT_SELECT ? - LFUN_CHAR_BACKWARD_SELECT : LFUN_CHAR_BACKWARD; + if (cur.reverseDirectionNeeded()) { + cmd.setAction(cmd.action() == LFUN_CHAR_RIGHT_SELECT ? + LFUN_CHAR_BACKWARD_SELECT : LFUN_CHAR_BACKWARD); } else { - cmd.action = cmd.action == LFUN_CHAR_RIGHT_SELECT ? - LFUN_CHAR_FORWARD_SELECT : LFUN_CHAR_FORWARD; + cmd.setAction(cmd.action() == LFUN_CHAR_RIGHT_SELECT ? + LFUN_CHAR_FORWARD_SELECT : LFUN_CHAR_FORWARD); } dispatch(cur, cmd); return; @@ -757,23 +848,34 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) case LFUN_UP: case LFUN_DOWN: { // stop/start the selection - bool select = cmd.action == LFUN_DOWN_SELECT || - cmd.action == LFUN_UP_SELECT; + bool select = cmd.action() == LFUN_DOWN_SELECT || + cmd.action() == LFUN_UP_SELECT; // move cursor up/down - bool up = cmd.action == LFUN_UP_SELECT || cmd.action == LFUN_UP; + bool up = cmd.action() == LFUN_UP_SELECT || cmd.action() == LFUN_UP; bool const atFirstOrLastRow = cur.atFirstOrLastRow(up); if (!atFirstOrLastRow) { - needsUpdate |= cur.selHandle(select); - cur.selHandle(select); + needsUpdate |= cur.selHandle(select); cur.upDownInText(up, needsUpdate); needsUpdate |= cur.beforeDispatchCursor().inMathed(); } else { + pos_type newpos = up ? 0 : cur.lastpos(); + if (lyxrc.mac_like_cursor_movement && cur.pos() != newpos) { + needsUpdate |= cur.selHandle(select); + // we do not reset the targetx of the cursor + cur.pos() = newpos; + needsUpdate |= bv->checkDepm(cur, bv->cursor()); + cur.updateTextTargetOffset(); + if (needsUpdate) + cur.forceBufferUpdate(); + break; + } + // if the cursor cannot be moved up or down do not remove // the selection right now, but wait for the next dispatch. if (select) - needsUpdate |= cur.selHandle(select); + needsUpdate |= cur.selHandle(select); cur.upDownInText(up, needsUpdate); cur.undispatched(); } @@ -783,25 +885,25 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) case LFUN_PARAGRAPH_UP: case LFUN_PARAGRAPH_UP_SELECT: - needsUpdate |= cur.selHandle(cmd.action == LFUN_PARAGRAPH_UP_SELECT); + needsUpdate |= cur.selHandle(cmd.action() == LFUN_PARAGRAPH_UP_SELECT); needsUpdate |= cursorUpParagraph(cur); break; case LFUN_PARAGRAPH_DOWN: case LFUN_PARAGRAPH_DOWN_SELECT: - needsUpdate |= cur.selHandle(cmd.action == LFUN_PARAGRAPH_DOWN_SELECT); + needsUpdate |= cur.selHandle(cmd.action() == LFUN_PARAGRAPH_DOWN_SELECT); needsUpdate |= cursorDownParagraph(cur); break; case LFUN_LINE_BEGIN: case LFUN_LINE_BEGIN_SELECT: - needsUpdate |= cur.selHandle(cmd.action == LFUN_LINE_BEGIN_SELECT); + needsUpdate |= cur.selHandle(cmd.action() == LFUN_LINE_BEGIN_SELECT); needsUpdate |= tm->cursorHome(cur); break; case LFUN_LINE_END: case LFUN_LINE_END_SELECT: - needsUpdate |= cur.selHandle(cmd.action == LFUN_LINE_END_SELECT); + needsUpdate |= cur.selHandle(cmd.action() == LFUN_LINE_END_SELECT); needsUpdate |= tm->cursorEnd(cur); break; @@ -811,12 +913,12 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) ParagraphList & pars = buf.text().paragraphs(); ParagraphList::iterator bgn = pars.begin(); // The first paragraph of the area to be selected: - ParagraphList::iterator start = boost::next(bgn, pit); + ParagraphList::iterator start = lyx::next(bgn, pit); // The final paragraph of area to be selected: ParagraphList::iterator finish = start; ParagraphList::iterator end = pars.end(); - int const thistoclevel = start->layout().toclevel; + int const thistoclevel = buf.text().getTocLevel(distance(bgn, start)); if (thistoclevel == Layout::NOT_IN_TOC) break; @@ -830,12 +932,14 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) // Seek the one (on same level) below for (; finish != end; ++finish, ++cur.pit()) { - int const toclevel = finish->layout().toclevel; + int const toclevel = buf.text().getTocLevel(distance(bgn, finish)); if (toclevel != Layout::NOT_IN_TOC && toclevel <= thistoclevel) break; } cur.pos() = cur.lastpos(); - + cur.boundary(false); + cur.setCurrentFont(); + needsUpdate |= cur != old_cur; break; } @@ -843,20 +947,21 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) case LFUN_WORD_RIGHT: case LFUN_WORD_RIGHT_SELECT: if (lyxrc.visual_cursor) { - needsUpdate |= cur.selHandle(cmd.action == LFUN_WORD_RIGHT_SELECT); - needsUpdate |= cursorVisRightOneWord(cur); - if (!needsUpdate && oldTopSlice == cur.top() - && cur.boundary() == oldBoundary) { + needsUpdate |= cur.selHandle(cmd.action() == LFUN_WORD_RIGHT_SELECT); + bool const cur_moved = cursorVisRightOneWord(cur); + needsUpdate |= cur_moved; + if (!cur_moved && oldTopSlice == cur.top() + && cur.boundary() == oldBoundary) { cur.undispatched(); cmd = FuncRequest(LFUN_FINISHED_RIGHT); } } else { - if (reverseDirectionNeeded(cur)) { - cmd.action = cmd.action == LFUN_WORD_RIGHT_SELECT ? - LFUN_WORD_BACKWARD_SELECT : LFUN_WORD_BACKWARD; + if (cur.reverseDirectionNeeded()) { + cmd.setAction(cmd.action() == LFUN_WORD_RIGHT_SELECT ? + LFUN_WORD_BACKWARD_SELECT : LFUN_WORD_BACKWARD); } else { - cmd.action = cmd.action == LFUN_WORD_RIGHT_SELECT ? - LFUN_WORD_FORWARD_SELECT : LFUN_WORD_FORWARD; + cmd.setAction(cmd.action() == LFUN_WORD_RIGHT_SELECT ? + LFUN_WORD_FORWARD_SELECT : LFUN_WORD_FORWARD); } dispatch(cur, cmd); return; @@ -864,28 +969,51 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) break; case LFUN_WORD_FORWARD: - case LFUN_WORD_FORWARD_SELECT: - needsUpdate |= cur.selHandle(cmd.action == LFUN_WORD_FORWARD_SELECT); - needsUpdate |= cursorForwardOneWord(cur); + case LFUN_WORD_FORWARD_SELECT: { + needsUpdate |= cur.selHandle(cmd.action() == LFUN_WORD_FORWARD_SELECT); + bool const cur_moved = cursorForwardOneWord(cur); + needsUpdate |= cur_moved; + + if (!cur_moved && oldTopSlice == cur.top() + && cur.boundary() == oldBoundary) { + cur.undispatched(); + cmd = FuncRequest(LFUN_FINISHED_FORWARD); + + // we will probably be moving out the inset, so we should execute + // the depm-mechanism, but only when the cursor has a place to + // go outside this inset, i.e. in a slice above. + if (cur.depth() > 1 && cur.pos() == cur.lastpos() + && cur.pit() == cur.lastpit()) { + // The cursor hasn't changed yet. To give the + // DEPM the possibility of doing something we must + // provide it with two different cursors. + Cursor dummy = cur; + dummy.pos() = dummy.pit() = 0; + if (cur.bv().checkDepm(dummy, cur)) + cur.forceBufferUpdate(); + } + } break; + } case LFUN_WORD_LEFT: case LFUN_WORD_LEFT_SELECT: if (lyxrc.visual_cursor) { - needsUpdate |= cur.selHandle(cmd.action == LFUN_WORD_LEFT_SELECT); - needsUpdate |= cursorVisLeftOneWord(cur); - if (!needsUpdate && oldTopSlice == cur.top() - && cur.boundary() == oldBoundary) { + needsUpdate |= cur.selHandle(cmd.action() == LFUN_WORD_LEFT_SELECT); + bool const cur_moved = cursorVisLeftOneWord(cur); + needsUpdate |= cur_moved; + if (!cur_moved && oldTopSlice == cur.top() + && cur.boundary() == oldBoundary) { cur.undispatched(); cmd = FuncRequest(LFUN_FINISHED_LEFT); } } else { - if (reverseDirectionNeeded(cur)) { - cmd.action = cmd.action == LFUN_WORD_LEFT_SELECT ? - LFUN_WORD_FORWARD_SELECT : LFUN_WORD_FORWARD; + if (cur.reverseDirectionNeeded()) { + cmd.setAction(cmd.action() == LFUN_WORD_LEFT_SELECT ? + LFUN_WORD_FORWARD_SELECT : LFUN_WORD_FORWARD); } else { - cmd.action = cmd.action == LFUN_WORD_LEFT_SELECT ? - LFUN_WORD_BACKWARD_SELECT : LFUN_WORD_BACKWARD; + cmd.setAction(cmd.action() == LFUN_WORD_LEFT_SELECT ? + LFUN_WORD_BACKWARD_SELECT : LFUN_WORD_BACKWARD); } dispatch(cur, cmd); return; @@ -893,10 +1021,33 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) break; case LFUN_WORD_BACKWARD: - case LFUN_WORD_BACKWARD_SELECT: - needsUpdate |= cur.selHandle(cmd.action == LFUN_WORD_BACKWARD_SELECT); - needsUpdate |= cursorBackwardOneWord(cur); + case LFUN_WORD_BACKWARD_SELECT: { + needsUpdate |= cur.selHandle(cmd.action() == LFUN_WORD_BACKWARD_SELECT); + bool const cur_moved = cursorBackwardOneWord(cur); + needsUpdate |= cur_moved; + + if (!cur_moved && oldTopSlice == cur.top() + && cur.boundary() == oldBoundary) { + cur.undispatched(); + cmd = FuncRequest(LFUN_FINISHED_BACKWARD); + + // we will probably be moving out the inset, so we should execute + // the depm-mechanism, but only when the cursor has a place to + // go outside this inset, i.e. in a slice above. + if (cur.depth() > 1 && cur.pos() == 0 + && cur.pit() == 0) { + // The cursor hasn't changed yet. To give the + // DEPM the possibility of doing something we must + // provide it with two different cursors. + Cursor dummy = cur; + dummy.pos() = cur.lastpos(); + dummy.pit() = cur.lastpit(); + if (cur.bv().checkDepm(dummy, cur)) + cur.forceBufferUpdate(); + } + } break; + } case LFUN_WORD_SELECT: { selectWord(cur, WHOLE_WORD); @@ -907,15 +1058,12 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) case LFUN_NEWLINE_INSERT: { InsetNewlineParams inp; docstring arg = cmd.argument(); - // this avoids a double undo - // FIXME: should not be needed, ideally - if (!cur.selection()) - cur.recordUndo(); - cap::replaceSelection(cur); if (arg == "linebreak") inp.kind = InsetNewlineParams::LINEBREAK; else inp.kind = InsetNewlineParams::NEWLINE; + cap::replaceSelection(cur); + cur.recordUndo(); cur.insert(new InsetNewline(inp)); cur.posForward(); moveCursor(cur, false); @@ -931,12 +1079,12 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) cur.recordUndoSelection(); pit_type const pit_end = cur.selEnd().pit(); for (pit_type pit = cur.selBegin().pit(); pit <= pit_end; pit++) { - pars_[pit].insertChar(0, '\t', - bv->buffer().params().trackChanges); + pars_[pit].insertChar(0, '\t', + bv->buffer().params().track_changes); // Update the selection pos to make sure the selection does not // change as the inserted tab will increase the logical pos. - if (cur.anchor_.pit() == pit) - cur.anchor_.forwardPos(); + if (cur.realAnchor().pit() == pit) + cur.realAnchor().forwardPos(); if (cur.pit() == pit) cur.forwardPos(); } @@ -945,13 +1093,13 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) // Maybe we shouldn't allow tabs within a line, because they // are not (yet) aligned as one might do expect. FuncRequest cmd(LFUN_SELF_INSERT, from_ascii("\t")); - dispatch(cur, cmd); + dispatch(cur, cmd); } break; } case LFUN_TAB_DELETE: { - bool const tc = bv->buffer().params().trackChanges; + bool const tc = bv->buffer().params().track_changes; if (cur.selection()) { // If there is a selection, a tab (if present) is removed from // the beginning of each paragraph. @@ -959,44 +1107,42 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) pit_type const pit_end = cur.selEnd().pit(); for (pit_type pit = cur.selBegin().pit(); pit <= pit_end; pit++) { Paragraph & par = paragraphs()[pit]; - if (par.getChar(0) == '\t') { - if (cur.pit() == pit) - cur.posBackward(); - if (cur.anchor_.pit() == pit && cur.anchor_.pos() > 0 ) - cur.anchor_.backwardPos(); - - par.eraseChar(0, tc); - } else - // If no tab was present, try to remove up to four spaces. - for (int n_spaces = 0; - par.getChar(0) == ' ' && n_spaces < 4; ++n_spaces) { + if (par.empty()) + continue; + char_type const c = par.getChar(0); + if (c == '\t' || c == ' ') { + // remove either 1 tab or 4 spaces. + int const n = (c == ' ' ? 4 : 1); + for (int i = 0; i < n + && !par.empty() && par.getChar(0) == c; ++i) { if (cur.pit() == pit) cur.posBackward(); - if (cur.anchor_.pit() == pit && cur.anchor_.pos() > 0 ) - cur.anchor_.backwardPos(); - + if (cur.realAnchor().pit() == pit + && cur.realAnchor().pos() > 0 ) + cur.realAnchor().backwardPos(); par.eraseChar(0, tc); } + } } cur.finishUndo(); } else { - // If there is no selection, try to remove a tab or some spaces + // If there is no selection, try to remove a tab or some spaces // before the position of the cursor. Paragraph & par = paragraphs()[cur.pit()]; pos_type const pos = cur.pos(); - + if (pos == 0) break; - + char_type const c = par.getChar(pos - 1); cur.recordUndo(); if (c == '\t') { cur.posBackward(); par.eraseChar(cur.pos(), tc); } else - for (int n_spaces = 0; + for (int n_spaces = 0; cur.pos() > 0 - && par.getChar(cur.pos() - 1) == ' ' + && par.getChar(cur.pos() - 1) == ' ' && n_spaces < 4; ++n_spaces) { cur.posBackward(); @@ -1012,10 +1158,15 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) if (cur.pos() == cur.paragraph().size()) // Par boundary, force full-screen update singleParUpdate = false; + else if (cmd.getArg(0) != "force" && cur.confirmDeletion()) { + cur.resetAnchor(); + cur.selection(true); + cur.posForward(); + cur.setSelection(); + break; + } needsUpdate |= erase(cur); cur.resetAnchor(); - // It is possible to make it a lot faster still - // just comment out the line below... } else { cutSelection(cur, true, false); singleParUpdate = false; @@ -1026,13 +1177,25 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) case LFUN_CHAR_DELETE_BACKWARD: if (!cur.selection()) { if (bv->getIntl().getTransManager().backspace()) { + bool par_boundary = cur.pos() == 0; + bool first_par = cur.pit() == 0; // Par boundary, full-screen update - if (cur.pos() == 0) + if (par_boundary) singleParUpdate = false; + else if (cmd.getArg(0) != "force" && cur.confirmDeletion(true)) { + cur.resetAnchor(); + cur.selection(true); + cur.posBackward(); + cur.setSelection(); + break; + } needsUpdate |= backspace(cur); cur.resetAnchor(); - // It is possible to make it a lot faster still - // just comment out the line below... + if (par_boundary && !first_par && cur.pos() > 0 + && cur.paragraph().isEnvSeparator(cur.pos() - 1)) { + needsUpdate |= backspace(cur); + cur.resetAnchor(); + } } } else { cutSelection(cur, true, false); @@ -1040,11 +1203,53 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) } break; - case LFUN_BREAK_PARAGRAPH: + case LFUN_PARAGRAPH_BREAK: { cap::replaceSelection(cur); - breakParagraph(cur, cmd.argument() == "inverse"); + pit_type pit = cur.pit(); + Paragraph const & par = pars_[pit]; + bool lastpar = (pit == pit_type(pars_.size() - 1)); + Paragraph const & nextpar = lastpar ? par : pars_[pit + 1]; + pit_type prev = pit > 0 ? depthHook(pit, par.getDepth()) : pit; + if (prev < pit && cur.pos() == par.beginOfBody() + && !par.size() && !par.isEnvSeparator(cur.pos()) + && !par.layout().isCommand() + && pars_[prev].layout() != par.layout() + && pars_[prev].layout().isEnvironment() + && !nextpar.isEnvSeparator(nextpar.beginOfBody())) { + if (par.layout().isEnvironment() + && pars_[prev].getDepth() == par.getDepth()) { + docstring const layout = par.layout().name(); + DocumentClass const & tc = bv->buffer().params().documentClass(); + lyx::dispatch(FuncRequest(LFUN_LAYOUT, tc.plainLayout().name())); + lyx::dispatch(FuncRequest(LFUN_SEPARATOR_INSERT, "plain")); + lyx::dispatch(FuncRequest(LFUN_PARAGRAPH_BREAK, "inverse")); + lyx::dispatch(FuncRequest(LFUN_LAYOUT, layout)); + } else { + lyx::dispatch(FuncRequest(LFUN_SEPARATOR_INSERT, "plain")); + breakParagraph(cur); + } + Font const f(inherit_font, cur.current_font.language()); + pars_[cur.pit() - 1].resetFonts(f); + } else { + if (par.isEnvSeparator(cur.pos()) && cmd.getArg(1) != "ignoresep") + cur.posForward(); + breakParagraph(cur, cmd.getArg(0) == "inverse"); + } cur.resetAnchor(); + // If we have a list and autoinsert item insets, + // insert them now. + Layout::LaTeXArgMap args = par.layout().args(); + Layout::LaTeXArgMap::const_iterator lait = args.begin(); + Layout::LaTeXArgMap::const_iterator const laend = args.end(); + for (; lait != laend; ++lait) { + Layout::latexarg arg = (*lait).second; + if (arg.autoinsert && prefixIs((*lait).first, "item:")) { + FuncRequest cmd(LFUN_ARGUMENT_INSERT, (*lait).first); + lyx::dispatch(cmd); + } + } break; + } case LFUN_INSET_INSERT: { cur.recordUndo(); @@ -1069,20 +1274,24 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) /* Paragraph & par = pars_[cur.pit()]; if (inset->lyxCode() == LABEL_CODE - && par.layout().labeltype == LABEL_COUNTER) { + && !par.layout().counter.empty()) { // Go to the end of the paragraph // Warning: Because of Change-Tracking, the last // position is 'size()' and not 'size()-1': cur.pos() = par.size(); // Insert a new paragraph - FuncRequest fr(LFUN_BREAK_PARAGRAPH); + FuncRequest fr(LFUN_PARAGRAPH_BREAK); dispatch(cur, fr); } */ if (cur.selection()) cutSelection(cur, true, false); cur.insert(inset); - cur.posForward(); + cur.forceBufferUpdate(); + if (inset->editable() && inset->asInsetText()) + inset->edit(cur, true); + else + cur.posForward(); // trigger InstantPreview now if (inset->lyxCode() == EXTERNAL_CODE) { @@ -1096,8 +1305,10 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) } case LFUN_INSET_DISSOLVE: { - if (dissolveInset(cur)) + if (dissolveInset(cur)) { needsUpdate = true; + cur.forceBufferUpdate(); + } break; } @@ -1121,6 +1332,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) } ins->setParams(inspar); + break; } case LFUN_SPACE_INSERT: @@ -1137,6 +1349,8 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) string const name = to_utf8(cmd.argument()); if (name == "hyphenation") specialChar(cur, InsetSpecialChar::HYPHENATION); + else if (name == "allowbreak") + specialChar(cur, InsetSpecialChar::ALLOWBREAK); else if (name == "ligature-break") specialChar(cur, InsetSpecialChar::LIGATURE_BREAK); else if (name == "slash") @@ -1149,6 +1363,14 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) specialChar(cur, InsetSpecialChar::END_OF_SENTENCE); else if (name == "menu-separator") specialChar(cur, InsetSpecialChar::MENU_SEPARATOR); + else if (name == "lyx") + specialChar(cur, InsetSpecialChar::PHRASE_LYX); + else if (name == "tex") + specialChar(cur, InsetSpecialChar::PHRASE_TEX); + else if (name == "latex") + specialChar(cur, InsetSpecialChar::PHRASE_LATEX); + else if (name == "latex2e") + specialChar(cur, InsetSpecialChar::PHRASE_LATEX2E); else if (name.empty()) lyxerr << "LyX function 'specialchar-insert' needs an argument." << endl; else @@ -1156,16 +1378,45 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) break; } + case LFUN_IPAMACRO_INSERT: { + string const arg = cmd.getArg(0); + if (arg == "deco") { + // Open the inset, and move the current selection + // inside it. + doInsertInset(cur, this, cmd, true, true); + cur.posForward(); + // Some insets are numbered, others are shown in the outline pane so + // let's update the labels and the toc backend. + cur.forceBufferUpdate(); + break; + } + if (arg == "tone-falling") + ipaChar(cur, InsetIPAChar::TONE_FALLING); + else if (arg == "tone-rising") + ipaChar(cur, InsetIPAChar::TONE_RISING); + else if (arg == "tone-high-rising") + ipaChar(cur, InsetIPAChar::TONE_HIGH_RISING); + else if (arg == "tone-low-rising") + ipaChar(cur, InsetIPAChar::TONE_LOW_RISING); + else if (arg == "tone-high-rising-falling") + ipaChar(cur, InsetIPAChar::TONE_HIGH_RISING_FALLING); + else if (arg.empty()) + lyxerr << "LyX function 'ipamacro-insert' needs an argument." << endl; + else + lyxerr << "Wrong argument for LyX function 'ipamacro-insert'." << endl; + break; + } + case LFUN_WORD_UPCASE: - changeCase(cur, text_uppercase); + changeCase(cur, text_uppercase, cmd.getArg(0) == "partial"); break; case LFUN_WORD_LOWCASE: - changeCase(cur, text_lowercase); + changeCase(cur, text_lowercase, cmd.getArg(0) == "partial"); break; case LFUN_WORD_CAPITALIZE: - changeCase(cur, text_capitalization); + changeCase(cur, text_capitalization, cmd.getArg(0) == "partial"); break; case LFUN_CHARS_TRANSPOSE: @@ -1174,23 +1425,30 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) case LFUN_PASTE: { cur.message(_("Paste")); - LASSERT(cur.selBegin().idx() == cur.selEnd().idx(), /**/); + LASSERT(cur.selBegin().idx() == cur.selEnd().idx(), break); cap::replaceSelection(cur); // without argument? string const arg = to_utf8(cmd.argument()); if (arg.empty()) { + bool tryGraphics = true; if (theClipboard().isInternal()) pasteFromStack(cur, bv->buffer().errorList("Paste"), 0); - else if (theClipboard().hasGraphicsContents() - && !theClipboard().hasTextContents()) + else if (theClipboard().hasTextContents()) { + if (pasteClipboardText(cur, bv->buffer().errorList("Paste"), + true, Clipboard::AnyTextType)) + tryGraphics = false; + } + if (tryGraphics && theClipboard().hasGraphicsContents()) pasteClipboardGraphics(cur, bv->buffer().errorList("Paste")); - else - pasteClipboardText(cur, bv->buffer().errorList("Paste")); } else if (isStrUnsignedInt(arg)) { // we have a numerical argument pasteFromStack(cur, bv->buffer().errorList("Paste"), convert(arg)); + } else if (arg == "html" || arg == "latex") { + Clipboard::TextType type = (arg == "html") ? + Clipboard::HtmlTextType : Clipboard::LaTeXTextType; + pasteClipboardText(cur, bv->buffer().errorList("Paste"), true, type); } else { Clipboard::GraphicsType type = Clipboard::AnyGraphicsType; if (arg == "pdf") @@ -1205,9 +1463,9 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) type = Clipboard::EmfGraphicsType; else if (arg == "wmf") type = Clipboard::WmfGraphicsType; - else - LASSERT(false, /**/); + // we also check in getStatus() + LYXERR0("Unrecognized graphics type: " << arg); pasteClipboardGraphics(cur, bv->buffer().errorList("Paste"), type); } @@ -1252,7 +1510,8 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) break; case LFUN_LAYOUT: { - docstring layout = cmd.argument(); + bool const ignoreautonests = cmd.getArg(1) == "ignoreautonests"; + docstring layout = ignoreautonests ? from_utf8(cmd.getArg(0)) : cmd.argument(); LYXERR(Debug::INFO, "LFUN_LAYOUT: (arg) " << to_utf8(layout)); Paragraph const & para = cur.paragraph(); @@ -1306,20 +1565,122 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) } } - if (change_layout) + if (change_layout) { setLayout(cur, layout); + if (cur.pit() > 0 && !ignoreautonests) { + set const & autonests = + pars_[cur.pit() - 1].layout().autonests(); + set const & autonested = + pars_[cur.pit()].layout().isAutonestedBy(); + if (autonests.find(layout) != autonests.end() + || autonested.find(old_layout) != autonested.end()) + lyx::dispatch(FuncRequest(LFUN_DEPTH_INCREMENT)); + } + } + + Layout::LaTeXArgMap args = tclass[layout].args(); + Layout::LaTeXArgMap::const_iterator lait = args.begin(); + Layout::LaTeXArgMap::const_iterator const laend = args.end(); + for (; lait != laend; ++lait) { + Layout::latexarg arg = (*lait).second; + if (arg.autoinsert) { + FuncRequest cmd(LFUN_ARGUMENT_INSERT, (*lait).first); + lyx::dispatch(cmd); + } + } + + break; + } + + case LFUN_ENVIRONMENT_SPLIT: { + bool const outer = cmd.argument() == "outer"; + bool const previous = cmd.argument() == "previous"; + bool const before = cmd.argument() == "before"; + bool const normal = cmd.argument().empty(); + Paragraph const & para = cur.paragraph(); + docstring layout; + if (para.layout().isEnvironment()) + layout = para.layout().name(); + depth_type split_depth = cur.paragraph().params().depth(); + depth_type nextpar_depth = 0; + if (outer || previous) { + // check if we have an environment in our scope + pit_type pit = cur.pit(); + Paragraph cpar = pars_[pit]; + while (true) { + if (pit == 0) + break; + --pit; + cpar = pars_[pit]; + if (layout.empty() && previous + && cpar.layout().isEnvironment() + && cpar.params().depth() <= split_depth) + layout = cpar.layout().name(); + if (cpar.params().depth() < split_depth + && cpar.layout().isEnvironment()) { + if (!previous) + layout = cpar.layout().name(); + split_depth = cpar.params().depth(); + } + if (cpar.params().depth() == 0) + break; + } + } + if ((outer || normal) && cur.pit() < cur.lastpit()) { + // save nesting of following paragraph + Paragraph cpar = pars_[cur.pit() + 1]; + nextpar_depth = cpar.params().depth(); + } + if (before) + cur.top().setPitPos(cur.pit(), 0); + if (before || cur.pos() > 0) + lyx::dispatch(FuncRequest(LFUN_PARAGRAPH_BREAK)); + else if (previous && cur.nextInset() && cur.nextInset()->lyxCode() == SEPARATOR_CODE) + lyx::dispatch(FuncRequest(LFUN_PARAGRAPH_BREAK, "inverse ignoresep")); + if (outer) { + while (cur.paragraph().params().depth() > split_depth) + lyx::dispatch(FuncRequest(LFUN_DEPTH_DECREMENT)); + } + DocumentClass const & tc = bv->buffer().params().documentClass(); + lyx::dispatch(FuncRequest(LFUN_LAYOUT, from_ascii("\"") + tc.plainLayout().name() + + from_ascii("\" ignoreautonests"))); + lyx::dispatch(FuncRequest(LFUN_SEPARATOR_INSERT, "plain")); + if (before) { + cur.backwardPos(); + lyx::dispatch(FuncRequest(LFUN_PARAGRAPH_BREAK, "inverse ignoresep")); + while (cur.paragraph().params().depth() < split_depth) + lyx::dispatch(FuncRequest(LFUN_DEPTH_INCREMENT)); + } + else + lyx::dispatch(FuncRequest(LFUN_PARAGRAPH_BREAK, "inverse")); + lyx::dispatch(FuncRequest(LFUN_LAYOUT, layout)); + if ((outer || normal) && nextpar_depth > 0) { + // restore nesting of following paragraph + DocIterator scur = cur; + depth_type const max_depth = cur.paragraph().params().depth() + 1; + cur.forwardPar(); + while (cur.paragraph().params().depth() < min(nextpar_depth, max_depth)) + lyx::dispatch(FuncRequest(LFUN_DEPTH_INCREMENT)); + cur.setCursor(scur); + } break; } case LFUN_CLIPBOARD_PASTE: - cur.clearSelection(); + cap::replaceSelection(cur); pasteClipboardText(cur, bv->buffer().errorList("Paste"), cmd.argument() == "paragraph"); bv->buffer().errors("Paste"); break; + case LFUN_CLIPBOARD_PASTE_SIMPLE: + cap::replaceSelection(cur); + pasteSimpleText(cur, cmd.argument() == "paragraph"); + break; + case LFUN_PRIMARY_SELECTION_PASTE: + cap::replaceSelection(cur); pasteString(cur, theSelection().get(), cmd.argument() == "paragraph"); break; @@ -1328,6 +1689,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) // Copy the selection buffer to the clipboard stack, // because we want it to appear in the "Edit->Paste // recent" menu. + cap::replaceSelection(cur); cap::copySelectionToStack(); cap::pasteSelection(bv->cursor(), bv->buffer().errorList("Paste")); bv->buffer().errors("Paste"); @@ -1349,33 +1711,53 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) } case LFUN_QUOTE_INSERT: { - Paragraph & par = cur.paragraph(); + cap::replaceSelection(cur); + cur.recordUndo(); + + Paragraph const & par = cur.paragraph(); pos_type pos = cur.pos(); - BufferParams const & bufparams = bv->buffer().params(); - Layout const & style = par.layout(); - InsetLayout const & ilayout = cur.inset().getLayout(); - if (!style.pass_thru && !ilayout.isPassThru() - && par.getFontSettings(bufparams, pos).language()->lang() != "hebrew") { - // this avoids a double undo - // FIXME: should not be needed, ideally - if (!cur.selection()) - cur.recordUndo(); - cap::replaceSelection(cur); - pos = cur.pos(); - char_type c; - if (pos == 0) - c = ' '; - else if (cur.prevInset() && cur.prevInset()->isSpace()) - c = ' '; - else + // Ignore deleted text before cursor + while (pos > 0 && par.isDeleted(pos - 1)) + --pos; + + bool const inner = (cmd.getArg(0) == "single" || cmd.getArg(0) == "inner"); + + // Guess quote side. + // A space triggers an opening quote. This is passed if the preceding + // char/inset is a space or at paragraph start. + char_type c = ' '; + if (pos > 0 && !par.isSpace(pos - 1)) { + if (cur.prevInset() && cur.prevInset()->lyxCode() == QUOTE_CODE) { + // If an opening double quotation mark precedes, and this + // is a single quote, make it opening as well + InsetQuotes & ins = + static_cast(*cur.prevInset()); + string const type = ins.getType(); + if (!suffixIs(type, "ld") || !inner) + c = par.getChar(pos - 1); + } + else if (!cur.prevInset() + || (cur.prevInset() && cur.prevInset()->isChar())) + // If a char precedes, pass that and let InsetQuote decide c = par.getChar(pos - 1); - string arg = to_utf8(cmd.argument()); - cur.insert(new InsetQuotes(cur.buffer(), c, (arg == "single") - ? InsetQuotes::SingleQuotes : InsetQuotes::DoubleQuotes)); - cur.posForward(); + else { + while (pos > 0) { + if (par.getInset(pos - 1) + && !par.getInset(pos - 1)->isPartOfTextSequence()) { + // skip "invisible" insets + --pos; + continue; + } + c = par.getChar(pos - 1); + break; + } + } } - else - lyx::dispatch(FuncRequest(LFUN_SELF_INSERT, "\"")); + InsetQuotesParams::QuoteLevel const quote_level = inner + ? InsetQuotesParams::SecondaryQuotes : InsetQuotesParams::PrimaryQuotes; + cur.insert(new InsetQuotes(cur.buffer(), c, quote_level, cmd.getArg(1), cmd.getArg(2))); + cur.buffer()->updateBuffer(); + cur.posForward(); break; } @@ -1399,7 +1781,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) case LFUN_MOUSE_DOUBLE: if (cmd.button() == mouse_button::button1) { - selectWord(cur, WHOLE_WORD_STRICT); + selectWord(cur, WHOLE_WORD); bv->cursor() = cur; } break; @@ -1411,20 +1793,24 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) bvcur.setMark(false); switch (cmd.button()) { case mouse_button::button1: - // Set the cursor - if (!bv->mouseSetCursor(cur, cmd.argument() == "region-select")) - cur.updateFlags(Update::SinglePar | Update::FitCursor); + if (!bvcur.selection()) + // Set the cursor + bvcur.resetAnchor(); + if (!bv->mouseSetCursor(cur, cmd.modifier() == ShiftModifier)) + cur.screenUpdateFlags(Update::SinglePar | Update::FitCursor); if (bvcur.wordSelection()) selectWord(bvcur, WHOLE_WORD); break; case mouse_button::button2: - // Middle mouse pasting. - bv->mouseSetCursor(cur); - lyx::dispatch( - FuncRequest(LFUN_COMMAND_ALTERNATIVES, - "selection-paste ; primary-selection-paste paragraph")); - cur.noUpdate(); + if (lyxrc.mouse_middlebutton_paste) { + // Middle mouse pasting. + bv->mouseSetCursor(cur); + lyx::dispatch( + FuncRequest(LFUN_COMMAND_ALTERNATIVES, + "selection-paste ; primary-selection-paste paragraph")); + } + cur.noScreenUpdate(); break; case mouse_button::button3: { @@ -1432,11 +1818,11 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) // selection, a context menu will popup. if (bvcur.selection() && cur >= bvcur.selectionBegin() && cur < bvcur.selectionEnd()) { - cur.noUpdate(); + cur.noScreenUpdate(); return; } if (!bv->mouseSetCursor(cur, false)) - cur.updateFlags(Update::SinglePar | Update::FitCursor); + cur.screenUpdateFlags(Update::FitCursor); break; } @@ -1448,41 +1834,45 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) case LFUN_MOUSE_MOTION: { // Mouse motion with right or middle mouse do nothing for now. if (cmd.button() != mouse_button::button1) { - cur.noUpdate(); + cur.noScreenUpdate(); return; } // ignore motions deeper nested than the real anchor Cursor & bvcur = cur.bv().cursor(); - if (!bvcur.anchor_.hasPart(cur)) { + if (!bvcur.realAnchor().hasPart(cur)) { cur.undispatched(); break; } CursorSlice old = bvcur.top(); int const wh = bv->workHeight(); - int const y = max(0, min(wh - 1, cmd.y)); - - tm->setCursorFromCoordinates(cur, cmd.x, y); - cur.setTargetX(cmd.x); - if (cmd.y >= wh) + int const y = max(0, min(wh - 1, cmd.y())); + + tm->setCursorFromCoordinates(cur, cmd.x(), y); + cur.setTargetX(cmd.x()); + // Don't allow selecting a separator inset + if (cur.pos() && cur.paragraph().isEnvSeparator(cur.pos() - 1)) + cur.posBackward(); + if (cmd.y() >= wh) lyx::dispatch(FuncRequest(LFUN_DOWN_SELECT)); - else if (cmd.y < 0) + else if (cmd.y() < 0) lyx::dispatch(FuncRequest(LFUN_UP_SELECT)); // This is to allow jumping over large insets if (cur.top() == old) { - if (cmd.y >= wh) + if (cmd.y() >= wh) lyx::dispatch(FuncRequest(LFUN_DOWN_SELECT)); - else if (cmd.y < 0) + else if (cmd.y() < 0) lyx::dispatch(FuncRequest(LFUN_UP_SELECT)); } // We continue with our existing selection or start a new one, so don't // reset the anchor. bvcur.setCursor(cur); - bvcur.setSelection(true); + bvcur.selection(true); + bvcur.setCurrentFont(); if (cur.top() == old) { // We didn't move one iota, so no need to update the screen. - cur.updateFlags(Update::SinglePar | Update::FitCursor); - //cur.noUpdate(); + cur.screenUpdateFlags(Update::SinglePar | Update::FitCursor); + //cur.noScreenUpdate(); return; } break; @@ -1503,23 +1893,23 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) cur.bv().cursor().setSelection(); // We might have removed an empty but drawn selection // (probably a margin) - cur.updateFlags(Update::SinglePar | Update::FitCursor); + cur.screenUpdateFlags(Update::SinglePar | Update::FitCursor); } else - cur.noUpdate(); + cur.noScreenUpdate(); // FIXME: We could try to handle drag and drop of selection here. return; case mouse_button::button2: // Middle mouse pasting is handled at mouse press time, // see LFUN_MOUSE_PRESS. - cur.noUpdate(); + cur.noScreenUpdate(); return; case mouse_button::button3: // Cursor was set at LFUN_MOUSE_PRESS time. // FIXME: If there is a selection we could try to handle a special // drag & drop context menu. - cur.noUpdate(); + cur.noScreenUpdate(); return; case mouse_button::none: @@ -1552,20 +1942,48 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) cur.resetAnchor(); moveCursor(cur, false); + cur.markNewWordPosition(); bv->bookmarkEditPosition(); break; } - case LFUN_HYPERLINK_INSERT: { - InsetCommandParams p(HYPERLINK_CODE); - docstring content; - if (cur.selection()) { + case LFUN_HREF_INSERT: { + docstring content = cmd.argument(); + if (content.empty() && cur.selection()) content = cur.selectionAsString(false); - cutSelection(cur, true, false); + + InsetCommandParams p(HYPERLINK_CODE); + if (!content.empty()){ + // if it looks like a link, we'll put it as target, + // otherwise as name (bug #8792). + + // We can't do: + // regex_match(to_utf8(content), matches, link_re) + // because smatch stores pointers to the substrings rather + // than making copies of them. And those pointers become + // invalid after regex_match returns, since it is then + // being given a temporary object. (Thanks to Georg for + // figuring that out.) + regex const link_re("^([a-z]+):.*"); + smatch matches; + string const c = to_utf8(lowercase(content)); + + if (c.substr(0,7) == "mailto:") { + p["target"] = content; + p["type"] = from_ascii("mailto:"); + } else if (regex_match(c, matches, link_re)) { + p["target"] = content; + string protocol = matches.str(1); + if (protocol == "file") + p["type"] = from_ascii("file:"); + } else + p["name"] = content; } - p["target"] = (cmd.argument().empty()) ? - content : cmd.argument(); - string const data = InsetCommand::params2string("href", p); + string const data = InsetCommand::params2string(p); + + // we need to have a target. if we already have one, then + // that gets used at the default for the name, too, which + // is probably what is wanted. if (p["target"].empty()) { bv->showDialog("href", data); } else { @@ -1581,7 +1999,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) p["name"] = (cmd.argument().empty()) ? cur.getPossibleLabel() : cmd.argument(); - string const data = InsetCommand::params2string("label", p); + string const data = InsetCommand::params2string(p); if (cmd.argument().empty()) { bv->showDialog("label", data); @@ -1607,29 +2025,63 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) break; cur.recordUndo(); insertInset(cur, inset); + cur.forceBufferUpdate(); cur.posForward(); break; } case LFUN_CAPTION_INSERT: case LFUN_FOOTNOTE_INSERT: case LFUN_NOTE_INSERT: - case LFUN_FLEX_INSERT: case LFUN_BOX_INSERT: case LFUN_BRANCH_INSERT: case LFUN_PHANTOM_INSERT: case LFUN_ERT_INSERT: case LFUN_LISTING_INSERT: case LFUN_MARGINALNOTE_INSERT: - case LFUN_OPTIONAL_INSERT: + case LFUN_ARGUMENT_INSERT: case LFUN_INDEX_INSERT: + case LFUN_PREVIEW_INSERT: + case LFUN_SCRIPT_INSERT: + case LFUN_IPA_INSERT: // Open the inset, and move the current selection // inside it. doInsertInset(cur, this, cmd, true, true); cur.posForward(); // Some insets are numbered, others are shown in the outline pane so // let's update the labels and the toc backend. - bv->buffer().updateLabels(); + cur.forceBufferUpdate(); + break; + + case LFUN_FLEX_INSERT: { + // Open the inset, and move the current selection + // inside it. + bool const sel = cur.selection(); + doInsertInset(cur, this, cmd, true, true); + // Insert auto-insert arguments + bool autoargs = false; + Layout::LaTeXArgMap args = cur.inset().getLayout().latexargs(); + Layout::LaTeXArgMap::const_iterator lait = args.begin(); + Layout::LaTeXArgMap::const_iterator const laend = args.end(); + for (; lait != laend; ++lait) { + Layout::latexarg arg = (*lait).second; + if (arg.autoinsert) { + // The cursor might have been invalidated by the replaceSelection. + cur.buffer()->changed(true); + FuncRequest cmd(LFUN_ARGUMENT_INSERT, (*lait).first); + lyx::dispatch(cmd); + autoargs = true; + } + } + if (!autoargs) { + if (sel) + cur.leaveInset(cur.inset()); + cur.posForward(); + } + // Some insets are numbered, others are shown in the outline pane so + // let's update the labels and the toc backend. + cur.forceBufferUpdate(); break; + } case LFUN_TABULAR_INSERT: // if there were no arguments, just open the dialog @@ -1643,16 +2095,19 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) case LFUN_FLOAT_INSERT: case LFUN_FLOAT_WIDE_INSERT: case LFUN_WRAP_INSERT: { - // will some text be moved into the inset? - bool content = cur.selection(); + // will some content be moved into the inset? + bool const content = cur.selection(); + // does the content consist of multiple paragraphs? + bool const singlepar = (cur.selBegin().pit() == cur.selEnd().pit()); doInsertInset(cur, this, cmd, true, true); cur.posForward(); - // If some text is moved into the inset, doInsertInset - // puts the cursor outside the inset. To insert the - // caption we put it back into the inset. - if (content) + // If some single-par content is moved into the inset, + // doInsertInset puts the cursor outside the inset. + // To insert the caption we put it back into the inset. + // FIXME cleanup doInsertInset to avoid such dances! + if (content && singlepar) cur.backwardPos(); ParagraphList & pars = cur.text()->paragraphs(); @@ -1682,8 +2137,8 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) // date metrics. FuncRequest cmd_caption(LFUN_CAPTION_INSERT); doInsertInset(cur, cur.text(), cmd_caption, true, false); - bv->buffer().updateLabels(); - cur.updateFlags(Update::Force); + cur.forceBufferUpdate(); + cur.screenUpdateFlags(Update::Force); // FIXME: When leaving the Float (or Wrap) inset we should // delete any empty paragraph left above or below the // caption. @@ -1696,7 +2151,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) p["symbol"] = bv->cursor().innerText()->getStringToIndex(bv->cursor()); else p["symbol"] = cmd.argument(); - string const data = InsetCommand::params2string("nomenclature", p); + string const data = InsetCommand::params2string(p); bv->showDialog("nomenclature", data); break; } @@ -1707,21 +2162,29 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) p["type"] = from_ascii("idx"); else p["type"] = cmd.argument(); - string const data = InsetCommand::params2string("index_print", p); + string const data = InsetCommand::params2string(p); FuncRequest fr(LFUN_INSET_INSERT, data); dispatch(cur, fr); break; } - + case LFUN_NOMENCL_PRINT: - case LFUN_TOC_INSERT: - case LFUN_LINE_INSERT: case LFUN_NEWPAGE_INSERT: // do nothing fancy doInsertInset(cur, this, cmd, false, false); cur.posForward(); break; + case LFUN_SEPARATOR_INSERT: { + doInsertInset(cur, this, cmd, false, false); + cur.posForward(); + // remove a following space + Paragraph & par = cur.paragraph(); + if (cur.pos() != cur.lastpos() && par.isLineSeparator(cur.pos())) + par.eraseChar(cur.pos(), cur.buffer()->params().track_changes); + break; + } + case LFUN_DEPTH_DECREMENT: changeDepth(cur, DEC_DEPTH); break; @@ -1730,26 +2193,44 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) changeDepth(cur, INC_DEPTH); break; - case LFUN_MATH_DISPLAY: - mathDispatch(cur, cmd, true); - break; - case LFUN_REGEXP_MODE: regexpDispatch(cur, cmd); break; - case LFUN_MATH_MODE: - if (cmd.argument() == "on") + case LFUN_MATH_MODE: { + if (cmd.argument() == "on" || cmd.argument() == "") { // don't pass "on" as argument - mathDispatch(cur, FuncRequest(LFUN_MATH_MODE), false); - else - mathDispatch(cur, cmd, false); + // (it would appear literally in the first cell) + docstring sel = cur.selectionAsString(false); + InsetMathMacroTemplate * macro = new InsetMathMacroTemplate(cur.buffer()); + // create a macro template if we see "\\newcommand" somewhere, and + // an ordinary formula otherwise + if (!sel.empty() + && (sel.find(from_ascii("\\newcommand")) != string::npos + || sel.find(from_ascii("\\newlyxcommand")) != string::npos + || sel.find(from_ascii("\\def")) != string::npos) + && macro->fromString(sel)) { + cur.recordUndo(); + replaceSelection(cur); + cur.insert(macro); + } else { + // no meaningful macro template was found + delete macro; + mathDispatch(cur,FuncRequest(LFUN_MATH_MODE)); + } + } else + // The argument is meaningful + // We replace cmd with LFUN_MATH_INSERT because LFUN_MATH_MODE + // has a different meaning in math mode + mathDispatch(cur, FuncRequest(LFUN_MATH_INSERT,cmd.argument())); break; + } case LFUN_MATH_MACRO: if (cmd.argument().empty()) cur.errorMessage(from_utf8(N_("Missing argument"))); else { + cur.recordUndo(); string s = to_utf8(cmd.argument()); string const s1 = token(s, ' ', 1); int const nargs = s1.empty() ? 0 : convert(s1); @@ -1757,7 +2238,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) MacroType type = MacroTypeNewcommand; if (s2 == "def") type = MacroTypeDef; - MathMacroTemplate * inset = new MathMacroTemplate(cur.buffer(), + InsetMathMacroTemplate * inset = new InsetMathMacroTemplate(cur.buffer(), from_utf8(token(s, ' ', 0)), nargs, false, type); inset->setBuffer(bv->buffer()); insertInset(cur, inset); @@ -1766,32 +2247,21 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) cur.push(*inset); cur.top().pos() = cur.top().lastpos(); cur.resetAnchor(); - cur.setSelection(true); + cur.selection(true); cur.top().pos() = 0; } break; - // passthrough hat and underscore outside mathed: + case LFUN_MATH_DISPLAY: case LFUN_MATH_SUBSCRIPT: - mathDispatch(cur, FuncRequest(LFUN_SELF_INSERT, "_"), false); - break; case LFUN_MATH_SUPERSCRIPT: - mathDispatch(cur, FuncRequest(LFUN_SELF_INSERT, "^"), false); - break; - case LFUN_MATH_INSERT: case LFUN_MATH_AMS_MATRIX: case LFUN_MATH_MATRIX: case LFUN_MATH_DELIM: - case LFUN_MATH_BIGDELIM: { - cur.recordUndo(); - cap::replaceSelection(cur); - cur.insert(new InsetMathHull(cur.buffer(), hullSimple)); - checkAndActivateInset(cur, true); - LASSERT(cur.inMathed(), /**/); - cur.dispatch(cmd); + case LFUN_MATH_BIGDELIM: + mathDispatch(cur, cmd); break; - } case LFUN_FONT_EMPH: { Font font(ignore_font, ignore_language); @@ -1856,14 +2326,21 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) break; } - case LFUN_FONT_UULINE: { + case LFUN_FONT_CROSSOUT: { + Font font(ignore_font, ignore_language); + font.fontInfo().setXout(FONT_TOGGLE); + toggleAndShow(cur, this, font); + break; + } + + case LFUN_FONT_UNDERUNDERLINE: { Font font(ignore_font, ignore_language); font.fontInfo().setUuline(FONT_TOGGLE); toggleAndShow(cur, this, font); break; } - case LFUN_FONT_UWAVE: { + case LFUN_FONT_UNDERWAVE: { Font font(ignore_font, ignore_language); font.fontInfo().setUwave(FONT_TOGGLE); toggleAndShow(cur, this, font); @@ -1885,11 +2362,19 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) } case LFUN_LANGUAGE: { - Language const * lang = languages.getLanguage(to_utf8(cmd.argument())); - if (!lang) + string const lang_arg = cmd.getArg(0); + bool const reset = (lang_arg.empty() || lang_arg == "reset"); + Language const * lang = + reset ? reset_language + : languages.getLanguage(lang_arg); + // we allow reset_language, which is 0, but only if it + // was requested via empty or "reset" arg. + if (!lang && !reset) break; + bool const toggle = (cmd.getArg(1) != "set"); + selectWordWhenUnderCursor(cur, WHOLE_WORD_STRICT); Font font(ignore_font, lang); - toggleAndShow(cur, this, font); + toggleAndShow(cur, this, font, toggle); break; } @@ -1938,6 +2423,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) case LFUN_FINISHED_BACKWARD: LYXERR(Debug::DEBUG, "handle LFUN_FINISHED_BACKWARD:\n" << cur); + cur.setCurrentFont(); break; case LFUN_FINISHED_FORWARD: @@ -1972,6 +2458,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) case LFUN_ACCENT_GRAVE: case LFUN_ACCENT_ACUTE: case LFUN_ACCENT_TILDE: + case LFUN_ACCENT_PERISPOMENI: case LFUN_ACCENT_CEDILLA: case LFUN_ACCENT_MACRON: case LFUN_ACCENT_DOT: @@ -1983,10 +2470,11 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) case LFUN_ACCENT_HUNGARIAN_UMLAUT: case LFUN_ACCENT_CIRCLE: case LFUN_ACCENT_OGONEK: - theApp()->handleKeyFunc(cmd.action); + theApp()->handleKeyFunc(cmd.action()); if (!cmd.argument().empty()) // FIXME: Are all these characters encoded in one byte in utf8? bv->translateAndInsert(cmd.argument()[0], this, cur); + cur.screenUpdateFlags(Update::FitCursor); break; case LFUN_FLOAT_LIST_INSERT: { @@ -2034,6 +2522,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) } case LFUN_THESAURUS_ENTRY: { + Language const * language = cur.getFont().language(); docstring arg = cmd.argument(); if (arg.empty()) { arg = cur.selectionAsString(false); @@ -2042,13 +2531,81 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) // Get word or selection selectWordWhenUnderCursor(cur, WHOLE_WORD); arg = cur.selectionAsString(false); - arg += " lang=" + from_ascii(cur.getFont().language()->lang()); + arg += " lang=" + from_ascii(language->lang()); + } + } else { + string lang = cmd.getArg(1); + // This duplicates the code in GuiThesaurus::initialiseParams + if (prefixIs(lang, "lang=")) { + language = languages.getLanguage(lang.substr(5)); + if (!language) + language = cur.getFont().language(); } } + string lang = language->code(); + if (lyxrc.thesaurusdir_path.empty() && !thesaurus.thesaurusInstalled(from_ascii(lang))) { + LYXERR(Debug::ACTION, "Command " << cmd << ". Thesaurus not found for language " << lang); + frontend::Alert::warning(_("Path to thesaurus directory not set!"), + _("The path to the thesaurus directory has not been specified.\n" + "The thesaurus is not functional.\n" + "Please refer to sec. 6.15.1 of the User's Guide for setup\n" + "instructions.")); + } bv->showDialog("thesaurus", to_utf8(arg)); break; } + case LFUN_SPELLING_ADD: { + Language const * language = getLanguage(cur, cmd.getArg(1)); + docstring word = from_utf8(cmd.getArg(0)); + if (word.empty()) { + word = cur.selectionAsString(false); + // FIXME + if (word.size() > 100 || word.empty()) { + // Get word or selection + selectWordWhenUnderCursor(cur, WHOLE_WORD); + word = cur.selectionAsString(false); + } + } + WordLangTuple wl(word, language); + theSpellChecker()->insert(wl); + break; + } + + case LFUN_SPELLING_IGNORE: { + Language const * language = getLanguage(cur, cmd.getArg(1)); + docstring word = from_utf8(cmd.getArg(0)); + if (word.empty()) { + word = cur.selectionAsString(false); + // FIXME + if (word.size() > 100 || word.empty()) { + // Get word or selection + selectWordWhenUnderCursor(cur, WHOLE_WORD); + word = cur.selectionAsString(false); + } + } + WordLangTuple wl(word, language); + theSpellChecker()->accept(wl); + break; + } + + case LFUN_SPELLING_REMOVE: { + Language const * language = getLanguage(cur, cmd.getArg(1)); + docstring word = from_utf8(cmd.getArg(0)); + if (word.empty()) { + word = cur.selectionAsString(false); + // FIXME + if (word.size() > 100 || word.empty()) { + // Get word or selection + selectWordWhenUnderCursor(cur, WHOLE_WORD); + word = cur.selectionAsString(false); + } + } + WordLangTuple wl(word, language); + theSpellChecker()->remove(wl); + break; + } + case LFUN_PARAGRAPH_PARAMS_APPLY: { // Given data, an encoding of the ParagraphParameters // generated in the Paragraph dialog, this function sets @@ -2073,7 +2630,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) case LFUN_ESCAPE: if (cur.selection()) { - cur.setSelection(false); + cur.selection(false); } else { cur.undispatched(); // This used to be LFUN_FINISHED_RIGHT, I think FORWARD is more @@ -2083,40 +2640,57 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) break; case LFUN_OUTLINE_UP: - outline(OutlineUp, cur); + outline(OutlineUp, cur, this); setCursor(cur, cur.pit(), 0); - cur.buffer()->updateLabels(); + cur.forceBufferUpdate(); needsUpdate = true; break; case LFUN_OUTLINE_DOWN: - outline(OutlineDown, cur); + outline(OutlineDown, cur, this); setCursor(cur, cur.pit(), 0); - cur.buffer()->updateLabels(); + cur.forceBufferUpdate(); needsUpdate = true; break; case LFUN_OUTLINE_IN: - outline(OutlineIn, cur); - cur.buffer()->updateLabels(); + outline(OutlineIn, cur, this); + cur.forceBufferUpdate(); needsUpdate = true; break; case LFUN_OUTLINE_OUT: - outline(OutlineOut, cur); - cur.buffer()->updateLabels(); + outline(OutlineOut, cur, this); + cur.forceBufferUpdate(); needsUpdate = true; break; - - case LFUN_OUTLINE_DRAGMOVE: { - int const move_id = convert(cmd.getArg(0)); - int const move_to_id = convert(cmd.getArg(1)); - dragMove(cur, move_id, move_to_id); - setCursor(cur, cur.pit(), 0); - cur.buffer()->updateLabels(); - needsUpdate = true; + + case LFUN_SERVER_GET_STATISTICS: + { + DocIterator from, to; + if (cur.selection()) { + from = cur.selectionBegin(); + to = cur.selectionEnd(); + } else { + from = doc_iterator_begin(cur.buffer()); + to = doc_iterator_end(cur.buffer()); + } + + cur.buffer()->updateStatistics(from, to); + string const arg0 = cmd.getArg(0); + if (arg0 == "words") { + cur.message(convert(cur.buffer()->wordCount())); + } else if (arg0 == "chars") { + cur.message(convert(cur.buffer()->charCount(false))); + } else if (arg0 == "chars-space") { + cur.message(convert(cur.buffer()->charCount(true))); + } else { + cur.message(convert(cur.buffer()->wordCount()) + " " + + convert(cur.buffer()->charCount(false)) + " " + + convert(cur.buffer()->charCount(true))); + } + } break; - } default: LYXERR(Debug::ACTION, "Command " << cmd << " not DISPATCHED by Text"); @@ -2126,12 +2700,27 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) needsUpdate |= (cur.pos() != cur.lastpos()) && cur.selection(); + if (lyxrc.spellcheck_continuously && !needsUpdate) { + // Check for misspelled text + // The redraw is useful because of the painting of + // misspelled markers depends on the cursor position. + // Trigger a redraw for cursor moves inside misspelled text. + if (!cur.inTexted()) { + // move from regular text to math + needsUpdate = last_misspelled; + } else if (oldTopSlice != cur.top() || oldBoundary != cur.boundary()) { + // move inside regular text + needsUpdate = last_misspelled + || cur.paragraph().isMisspelled(cur.pos(), true); + } + } + // FIXME: The cursor flag is reset two lines below // so we need to check here if some of the LFUN did touch that. // for now only Text::erase() and Text::backspace() do that. // The plan is to verify all the LFUNs and then to remove this // singleParUpdate boolean altogether. - if (cur.result().update() & Update::Force) { + if (cur.result().screenUpdate() & Update::Force) { singleParUpdate = false; needsUpdate = true; } @@ -2142,40 +2731,40 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) // Inserting characters does not change par height in general. So, try // to update _only_ this paragraph. BufferView will detect if a full // metrics update is needed anyway. - cur.updateFlags(Update::SinglePar | Update::FitCursor); + cur.screenUpdateFlags(Update::SinglePar | Update::FitCursor); return; } - if (!needsUpdate && &oldTopSlice.inset() == &cur.inset() && oldTopSlice.idx() == cur.idx() - && !sel // sel is a backup of cur.selection() at the beginning of the function. + && !oldSelection // oldSelection is a backup of cur.selection() at the beginning of the function. && !cur.selection()) // FIXME: it would be better if we could just do this // //if (cur.result().update() != Update::FitCursor) - // cur.noUpdate(); + // cur.noScreenUpdate(); // // But some LFUNs do not set Update::FitCursor when needed, so we // do it for all. This is not very harmfull as FitCursor will provoke // a full redraw only if needed but still, a proper review of all LFUN // should be done and this needsUpdate boolean can then be removed. - cur.updateFlags(Update::FitCursor); + cur.screenUpdateFlags(Update::FitCursor); else - cur.updateFlags(Update::Force | Update::FitCursor); + cur.screenUpdateFlags(Update::Force | Update::FitCursor); } bool Text::getStatus(Cursor & cur, FuncRequest const & cmd, FuncStatus & flag) const { - LASSERT(cur.text() == this, /**/); + LBUFERR(this == cur.text()); FontInfo const & fontinfo = cur.real_current_font.fontInfo(); bool enable = true; + bool allow_in_passthru = false; InsetCode code = NO_CODE; - switch (cmd.action) { + switch (cmd.action()) { case LFUN_DEPTH_DECREMENT: enable = changeDepthAllowed(cur, DEC_DEPTH); @@ -2186,6 +2775,9 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd, break; case LFUN_APPENDIX: + // FIXME We really should not allow this to be put, e.g., + // in a footnote, or in ERT. But it would make sense in a + // branch, so I'm not sure what to do. flag.setOnOff(cur.paragraph().params().startOfAppendix()); break; @@ -2219,12 +2811,18 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd, code = INDEX_CODE; else if (cmd.argument() == "index_print") code = INDEX_PRINT_CODE; + else if (cmd.argument() == "listings") + code = LISTINGS_CODE; + else if (cmd.argument() == "mathspace") + code = MATH_HULL_CODE; else if (cmd.argument() == "nomenclature") code = NOMENCL_CODE; else if (cmd.argument() == "nomencl_print") code = NOMENCL_PRINT_CODE; else if (cmd.argument() == "label") code = LABEL_CODE; + else if (cmd.argument() == "line") + code = LINE_CODE; else if (cmd.argument() == "note") code = NOTE_CODE; else if (cmd.argument() == "phantom") @@ -2239,8 +2837,6 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd, code = VSPACE_CODE; else if (cmd.argument() == "wrap") code = WRAP_CODE; - else if (cmd.argument() == "listings") - code = LISTINGS_CODE; break; case LFUN_ERT_INSERT: @@ -2298,16 +2894,35 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd, // not allowed in description items enable = !inDescriptionItem(cur); break; - case LFUN_FLOAT_LIST_INSERT: + case LFUN_FLOAT_LIST_INSERT: { code = FLOAT_LIST_CODE; // not allowed in description items enable = !inDescriptionItem(cur); + if (enable) { + FloatList const & floats = cur.buffer()->params().documentClass().floats(); + FloatList::const_iterator cit = floats[to_ascii(cmd.argument())]; + // make sure we know about such floats + if (cit == floats.end() || + // and that we know how to generate a list of them + (!cit->second.usesFloatPkg() && cit->second.listCommand().empty())) { + flag.setUnknown(true); + // probably not necessary, but... + enable = false; + } + } break; - case LFUN_CAPTION_INSERT: + } + case LFUN_CAPTION_INSERT: { code = CAPTION_CODE; - // not allowed in description items - enable = !inDescriptionItem(cur); + string arg = cmd.getArg(0); + bool varia = arg != "Unnumbered" + && cur.inset().allowsCaptionVariation(arg); + // not allowed in description items, + // and in specific insets + enable = !inDescriptionItem(cur) + && (varia || arg.empty() || arg == "Standard"); break; + } case LFUN_NOTE_INSERT: code = NOTE_CODE; // in commands (sections etc.) and description items, @@ -2337,23 +2952,65 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd, && cur.buffer()->params().branchlist().empty()) enable = false; break; + case LFUN_IPA_INSERT: + code = IPA_CODE; + break; case LFUN_PHANTOM_INSERT: code = PHANTOM_CODE; break; case LFUN_LABEL_INSERT: code = LABEL_CODE; break; - case LFUN_LINE_INSERT: - code = LINE_CODE; - break; case LFUN_INFO_INSERT: code = INFO_CODE; break; - case LFUN_OPTIONAL_INSERT: - code = OPTARG_CODE; - enable = cur.paragraph().insetList().count(OPTARG_CODE) - < cur.paragraph().layout().optionalargs; + case LFUN_ARGUMENT_INSERT: { + code = ARG_CODE; + allow_in_passthru = true; + string const arg = cmd.getArg(0); + if (arg.empty()) { + enable = false; + break; + } + Layout const & lay = cur.paragraph().layout(); + Layout::LaTeXArgMap args = lay.args(); + Layout::LaTeXArgMap::const_iterator const lait = + args.find(arg); + if (lait != args.end()) { + enable = true; + pit_type pit = cur.pit(); + pit_type lastpit = cur.pit(); + if (lay.isEnvironment() && !prefixIs(arg, "item:")) { + // In a sequence of "merged" environment layouts, we only allow + // non-item arguments once. + lastpit = cur.lastpit(); + // get the first paragraph in sequence with this layout + depth_type const current_depth = cur.paragraph().params().depth(); + while (true) { + if (pit == 0) + break; + Paragraph cpar = pars_[pit - 1]; + if (cpar.layout() == lay && cpar.params().depth() == current_depth) + --pit; + else + break; + } + } + for (; pit <= lastpit; ++pit) { + if (pars_[pit].layout() != lay) + break; + for (auto const & table : pars_[pit].insetList()) + if (InsetArgument const * ins = table.inset->asInsetArgument()) + if (ins->name() == arg) { + // we have this already + enable = false; + break; + } + } + } else + enable = false; break; + } case LFUN_INDEX_INSERT: code = INDEX_CODE; break; @@ -2374,21 +3031,25 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd, // not allowed in description items enable = !inDescriptionItem(cur); break; - case LFUN_TOC_INSERT: - code = TOC_CODE; - // not allowed in description items - enable = !inDescriptionItem(cur); - break; - case LFUN_HYPERLINK_INSERT: + case LFUN_HREF_INSERT: if (cur.selIsMultiCell() || cur.selIsMultiLine()) { enable = false; break; } code = HYPERLINK_CODE; break; + case LFUN_IPAMACRO_INSERT: { + string const arg = cmd.getArg(0); + if (arg == "deco") + code = IPADECO_CODE; + else + code = IPACHAR_CODE; + break; + } case LFUN_QUOTE_INSERT: // always allow this, since we will inset a raw quote // if an inset is not allowed. + allow_in_passthru = true; break; case LFUN_SPECIALCHAR_INSERT: code = SPECIALCHAR_CODE; @@ -2398,6 +3059,12 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd, if (cur.inTexted()) code = SPACE_CODE; break; + case LFUN_PREVIEW_INSERT: + code = PREVIEW_CODE; + break; + case LFUN_SCRIPT_INSERT: + code = SCRIPT_CODE; + break; case LFUN_MATH_INSERT: case LFUN_MATH_AMS_MATRIX: @@ -2412,6 +3079,11 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd, code = MATH_HULL_CODE; break; + case LFUN_REGEXP_MODE: + code = MATH_HULL_CODE; + enable = cur.buffer()->isInternal() && !cur.inRegexped(); + break; + case LFUN_INSET_MODIFY: // We need to disable this, because we may get called for a // tabular cell via @@ -2422,31 +3094,38 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd, case LFUN_FONT_EMPH: flag.setOnOff(fontinfo.emph() == FONT_ON); + enable = !cur.paragraph().isPassThru(); break; case LFUN_FONT_ITAL: flag.setOnOff(fontinfo.shape() == ITALIC_SHAPE); + enable = !cur.paragraph().isPassThru(); break; case LFUN_FONT_NOUN: flag.setOnOff(fontinfo.noun() == FONT_ON); + enable = !cur.paragraph().isPassThru(); break; case LFUN_FONT_BOLD: case LFUN_FONT_BOLDSYMBOL: flag.setOnOff(fontinfo.series() == BOLD_SERIES); + enable = !cur.paragraph().isPassThru(); break; case LFUN_FONT_SANS: flag.setOnOff(fontinfo.family() == SANS_FAMILY); + enable = !cur.paragraph().isPassThru(); break; case LFUN_FONT_ROMAN: flag.setOnOff(fontinfo.family() == ROMAN_FAMILY); + enable = !cur.paragraph().isPassThru(); break; case LFUN_FONT_TYPEWRITER: flag.setOnOff(fontinfo.family() == TYPEWRITER_FAMILY); + enable = !cur.paragraph().isPassThru(); break; case LFUN_CUT: @@ -2472,24 +3151,47 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd, break; } - // explicit graphics type? - Clipboard::GraphicsType type = Clipboard::AnyGraphicsType; - if ((arg == "pdf" && (type = Clipboard::PdfGraphicsType)) - || (arg == "png" && (type = Clipboard::PngGraphicsType)) - || (arg == "jpeg" && (type = Clipboard::JpegGraphicsType)) - || (arg == "linkback" && (type = Clipboard::LinkBackGraphicsType)) - || (arg == "emf" && (type = Clipboard::EmfGraphicsType)) - || (arg == "wmf" && (type = Clipboard::WmfGraphicsType))) { - enable = theClipboard().hasGraphicsContents(type); + // explicit text type? + if (arg == "html") { + // Do not enable for PlainTextType, since some tidying in the + // frontend is needed for HTML, which is too unsafe for plain text. + enable = theClipboard().hasTextContents(Clipboard::HtmlTextType); + break; + } else if (arg == "latex") { + // LaTeX is usually not available on the clipboard with + // the correct MIME type, but in plain text. + enable = theClipboard().hasTextContents(Clipboard::PlainTextType) || + theClipboard().hasTextContents(Clipboard::LaTeXTextType); break; } - // unknown argument - enable = false; + Clipboard::GraphicsType type = Clipboard::AnyGraphicsType; + if (arg == "pdf") + type = Clipboard::PdfGraphicsType; + else if (arg == "png") + type = Clipboard::PngGraphicsType; + else if (arg == "jpeg") + type = Clipboard::JpegGraphicsType; + else if (arg == "linkback") + type = Clipboard::LinkBackGraphicsType; + else if (arg == "emf") + type = Clipboard::EmfGraphicsType; + else if (arg == "wmf") + type = Clipboard::WmfGraphicsType; + else { + // unknown argument + LYXERR0("Unrecognized graphics type: " << arg); + // we don't want to assert if the user just mistyped the LFUN + LATTEST(cmd.origin() != FuncRequest::INTERNAL); + enable = false; + break; + } + enable = theClipboard().hasGraphicsContents(type); break; - } + } case LFUN_CLIPBOARD_PASTE: + case LFUN_CLIPBOARD_PASTE_SIMPLE: enable = !theClipboard().empty(); break; @@ -2528,20 +3230,25 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd, case LFUN_OUTLINE_DOWN: case LFUN_OUTLINE_IN: case LFUN_OUTLINE_OUT: - case LFUN_OUTLINE_DRAGMOVE: // FIXME: LyX is not ready for outlining within inset. enable = isMainText() - && cur.paragraph().layout().toclevel != Layout::NOT_IN_TOC; + && cur.buffer()->text().getTocLevel(cur.pit()) != Layout::NOT_IN_TOC; break; case LFUN_NEWLINE_INSERT: // LaTeX restrictions (labels or empty par) - enable = (cur.pos() > cur.paragraph().beginOfBody()); + enable = !cur.paragraph().isPassThru() + && cur.pos() > cur.paragraph().beginOfBody(); + break; + + case LFUN_SEPARATOR_INSERT: + // Always enabled for now + enable = true; break; case LFUN_TAB_INSERT: case LFUN_TAB_DELETE: - enable = cur.inset().getLayout().isPassThru(); + enable = cur.paragraph().isPassThru(); break; case LFUN_SET_GRAPHICS_GROUP: { @@ -2567,16 +3274,122 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd, } case LFUN_LANGUAGE: - enable = !cur.inset().getLayout().isPassThru(); + enable = !cur.paragraph().isPassThru(); + flag.setOnOff(cmd.getArg(0) == cur.real_current_font.language()->lang()); + break; + + case LFUN_PARAGRAPH_BREAK: + enable = inset().allowMultiPar(); + break; + + case LFUN_SPELLING_ADD: + case LFUN_SPELLING_IGNORE: + case LFUN_SPELLING_REMOVE: + enable = theSpellChecker() != NULL; + if (enable && !cmd.getArg(1).empty()) { + // validate explicitly given language + Language const * const lang = const_cast(languages.getLanguage(cmd.getArg(1))); + enable &= lang != NULL; + } + break; + + case LFUN_LAYOUT: { + DocumentClass const & tclass = cur.buffer()->params().documentClass(); + bool const ignoreautonests = cmd.getArg(1) == "ignoreautonests"; + docstring layout = ignoreautonests ? from_utf8(cmd.getArg(0)) : cmd.argument(); + if (layout.empty()) + layout = tclass.defaultLayoutName(); + enable = !owner_->forcePlainLayout() && tclass.hasLayout(layout); + + flag.setOnOff(layout == cur.paragraph().layout().name()); + break; + } + + case LFUN_ENVIRONMENT_SPLIT: { + if (cmd.argument() == "outer") { + // check if we have an environment in our nesting hierarchy + bool res = false; + depth_type const current_depth = cur.paragraph().params().depth(); + pit_type pit = cur.pit(); + Paragraph cpar = pars_[pit]; + while (true) { + if (pit == 0 || cpar.params().depth() == 0) + break; + --pit; + cpar = pars_[pit]; + if (cpar.params().depth() < current_depth) + res = cpar.layout().isEnvironment(); + } + enable = res; + break; + } + else if (cmd.argument() == "previous") { + // look if we have an environment in the previous par + pit_type pit = cur.pit(); + Paragraph cpar = pars_[pit]; + if (pit > 0) { + --pit; + cpar = pars_[pit]; + enable = cpar.layout().isEnvironment(); + break; + } + enable = false; + break; + } + else if (cur.paragraph().layout().isEnvironment()) { + enable = cmd.argument() == "before" + || cur.pos() > 0 || !isFirstInSequence(cur.pit()); + break; + } + enable = false; + break; + } + + case LFUN_LAYOUT_PARAGRAPH: + case LFUN_PARAGRAPH_PARAMS: + case LFUN_PARAGRAPH_PARAMS_APPLY: + case LFUN_PARAGRAPH_UPDATE: + enable = owner_->allowParagraphCustomization(); break; - case LFUN_BREAK_PARAGRAPH: - enable = cur.inset().getLayout().isMultiPar(); + // FIXME: why are accent lfuns forbidden with pass_thru layouts? + // Because they insert COMBINING DIACRITICAL Unicode characters, + // that cannot be handled by LaTeX but must be converted according + // to the definition in lib/unicodesymbols? + case LFUN_ACCENT_ACUTE: + case LFUN_ACCENT_BREVE: + case LFUN_ACCENT_CARON: + case LFUN_ACCENT_CEDILLA: + case LFUN_ACCENT_CIRCLE: + case LFUN_ACCENT_CIRCUMFLEX: + case LFUN_ACCENT_DOT: + case LFUN_ACCENT_GRAVE: + case LFUN_ACCENT_HUNGARIAN_UMLAUT: + case LFUN_ACCENT_MACRON: + case LFUN_ACCENT_OGONEK: + case LFUN_ACCENT_TIE: + case LFUN_ACCENT_TILDE: + case LFUN_ACCENT_PERISPOMENI: + case LFUN_ACCENT_UMLAUT: + case LFUN_ACCENT_UNDERBAR: + case LFUN_ACCENT_UNDERDOT: + case LFUN_FONT_DEFAULT: + case LFUN_FONT_FRAK: + case LFUN_FONT_SIZE: + case LFUN_FONT_STATE: + case LFUN_FONT_UNDERLINE: + case LFUN_FONT_STRIKEOUT: + case LFUN_FONT_CROSSOUT: + case LFUN_FONT_UNDERUNDERLINE: + case LFUN_FONT_UNDERWAVE: + case LFUN_TEXTSTYLE_APPLY: + case LFUN_TEXTSTYLE_UPDATE: + enable = !cur.paragraph().isPassThru(); break; case LFUN_WORD_DELETE_FORWARD: case LFUN_WORD_DELETE_BACKWARD: - case LFUN_LINE_DELETE: + case LFUN_LINE_DELETE_FORWARD: case LFUN_WORD_FORWARD: case LFUN_WORD_BACKWARD: case LFUN_WORD_RIGHT: @@ -2603,13 +3416,20 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd, case LFUN_WORD_LEFT_SELECT: case LFUN_WORD_SELECT: case LFUN_SECTION_SELECT: + case LFUN_BUFFER_BEGIN: + case LFUN_BUFFER_END: + case LFUN_BUFFER_BEGIN_SELECT: + case LFUN_BUFFER_END_SELECT: + case LFUN_INSET_BEGIN: + case LFUN_INSET_END: + case LFUN_INSET_BEGIN_SELECT: + case LFUN_INSET_END_SELECT: case LFUN_PARAGRAPH_UP: case LFUN_PARAGRAPH_DOWN: case LFUN_LINE_BEGIN: case LFUN_LINE_END: case LFUN_CHAR_DELETE_FORWARD: case LFUN_CHAR_DELETE_BACKWARD: - case LFUN_INSET_INSERT: case LFUN_WORD_UPCASE: case LFUN_WORD_LOWCASE: case LFUN_WORD_CAPITALIZE: @@ -2617,104 +3437,38 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd, case LFUN_SERVER_GET_XY: case LFUN_SERVER_SET_XY: case LFUN_SERVER_GET_LAYOUT: - case LFUN_LAYOUT: case LFUN_SELF_INSERT: - case LFUN_FONT_DEFAULT: - case LFUN_FONT_UNDERLINE: - case LFUN_FONT_STRIKEOUT: - case LFUN_FONT_UULINE: - case LFUN_FONT_UWAVE: - case LFUN_FONT_SIZE: - case LFUN_TEXTSTYLE_APPLY: - case LFUN_TEXTSTYLE_UPDATE: - case LFUN_LAYOUT_PARAGRAPH: - case LFUN_PARAGRAPH_UPDATE: - case LFUN_ACCENT_UMLAUT: - case LFUN_ACCENT_CIRCUMFLEX: - case LFUN_ACCENT_GRAVE: - case LFUN_ACCENT_ACUTE: - case LFUN_ACCENT_TILDE: - case LFUN_ACCENT_CEDILLA: - case LFUN_ACCENT_MACRON: - case LFUN_ACCENT_DOT: - case LFUN_ACCENT_UNDERDOT: - case LFUN_ACCENT_UNDERBAR: - case LFUN_ACCENT_CARON: - case LFUN_ACCENT_BREVE: - case LFUN_ACCENT_TIE: - case LFUN_ACCENT_HUNGARIAN_UMLAUT: - case LFUN_ACCENT_CIRCLE: - case LFUN_ACCENT_OGONEK: + case LFUN_UNICODE_INSERT: case LFUN_THESAURUS_ENTRY: - case LFUN_PARAGRAPH_PARAMS_APPLY: - case LFUN_PARAGRAPH_PARAMS: case LFUN_ESCAPE: - case LFUN_BUFFER_BEGIN: - case LFUN_BUFFER_END: - case LFUN_BUFFER_BEGIN_SELECT: - case LFUN_BUFFER_END_SELECT: - case LFUN_INSET_BEGIN: - case LFUN_INSET_END: - case LFUN_INSET_BEGIN_SELECT: - case LFUN_INSET_END_SELECT: - case LFUN_INSET_SELECT_ALL: - case LFUN_UNICODE_INSERT: + case LFUN_SERVER_GET_STATISTICS: // these are handled in our dispatch() enable = true; break; + case LFUN_INSET_INSERT: { + string const type = cmd.getArg(0); + if (type == "toc") { + code = TOC_CODE; + // not allowed in description items + //FIXME: couldn't this be merged in Inset::insetAllowed()? + enable = !inDescriptionItem(cur); + } else { + enable = true; + } + break; + } + default: return false; } if (code != NO_CODE - && (cur.empty() + && (cur.empty() || !cur.inset().insetAllowed(code) - || cur.paragraph().layout().pass_thru)) + || (cur.paragraph().layout().pass_thru && !allow_in_passthru))) enable = false; - switch (cmd.action) { - case LFUN_ACCENT_ACUTE: - case LFUN_ACCENT_BREVE: - case LFUN_ACCENT_CARON: - case LFUN_ACCENT_CEDILLA: - case LFUN_ACCENT_CIRCLE: - case LFUN_ACCENT_CIRCUMFLEX: - case LFUN_ACCENT_DOT: - case LFUN_ACCENT_GRAVE: - case LFUN_ACCENT_HUNGARIAN_UMLAUT: - case LFUN_ACCENT_MACRON: - case LFUN_ACCENT_OGONEK: - case LFUN_ACCENT_TIE: - case LFUN_ACCENT_TILDE: - case LFUN_ACCENT_UMLAUT: - case LFUN_ACCENT_UNDERBAR: - case LFUN_ACCENT_UNDERDOT: - case LFUN_FONT_BOLD: - case LFUN_FONT_BOLDSYMBOL: - case LFUN_FONT_TYPEWRITER: - case LFUN_FONT_DEFAULT: - case LFUN_FONT_EMPH: - case LFUN_FONT_NOUN: - case LFUN_FONT_ROMAN: - case LFUN_FONT_SANS: - case LFUN_FONT_FRAK: - case LFUN_FONT_ITAL: - case LFUN_FONT_SIZE: - case LFUN_FONT_STATE: - case LFUN_FONT_UNDERLINE: - case LFUN_FONT_STRIKEOUT: - case LFUN_FONT_UULINE: - case LFUN_FONT_UWAVE: - case LFUN_TEXTSTYLE_APPLY: - case LFUN_TEXTSTYLE_UPDATE: - if (cur.inset().getLayout().isPassThru()) - enable = false; - break; - default: - break; - } - flag.setEnabled(enable); return true; } @@ -2723,7 +3477,6 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd, void Text::pasteString(Cursor & cur, docstring const & clip, bool asParagraphs) { - cur.clearSelection(); if (!clip.empty()) { cur.recordUndo(); if (asParagraphs)