X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FText3.cpp;h=f871bb31d157c1b1a91371428be779b2774ebb21;hb=809a063358ba6ee5ca2be27be111b0d605e0d723;hp=9dce236a41fcdb1d2480847f661951ede252472f;hpb=154b4fdecec9ba8e5f5c1d1210b07992e68e7d15;p=features.git diff --git a/src/Text3.cpp b/src/Text3.cpp index 9dce236a41..f871bb31d1 100644 --- a/src/Text3.cpp +++ b/src/Text3.cpp @@ -18,18 +18,15 @@ #include "Text.h" #include "BranchList.h" -#include "FloatList.h" -#include "FuncStatus.h" #include "Buffer.h" -#include "buffer_funcs.h" #include "BufferParams.h" #include "BufferView.h" -#include "Changes.h" #include "Cursor.h" #include "CutAndPaste.h" #include "DispatchResult.h" -#include "ErrorList.h" #include "factory.h" +#include "FloatList.h" +#include "FuncStatus.h" #include "FuncRequest.h" #include "InsetList.h" #include "Intl.h" @@ -70,20 +67,19 @@ #include "support/convert.h" #include "support/debug.h" +#include "support/docstring_list.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" -#include "support/os.h" -#include "support/regex.h" #include "mathed/InsetMathHull.h" #include "mathed/InsetMathMacroTemplate.h" #include "lyxfind.h" #include +#include #include using namespace std; @@ -122,6 +118,11 @@ static void toggleAndShow(Cursor & cur, Text * text, cur.real_current_font)) text->setCursor(cur, cur.pit(), cur.pos(), false, !cur.boundary()); + if (font.language() != ignore_language) + // We need a buffer update if we change the language + // (e.g., with info insets or if the selection contains + // a par label) + cur.forceBufferUpdate(); } } @@ -242,7 +243,8 @@ static void ipaChar(Cursor & cur, InsetIPAChar::Kind kind) static bool doInsertInset(Cursor & cur, Text * text, - FuncRequest const & cmd, bool edit, bool pastesel) + FuncRequest const & cmd, bool edit, + bool pastesel, bool resetfont = false) { Buffer & buffer = cur.bv().buffer(); BufferParams const & bparams = buffer.params(); @@ -256,7 +258,7 @@ static bool doInsertInset(Cursor & cur, Text * text, cur.recordUndo(); if (cmd.action() == LFUN_ARGUMENT_INSERT) { bool cotextinsert = false; - InsetArgument const * const ia = static_cast(inset); + InsetArgument * 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()); @@ -279,6 +281,7 @@ static bool doInsertInset(Cursor & cur, Text * text, else ds = cur.paragraph().asString(); text->insertInset(cur, inset); + ia->init(cur.paragraph()); if (edit) inset->edit(cur, true); // Now put co-text into inset @@ -292,11 +295,25 @@ static bool doInsertInset(Cursor & cur, Text * text, } bool gotsel = false; + bool move_layout = false; if (cur.selection()) { if (cmd.action() == LFUN_INDEX_INSERT) copySelectionToTemp(cur); - else + 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. + * FIXME: figure out a good test in the environment case (see #12251). + */ + if (cur.paragraph().layout().isCommand() + && cur.paragraph().empty() + && !inset->forcePlainLayout()) { + cur.paragraph().setPlainOrDefaultLayout(bparams.documentClass()); + move_layout = true; + } + } cur.clearSelection(); gotsel = true; } else if (cmd.action() == LFUN_INDEX_INSERT) { @@ -306,6 +323,19 @@ static bool doInsertInset(Cursor & cur, Text * text, } text->insertInset(cur, inset); + InsetText * inset_text = inset->asInsetText(); + if (inset_text) { + Font const & font = inset->inheritFont() + ? cur.bv().textMetrics(text).displayFont(cur.pit(), cur.pos()) + : bparams.getFont(); + inset_text->setOuterFont(cur.bv(), font.fontInfo()); + } + + if (cmd.action() == LFUN_ARGUMENT_INSERT) { + InsetArgument * const ia = static_cast(inset); + ia->init(cur.paragraph()); + } + if (edit) inset->edit(cur, true); @@ -316,27 +346,31 @@ static bool doInsertInset(Cursor & cur, Text * text, cur.buffer()->errors("Paste"); cur.clearSelection(); // bug 393 cur.finishUndo(); - 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); + if (resetfont) { + // Reset of font (not language) is requested. + // Used by InsetIndex (#11961). + Language const * lang = cur.getFont().language(); + Font font(bparams.getFont().fontInfo(), lang); + cur.paragraph().resetFonts(font); } + inset_text->fixParagraphsFont(); + cur.pos() = 0; + cur.pit() = 0; + /* If the containing paragraph has kept its layout, reset the + * layout of the first paragraph of the inset. + */ + if (!move_layout) + cur.paragraph().setPlainOrDefaultLayout(bparams.documentClass()); + // 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 @@ -359,7 +393,7 @@ enum OutlineOp { }; -static void insertSeparator(Cursor & cur, depth_type const depth) +static void insertSeparator(Cursor const & cur, depth_type const depth) { Buffer & buf = *cur.buffer(); lyx::dispatch(FuncRequest(LFUN_PARAGRAPH_BREAK)); @@ -382,7 +416,7 @@ static void outline(OutlineOp mode, Cursor & cur, Text * text) ParagraphList & pars = buf.text().paragraphs(); ParagraphList::iterator const bgn = pars.begin(); // The first paragraph of the area to be copied: - ParagraphList::iterator start = lyx::next(bgn, pit); + ParagraphList::iterator start = pars.iterator_at(pit); // The final paragraph of area to be copied: ParagraphList::iterator finish = start; ParagraphList::iterator const end = pars.end(); @@ -533,16 +567,14 @@ static void outline(OutlineOp mode, Cursor & cur, Text * text) 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 == newtoclevel && - lit->labeltype == oldlabeltype) { - start->setLayout(*lit); + for (auto const & lay : tc) { + if (lay.toclevel == newtoclevel && + lay.labeltype == oldlabeltype) { + start->setLayout(lay); break; } } @@ -561,10 +593,10 @@ 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()); } @@ -579,7 +611,6 @@ Language const * getLanguage(Cursor const & cur, string const & lang) docstring resolveLayout(docstring layout, DocIterator const & dit) { Paragraph const & par = dit.paragraph(); - docstring const old_layout = par.layout().name(); DocumentClass const & tclass = dit.buffer()->params().documentClass(); if (layout.empty()) @@ -672,7 +703,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(); @@ -786,24 +816,20 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) bool const cur_moved = cursorForward(cur); needsUpdate |= cur_moved; - if (!cur_moved && oldTopSlice == cur.top() - && cur.boundary() == oldBoundary) { + if (!cur_moved && cur.depth() > 1 + && 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(); - } + // we will be moving out the inset, so we should execute + // the depm-mechanism. + // 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; } @@ -815,24 +841,21 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) bool const cur_moved = cursorBackward(cur); needsUpdate |= cur_moved; - if (!cur_moved && oldTopSlice == cur.top() - && cur.boundary() == oldBoundary) { + if (!cur_moved && cur.depth() > 1 + && 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(); - } + // we will be moving out the inset, so we should execute + // the depm-mechanism. + // 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; } @@ -843,8 +866,8 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) 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) { + if (!cur_moved && cur.depth() > 1 + && oldTopSlice == cur.top() && cur.boundary() == oldBoundary) { cur.undispatched(); cmd = FuncRequest(LFUN_FINISHED_LEFT); } @@ -867,8 +890,8 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) 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) { + if (!cur_moved && cur.depth() > 1 + && oldTopSlice == cur.top() && cur.boundary() == oldBoundary) { cur.undispatched(); cmd = FuncRequest(LFUN_FINISHED_RIGHT); } @@ -891,14 +914,12 @@ 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 const 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 const atFirstOrLastRow = cur.atFirstOrLastRow(up); + bool const up = cmd.action() == LFUN_UP_SELECT || cmd.action() == LFUN_UP; - if (!atFirstOrLastRow) { + if (!cur.atFirstOrLastRow(up)) { needsUpdate |= cur.selHandle(select); cur.upDownInText(up, needsUpdate); needsUpdate |= cur.beforeDispatchCursor().inMathed(); @@ -914,18 +935,48 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) cur.forceBufferUpdate(); break; } + needsUpdate |= cur.selHandle(select); + bool const can_move = cur.upDownInText(up, needsUpdate); + // if the cursor can be moved up or down at an upper level, + // delegate the dispatch to next level. Otherwise, we are + // done. + if (can_move) { + cmd = FuncRequest(up ? LFUN_FINISHED_UP : LFUN_FINISHED_DOWN); + cur.undispatched(); + } + } - // 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); + break; + } + + case LFUN_FINISHED_UP: + case LFUN_FINISHED_DOWN: { + // move cursor up/down + bool const up = cmd.action() == LFUN_FINISHED_UP; + + if (!cur.atFirstOrLastRow(up)) { cur.upDownInText(up, needsUpdate); - cur.undispatched(); + needsUpdate |= cur.beforeDispatchCursor().inMathed(); + } else { + bool const can_move = cur.upDownInText(up, needsUpdate); + // if the cursor can be moved up or down and we are not + // moving cusor at top level, wait for the next dispatch. + // Otherwise, we are done. + if (can_move) + cur.undispatched(); } 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); @@ -956,7 +1007,7 @@ 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 = lyx::next(bgn, pit); + ParagraphList::iterator start = pars.iterator_at(pit); // The final paragraph of area to be selected: ParagraphList::iterator finish = start; ParagraphList::iterator end = pars.end(); @@ -993,8 +1044,8 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) 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) { + if (!cur_moved && cur.depth() > 1 + && oldTopSlice == cur.top() && cur.boundary() == oldBoundary) { cur.undispatched(); cmd = FuncRequest(LFUN_FINISHED_RIGHT); } @@ -1017,24 +1068,20 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) bool const cur_moved = cursorForwardOneWord(cur); needsUpdate |= cur_moved; - if (!cur_moved && oldTopSlice == cur.top() - && cur.boundary() == oldBoundary) { + if (!cur_moved && cur.depth() > 1 + && 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(); - } + // we will be moving out the inset, so we should execute + // the depm-mechanism. + // 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; } @@ -1045,8 +1092,8 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) 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) { + if (!cur_moved && cur.depth() > 1 + && oldTopSlice == cur.top() && cur.boundary() == oldBoundary) { cur.undispatched(); cmd = FuncRequest(LFUN_FINISHED_LEFT); } @@ -1069,25 +1116,21 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) bool const cur_moved = cursorBackwardOneWord(cur); needsUpdate |= cur_moved; - if (!cur_moved && oldTopSlice == cur.top() - && cur.boundary() == oldBoundary) { + if (!cur_moved && cur.depth() > 1 + && 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(); - } + // we will be moving out the inset, so we should execute + // the depm-mechanism. + // 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; } @@ -1100,7 +1143,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) case LFUN_NEWLINE_INSERT: { InsetNewlineParams inp; - docstring arg = cmd.argument(); + docstring const & arg = cmd.argument(); if (arg == "linebreak") inp.kind = InsetNewlineParams::LINEBREAK; else @@ -1212,6 +1255,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) cur.resetAnchor(); } else { cutSelection(cur, false); + cur.setCurrentFont(); singleParUpdate = false; } moveCursor(cur, false); @@ -1241,7 +1285,14 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) } } } else { + 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); + cur.setCurrentFont(); singleParUpdate = false; } break; @@ -1254,7 +1305,8 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) 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.empty() && !par.isEnvSeparator(cur.pos()) + && !par.layout().keepempty && !par.layout().isCommand() && pars_[prev].layout() != par.layout() && pars_[prev].layout().isEnvironment() @@ -1353,6 +1405,14 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) break; } + case LFUN_INSET_SPLIT: { + if (splitInset(cur)) { + needsUpdate = true; + cur.forceBufferUpdate(); + } + break; + } + case LFUN_GRAPHICS_SET_GROUP: { InsetGraphics * ins = graphics::getCurrentGraphicsInset(cur); if (!ins) @@ -1477,7 +1537,8 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) pasteFromStack(cur, bv->buffer().errorList("Paste"), 0); else if (theClipboard().hasTextContents()) { if (pasteClipboardText(cur, bv->buffer().errorList("Paste"), - true, Clipboard::AnyTextType)) + !cur.paragraph().parbreakIsNewline(), + Clipboard::AnyTextType)) tryGraphics = false; } if (tryGraphics && theClipboard().hasGraphicsContents()) @@ -1512,6 +1573,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) } bv->buffer().errors("Paste"); + bv->buffer().updatePreviews(); // bug 11619 cur.clearSelection(); // bug 393 cur.finishUndo(); break; @@ -1522,11 +1584,6 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) cur.message(_("Cut")); break; - case LFUN_COPY: - copySelection(cur); - cur.message(_("Copy")); - break; - case LFUN_SERVER_GET_XY: cur.message(from_utf8( convert(tm->cursorX(cur.top(), cur.boundary())) @@ -1574,8 +1631,13 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) if (change_layout) { setLayout(cur, layout); if (cur.pit() > 0 && !ignoreautonests) { + pit_type prev_pit = cur.pit() - 1; + depth_type const cur_depth = pars_[cur.pit()].getDepth(); + // Scan for the previous par on same nesting level + while (prev_pit > 0 && pars_[prev_pit].getDepth() > cur_depth) + --prev_pit; set const & autonests = - pars_[cur.pit() - 1].layout().autonests(); + pars_[prev_pit].layout().autonests(); set const & autonested = pars_[cur.pit()].layout().isAutonestedBy(); if (autonests.find(layout) != autonests.end() @@ -1585,11 +1647,19 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) } 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) { + // 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; } } @@ -1606,7 +1676,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) if (para.layout().isEnvironment()) layout = para.layout().name(); depth_type split_depth = cur.paragraph().params().depth(); - depth_type nextpar_depth = 0; + vector nextpars_depth; if (outer || previous) { // check if we have an environment in our scope pit_type pit = cur.pit(); @@ -1631,9 +1701,20 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) } } if ((outer || normal) && cur.pit() < cur.lastpit()) { - // save nesting of following paragraph - Paragraph cpar = pars_[cur.pit() + 1]; - nextpar_depth = cpar.params().depth(); + // save nesting of following paragraphs if they are deeper + // or same depth + pit_type offset = 1; + depth_type cur_depth = pars_[cur.pit()].params().depth(); + while (cur.pit() + offset <= cur.lastpit()) { + Paragraph cpar = pars_[cur.pit() + offset]; + depth_type nextpar_depth = cpar.params().depth(); + if (cur_depth <= nextpar_depth && nextpar_depth > 0) { + nextpars_depth.push_back(nextpar_depth); + cur_depth = nextpar_depth; + ++offset; + } else + break; + } } if (before) cur.top().setPitPos(cur.pit(), 0); @@ -1661,17 +1742,20 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) 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 + if ((outer || normal) && !nextpars_depth.empty()) { + // restore nesting of following paragraphs 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; + depth_type max_depth = cur.paragraph().params().depth() + 1; + for (auto nextpar_depth : nextpars_depth) { + 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; + } + max_depth = cur.paragraph().params().depth() + 1; } cur.setCursor(scur); } @@ -1750,8 +1834,8 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) } } } - InsetQuotesParams::QuoteLevel const quote_level = inner - ? InsetQuotesParams::SecondaryQuotes : InsetQuotesParams::PrimaryQuotes; + QuoteLevel const quote_level = inner + ? QuoteLevel::Secondary : QuoteLevel::Primary; cur.insert(new InsetQuotes(cur.buffer(), c, quote_level, cmd.getArg(1), cmd.getArg(2))); cur.buffer()->updateBuffer(); cur.posForward(); @@ -1760,9 +1844,12 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) 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; } @@ -1787,8 +1874,18 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) bvcur.resetAnchor(); if (!bv->mouseSetCursor(cur, cmd.modifier() == ShiftModifier)) cur.screenUpdateFlags(Update::SinglePar | Update::FitCursor); - if (bvcur.wordSelection()) - selectWord(bvcur, WHOLE_WORD); + // FIXME: move this to mouseSetCursor? + if (bvcur.wordSelection() && bvcur.inTexted()) { + // select word around new position + Cursor c = bvcur; + c.selection(false); + c.text()->selectWord(c, WHOLE_WORD); + // use the correct word boundary, depending on selection direction + if (bvcur.top() > bvcur.normalAnchor()) + bvcur.pos() = c.selEnd().pos(); + else + bvcur.pos() = c.selBegin().pos(); + } break; case mouse_button::button2: @@ -1806,7 +1903,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) // Don't do anything if we right-click a // selection, a context menu will popup. if (bvcur.selection() && cur >= bvcur.selectionBegin() - && cur < bvcur.selectionEnd()) { + && cur <= bvcur.selectionEnd()) { cur.noScreenUpdate(); return; } @@ -1919,8 +2016,10 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) // "auto_region_delete", which defaults to // true (on). - if (lyxrc.auto_region_delete && cur.selection()) + if (lyxrc.auto_region_delete && cur.selection()) { cutSelection(cur, false); + cur.setCurrentFont(); + } cur.clearSelection(); for (char_type c : cmd.argument()) @@ -2024,15 +2123,19 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) case LFUN_INDEX_INSERT: case LFUN_PREVIEW_INSERT: case LFUN_SCRIPT_INSERT: - case LFUN_IPA_INSERT: + case LFUN_IPA_INSERT: { + // Indexes reset font formatting (#11961) + bool const resetfont = cmd.action() == LFUN_INDEX_INSERT; // Open the inset, and move the current selection // inside it. - doInsertInset(cur, this, cmd, true, true); + doInsertInset(cur, this, cmd, true, true, resetfont); cur.posForward(); + 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(); break; + } case LFUN_FLEX_INSERT: { // Open the inset, and move the current selection @@ -2040,18 +2143,32 @@ 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(); - Layout::LaTeXArgMap::const_iterator lait = args.begin(); - Layout::LaTeXArgMap::const_iterator const laend = args.end(); - for (; lait != laend; ++lait) { - Layout::latexarg arg = (*lait).second; + bool autoargs = false, inautoarg = false; + Layout::LaTeXArgMap args = cur.inset().getLayout().args(); + for (auto const & argt : args) { + Layout::latexarg arg = argt.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 cmd2(LFUN_ARGUMENT_INSERT, (*lait).first); + // 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.setCurrentFont(); + cur.posForward(); + if (arg.insertonnewline && cur.pos() > 0) { + FuncRequest cmd2(LFUN_PARAGRAPH_BREAK); + lyx::dispatch(cmd2); + } + } + FuncRequest cmd2(LFUN_ARGUMENT_INSERT, argt.first); lyx::dispatch(cmd2); autoargs = true; + inautoarg = true; } } if (!autoargs) { @@ -2065,14 +2182,77 @@ 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: @@ -2130,7 +2310,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) case LFUN_NOMENCL_INSERT: { InsetCommandParams p(NOMENCL_CODE); if (cmd.argument().empty()) { - p["symbol"] = + p["symbol"] = bv->cursor().innerText()->getStringForDialog(bv->cursor()); cur.clearSelection(); } else @@ -2338,6 +2518,13 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) break; } + case LFUN_FONT_NO_SPELLCHECK: { + Font font(ignore_font, ignore_language); + font.fontInfo().setNoSpellcheck(FONT_TOGGLE); + toggleAndShow(cur, this, font); + break; + } + case LFUN_FONT_SIZE: { Font font(ignore_font, ignore_language); setLyXSize(to_utf8(cmd.argument()), font.fontInfo()); @@ -2359,10 +2546,6 @@ 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; } @@ -2378,7 +2561,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) break; } } else { - cur.message(_("Invalid argument (must be a positive number)!")); + cur.message(_("Invalid argument (must be a non-negative number)!")); break; } } @@ -2390,17 +2573,13 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) // 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)) { docstring const props = font.stateText(&bv->buffer().params(), true); freeFonts.push(make_pair(props, font)); toggleall = toggle; 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"); @@ -2534,8 +2713,15 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) docstring arg = cmd.argument(); if (arg.empty()) { arg = cur.selectionAsString(false); - // FIXME + // Too large. We unselect if needed and try to get + // the first word in selection or under cursor if (arg.size() > 100 || arg.empty()) { + if (cur.selection()) { + DocIterator selbeg = cur.selectionBegin(); + cur.clearSelection(); + setCursorIntern(cur, selbeg.pit(), selbeg.pos()); + cur.screenUpdateFlags(Update::Force); + } // Get word or selection selectWordWhenUnderCursor(cur, WHOLE_WORD); arg = cur.selectionAsString(false); @@ -2580,6 +2766,65 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) break; } + case LFUN_SPELLING_ADD_LOCAL: { + Language const * language = getLanguage(cur, cmd.getArg(1)); + docstring word = from_utf8(cmd.getArg(0)); + if (word.empty()) { + word = cur.selectionAsString(false); + if (word.size() > 100) + break; + if (word.empty()) { + // Get word or selection + selectWordWhenUnderCursor(cur, WHOLE_WORD); + word = cur.selectionAsString(false); + } + } + WordLangTuple wl(word, language); + if (!bv->buffer().params().spellignored(wl)) { + cur.recordUndoBufferParams(); + bv->buffer().params().spellignore().push_back(wl); + cur.recordUndo(); + // trigger re-check of whole buffer + bv->buffer().requestSpellcheck(); + } + break; + } + + case LFUN_SPELLING_REMOVE_LOCAL: { + Language const * language = getLanguage(cur, cmd.getArg(1)); + docstring word = from_utf8(cmd.getArg(0)); + if (word.empty()) { + word = cur.selectionAsString(false); + if (word.size() > 100) + break; + if (word.empty()) { + // Get word or selection + selectWordWhenUnderCursor(cur, WHOLE_WORD); + word = cur.selectionAsString(false); + } + } + WordLangTuple wl(word, language); + bool has_item = false; + vector::const_iterator it = bv->buffer().params().spellignore().begin(); + for (; it != bv->buffer().params().spellignore().end(); ++it) { + if (it->lang()->code() != wl.lang()->code()) + continue; + if (it->word() == wl.word()) { + has_item = true; + break; + } + } + if (has_item) { + cur.recordUndoBufferParams(); + bv->buffer().params().spellignore().erase(it); + cur.recordUndo(); + // trigger re-check of whole buffer + bv->buffer().requestSpellcheck(); + } + break; + } + + case LFUN_SPELLING_IGNORE: { Language const * language = getLanguage(cur, cmd.getArg(1)); docstring word = from_utf8(cmd.getArg(0)); @@ -2647,19 +2892,23 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) } break; - case LFUN_OUTLINE_UP: + case LFUN_OUTLINE_UP: { + pos_type const opos = cur.pos(); outline(OutlineUp, cur, this); - setCursor(cur, cur.pit(), 0); + setCursor(cur, cur.pit(), opos); cur.forceBufferUpdate(); needsUpdate = true; break; + } - case LFUN_OUTLINE_DOWN: + case LFUN_OUTLINE_DOWN: { + pos_type const opos = cur.pos(); outline(OutlineDown, cur, this); - setCursor(cur, cur.pit(), 0); + setCursor(cur, cur.pit(), opos); cur.forceBufferUpdate(); needsUpdate = true; break; + } case LFUN_OUTLINE_IN: outline(OutlineIn, cur, this); @@ -2673,32 +2922,31 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) needsUpdate = true; break; - 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))); - } + 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"); @@ -2763,7 +3011,7 @@ void Text::dispatch(Cursor & cur, FuncRequest & cmd) bool Text::getStatus(Cursor & cur, FuncRequest const & cmd, - FuncStatus & flag) const + FuncStatus & status) const { LBUFERR(this == cur.text()); @@ -2786,7 +3034,7 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd, // 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()); + status.setOnOff(cur.paragraph().params().startOfAppendix()); break; case LFUN_DIALOG_SHOW_NEW_INSET: @@ -2803,6 +3051,8 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd, code = BRANCH_CODE; else if (cmd.argument() == "citation") code = CITE_CODE; + else if (cmd.argument() == "counter") + code = COUNTER_CODE; else if (cmd.argument() == "ert") code = ERT_CODE; else if (cmd.argument() == "external") @@ -2861,6 +3111,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; @@ -2913,7 +3166,7 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd, 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); + status.setUnknown(true); // probably not necessary, but... enable = false; } @@ -2939,10 +3192,9 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd, string s = cmd.getArg(0); InsetLayout il = cur.buffer()->params().documentClass().insetLayout(from_utf8(s)); - if (il.lyxtype() != InsetLayout::CHARSTYLE && - il.lyxtype() != InsetLayout::CUSTOM && - il.lyxtype() != InsetLayout::ELEMENT && - il.lyxtype ()!= InsetLayout::STANDARD) + if (il.lyxtype() != InsetLyXType::CHARSTYLE && + il.lyxtype() != InsetLyXType::CUSTOM && + il.lyxtype ()!= InsetLyXType::STANDARD) enable = false; break; } @@ -3098,43 +3350,42 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd, break; case LFUN_FONT_EMPH: - flag.setOnOff(fontinfo.emph() == FONT_ON); + status.setOnOff(fontinfo.emph() == FONT_ON); enable = !cur.paragraph().isPassThru(); break; case LFUN_FONT_ITAL: - flag.setOnOff(fontinfo.shape() == ITALIC_SHAPE); + status.setOnOff(fontinfo.shape() == ITALIC_SHAPE); enable = !cur.paragraph().isPassThru(); break; case LFUN_FONT_NOUN: - flag.setOnOff(fontinfo.noun() == FONT_ON); + status.setOnOff(fontinfo.noun() == FONT_ON); enable = !cur.paragraph().isPassThru(); break; case LFUN_FONT_BOLD: case LFUN_FONT_BOLDSYMBOL: - flag.setOnOff(fontinfo.series() == BOLD_SERIES); + status.setOnOff(fontinfo.series() == BOLD_SERIES); enable = !cur.paragraph().isPassThru(); break; case LFUN_FONT_SANS: - flag.setOnOff(fontinfo.family() == SANS_FAMILY); + status.setOnOff(fontinfo.family() == SANS_FAMILY); enable = !cur.paragraph().isPassThru(); break; case LFUN_FONT_ROMAN: - flag.setOnOff(fontinfo.family() == ROMAN_FAMILY); + status.setOnOff(fontinfo.family() == ROMAN_FAMILY); enable = !cur.paragraph().isPassThru(); break; case LFUN_FONT_TYPEWRITER: - flag.setOnOff(fontinfo.family() == TYPEWRITER_FAMILY); + status.setOnOff(fontinfo.family() == TYPEWRITER_FAMILY); enable = !cur.paragraph().isPassThru(); break; case LFUN_CUT: - case LFUN_COPY: enable = cur.selection(); break; @@ -3201,6 +3452,7 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd, break; case LFUN_PRIMARY_SELECTION_PASTE: + status.setUnknown(!theSelection().supported()); enable = cur.selection() || !theSelection().empty(); break; @@ -3233,15 +3485,22 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd, 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()); + bool const in_last_par = (it.pit() == cur.selectionEnd().pit() && + it.idx() == cur.selectionEnd().idx()); if (in_last_par) end = cur.selectionEnd().pos(); else - end = it.lastpos(); + // 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 (beg != end && it.paragraph().hasChangedInsets(beg, end)) { + enable = true; + break; + } if (in_last_par) break; } @@ -3278,7 +3537,7 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd, if (!ins) enable = false; else - flag.setOnOff(to_utf8(cmd.argument()) == ins->getParams().groupId); + status.setOnOff(to_utf8(cmd.argument()) == ins->getParams().groupId); break; } @@ -3290,7 +3549,7 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd, case LFUN_LANGUAGE: enable = !cur.paragraph().isPassThru(); - flag.setOnOff(cmd.getArg(0) == cur.real_current_font.language()->lang()); + status.setOnOff(cmd.getArg(0) == cur.real_current_font.language()->lang()); break; case LFUN_PARAGRAPH_BREAK: @@ -3298,13 +3557,15 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd, break; case LFUN_SPELLING_ADD: + case LFUN_SPELLING_ADD_LOCAL: + case LFUN_SPELLING_REMOVE_LOCAL: case LFUN_SPELLING_IGNORE: case LFUN_SPELLING_REMOVE: - enable = theSpellChecker() != NULL; + enable = theSpellChecker() != nullptr; if (enable && !cmd.getArg(1).empty()) { // validate explicitly given language Language const * const lang = const_cast(languages.getLanguage(cmd.getArg(1))); - enable &= lang != NULL; + enable &= lang != nullptr; } break; @@ -3315,7 +3576,7 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd, docstring const layout = resolveLayout(req_layout, cur); enable = !owner_->forcePlainLayout() && !layout.empty(); - flag.setOnOff(isAlreadyLayout(layout, cur)); + status.setOnOff(!owner_->forcePlainLayout() && isAlreadyLayout(layout, cur)); break; } @@ -3387,7 +3648,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: @@ -3396,10 +3656,43 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd, case LFUN_FONT_CROSSOUT: case LFUN_FONT_UNDERUNDERLINE: case LFUN_FONT_UNDERWAVE: + case LFUN_FONT_NO_SPELLCHECK: 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; @@ -3423,6 +3716,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: @@ -3492,7 +3786,7 @@ bool Text::getStatus(Cursor & cur, FuncRequest const & cmd, || (cur.paragraph().layout().pass_thru && !allow_in_passthru))) enable = false; - flag.setEnabled(enable); + status.setEnabled(enable); return true; } @@ -3511,9 +3805,9 @@ void Text::pasteString(Cursor & cur, docstring const & clip, // FIXME: an item inset would make things much easier. -bool Text::inDescriptionItem(Cursor & cur) const +bool Text::inDescriptionItem(Cursor const & cur) const { - Paragraph & par = cur.paragraph(); + Paragraph const & par = cur.paragraph(); pos_type const pos = cur.pos(); pos_type const body_pos = par.beginOfBody(); @@ -3532,12 +3826,8 @@ 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); + for (auto const & f : freeFonts) + ffList.push_back(f.first); return ffList; }