#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"
#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"
#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 <clocale>
+#include <regex>
#include <sstream>
using namespace std;
using frontend::Clipboard;
// globals...
-static Font freefont(ignore_font, ignore_language);
+typedef limited_stack<pair<docstring, Font>> FontStack;
+static FontStack freeFonts(15);
static bool toggleall = false;
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();
}
}
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();
cur.recordUndo();
if (cmd.action() == LFUN_ARGUMENT_INSERT) {
bool cotextinsert = false;
- InsetArgument const * const ia = static_cast<InsetArgument const *>(inset);
+ InsetArgument * const ia = static_cast<InsetArgument *>(inset);
Layout const & lay = cur.paragraph().layout();
Layout::LaTeXArgMap args = lay.args();
Layout::LaTeXArgMap::const_iterator const lait = args.find(ia->name());
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
}
bool gotsel = false;
+ bool move_layout = false;
if (cur.selection()) {
if (cmd.action() == LFUN_INDEX_INSERT)
copySelectionToTemp(cur);
- else
- cutSelectionToTemp(cur, false, pastesel);
+ 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) {
}
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<InsetArgument *>(inset);
+ ia->init(cur.paragraph());
+ }
+
if (edit)
inset->edit(cur, true);
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
};
-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));
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();
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;
}
}
}
-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
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();
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);
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);
case LFUN_LINE_DELETE_FORWARD:
if (cur.selection())
- cutSelection(cur, true, false);
+ cutSelection(cur, false);
else
tm->deleteLineForward(cur);
finishChange(cur, false);
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;
}
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;
}
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);
}
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);
}
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();
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);
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();
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);
}
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;
}
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);
}
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;
}
case LFUN_NEWLINE_INSERT: {
InsetNewlineParams inp;
- docstring arg = cmd.argument();
+ docstring const & arg = cmd.argument();
if (arg == "linebreak")
inp.kind = InsetNewlineParams::LINEBREAK;
else
needsUpdate |= erase(cur);
cur.resetAnchor();
} else {
- cutSelection(cur, true, false);
+ cutSelection(cur, false);
+ cur.setCurrentFont();
singleParUpdate = false;
}
moveCursor(cur, false);
}
}
} 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);
+ cur.setCurrentFont();
singleParUpdate = false;
}
break;
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()
}
*/
if (cur.selection())
- cutSelection(cur, true, false);
+ cutSelection(cur, false);
cur.insert(inset);
cur.forceBufferUpdate();
if (inset->editable() && inset->asInsetText())
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)
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())
}
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;
- case LFUN_COPY:
- copySelection(cur);
- cur.message(_("Copy"));
- break;
-
case LFUN_SERVER_GET_XY:
cur.message(from_utf8(
convert<string>(tm->cursorX(cur.top(), cur.boundary()))
cur.message(cur.paragraph().layout().name());
break;
- case LFUN_LAYOUT: {
+ case LFUN_LAYOUT:
+ case LFUN_LAYOUT_TOGGLE: {
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();
- docstring const old_layout = para.layout().name();
- DocumentClass const & tclass = bv->buffer().params().documentClass();
-
- 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);
+ docstring req_layout = ignoreautonests ? from_utf8(cmd.getArg(0)) : cmd.argument();
+ LYXERR(Debug::INFO, "LFUN_LAYOUT: (arg) " << to_utf8(req_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) {
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<docstring> const & autonests =
- pars_[cur.pit() - 1].layout().autonests();
+ pars_[prev_pit].layout().autonests();
set<docstring> const & autonested =
pars_[cur.pit()].layout().isAutonestedBy();
if (autonests.find(layout) != autonests.end()
}
}
- 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 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.posForward();
+ }
+ FuncRequest const cmd2(LFUN_ARGUMENT_INSERT, la_pair.first);
lyx::dispatch(cmd2);
+ inautoarg = true;
}
}
if (para.layout().isEnvironment())
layout = para.layout().name();
depth_type split_depth = cur.paragraph().params().depth();
- depth_type nextpar_depth = 0;
+ vector<depth_type> nextpars_depth;
if (outer || previous) {
// check if we have an environment in our scope
pit_type pit = cur.pit();
}
}
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);
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))
- lyx::dispatch(FuncRequest(LFUN_DEPTH_INCREMENT));
+ 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);
}
}
}
}
- 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();
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;
}
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:
// 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;
}
// "auto_region_delete", which defaults to
// true (on).
- if (lyxrc.auto_region_delete && cur.selection())
- cutSelection(cur, false, false);
-
+ if (lyxrc.auto_region_delete && cur.selection()) {
+ cutSelection(cur, false);
+ cur.setCurrentFont();
+ }
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);
}
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.forceBufferUpdate();
- cur.posForward();
break;
}
case LFUN_CAPTION_INSERT:
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
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) {
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<int>(rows);
+ int const c = convert<int>(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:
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
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());
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<uint>(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);
+ cur.message(bformat(_("Text properties applied: %1$s"), props));
+ } else
+ LYXERR0("Invalid argument of textstyle-update");
break;
}
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) {
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);
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<WordLangTuple>::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));
}
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);
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<docstring>(cur.buffer()->wordCount()));
- } else if (arg0 == "chars") {
- cur.message(convert<docstring>(cur.buffer()->charCount(false)));
- } else if (arg0 == "chars-space") {
- cur.message(convert<docstring>(cur.buffer()->charCount(true)));
- } else {
- cur.message(convert<docstring>(cur.buffer()->wordCount()) + " "
- + convert<docstring>(cur.buffer()->charCount(false)) + " "
- + convert<docstring>(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<docstring>(cur.buffer()->wordCount()));
+ } else if (arg0 == "chars") {
+ cur.message(convert<docstring>(cur.buffer()->charCount(false)));
+ } else if (arg0 == "chars-space") {
+ cur.message(convert<docstring>(cur.buffer()->charCount(true)));
+ } else {
+ cur.message(convert<docstring>(cur.buffer()->wordCount()) + " "
+ + convert<docstring>(cur.buffer()->charCount(false)) + " "
+ + convert<docstring>(cur.buffer()->charCount(true)));
}
break;
+ }
default:
LYXERR(Debug::ACTION, "Command " << cmd << " not DISPATCHED by Text");
bool Text::getStatus(Cursor & cur, FuncRequest const & cmd,
- FuncStatus & flag) const
+ FuncStatus & status) const
{
LBUFERR(this == cur.text());
// 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:
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")
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;
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;
}
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;
}
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;
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;
break;
case LFUN_PRIMARY_SELECTION_PASTE:
+ status.setUnknown(!theSelection().supported());
enable = cur.selection() || !theSelection().empty();
break;
if (!cur.buffer()->areChangesPresent())
break;
- for (DocIterator it = cur.selectionBegin(); it < cur.selectionEnd(); it.forwardPar()) {
+ for (DocIterator it = cur.selectionBegin(); ; it.forwardPar()) {
pos_type const beg = it.pos();
pos_type end;
- if (it.paragraph().id() == cur.selectionEnd().paragraph().id())
+ 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.paragraph().size();
+ // 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;
}
}
break;
if (!ins)
enable = false;
else
- flag.setOnOff(to_utf8(cmd.argument()) == ins->getParams().groupId);
+ status.setOnOff(to_utf8(cmd.argument()) == ins->getParams().groupId);
break;
}
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());
+ status.setOnOff(cmd.getArg(0) == cur.real_current_font.language()->lang());
break;
case LFUN_PARAGRAPH_BREAK:
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<Language *>(languages.getLanguage(cmd.getArg(1)));
- enable &= lang != NULL;
+ enable &= lang != nullptr;
}
break;
- case LFUN_LAYOUT: {
- DocumentClass const & tclass = cur.buffer()->params().documentClass();
+ case LFUN_LAYOUT:
+ case LFUN_LAYOUT_TOGGLE: {
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);
+ 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();
+ status.setOnOff(!owner_->forcePlainLayout() && isAlreadyLayout(layout, cur));
break;
}
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_CROSSOUT:
case LFUN_FONT_UNDERUNDERLINE:
case LFUN_FONT_UNDERWAVE:
- case LFUN_TEXTSTYLE_APPLY:
+ 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;
+
case LFUN_WORD_DELETE_FORWARD:
case LFUN_WORD_DELETE_BACKWARD:
case LFUN_LINE_DELETE_FORWARD:
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:
break;
}
+ case LFUN_SEARCH_IGNORE: {
+ bool const value = cmd.getArg(1) == "true";
+ setIgnoreFormat(cmd.getArg(0), value);
+ break;
+ }
+
default:
return false;
}
|| (cur.paragraph().layout().pass_thru && !allow_in_passthru)))
enable = false;
- flag.setEnabled(enable);
+ status.setEnabled(enable);
return true;
}
// 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();
&& (pos == 0 || par.getChar(pos - 1) != ' ')));
}
+
+std::vector<docstring> Text::getFreeFonts() const
+{
+ vector<docstring> ffList;
+
+ for (auto const & f : freeFonts)
+ ffList.push_back(f.first);
+
+ return ffList;
+}
+
} // namespace lyx
projects / features.git / blobdiff