X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FText3.cpp;h=1e0180cc2e726375487a1818373d1851e758dab1;hb=62af7ee772f16f154225d2d0b65d77f4376b6001;hp=68e3f2f66bd5c600683af2b227731cecb4189aa9;hpb=e30f3d76d2bee0011ceaeb5f0cc221156458cbad;p=lyx.git diff --git a/src/Text3.cpp b/src/Text3.cpp index 68e3f2f66b..1e0180cc2e 100644 --- a/src/Text3.cpp +++ b/src/Text3.cpp @@ -53,13 +53,14 @@ #include "frontends/Selection.h" #include "insets/InsetArgument.h" -#include "insets/InsetCollapsable.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/InsetInfo.h" #include "insets/InsetIPAMacro.h" #include "insets/InsetNewline.h" #include "insets/InsetQuotes.h" @@ -69,8 +70,10 @@ #include "support/convert.h" #include "support/debug.h" +#include "support/filetools.h" #include "support/gettext.h" #include "support/lassert.h" +#include "support/limited_stack.h" #include "support/lstrings.h" #include "support/lyxalgo.h" #include "support/lyxtime.h" @@ -79,6 +82,7 @@ #include "mathed/InsetMathHull.h" #include "mathed/InsetMathMacroTemplate.h" +#include "lyxfind.h" #include #include @@ -89,6 +93,7 @@ using namespace lyx::support; namespace lyx { using cap::copySelection; +using cap::copySelectionToTemp; using cap::cutSelection; using cap::cutSelectionToTemp; using cap::pasteFromStack; @@ -102,13 +107,14 @@ using cap::pasteSimpleText; using frontend::Clipboard; // globals... -static Font freefont(ignore_font, ignore_language); +typedef limited_stack> FontStack; +static FontStack freeFonts(15); static bool toggleall = false; static void toggleAndShow(Cursor & cur, Text * text, - Font const & font, bool toggleall = true) + Font const & font, bool togall = true) { - text->toggleFree(cur, font, toggleall); + text->toggleFree(cur, font, togall); if (font.language() != ignore_language || font.fontInfo().number() != FONT_IGNORE) { @@ -245,24 +251,11 @@ 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) { - docstring ds = subst(text->getStringToIndex(cur), '\n', ' '); - text->insertInset(cur, inset); - if (edit) - inset->edit(cur, true); - // Now put this 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; - } - else if (cmd.action() == LFUN_ARGUMENT_INSERT) { + if (cmd.action() == LFUN_ARGUMENT_INSERT) { bool cotextinsert = false; InsetArgument const * const ia = static_cast(inset); Layout const & lay = cur.paragraph().layout(); @@ -301,9 +294,24 @@ static bool doInsertInset(Cursor & cur, Text * text, bool gotsel = false; if (cur.selection()) { - cutSelectionToTemp(cur, false, pastesel); + if (cmd.action() == LFUN_INDEX_INSERT) + copySelectionToTemp(cur); + else { + cutSelectionToTemp(cur, pastesel); + /* Move layout information inside the inset if the whole + * paragraph and the inset allows setting layout + * FIXME: this does not work as expected when change tracking is on + * However, we do not really know what to do in this case. + */ + if (cur.paragraph().empty() && !inset->forcePlainLayout()) + cur.paragraph().setPlainOrDefaultLayout(bparams.documentClass()); + } cur.clearSelection(); gotsel = true; + } else if (cmd.action() == LFUN_INDEX_INSERT) { + gotsel = text->selectWordWhenUnderCursor(cur, WHOLE_WORD); + copySelectionToTemp(cur); + cur.clearSelection(); } text->insertInset(cur, inset); @@ -320,24 +328,17 @@ static bool doInsertInset(Cursor & cur, Text * text, 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()); - cur.pos() = 0; - cur.pit() = 0; - // 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); - } + cur.pos() = 0; + cur.pit() = 0; + // FIXME: what does this do? + 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); // reset surrounding par to default @@ -351,12 +352,6 @@ static bool doInsertInset(Cursor & cur, Text * text, } -string const freefont2string() -{ - return freefont.toString(toggleall); -} - - /// the type of outline operation enum OutlineOp { OutlineUp, // Move this header with text down @@ -366,7 +361,23 @@ 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(); @@ -377,6 +388,7 @@ static void outline(OutlineOp mode, Cursor & cur) // 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(); int const thistoclevel = buf.text().getTocLevel(distance(bgn, start)); int toclevel; @@ -411,10 +423,47 @@ static void outline(OutlineOp mode, Cursor & cur) // 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, 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; @@ -432,9 +481,45 @@ static void outline(OutlineOp mode, Cursor & cur) && 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, 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; @@ -478,18 +563,67 @@ void Text::number(Cursor & cur) } -bool Text::isRTL(Paragraph const & par) const +bool Text::isRTL(pit_type const pit) const { Buffer const & buffer = owner_->buffer(); - return par.isRTL(buffer.params()); + return pars_[pit].isRTL(buffer.params()); } namespace { - Language const * getLanguage(Cursor const & cur, string const & lang) { - return lang.empty() ? cur.getFont().language() : languages.getLanguage(lang); +Language const * getLanguage(Cursor const & cur, string const & lang) +{ + return lang.empty() ? cur.getFont().language() : languages.getLanguage(lang); +} + + +docstring resolveLayout(docstring layout, DocIterator const & dit) +{ + Paragraph const & par = dit.paragraph(); + DocumentClass const & tclass = dit.buffer()->params().documentClass(); + + if (layout.empty()) + layout = tclass.defaultLayoutName(); + + if (dit.inset().forcePlainLayout(dit.idx())) + // in this case only the empty layout is allowed + layout = tclass.plainLayoutName(); + else if (par.usePlainLayout()) { + // in this case, default layout maps to empty layout + if (layout == tclass.defaultLayoutName()) + layout = tclass.plainLayoutName(); + } else { + // otherwise, the empty layout maps to the default + if (layout == tclass.plainLayoutName()) + layout = tclass.defaultLayoutName(); + } + + // If the entry is obsolete, use the new one instead. + if (tclass.hasLayout(layout)) { + docstring const & obs = tclass[layout].obsoleted_by(); + if (!obs.empty()) + layout = obs; } + if (!tclass.hasLayout(layout)) + layout.clear(); + return layout; +} + + +bool isAlreadyLayout(docstring const & layout, CursorData const & cur) +{ + ParagraphList const & pars = cur.text()->paragraphs(); + + pit_type pit = cur.selBegin().pit(); + pit_type const epit = cur.selEnd().pit() + 1; + for ( ; pit != epit; ++pit) + if (pars[pit].layout().name() != layout) + return false; + + return true; +} + } // namespace @@ -539,7 +673,6 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) case LFUN_PARAGRAPH_MOVE_DOWN: { pit_type const pit = cur.pit(); cur.recordUndo(pit, pit + 1); - cur.finishUndo(); pars_.swap(pit, pit + 1); needsUpdate = true; cur.forceBufferUpdate(); @@ -584,7 +717,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) case LFUN_WORD_DELETE_FORWARD: if (cur.selection()) - cutSelection(cur, true, false); + cutSelection(cur, false); else deleteWordForward(cur, cmd.getArg(0) == "force"); finishChange(cur, false); @@ -592,7 +725,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) case LFUN_WORD_DELETE_BACKWARD: if (cur.selection()) - cutSelection(cur, true, false); + cutSelection(cur, false); else deleteWordBackward(cur, cmd.getArg(0) == "force"); finishChange(cur, false); @@ -600,7 +733,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) case LFUN_LINE_DELETE_FORWARD: if (cur.selection()) - cutSelection(cur, true, false); + cutSelection(cur, false); else tm->deleteLineForward(cur); finishChange(cur, false); @@ -770,6 +903,18 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) 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) @@ -781,6 +926,14 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) break; } + case LFUN_PARAGRAPH_SELECT: + if (cur.pos() > 0) + needsUpdate |= setCursor(cur, cur.pit(), 0); + needsUpdate |= cur.selHandle(true); + if (cur.pos() < cur.lastpos()) + needsUpdate |= setCursor(cur, cur.pit(), cur.lastpos()); + break; + case LFUN_PARAGRAPH_UP: case LFUN_PARAGRAPH_UP_SELECT: needsUpdate |= cur.selHandle(cmd.action() == LFUN_PARAGRAPH_UP_SELECT); @@ -835,6 +988,8 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) break; } cur.pos() = cur.lastpos(); + cur.boundary(false); + cur.setCurrentFont(); needsUpdate |= cur != old_cur; break; @@ -988,8 +1143,8 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) } else { // 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); + FuncRequest ncmd(LFUN_SELF_INSERT, from_ascii("\t")); + dispatch(cur, ncmd); } break; } @@ -1064,7 +1219,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) needsUpdate |= erase(cur); cur.resetAnchor(); } else { - cutSelection(cur, true, false); + cutSelection(cur, false); singleParUpdate = false; } moveCursor(cur, false); @@ -1094,7 +1249,13 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) } } } else { - cutSelection(cur, true, false); + DocIterator const dit = cur.selectionBegin(); + cutSelection(cur, false); + if (cur.buffer()->params().track_changes) + // since we're doing backwards deletion, + // and the selection is not really cut, + // move cursor before selection (#11630) + cur.setCursor(dit); singleParUpdate = false; } break; @@ -1108,6 +1269,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) 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().keepempty && !par.layout().isCommand() && pars_[prev].layout() != par.layout() && pars_[prev].layout().isEnvironment() @@ -1127,21 +1289,19 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) Font const f(inherit_font, cur.current_font.language()); pars_[cur.pit() - 1].resetFonts(f); } else { - if (par.isEnvSeparator(cur.pos())) + if (par.isEnvSeparator(cur.pos()) && cmd.getArg(1) != "ignoresep") cur.posForward(); - breakParagraph(cur, cmd.argument() == "inverse"); + 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); + for (auto const & thearg : args) { + Layout::latexarg arg = thearg.second; + if (arg.autoinsert && prefixIs(thearg.first, "item:")) { + FuncRequest cmd2(LFUN_ARGUMENT_INSERT, thearg.first); + lyx::dispatch(cmd2); } } break; @@ -1181,8 +1341,9 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) } */ if (cur.selection()) - cutSelection(cur, true, false); + cutSelection(cur, false); cur.insert(inset); + cur.forceBufferUpdate(); if (inset->editable() && inset->asInsetText()) inset->edit(cur, true); else @@ -1207,7 +1368,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) break; } - case LFUN_SET_GRAPHICS_GROUP: { + case LFUN_GRAPHICS_SET_GROUP: { InsetGraphics * ins = graphics::getCurrentGraphicsInset(cur); if (!ins) break; @@ -1227,6 +1388,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) } ins->setParams(inspar); + break; } case LFUN_SPACE_INSERT: @@ -1365,13 +1527,14 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) } bv->buffer().errors("Paste"); + bv->buffer().updatePreviews(); // bug 11619 cur.clearSelection(); // bug 393 cur.finishUndo(); break; } case LFUN_CUT: - cutSelection(cur, true, true); + cutSelection(cur, true); cur.message(_("Cut")); break; @@ -1403,72 +1566,54 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) cur.message(cur.paragraph().layout().name()); break; - case LFUN_LAYOUT: { - docstring layout = cmd.argument(); - LYXERR(Debug::INFO, "LFUN_LAYOUT: (arg) " << to_utf8(layout)); - - Paragraph const & para = cur.paragraph(); - docstring const old_layout = para.layout().name(); - DocumentClass const & tclass = bv->buffer().params().documentClass(); + case LFUN_LAYOUT: + case LFUN_LAYOUT_TOGGLE: { + bool const ignoreautonests = cmd.getArg(1) == "ignoreautonests"; + docstring req_layout = ignoreautonests ? from_utf8(cmd.getArg(0)) : cmd.argument(); + LYXERR(Debug::INFO, "LFUN_LAYOUT: (arg) " << to_utf8(req_layout)); - if (layout.empty()) - layout = tclass.defaultLayoutName(); - - if (owner_->forcePlainLayout()) - // in this case only the empty layout is allowed - layout = tclass.plainLayoutName(); - else if (para.usePlainLayout()) { - // in this case, default layout maps to empty layout - if (layout == tclass.defaultLayoutName()) - layout = tclass.plainLayoutName(); - } else { - // otherwise, the empty layout maps to the default - if (layout == tclass.plainLayoutName()) - layout = tclass.defaultLayoutName(); - } - - bool hasLayout = tclass.hasLayout(layout); - - // If the entry is obsolete, use the new one instead. - if (hasLayout) { - docstring const & obs = tclass[layout].obsoleted_by(); - if (!obs.empty()) - layout = obs; - } - - if (!hasLayout) { - cur.errorMessage(from_utf8(N_("Layout ")) + cmd.argument() + + docstring layout = resolveLayout(req_layout, cur); + if (layout.empty()) { + cur.errorMessage(from_utf8(N_("Layout ")) + req_layout + from_utf8(N_(" not known"))); break; } - bool change_layout = (old_layout != layout); + docstring const old_layout = cur.paragraph().layout().name(); + bool change_layout = !isAlreadyLayout(layout, cur); - if (!change_layout && cur.selection() && - cur.selBegin().pit() != cur.selEnd().pit()) - { - pit_type spit = cur.selBegin().pit(); - pit_type epit = cur.selEnd().pit() + 1; - while (spit != epit) { - if (pars_[spit].layout().name() != old_layout) { - change_layout = true; - break; - } - ++spit; - } + if (cmd.action() == LFUN_LAYOUT_TOGGLE && !change_layout) { + change_layout = true; + layout = resolveLayout(docstring(), cur); } - 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; + DocumentClass const & tclass = bv->buffer().params().documentClass(); + bool inautoarg = false; + for (auto const & la_pair : tclass[layout].args()) { + Layout::latexarg const & arg = la_pair.second; if (arg.autoinsert) { - FuncRequest cmd(LFUN_ARGUMENT_INSERT, (*lait).first); - lyx::dispatch(cmd); + // If we had already inserted an arg automatically, + // leave this now in order to insert the next one. + if (inautoarg) { + cur.leaveInset(cur.inset()); + cur.posForward(); + } + FuncRequest const cmd2(LFUN_ARGUMENT_INSERT, la_pair.first); + lyx::dispatch(cmd2); + inautoarg = true; } } @@ -1477,36 +1622,83 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) 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 = para.layout().name(); + docstring layout; + if (para.layout().isEnvironment()) + layout = para.layout().name(); depth_type split_depth = cur.paragraph().params().depth(); - if (outer) { - // check if we have an environment in our nesting hierarchy + 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 || cpar.params().depth() == 0) + 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()) { - layout = cpar.layout().name(); + if (!previous) + layout = cpar.layout().name(); split_depth = cpar.params().depth(); } + if (cpar.params().depth() == 0) + break; } } - if (cur.pos() > 0) + 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, tc.plainLayout().name())); + 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")); - lyx::dispatch(FuncRequest(LFUN_PARAGRAPH_BREAK, "inverse")); + 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)) { + depth_type const olddepth = cur.paragraph().params().depth(); + lyx::dispatch(FuncRequest(LFUN_DEPTH_INCREMENT)); + if (olddepth == cur.paragraph().params().depth()) + // leave loop if no incrementation happens + break; + } + cur.setCursor(scur); + } break; } @@ -1539,21 +1731,6 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) bv->buffer().errors("Paste"); break; - case LFUN_UNICODE_INSERT: { - if (cmd.argument().empty()) - break; - docstring hexstring = cmd.argument(); - if (isHex(hexstring)) { - char_type c = hexToInt(hexstring); - if (c >= 32 && c < 0x10ffff) { - lyxerr << "Inserting c: " << c << endl; - docstring s = docstring(1, c); - lyx::dispatch(FuncRequest(LFUN_SELF_INSERT, s)); - } - } - break; - } - case LFUN_QUOTE_INSERT: { cap::replaceSelection(cur); cur.recordUndo(); @@ -1605,19 +1782,14 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) break; } - case LFUN_DATE_INSERT: { - string const format = cmd.argument().empty() - ? lyxrc.date_insert_format : to_utf8(cmd.argument()); - string const time = formatted_time(current_time(), format); - lyx::dispatch(FuncRequest(LFUN_SELF_INSERT, time)); - break; - } - case LFUN_MOUSE_TRIPLE: if (cmd.button() == mouse_button::button1) { - tm->cursorHome(cur); + if (cur.pos() > 0) + setCursor(cur, cur.pit(), 0); + bv->cursor() = cur; cur.resetAnchor(); - tm->cursorEnd(cur); + if (cur.pos() < cur.lastpos()) + setCursor(cur, cur.pit(), cur.lastpos()); cur.setSelection(); bv->cursor() = cur; } @@ -1712,6 +1884,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) // reset the anchor. bvcur.setCursor(cur); bvcur.selection(true); + bvcur.setCurrentFont(); if (cur.top() == old) { // We didn't move one iota, so no need to update the screen. cur.screenUpdateFlags(Update::SinglePar | Update::FitCursor); @@ -1774,14 +1947,11 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) // true (on). if (lyxrc.auto_region_delete && cur.selection()) - cutSelection(cur, false, false); - + cutSelection(cur, false); cur.clearSelection(); - docstring::const_iterator cit = cmd.argument().begin(); - docstring::const_iterator const end = cmd.argument().end(); - for (; cit != end; ++cit) - bv->translateAndInsert(*cit, this, cur); + for (char_type c : cmd.argument()) + bv->translateAndInsert(c, this, cur); cur.resetAnchor(); moveCursor(cur, false); @@ -1854,21 +2024,18 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) } case LFUN_INFO_INSERT: { - Inset * inset; - if (cmd.argument().empty() && cur.selection()) { - // if command argument is empty use current selection as parameter. - docstring ds = cur.selectionAsString(false); - cutSelection(cur, true, false); - FuncRequest cmd0(cmd, ds); - inset = createInset(cur.buffer(), cmd0); + if (cmd.argument().empty()) { + bv->showDialog("info", cur.current_font.language()->lang()); } else { + Inset * inset; inset = createInset(cur.buffer(), cmd); + if (!inset) + break; + cur.recordUndo(); + insertInset(cur, inset); + cur.forceBufferUpdate(); + cur.posForward(); } - if (!inset) - break; - cur.recordUndo(); - insertInset(cur, inset); - cur.posForward(); break; } case LFUN_CAPTION_INSERT: @@ -1889,6 +2056,16 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) // inside it. doInsertInset(cur, this, cmd, true, true); cur.posForward(); + if (act == LFUN_SCRIPT_INSERT) { + /* Script insets change the font style in metrics(), and + * this is used to compute the height of the caret + * (because the font is stored in TextMetrics::font_). + * When we insert, we have to make sure that metrics are + * computed so that the caret height is wrong. Arguably, + * this is hackish.*/ + bv->processUpdateFlags(Update::SinglePar); + } + cur.setCurrentFont(); // Some insets are numbered, others are shown in the outline pane so // let's update the labels and the toc backend. cur.forceBufferUpdate(); @@ -1900,18 +2077,33 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) 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(); + bool autoargs = false, inautoarg = false; + Layout::LaTeXArgMap args = cur.inset().getLayout().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 (!inautoarg && arg.insertonnewline && cur.pos() > 0) { + FuncRequest cmd2(LFUN_PARAGRAPH_BREAK); + lyx::dispatch(cmd2); + } 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); + // If we had already inserted an arg automatically, + // leave this now in order to insert the next one. + if (inautoarg) { + cur.leaveInset(cur.inset()); + cur.posForward(); + if (arg.insertonnewline && cur.pos() > 0) { + FuncRequest cmd2(LFUN_PARAGRAPH_BREAK); + lyx::dispatch(cmd2); + } + } + FuncRequest cmd2(LFUN_ARGUMENT_INSERT, (*lait).first); + lyx::dispatch(cmd2); autoargs = true; + inautoarg = true; } } if (!autoargs) { @@ -1925,14 +2117,78 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) break; } - case LFUN_TABULAR_INSERT: + case LFUN_TABULAR_INSERT: { // if there were no arguments, just open the dialog + if (cmd.argument().empty()) { + bv->showDialog("tabularcreate"); + break; + } else if (cur.buffer()->masterParams().tablestyle != "default" + || bv->buffer().params().documentClass().tablestyle() != "default") { + string tabstyle = cur.buffer()->masterParams().tablestyle; + if (tabstyle == "default") + tabstyle = bv->buffer().params().documentClass().tablestyle(); + if (!libFileSearch("tabletemplates", tabstyle + ".lyx").empty()) { + FuncRequest fr(LFUN_TABULAR_STYLE_INSERT, + tabstyle + " " + to_ascii(cmd.argument())); + lyx::dispatch(fr); + break; + } else + // Unknown style. Report and fall back to default. + cur.errorMessage(from_utf8(N_("Table Style ")) + from_utf8(tabstyle) + + from_utf8(N_(" not known"))); + + } if (doInsertInset(cur, this, cmd, false, true)) cur.posForward(); - else - bv->showDialog("tabularcreate"); + break; + } + case LFUN_TABULAR_STYLE_INSERT: { + string const style = cmd.getArg(0); + string const rows = cmd.getArg(1); + string const cols = cmd.getArg(2); + if (cols.empty() || !isStrInt(cols) + || rows.empty() || !isStrInt(rows)) + break; + int const r = convert(rows); + int const c = convert(cols); + + string suffix; + if (r == 1) + suffix = "_1x1"; + else if (r == 2) + suffix = "_1x2"; + FileName const tabstyle = libFileSearch("tabletemplates", + style + suffix + ".lyx", "lyx"); + if (tabstyle.empty()) + break; + UndoGroupHelper ugh(cur.buffer()); + cur.recordUndo(); + FuncRequest cmd2(LFUN_FILE_INSERT, tabstyle.absFileName() + " ignorelang"); + lyx::dispatch(cmd2); + // go into table + cur.backwardPos(); + if (r > 2) { + // move one cell up to middle cell + cur.up(); + // add the missing rows + int const addrows = r - 3; + for (int i = 0 ; i < addrows ; ++i) { + FuncRequest fr(LFUN_TABULAR_FEATURE, "append-row"); + lyx::dispatch(fr); + } + } + // add the missing columns + int const addcols = c - 1; + for (int i = 0 ; i < addcols ; ++i) { + FuncRequest fr(LFUN_TABULAR_FEATURE, "append-column"); + lyx::dispatch(fr); + } + if (r > 1) + // go to first cell + cur.up(); break; + } case LFUN_FLOAT_INSERT: case LFUN_FLOAT_WIDE_INSERT: @@ -1989,9 +2245,11 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) case LFUN_NOMENCL_INSERT: { InsetCommandParams p(NOMENCL_CODE); - if (cmd.argument().empty()) - p["symbol"] = bv->cursor().innerText()->getStringToIndex(bv->cursor()); - else + if (cmd.argument().empty()) { + p["symbol"] = + bv->cursor().innerText()->getStringForDialog(bv->cursor()); + cur.clearSelection(); + } else p["symbol"] = cmd.argument(); string const data = InsetCommand::params2string(p); bv->showDialog("nomenclature", data); @@ -2217,27 +2475,51 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) selectWordWhenUnderCursor(cur, WHOLE_WORD_STRICT); Font font(ignore_font, lang); toggleAndShow(cur, this, font, toggle); + // We need a buffer update if we change the language + // of an info inset + if (cur.insetInSelection(INFO_CODE)) + cur.forceBufferUpdate(); break; } - case LFUN_TEXTSTYLE_APPLY: - toggleAndShow(cur, this, freefont, toggleall); - cur.message(_("Character set")); + case LFUN_TEXTSTYLE_APPLY: { + unsigned int num = 0; + string const arg = to_utf8(cmd.argument()); + // Argument? + if (!arg.empty()) { + if (isStrUnsignedInt(arg)) { + num = convert(arg); + if (num >= freeFonts.size()) { + cur.message(_("Invalid argument (number exceeds stack size)!")); + break; + } + } else { + cur.message(_("Invalid argument (must be a non-negative number)!")); + break; + } + } + toggleAndShow(cur, this, freeFonts[num].second, toggleall); + cur.message(bformat(_("Text properties applied: %1$s"), freeFonts[num].first)); break; + } // Set the freefont using the contents of \param data dispatched from // the frontends and apply it at the current cursor location. case LFUN_TEXTSTYLE_UPDATE: { - Font font; + Font font(ignore_font, ignore_language); bool toggle; if (font.fromString(to_utf8(cmd.argument()), toggle)) { - freefont = font; + docstring const props = font.stateText(&bv->buffer().params(), true); + freeFonts.push(make_pair(props, font)); toggleall = toggle; - toggleAndShow(cur, this, freefont, toggleall); - cur.message(_("Character set")); - } else { - lyxerr << "Argument not ok"; - } + toggleAndShow(cur, this, font, toggleall); + // We need a buffer update if we change the language + // of an info inset + if (cur.insetInSelection(INFO_CODE)) + cur.forceBufferUpdate(); + cur.message(bformat(_("Text properties applied: %1$s"), props)); + } else + LYXERR0("Invalid argument of textstyle-update"); break; } @@ -2324,7 +2606,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) if (tclass.floats().typeExist(to_utf8(cmd.argument()))) { cur.recordUndo(); if (cur.selection()) - cutSelection(cur, true, false); + cutSelection(cur, false); breakParagraph(cur); if (cur.lastpos() != 0) { @@ -2482,27 +2764,27 @@ 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.forceBufferUpdate(); needsUpdate = true; break; case LFUN_OUTLINE_DOWN: - outline(OutlineDown, cur); + outline(OutlineDown, cur, this); setCursor(cur, cur.pit(), 0); cur.forceBufferUpdate(); needsUpdate = true; break; case LFUN_OUTLINE_IN: - outline(OutlineIn, cur); + outline(OutlineIn, cur, this); cur.forceBufferUpdate(); needsUpdate = true; break; case LFUN_OUTLINE_OUT: - outline(OutlineOut, cur); + outline(OutlineOut, cur, this); cur.forceBufferUpdate(); needsUpdate = true; break; @@ -2605,7 +2887,7 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd, bool enable = true; bool allow_in_passthru = false; InsetCode code = NO_CODE; - + switch (cmd.action()) { case LFUN_DEPTH_DECREMENT: @@ -2695,6 +2977,9 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd, case LFUN_TABULAR_INSERT: code = TABULAR_CODE; break; + case LFUN_TABULAR_STYLE_INSERT: + code = TABULAR_CODE; + break; case LFUN_MARGINALNOTE_INSERT: code = MARGIN_CODE; break; @@ -2767,11 +3052,6 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd, } case LFUN_NOTE_INSERT: code = NOTE_CODE; - // in commands (sections etc.) and description items, - // only Notes are allowed - enable = (cmd.argument().empty() || cmd.getArg(0) == "Note" || - (!cur.paragraph().layout().isCommand() - && !inDescriptionItem(cur))); break; case LFUN_FLEX_INSERT: { code = FLEX_CODE; @@ -2805,6 +3085,8 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd, break; case LFUN_INFO_INSERT: code = INFO_CODE; + enable = cmd.argument().empty() + || infoparams.validateArgument(cur.buffer(), cmd.argument(), true); break; case LFUN_ARGUMENT_INSERT: { code = ARG_CODE; @@ -3055,17 +3337,37 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd, case LFUN_CHANGE_ACCEPT: case LFUN_CHANGE_REJECT: - // In principle, these LFUNs should only be enabled if there - // is a change at the current position/in the current selection. - // However, without proper optimizations, this will inevitably - // result in unacceptable performance - just imagine a user who - // wants to select the complete content of a long document. if (!cur.selection()) enable = cur.paragraph().isChanged(cur.pos()); - else - // TODO: context-sensitive enabling of LFUN_CHANGE_ACCEPT/REJECT - // for selections. - enable = true; + else { + // will enable if there is a change in the selection + enable = false; + + // cheap improvement for efficiency: using cached + // buffer variable, if there is no change in the + // document, no need to check further. + if (!cur.buffer()->areChangesPresent()) + break; + + for (DocIterator it = cur.selectionBegin(); ; it.forwardPar()) { + pos_type const beg = it.pos(); + pos_type end; + bool const in_last_par = (it.pit() == cur.selectionEnd().pit() && + it.idx() == cur.selectionEnd().idx()); + if (in_last_par) + end = cur.selectionEnd().pos(); + else + // the +1 is needed for cases, e.g., where there is a + // paragraph break. See #11629. + end = it.lastpos() + 1; + if (beg != end && it.paragraph().isChanged(beg, end)) { + enable = true; + break; + } + if (in_last_par) + break; + } + } break; case LFUN_OUTLINE_UP: @@ -3093,7 +3395,7 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd, enable = cur.paragraph().isPassThru(); break; - case LFUN_SET_GRAPHICS_GROUP: { + case LFUN_GRAPHICS_SET_GROUP: { InsetGraphics * ins = graphics::getCurrentGraphicsInset(cur); if (!ins) enable = false; @@ -3108,13 +3410,6 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd, enable = !inDescriptionItem(cur); break; - case LFUN_DATE_INSERT: { - string const format = cmd.argument().empty() - ? lyxrc.date_insert_format : to_utf8(cmd.argument()); - enable = support::os::is_valid_strftime(format); - break; - } - case LFUN_LANGUAGE: enable = !cur.paragraph().isPassThru(); flag.setOnOff(cmd.getArg(0) == cur.real_current_font.language()->lang()); @@ -3135,14 +3430,14 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd, } break; - case LFUN_LAYOUT: { - DocumentClass const & tclass = cur.buffer()->params().documentClass(); - docstring layout = cmd.argument(); - if (layout.empty()) - layout = tclass.defaultLayoutName(); - enable = !owner_->forcePlainLayout() && tclass.hasLayout(layout); + case LFUN_LAYOUT: + case LFUN_LAYOUT_TOGGLE: { + bool const ignoreautonests = cmd.getArg(1) == "ignoreautonests"; + docstring const req_layout = ignoreautonests ? from_utf8(cmd.getArg(0)) : cmd.argument(); + docstring const layout = resolveLayout(req_layout, cur); - flag.setOnOff(layout == cur.paragraph().layout().name()); + enable = !owner_->forcePlainLayout() && !layout.empty(); + flag.setOnOff(isAlreadyLayout(layout, cur)); break; } @@ -3164,8 +3459,22 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd, 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 = true; + enable = cmd.argument() == "before" + || cur.pos() > 0 || !isFirstInSequence(cur.pit()); break; } enable = false; @@ -3200,7 +3509,6 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd, 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: @@ -3209,11 +3517,46 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd, 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_FONT_DEFAULT: { + Font font(inherit_font, ignore_language); + BufferParams const & bp = cur.buffer()->masterParams(); + if (cur.selection()) { + enable = false; + // Check if we have a non-default font attribute + // in the selection range. + DocIterator const from = cur.selectionBegin(); + DocIterator const to = cur.selectionEnd(); + for (DocIterator dit = from ; dit != to && !dit.atEnd(); ) { + if (!dit.inTexted()) { + dit.forwardPos(); + continue; + } + Paragraph const & par = dit.paragraph(); + pos_type const pos = dit.pos(); + Font tmp = par.getFontSettings(bp, pos); + if (tmp.fontInfo() != font.fontInfo() + || tmp.language() != bp.language) { + enable = true; + break; + } + dit.forwardPos(); + } + break; + } + // Disable if all is default already. + enable = (cur.current_font.fontInfo() != font.fontInfo() + || cur.current_font.language() != bp.language); + break; + } + + case LFUN_TEXTSTYLE_APPLY: + enable = !freeFonts.empty(); + break; + case LFUN_WORD_DELETE_FORWARD: case LFUN_WORD_DELETE_BACKWARD: case LFUN_LINE_DELETE_FORWARD: @@ -3233,6 +3576,7 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd, case LFUN_UP_SELECT: case LFUN_DOWN: case LFUN_DOWN_SELECT: + case LFUN_PARAGRAPH_SELECT: case LFUN_PARAGRAPH_UP_SELECT: case LFUN_PARAGRAPH_DOWN_SELECT: case LFUN_LINE_BEGIN_SELECT: @@ -3286,6 +3630,12 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd, break; } + case LFUN_SEARCH_IGNORE: { + bool const value = cmd.getArg(1) == "true"; + setIgnoreFormat(cmd.getArg(0), value); + break; + } + default: return false; } @@ -3331,4 +3681,19 @@ bool Text::inDescriptionItem(Cursor & cur) const && (pos == 0 || par.getChar(pos - 1) != ' '))); } + +std::vector Text::getFreeFonts() const +{ + vector ffList; + + FontStack::const_iterator cit = freeFonts.begin(); + FontStack::const_iterator end = freeFonts.end(); + for (; cit != end; ++cit) + // we do not use cit-> here because gcc 2.9x does not + // like it (JMarc) + ffList.push_back((*cit).first); + + return ffList; +} + } // namespace lyx