#include "Text.h"
-#include "Bidi.h"
#include "BranchList.h"
#include "FloatList.h"
#include "FuncStatus.h"
#include "SpellChecker.h"
#include "TextClass.h"
#include "TextMetrics.h"
+#include "Thesaurus.h"
#include "WordLangTuple.h"
#include "frontends/alert.h"
#include "frontends/Selection.h"
#include "insets/InsetArgument.h"
-#include "insets/InsetCollapsable.h"
+#include "insets/InsetCollapsible.h"
#include "insets/InsetCommand.h"
#include "insets/InsetExternal.h"
#include "insets/InsetFloat.h"
#include "support/regex.h"
#include "mathed/InsetMathHull.h"
-#include "mathed/MathMacroTemplate.h"
+#include "mathed/InsetMathMacroTemplate.h"
#include <clocale>
#include <sstream>
namespace lyx {
using cap::copySelection;
+using cap::copySelectionToTemp;
using cap::cutSelection;
+using cap::cutSelectionToTemp;
using cap::pasteFromStack;
+using cap::pasteFromTemp;
using cap::pasteClipboardText;
using cap::pasteClipboardGraphics;
using cap::replaceSelection;
using cap::grabAndEraseSelection;
using cap::selClearOrDel;
using cap::pasteSimpleText;
+using frontend::Clipboard;
// globals...
static Font freefont(ignore_font, ignore_language);
static bool toggleall = false;
static void toggleAndShow(Cursor & cur, Text * text,
- Font const & font, bool toggleall = true)
+ Font const & font, bool togall = true)
{
- text->toggleFree(cur, font, toggleall);
+ text->toggleFree(cur, font, togall);
if (font.language() != ignore_language ||
font.fontInfo().number() != FONT_IGNORE) {
}
-static void mathDispatch(Cursor & cur, FuncRequest const & cmd, bool display)
+static void mathDispatch(Cursor & cur, FuncRequest const & cmd)
{
cur.recordUndo();
docstring sel = cur.selectionAsString(false);
LATTEST(old_pos == cur.pos());
#endif
cur.nextInset()->edit(cur, true);
- // don't do that also for LFUN_MATH_MODE
- // unless you want end up with always changing
- // to mathrm when opening an inlined inset --
- // I really hate "LyXfunc overloading"...
- if (display)
- cur.dispatch(FuncRequest(LFUN_MATH_DISPLAY));
- // Avoid an unnecessary undo step if cmd.argument
- // is empty
- if (!cmd.argument().empty())
- cur.dispatch(FuncRequest(LFUN_MATH_INSERT,
- cmd.argument()));
+ if (cmd.action() != LFUN_MATH_MODE)
+ // LFUN_MATH_MODE has a different meaning in math mode
+ cur.dispatch(cmd);
} else {
- // create a macro if we see "\\newcommand"
- // somewhere, and an ordinary formula
- // otherwise
- if (sel.find(from_ascii("\\newcommand")) == string::npos
- && sel.find(from_ascii("\\newlyxcommand")) == string::npos
- && sel.find(from_ascii("\\def")) == string::npos)
- {
- InsetMathHull * formula = new InsetMathHull(cur.buffer());
- string const selstr = to_utf8(sel);
- istringstream is(selstr);
- Lexer lex;
+ InsetMathHull * formula = new InsetMathHull(cur.buffer());
+ string const selstr = to_utf8(sel);
+ istringstream is(selstr);
+ Lexer lex;
+ lex.setStream(is);
+ if (!formula->readQuiet(lex)) {
+ // No valid formula, let's try with delims
+ is.str("$" + selstr + "$");
lex.setStream(is);
if (!formula->readQuiet(lex)) {
- // No valid formula, let's try with delims
- is.str("$" + selstr + "$");
- lex.setStream(is);
- if (!formula->readQuiet(lex)) {
- // Still not valid, leave it as is
- valid = false;
- delete formula;
- cur.insert(sel);
- } else
- cur.insert(formula);
- } else
- cur.insert(formula);
- } else {
- cur.insert(new MathMacroTemplate(cur.buffer(), sel));
+ // Still not valid, leave it as is
+ valid = false;
+ delete formula;
+ cur.insert(sel);
+ }
+ }
+ if (valid) {
+ cur.insert(formula);
+ cur.nextInset()->edit(cur, true);
+ LASSERT(cur.inMathed(), return);
+ cur.pos() = 0;
+ cur.resetAnchor();
+ cur.selection(true);
+ cur.pos() = cur.lastpos();
+ if (cmd.action() != LFUN_MATH_MODE)
+ // LFUN_MATH_MODE has a different meaning in math mode
+ cur.dispatch(cmd);
+ cur.clearSelection();
+ cur.pos() = cur.lastpos();
}
}
if (valid)
if (!inset)
return false;
- if (InsetCollapsable * ci = inset->asInsetCollapsable())
+ if (InsetCollapsible * ci = inset->asInsetCollapsible())
ci->setButtonLabel();
cur.recordUndo();
- if (cmd.action() == LFUN_INDEX_INSERT) {
- docstring ds = subst(text->getStringToIndex(cur), '\n', ' ');
- text->insertInset(cur, inset);
- if (edit)
- inset->edit(cur, true);
- // Now put this into inset
- Font const f(inherit_font, cur.current_font.language());
- if (!ds.empty()) {
- cur.text()->insertStringAsLines(cur, ds, f);
- cur.leaveInset(*inset);
- }
- return true;
- }
- else if (cmd.action() == LFUN_ARGUMENT_INSERT) {
+ if (cmd.action() == LFUN_ARGUMENT_INSERT) {
bool cotextinsert = false;
InsetArgument const * const ia = static_cast<InsetArgument const *>(inset);
Layout const & lay = cur.paragraph().layout();
Layout::LaTeXArgMap::const_iterator const lait = args.find(ia->name());
if (lait != args.end())
cotextinsert = (*lait).second.insertcotext;
+ else {
+ InsetLayout const & il = cur.inset().getLayout();
+ args = il.args();
+ Layout::LaTeXArgMap::const_iterator const ilait = args.find(ia->name());
+ if (ilait != args.end())
+ cotextinsert = (*ilait).second.insertcotext;
+ }
// The argument requests to insert a copy of the co-text to the inset
if (cotextinsert) {
docstring ds;
bool gotsel = false;
if (cur.selection()) {
- cutSelection(cur, false, pastesel);
+ if (cmd.action() == LFUN_INDEX_INSERT)
+ copySelectionToTemp(cur);
+ else
+ cutSelectionToTemp(cur, pastesel);
cur.clearSelection();
gotsel = true;
+ } else if (cmd.action() == LFUN_INDEX_INSERT) {
+ gotsel = text->selectWordWhenUnderCursor(cur, WHOLE_WORD);
+ copySelectionToTemp(cur);
+ cur.clearSelection();
}
text->insertInset(cur, inset);
if (!gotsel || !pastesel)
return true;
- pasteFromStack(cur, cur.buffer()->errorList("Paste"), 0);
+ pasteFromTemp(cur, cur.buffer()->errorList("Paste"));
cur.buffer()->errors("Paste");
cur.clearSelection(); // bug 393
cur.finishUndo();
}
-string const freefont2string()
-{
- return freefont.toString(toggleall);
-}
-
-
/// the type of outline operation
enum OutlineOp {
OutlineUp, // Move this header with text down
};
-static void outline(OutlineOp mode, Cursor & cur)
+static void insertSeparator(Cursor & cur, depth_type const depth)
+{
+ Buffer & buf = *cur.buffer();
+ lyx::dispatch(FuncRequest(LFUN_PARAGRAPH_BREAK));
+ DocumentClass const & tc = buf.params().documentClass();
+ lyx::dispatch(FuncRequest(LFUN_LAYOUT, from_ascii("\"") + tc.plainLayout().name()
+ + from_ascii("\" ignoreautonests")));
+ // FIXME: Bibitem mess!
+ if (cur.prevInset() && cur.prevInset()->lyxCode() == BIBITEM_CODE)
+ lyx::dispatch(FuncRequest(LFUN_CHAR_DELETE_BACKWARD));
+ lyx::dispatch(FuncRequest(LFUN_SEPARATOR_INSERT, "plain"));
+ while (cur.paragraph().params().depth() > depth)
+ lyx::dispatch(FuncRequest(LFUN_DEPTH_DECREMENT));
+}
+
+
+static void outline(OutlineOp mode, Cursor & cur, Text * text)
{
Buffer & buf = *cur.buffer();
pit_type & pit = cur.pit();
ParagraphList & pars = buf.text().paragraphs();
ParagraphList::iterator const bgn = pars.begin();
// The first paragraph of the area to be copied:
- ParagraphList::iterator start = next(bgn, pit);
+ ParagraphList::iterator start = lyx::next(bgn, pit);
// The final paragraph of area to be copied:
ParagraphList::iterator finish = start;
ParagraphList::iterator const end = pars.end();
+ depth_type const current_depth = cur.paragraph().params().depth();
int const thistoclevel = buf.text().getTocLevel(distance(bgn, start));
int toclevel;
// Not found; do nothing
if (toclevel == Layout::NOT_IN_TOC || toclevel > thistoclevel)
return;
- pit_type const newpit = distance(bgn, dest);
+ pit_type newpit = distance(bgn, dest);
pit_type const len = distance(start, finish);
pit_type const deletepit = pit + len;
buf.undo().recordUndo(cur, newpit, deletepit - 1);
+ // If we move an environment upwards, make sure it is
+ // separated from its new neighbour below:
+ // If an environment of the same layout follows, and the moved
+ // paragraph sequence does not end with a separator, insert one.
+ ParagraphList::iterator lastmoved = finish;
+ --lastmoved;
+ if (start->layout().isEnvironment()
+ && dest->layout() == start->layout()
+ && !lastmoved->isEnvSeparator(lastmoved->beginOfBody())) {
+ cur.pit() = distance(bgn, lastmoved);
+ cur.pos() = cur.lastpos();
+ insertSeparator(cur, current_depth);
+ cur.pit() = pit;
+ }
+ // Likewise, if we moved an environment upwards, make sure it
+ // is separated from its new neighbour above.
+ // The paragraph before the target of movement
+ if (dest != bgn) {
+ ParagraphList::iterator before = dest;
+ --before;
+ // Get the parent paragraph (outer in nested context)
+ pit_type const parent =
+ before->params().depth() > current_depth
+ ? text->depthHook(distance(bgn, before), current_depth)
+ : distance(bgn, before);
+ // If a environment with same layout preceeds the moved one in the new
+ // position, and there is no separator yet, insert one.
+ if (start->layout().isEnvironment()
+ && pars[parent].layout() == start->layout()
+ && !before->isEnvSeparator(before->beginOfBody())) {
+ cur.pit() = distance(bgn, before);
+ cur.pos() = cur.lastpos();
+ insertSeparator(cur, current_depth);
+ cur.pit() = pit;
+ }
+ }
+ newpit = distance(bgn, dest);
pars.splice(dest, start, finish);
cur.pit() = newpit;
break;
&& toclevel <= thistoclevel)
break;
}
- // One such was found:
+ // One such was found, so go on...
+ // If we move an environment downwards, make sure it is
+ // separated from its new neighbour above.
pit_type newpit = distance(bgn, dest);
buf.undo().recordUndo(cur, pit, newpit - 1);
+ // The paragraph before the target of movement
+ ParagraphList::iterator before = dest;
+ --before;
+ // Get the parent paragraph (outer in nested context)
+ pit_type const parent =
+ before->params().depth() > current_depth
+ ? text->depthHook(distance(bgn, before), current_depth)
+ : distance(bgn, before);
+ // If a environment with same layout preceeds the moved one in the new
+ // position, and there is no separator yet, insert one.
+ if (start->layout().isEnvironment()
+ && pars[parent].layout() == start->layout()
+ && !before->isEnvSeparator(before->beginOfBody())) {
+ cur.pit() = distance(bgn, before);
+ cur.pos() = cur.lastpos();
+ insertSeparator(cur, current_depth);
+ cur.pit() = pit;
+ }
+ // Likewise, make sure moved environments are separated
+ // from their new neighbour below:
+ // If an environment of the same layout follows, and the moved
+ // paragraph sequence does not end with a separator, insert one.
+ ParagraphList::iterator lastmoved = finish;
+ --lastmoved;
+ if (dest != end
+ && start->layout().isEnvironment()
+ && dest->layout() == start->layout()
+ && !lastmoved->isEnvSeparator(lastmoved->beginOfBody())) {
+ cur.pit() = distance(bgn, lastmoved);
+ cur.pos() = cur.lastpos();
+ insertSeparator(cur, current_depth);
+ cur.pit() = pit;
+ }
+ newpit = distance(bgn, dest);
pit_type const len = distance(start, finish);
pars.splice(dest, start, finish);
cur.pit() = newpit - len;
DocumentClass const & tc = buf.params().documentClass();
DocumentClass::const_iterator lit = tc.begin();
DocumentClass::const_iterator len = tc.end();
- int const newtoclevel =
+ int const newtoclevel =
(mode == OutlineIn ? toclevel + 1 : toclevel - 1);
LabelType const oldlabeltype = start->layout().labeltype;
}
+namespace {
+
+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();
+ docstring const old_layout = par.layout().name();
+ 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
+
+
void Text::dispatch(Cursor & cur, FuncRequest & cmd)
{
LYXERR(Debug::ACTION, "Text::dispatch: cmd: " << cmd);
cur.noScreenUpdate();
LBUFERR(this == cur.text());
-
+
// NOTE: This should NOT be a reference. See commit 94a5481a.
CursorSlice const oldTopSlice = cur.top();
bool const oldBoundary = cur.boundary();
case LFUN_WORD_DELETE_FORWARD:
if (cur.selection())
- cutSelection(cur, true, false);
+ cutSelection(cur, false);
else
- deleteWordForward(cur);
+ deleteWordForward(cur, cmd.getArg(0) == "force");
finishChange(cur, false);
break;
case LFUN_WORD_DELETE_BACKWARD:
if (cur.selection())
- cutSelection(cur, true, false);
+ cutSelection(cur, false);
else
- deleteWordBackward(cur);
+ deleteWordBackward(cur, cmd.getArg(0) == "force");
finishChange(cur, false);
break;
case LFUN_LINE_DELETE_FORWARD:
if (cur.selection())
- cutSelection(cur, true, false);
+ cutSelection(cur, false);
else
tm->deleteLineForward(cur);
finishChange(cur, false);
cmd = FuncRequest(LFUN_FINISHED_LEFT);
}
} else {
- if (reverseDirectionNeeded(cur)) {
+ if (cur.reverseDirectionNeeded()) {
cmd.setAction(cmd.action() == LFUN_CHAR_LEFT_SELECT ?
LFUN_CHAR_FORWARD_SELECT : LFUN_CHAR_FORWARD);
} else {
cmd = FuncRequest(LFUN_FINISHED_RIGHT);
}
} else {
- if (reverseDirectionNeeded(cur)) {
+ if (cur.reverseDirectionNeeded()) {
cmd.setAction(cmd.action() == LFUN_CHAR_RIGHT_SELECT ?
LFUN_CHAR_BACKWARD_SELECT : LFUN_CHAR_BACKWARD);
} else {
cur.upDownInText(up, needsUpdate);
needsUpdate |= cur.beforeDispatchCursor().inMathed();
} else {
+ pos_type newpos = up ? 0 : cur.lastpos();
+ if (lyxrc.mac_like_cursor_movement && cur.pos() != newpos) {
+ needsUpdate |= cur.selHandle(select);
+ // we do not reset the targetx of the cursor
+ cur.pos() = newpos;
+ needsUpdate |= bv->checkDepm(cur, bv->cursor());
+ cur.updateTextTargetOffset();
+ if (needsUpdate)
+ cur.forceBufferUpdate();
+ break;
+ }
+
// if the cursor cannot be moved up or down do not remove
// the selection right now, but wait for the next dispatch.
if (select)
ParagraphList & pars = buf.text().paragraphs();
ParagraphList::iterator bgn = pars.begin();
// The first paragraph of the area to be selected:
- ParagraphList::iterator start = next(bgn, pit);
+ ParagraphList::iterator start = lyx::next(bgn, pit);
// The final paragraph of area to be selected:
ParagraphList::iterator finish = start;
ParagraphList::iterator end = pars.end();
break;
}
cur.pos() = cur.lastpos();
+ cur.boundary(false);
+ cur.setCurrentFont();
needsUpdate |= cur != old_cur;
break;
cmd = FuncRequest(LFUN_FINISHED_RIGHT);
}
} else {
- if (reverseDirectionNeeded(cur)) {
+ if (cur.reverseDirectionNeeded()) {
cmd.setAction(cmd.action() == LFUN_WORD_RIGHT_SELECT ?
LFUN_WORD_BACKWARD_SELECT : LFUN_WORD_BACKWARD);
} else {
cmd = FuncRequest(LFUN_FINISHED_LEFT);
}
} else {
- if (reverseDirectionNeeded(cur)) {
+ if (cur.reverseDirectionNeeded()) {
cmd.setAction(cmd.action() == LFUN_WORD_LEFT_SELECT ?
LFUN_WORD_FORWARD_SELECT : LFUN_WORD_FORWARD);
} else {
} else {
// Maybe we shouldn't allow tabs within a line, because they
// are not (yet) aligned as one might do expect.
- FuncRequest cmd(LFUN_SELF_INSERT, from_ascii("\t"));
- dispatch(cur, cmd);
+ FuncRequest ncmd(LFUN_SELF_INSERT, from_ascii("\t"));
+ dispatch(cur, ncmd);
}
break;
}
case LFUN_CHAR_DELETE_FORWARD:
if (!cur.selection()) {
- bool was_separator = cur.paragraph().isEnvSeparator(cur.pos());
if (cur.pos() == cur.paragraph().size())
// Par boundary, force full-screen update
singleParUpdate = false;
- needsUpdate |= erase(cur);
- cur.resetAnchor();
- if (was_separator && cur.pos() == cur.paragraph().size()
- && (!cur.paragraph().layout().isEnvironment()
- || cur.paragraph().size() > 0)) {
- // Force full-screen update
- singleParUpdate = false;
- needsUpdate |= erase(cur);
+ else if (cmd.getArg(0) != "force" && cur.confirmDeletion()) {
cur.resetAnchor();
+ cur.selection(true);
+ cur.posForward();
+ cur.setSelection();
+ break;
}
- // It is possible to make it a lot faster still
- // just comment out the line below...
+ needsUpdate |= erase(cur);
+ cur.resetAnchor();
} else {
- cutSelection(cur, true, false);
+ cutSelection(cur, false);
singleParUpdate = false;
}
moveCursor(cur, false);
if (!cur.selection()) {
if (bv->getIntl().getTransManager().backspace()) {
bool par_boundary = cur.pos() == 0;
+ bool first_par = cur.pit() == 0;
// Par boundary, full-screen update
if (par_boundary)
singleParUpdate = false;
+ else if (cmd.getArg(0) != "force" && cur.confirmDeletion(true)) {
+ cur.resetAnchor();
+ cur.selection(true);
+ cur.posBackward();
+ cur.setSelection();
+ break;
+ }
needsUpdate |= backspace(cur);
cur.resetAnchor();
- if (par_boundary && cur.pos() > 0
+ if (par_boundary && !first_par && cur.pos() > 0
&& cur.paragraph().isEnvSeparator(cur.pos() - 1)) {
needsUpdate |= backspace(cur);
cur.resetAnchor();
}
- // It is possible to make it a lot faster still
- // just comment out the line below...
}
} else {
- cutSelection(cur, true, false);
+ cutSelection(cur, false);
singleParUpdate = false;
}
break;
cap::replaceSelection(cur);
pit_type pit = cur.pit();
Paragraph const & par = pars_[pit];
- pit_type prev = pit;
- if (pit > 0) {
- if (!pars_[pit - 1].layout().isEnvironment())
- prev = depthHook(pit, par.getDepth());
- else if (pars_[pit - 1].getDepth() >= par.getDepth())
- prev = pit - 1;
- }
+ bool lastpar = (pit == pit_type(pars_.size() - 1));
+ Paragraph const & nextpar = lastpar ? par : pars_[pit + 1];
+ pit_type prev = pit > 0 ? depthHook(pit, par.getDepth()) : pit;
if (prev < pit && cur.pos() == par.beginOfBody()
- && !par.isEnvSeparator(cur.pos())
+ && !par.size() && !par.isEnvSeparator(cur.pos())
&& !par.layout().isCommand()
&& pars_[prev].layout() != par.layout()
- && pars_[prev].layout().isEnvironment()) {
+ && pars_[prev].layout().isEnvironment()
+ && !nextpar.isEnvSeparator(nextpar.beginOfBody())) {
if (par.layout().isEnvironment()
&& pars_[prev].getDepth() == par.getDepth()) {
docstring const layout = par.layout().name();
DocumentClass const & tc = bv->buffer().params().documentClass();
lyx::dispatch(FuncRequest(LFUN_LAYOUT, tc.plainLayout().name()));
- lyx::dispatch(FuncRequest(LFUN_SEPARATOR_INSERT, "parbreak"));
+ lyx::dispatch(FuncRequest(LFUN_SEPARATOR_INSERT, "plain"));
lyx::dispatch(FuncRequest(LFUN_PARAGRAPH_BREAK, "inverse"));
lyx::dispatch(FuncRequest(LFUN_LAYOUT, layout));
} else {
- lyx::dispatch(FuncRequest(LFUN_SEPARATOR_INSERT, "parbreak"));
+ lyx::dispatch(FuncRequest(LFUN_SEPARATOR_INSERT, "plain"));
breakParagraph(cur);
}
Font const f(inherit_font, cur.current_font.language());
pars_[cur.pit() - 1].resetFonts(f);
} else {
- breakParagraph(cur, cmd.argument() == "inverse");
+ if (par.isEnvSeparator(cur.pos()) && cmd.getArg(1) != "ignoresep")
+ cur.posForward();
+ breakParagraph(cur, cmd.getArg(0) == "inverse");
}
cur.resetAnchor();
+ // If we have a list and autoinsert item insets,
+ // insert them now.
+ Layout::LaTeXArgMap args = par.layout().args();
+ for (auto const & thearg : args) {
+ Layout::latexarg arg = thearg.second;
+ if (arg.autoinsert && prefixIs(thearg.first, "item:")) {
+ FuncRequest cmd2(LFUN_ARGUMENT_INSERT, thearg.first);
+ lyx::dispatch(cmd2);
+ }
+ }
break;
}
}
*/
if (cur.selection())
- cutSelection(cur, true, false);
+ cutSelection(cur, false);
cur.insert(inset);
+ cur.forceBufferUpdate();
if (inset->editable() && inset->asInsetText())
inset->edit(cur, true);
else
break;
}
- case LFUN_SET_GRAPHICS_GROUP: {
+ case LFUN_GRAPHICS_SET_GROUP: {
InsetGraphics * ins = graphics::getCurrentGraphicsInset(cur);
if (!ins)
break;
}
ins->setParams(inspar);
+ break;
}
case LFUN_SPACE_INSERT:
string const name = to_utf8(cmd.argument());
if (name == "hyphenation")
specialChar(cur, InsetSpecialChar::HYPHENATION);
+ else if (name == "allowbreak")
+ specialChar(cur, InsetSpecialChar::ALLOWBREAK);
else if (name == "ligature-break")
specialChar(cur, InsetSpecialChar::LIGATURE_BREAK);
else if (name == "slash")
}
case LFUN_WORD_UPCASE:
- changeCase(cur, text_uppercase);
+ changeCase(cur, text_uppercase, cmd.getArg(0) == "partial");
break;
case LFUN_WORD_LOWCASE:
- changeCase(cur, text_lowercase);
+ changeCase(cur, text_lowercase, cmd.getArg(0) == "partial");
break;
case LFUN_WORD_CAPITALIZE:
- changeCase(cur, text_capitalization);
+ changeCase(cur, text_capitalization, cmd.getArg(0) == "partial");
break;
case LFUN_CHARS_TRANSPOSE:
bv->buffer().errors("Paste");
cur.clearSelection(); // bug 393
cur.finishUndo();
- bv->buffer().updatePreviews();
break;
}
case LFUN_CUT:
- cutSelection(cur, true, true);
+ cutSelection(cur, true);
cur.message(_("Cut"));
break;
cur.message(cur.paragraph().layout().name());
break;
- case LFUN_LAYOUT: {
- docstring layout = cmd.argument();
- LYXERR(Debug::INFO, "LFUN_LAYOUT: (arg) " << to_utf8(layout));
-
- Paragraph const & para = cur.paragraph();
- docstring const old_layout = para.layout().name();
- DocumentClass const & tclass = bv->buffer().params().documentClass();
-
- if (layout.empty())
- layout = tclass.defaultLayoutName();
-
- if (owner_->forcePlainLayout())
- // in this case only the empty layout is allowed
- layout = tclass.plainLayoutName();
- else if (para.usePlainLayout()) {
- // in this case, default layout maps to empty layout
- if (layout == tclass.defaultLayoutName())
- layout = tclass.plainLayoutName();
- } else {
- // otherwise, the empty layout maps to the default
- if (layout == tclass.plainLayoutName())
- layout = tclass.defaultLayoutName();
- }
-
- bool hasLayout = tclass.hasLayout(layout);
-
- // If the entry is obsolete, use the new one instead.
- if (hasLayout) {
- docstring const & obs = tclass[layout].obsoleted_by();
- if (!obs.empty())
- layout = obs;
- }
+ case LFUN_LAYOUT:
+ case LFUN_LAYOUT_TOGGLE: {
+ bool const ignoreautonests = cmd.getArg(1) == "ignoreautonests";
+ docstring req_layout = ignoreautonests ? from_utf8(cmd.getArg(0)) : cmd.argument();
+ LYXERR(Debug::INFO, "LFUN_LAYOUT: (arg) " << to_utf8(req_layout));
- if (!hasLayout) {
- cur.errorMessage(from_utf8(N_("Layout ")) + cmd.argument() +
+ docstring layout = resolveLayout(req_layout, cur);
+ if (layout.empty()) {
+ cur.errorMessage(from_utf8(N_("Layout ")) + req_layout +
from_utf8(N_(" not known")));
break;
}
- bool change_layout = (old_layout != layout);
+ docstring const old_layout = cur.paragraph().layout().name();
+ bool change_layout = !isAlreadyLayout(layout, cur);
- if (!change_layout && cur.selection() &&
- cur.selBegin().pit() != cur.selEnd().pit())
- {
- pit_type spit = cur.selBegin().pit();
- pit_type epit = cur.selEnd().pit() + 1;
- while (spit != epit) {
- if (pars_[spit].layout().name() != old_layout) {
- change_layout = true;
- break;
- }
- ++spit;
- }
+ if (cmd.action() == LFUN_LAYOUT_TOGGLE && !change_layout) {
+ change_layout = true;
+ layout = resolveLayout(docstring(), cur);
}
- if (change_layout)
+ if (change_layout) {
setLayout(cur, layout);
+ if (cur.pit() > 0 && !ignoreautonests) {
+ set<docstring> const & autonests =
+ pars_[cur.pit() - 1].layout().autonests();
+ set<docstring> const & autonested =
+ pars_[cur.pit()].layout().isAutonestedBy();
+ if (autonests.find(layout) != autonests.end()
+ || autonested.find(old_layout) != autonested.end())
+ lyx::dispatch(FuncRequest(LFUN_DEPTH_INCREMENT));
+ }
+ }
- Layout::LaTeXArgMap args = tclass[layout].args();
- Layout::LaTeXArgMap::const_iterator lait = args.begin();
- Layout::LaTeXArgMap::const_iterator const laend = args.end();
- for (; lait != laend; ++lait) {
- Layout::latexarg arg = (*lait).second;
+ DocumentClass const & tclass = bv->buffer().params().documentClass();
+ for (auto const & la_pair : tclass[layout].args()) {
+ Layout::latexarg const & arg = la_pair.second;
if (arg.autoinsert) {
- FuncRequest cmd(LFUN_ARGUMENT_INSERT, (*lait).first);
- lyx::dispatch(cmd);
+ FuncRequest const cmd2(LFUN_ARGUMENT_INSERT, la_pair.first);
+ lyx::dispatch(cmd2);
}
}
case LFUN_ENVIRONMENT_SPLIT: {
bool const outer = cmd.argument() == "outer";
+ bool const previous = cmd.argument() == "previous";
+ bool const before = cmd.argument() == "before";
+ bool const normal = cmd.argument().empty();
Paragraph const & para = cur.paragraph();
- docstring layout = para.layout().name();
+ docstring layout;
+ if (para.layout().isEnvironment())
+ layout = para.layout().name();
depth_type split_depth = cur.paragraph().params().depth();
- if (outer) {
- // check if we have an environment in our nesting hierarchy
+ depth_type nextpar_depth = 0;
+ if (outer || previous) {
+ // check if we have an environment in our scope
pit_type pit = cur.pit();
Paragraph cpar = pars_[pit];
while (true) {
- if (pit == 0 || cpar.params().depth() == 0)
+ if (pit == 0)
break;
--pit;
cpar = pars_[pit];
+ if (layout.empty() && previous
+ && cpar.layout().isEnvironment()
+ && cpar.params().depth() <= split_depth)
+ layout = cpar.layout().name();
if (cpar.params().depth() < split_depth
&& cpar.layout().isEnvironment()) {
- layout = cpar.layout().name();
+ if (!previous)
+ layout = cpar.layout().name();
split_depth = cpar.params().depth();
}
+ if (cpar.params().depth() == 0)
+ break;
}
}
- if (cur.pos() > 0)
+ if ((outer || normal) && cur.pit() < cur.lastpit()) {
+ // save nesting of following paragraph
+ Paragraph cpar = pars_[cur.pit() + 1];
+ nextpar_depth = cpar.params().depth();
+ }
+ if (before)
+ cur.top().setPitPos(cur.pit(), 0);
+ if (before || cur.pos() > 0)
lyx::dispatch(FuncRequest(LFUN_PARAGRAPH_BREAK));
+ else if (previous && cur.nextInset() && cur.nextInset()->lyxCode() == SEPARATOR_CODE)
+ lyx::dispatch(FuncRequest(LFUN_PARAGRAPH_BREAK, "inverse ignoresep"));
if (outer) {
while (cur.paragraph().params().depth() > split_depth)
lyx::dispatch(FuncRequest(LFUN_DEPTH_DECREMENT));
}
DocumentClass const & tc = bv->buffer().params().documentClass();
- lyx::dispatch(FuncRequest(LFUN_LAYOUT, tc.plainLayout().name()));
+ lyx::dispatch(FuncRequest(LFUN_LAYOUT, from_ascii("\"") + tc.plainLayout().name()
+ + from_ascii("\" ignoreautonests")));
+ // FIXME: Bibitem mess!
+ if (cur.prevInset() && cur.prevInset()->lyxCode() == BIBITEM_CODE)
+ lyx::dispatch(FuncRequest(LFUN_CHAR_DELETE_BACKWARD));
lyx::dispatch(FuncRequest(LFUN_SEPARATOR_INSERT, "plain"));
- lyx::dispatch(FuncRequest(LFUN_PARAGRAPH_BREAK, "inverse"));
+ if (before) {
+ cur.backwardPos();
+ lyx::dispatch(FuncRequest(LFUN_PARAGRAPH_BREAK, "inverse ignoresep"));
+ while (cur.paragraph().params().depth() < split_depth)
+ lyx::dispatch(FuncRequest(LFUN_DEPTH_INCREMENT));
+ }
+ else
+ lyx::dispatch(FuncRequest(LFUN_PARAGRAPH_BREAK, "inverse"));
lyx::dispatch(FuncRequest(LFUN_LAYOUT, layout));
+ if ((outer || normal) && nextpar_depth > 0) {
+ // restore nesting of following paragraph
+ DocIterator scur = cur;
+ depth_type const max_depth = cur.paragraph().params().depth() + 1;
+ cur.forwardPar();
+ while (cur.paragraph().params().depth() < min(nextpar_depth, max_depth))
+ lyx::dispatch(FuncRequest(LFUN_DEPTH_INCREMENT));
+ cur.setCursor(scur);
+ }
break;
}
bv->buffer().errors("Paste");
break;
- case LFUN_UNICODE_INSERT: {
- if (cmd.argument().empty())
- break;
- docstring hexstring = cmd.argument();
- if (isHex(hexstring)) {
- char_type c = hexToInt(hexstring);
- if (c >= 32 && c < 0x10ffff) {
- lyxerr << "Inserting c: " << c << endl;
- docstring s = docstring(1, c);
- lyx::dispatch(FuncRequest(LFUN_SELF_INSERT, s));
- }
- }
- break;
- }
-
case LFUN_QUOTE_INSERT: {
cap::replaceSelection(cur);
cur.recordUndo();
while (pos > 0 && par.isDeleted(pos - 1))
--pos;
- BufferParams const & bufparams = bv->buffer().params();
- bool const hebrew =
- par.getFontSettings(bufparams, pos).language()->lang() == "hebrew";
- bool const allow_inset_quote = !(par.isPassThru() || hebrew);
-
- string const arg = to_utf8(cmd.argument());
- if (allow_inset_quote) {
- char_type c = ' ';
- if (pos > 0 && (!cur.prevInset() || !cur.prevInset()->isSpace()))
+ bool const inner = (cmd.getArg(0) == "single" || cmd.getArg(0) == "inner");
+
+ // Guess quote side.
+ // A space triggers an opening quote. This is passed if the preceding
+ // char/inset is a space or at paragraph start.
+ char_type c = ' ';
+ if (pos > 0 && !par.isSpace(pos - 1)) {
+ if (cur.prevInset() && cur.prevInset()->lyxCode() == QUOTE_CODE) {
+ // If an opening double quotation mark precedes, and this
+ // is a single quote, make it opening as well
+ InsetQuotes & ins =
+ static_cast<InsetQuotes &>(*cur.prevInset());
+ string const type = ins.getType();
+ if (!suffixIs(type, "ld") || !inner)
+ c = par.getChar(pos - 1);
+ }
+ else if (!cur.prevInset()
+ || (cur.prevInset() && cur.prevInset()->isChar()))
+ // If a char precedes, pass that and let InsetQuote decide
c = par.getChar(pos - 1);
- InsetQuotes::QuoteTimes const quote_type = (arg == "single")
- ? InsetQuotes::SingleQuotes : InsetQuotes::DoubleQuotes;
- cur.insert(new InsetQuotes(cur.buffer(), c, quote_type));
- cur.posForward();
- } else {
- // The cursor might have been invalidated by the replaceSelection.
- cur.buffer()->changed(true);
- string const quote_string = (arg == "single") ? "'" : "\"";
- lyx::dispatch(FuncRequest(LFUN_SELF_INSERT, quote_string));
+ else {
+ while (pos > 0) {
+ if (par.getInset(pos - 1)
+ && !par.getInset(pos - 1)->isPartOfTextSequence()) {
+ // skip "invisible" insets
+ --pos;
+ continue;
+ }
+ c = par.getChar(pos - 1);
+ break;
+ }
+ }
}
+ InsetQuotesParams::QuoteLevel const quote_level = inner
+ ? InsetQuotesParams::SecondaryQuotes : InsetQuotesParams::PrimaryQuotes;
+ cur.insert(new InsetQuotes(cur.buffer(), c, quote_level, cmd.getArg(1), cmd.getArg(2)));
+ cur.buffer()->updateBuffer();
+ cur.posForward();
break;
}
bvcur.setMark(false);
switch (cmd.button()) {
case mouse_button::button1:
- // Set the cursor
- if (!bv->mouseSetCursor(cur, cmd.argument() == "region-select"))
+ if (!bvcur.selection())
+ // Set the cursor
+ bvcur.resetAnchor();
+ if (!bv->mouseSetCursor(cur, cmd.modifier() == ShiftModifier))
cur.screenUpdateFlags(Update::SinglePar | Update::FitCursor);
if (bvcur.wordSelection())
selectWord(bvcur, WHOLE_WORD);
return;
}
if (!bv->mouseSetCursor(cur, false))
- cur.screenUpdateFlags(Update::SinglePar | Update::FitCursor);
+ cur.screenUpdateFlags(Update::FitCursor);
break;
}
tm->setCursorFromCoordinates(cur, cmd.x(), y);
cur.setTargetX(cmd.x());
+ // Don't allow selecting a separator inset
+ if (cur.pos() && cur.paragraph().isEnvSeparator(cur.pos() - 1))
+ cur.posBackward();
if (cmd.y() >= wh)
lyx::dispatch(FuncRequest(LFUN_DOWN_SELECT));
else if (cmd.y() < 0)
// We continue with our existing selection or start a new one, so don't
// reset the anchor.
bvcur.setCursor(cur);
- bvcur.setSelection(true);
+ bvcur.selection(true);
+ bvcur.setCurrentFont();
if (cur.top() == old) {
// We didn't move one iota, so no need to update the screen.
cur.screenUpdateFlags(Update::SinglePar | Update::FitCursor);
// true (on).
if (lyxrc.auto_region_delete && cur.selection())
- cutSelection(cur, false, false);
-
+ cutSelection(cur, false);
cur.clearSelection();
- docstring::const_iterator cit = cmd.argument().begin();
- docstring::const_iterator const end = cmd.argument().end();
- for (; cit != end; ++cit)
- bv->translateAndInsert(*cit, this, cur);
+ for (char_type c : cmd.argument())
+ bv->translateAndInsert(c, this, cur);
cur.resetAnchor();
moveCursor(cur, false);
}
case LFUN_HREF_INSERT: {
- // FIXME If we're actually given an argument, shouldn't
- // we use it, whether or not we have a selection?
docstring content = cmd.argument();
- if (cur.selection()) {
+ if (content.empty() && cur.selection())
content = cur.selectionAsString(false);
- cutSelection(cur, true, false);
- }
InsetCommandParams p(HYPERLINK_CODE);
if (!content.empty()){
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);
+ cutSelection(cur, false);
FuncRequest cmd0(cmd, ds);
inset = createInset(cur.buffer(), cmd0);
} else {
break;
cur.recordUndo();
insertInset(cur, inset);
+ cur.forceBufferUpdate();
cur.posForward();
break;
}
if (arg.autoinsert) {
// The cursor might have been invalidated by the replaceSelection.
cur.buffer()->changed(true);
- FuncRequest cmd(LFUN_ARGUMENT_INSERT, (*lait).first);
- lyx::dispatch(cmd);
+ FuncRequest cmd2(LFUN_ARGUMENT_INSERT, (*lait).first);
+ lyx::dispatch(cmd2);
autoargs = true;
}
}
case LFUN_NOMENCL_INSERT: {
InsetCommandParams p(NOMENCL_CODE);
- if (cmd.argument().empty())
- p["symbol"] = bv->cursor().innerText()->getStringToIndex(bv->cursor());
- else
+ if (cmd.argument().empty()) {
+ p["symbol"] =
+ bv->cursor().innerText()->getStringForDialog(bv->cursor());
+ cur.clearSelection();
+ } else
p["symbol"] = cmd.argument();
string const data = InsetCommand::params2string(p);
bv->showDialog("nomenclature", data);
changeDepth(cur, INC_DEPTH);
break;
- case LFUN_MATH_DISPLAY:
- mathDispatch(cur, cmd, true);
- break;
-
case LFUN_REGEXP_MODE:
regexpDispatch(cur, cmd);
break;
- case LFUN_MATH_MODE:
- if (cmd.argument() == "on")
+ case LFUN_MATH_MODE: {
+ if (cmd.argument() == "on" || cmd.argument() == "") {
// don't pass "on" as argument
// (it would appear literally in the first cell)
- mathDispatch(cur, FuncRequest(LFUN_MATH_MODE), false);
- else
- mathDispatch(cur, cmd, false);
+ docstring sel = cur.selectionAsString(false);
+ InsetMathMacroTemplate * macro = new InsetMathMacroTemplate(cur.buffer());
+ // create a macro template if we see "\\newcommand" somewhere, and
+ // an ordinary formula otherwise
+ if (!sel.empty()
+ && (sel.find(from_ascii("\\newcommand")) != string::npos
+ || sel.find(from_ascii("\\newlyxcommand")) != string::npos
+ || sel.find(from_ascii("\\def")) != string::npos)
+ && macro->fromString(sel)) {
+ cur.recordUndo();
+ replaceSelection(cur);
+ cur.insert(macro);
+ } else {
+ // no meaningful macro template was found
+ delete macro;
+ mathDispatch(cur,FuncRequest(LFUN_MATH_MODE));
+ }
+ } else
+ // The argument is meaningful
+ // We replace cmd with LFUN_MATH_INSERT because LFUN_MATH_MODE
+ // has a different meaning in math mode
+ mathDispatch(cur, FuncRequest(LFUN_MATH_INSERT,cmd.argument()));
break;
+ }
case LFUN_MATH_MACRO:
if (cmd.argument().empty())
MacroType type = MacroTypeNewcommand;
if (s2 == "def")
type = MacroTypeDef;
- MathMacroTemplate * inset = new MathMacroTemplate(cur.buffer(),
+ InsetMathMacroTemplate * inset = new InsetMathMacroTemplate(cur.buffer(),
from_utf8(token(s, ' ', 0)), nargs, false, type);
inset->setBuffer(bv->buffer());
insertInset(cur, inset);
cur.push(*inset);
cur.top().pos() = cur.top().lastpos();
cur.resetAnchor();
- cur.setSelection(true);
+ cur.selection(true);
cur.top().pos() = 0;
}
break;
- // passthrough hat and underscore outside mathed:
+ case LFUN_MATH_DISPLAY:
case LFUN_MATH_SUBSCRIPT:
- mathDispatch(cur, FuncRequest(LFUN_SELF_INSERT, "_"), false);
- break;
case LFUN_MATH_SUPERSCRIPT:
- mathDispatch(cur, FuncRequest(LFUN_SELF_INSERT, "^"), false);
- break;
-
case LFUN_MATH_INSERT:
case LFUN_MATH_AMS_MATRIX:
case LFUN_MATH_MATRIX:
case LFUN_MATH_DELIM:
- case LFUN_MATH_BIGDELIM: {
- cur.recordUndo();
- cap::replaceSelection(cur);
- cur.insert(new InsetMathHull(cur.buffer(), hullSimple));
- checkAndActivateInset(cur, true);
- LASSERT(cur.inMathed(), break);
- cur.dispatch(cmd);
+ case LFUN_MATH_BIGDELIM:
+ mathDispatch(cur, cmd);
break;
- }
case LFUN_FONT_EMPH: {
Font font(ignore_font, ignore_language);
break;
}
+ case LFUN_FONT_CROSSOUT: {
+ Font font(ignore_font, ignore_language);
+ font.fontInfo().setXout(FONT_TOGGLE);
+ toggleAndShow(cur, this, font);
+ break;
+ }
+
case LFUN_FONT_UNDERUNDERLINE: {
Font font(ignore_font, ignore_language);
font.fontInfo().setUuline(FONT_TOGGLE);
case LFUN_FINISHED_BACKWARD:
LYXERR(Debug::DEBUG, "handle LFUN_FINISHED_BACKWARD:\n" << cur);
+ cur.setCurrentFont();
break;
case LFUN_FINISHED_FORWARD:
case LFUN_ACCENT_GRAVE:
case LFUN_ACCENT_ACUTE:
case LFUN_ACCENT_TILDE:
+ case LFUN_ACCENT_PERISPOMENI:
case LFUN_ACCENT_CEDILLA:
case LFUN_ACCENT_MACRON:
case LFUN_ACCENT_DOT:
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) {
}
case LFUN_THESAURUS_ENTRY: {
+ Language const * language = cur.getFont().language();
docstring arg = cmd.argument();
if (arg.empty()) {
arg = cur.selectionAsString(false);
// Get word or selection
selectWordWhenUnderCursor(cur, WHOLE_WORD);
arg = cur.selectionAsString(false);
- arg += " lang=" + from_ascii(cur.getFont().language()->lang());
+ arg += " lang=" + from_ascii(language->lang());
+ }
+ } else {
+ string lang = cmd.getArg(1);
+ // This duplicates the code in GuiThesaurus::initialiseParams
+ if (prefixIs(lang, "lang=")) {
+ language = languages.getLanguage(lang.substr(5));
+ if (!language)
+ language = cur.getFont().language();
}
}
- if (lyxrc.thesaurusdir_path.empty()) {
+ string lang = language->code();
+ if (lyxrc.thesaurusdir_path.empty() && !thesaurus.thesaurusInstalled(from_ascii(lang))) {
+ LYXERR(Debug::ACTION, "Command " << cmd << ". Thesaurus not found for language " << lang);
frontend::Alert::warning(_("Path to thesaurus directory not set!"),
_("The path to the thesaurus directory has not been specified.\n"
"The thesaurus is not functional.\n"
}
case LFUN_SPELLING_ADD: {
+ Language const * language = getLanguage(cur, cmd.getArg(1));
docstring word = from_utf8(cmd.getArg(0));
- Language * lang;
if (word.empty()) {
word = cur.selectionAsString(false);
// FIXME
selectWordWhenUnderCursor(cur, WHOLE_WORD);
word = cur.selectionAsString(false);
}
- lang = const_cast<Language *>(cur.getFont().language());
- } else if (cmd.getArg(1).empty()) {
- // optional language argument is missing
- // use the language at cursor position
- lang = const_cast<Language *>(cur.getFont().language());
- } else {
- lang = const_cast<Language *>(languages.getLanguage(cmd.getArg(1)));
}
- WordLangTuple wl(word, lang);
+ WordLangTuple wl(word, language);
theSpellChecker()->insert(wl);
break;
}
case LFUN_SPELLING_IGNORE: {
+ Language const * language = getLanguage(cur, cmd.getArg(1));
docstring word = from_utf8(cmd.getArg(0));
- Language * lang;
if (word.empty()) {
word = cur.selectionAsString(false);
// FIXME
selectWordWhenUnderCursor(cur, WHOLE_WORD);
word = cur.selectionAsString(false);
}
- lang = const_cast<Language *>(cur.getFont().language());
- } else if (cmd.getArg(1).empty()) {
- lang = const_cast<Language *>(cur.getFont().language());
- } else {
- lang = const_cast<Language *>(languages.getLanguage(cmd.getArg(1)));
}
- WordLangTuple wl(word, lang);
+ WordLangTuple wl(word, language);
theSpellChecker()->accept(wl);
break;
}
case LFUN_SPELLING_REMOVE: {
+ Language const * language = getLanguage(cur, cmd.getArg(1));
docstring word = from_utf8(cmd.getArg(0));
- Language * lang;
if (word.empty()) {
word = cur.selectionAsString(false);
// FIXME
selectWordWhenUnderCursor(cur, WHOLE_WORD);
word = cur.selectionAsString(false);
}
- lang = const_cast<Language *>(cur.getFont().language());
- } else if (cmd.getArg(1).empty()) {
- lang = const_cast<Language *>(cur.getFont().language());
- } else {
- lang = const_cast<Language *>(languages.getLanguage(cmd.getArg(1)));
}
- WordLangTuple wl(word, lang);
+ WordLangTuple wl(word, language);
theSpellChecker()->remove(wl);
break;
}
case LFUN_ESCAPE:
if (cur.selection()) {
- cur.setSelection(false);
+ cur.selection(false);
} else {
cur.undispatched();
// This used to be LFUN_FINISHED_RIGHT, I think FORWARD is more
break;
case LFUN_OUTLINE_UP:
- outline(OutlineUp, cur);
+ outline(OutlineUp, cur, this);
setCursor(cur, cur.pit(), 0);
cur.forceBufferUpdate();
needsUpdate = true;
break;
case LFUN_OUTLINE_DOWN:
- outline(OutlineDown, cur);
+ outline(OutlineDown, cur, this);
setCursor(cur, cur.pit(), 0);
cur.forceBufferUpdate();
needsUpdate = true;
break;
case LFUN_OUTLINE_IN:
- outline(OutlineIn, cur);
+ outline(OutlineIn, cur, this);
cur.forceBufferUpdate();
needsUpdate = true;
break;
case LFUN_OUTLINE_OUT:
- outline(OutlineOut, cur);
+ outline(OutlineOut, cur, this);
cur.forceBufferUpdate();
needsUpdate = true;
break;
case LFUN_CAPTION_INSERT: {
code = CAPTION_CODE;
string arg = cmd.getArg(0);
- bool varia = arg != "LongTableNoNumber"
+ bool varia = arg != "Unnumbered"
&& cur.inset().allowsCaptionVariation(arg);
// not allowed in description items,
// and in specific insets
}
case LFUN_NOTE_INSERT:
code = NOTE_CODE;
- // in commands (sections etc.) and description items,
- // only Notes are allowed
- enable = (cmd.argument().empty() || cmd.getArg(0) == "Note" ||
- (!cur.paragraph().layout().isCommand()
- && !inDescriptionItem(cur)));
break;
case LFUN_FLEX_INSERT: {
code = FLEX_CODE;
for (; pit <= lastpit; ++pit) {
if (pars_[pit].layout() != lay)
break;
- InsetList::const_iterator it = pars_[pit].insetList().begin();
- InsetList::const_iterator end = pars_[pit].insetList().end();
- for (; it != end; ++it) {
- if (it->inset->lyxCode() == ARG_CODE) {
- InsetArgument const * ins =
- static_cast<InsetArgument const *>(it->inset);
+ for (auto const & table : pars_[pit].insetList())
+ if (InsetArgument const * ins = table.inset->asInsetArgument())
if (ins->name() == arg) {
// we have this already
enable = false;
break;
}
- }
- }
}
} else
enable = false;
case LFUN_QUOTE_INSERT:
// always allow this, since we will inset a raw quote
// if an inset is not allowed.
+ allow_in_passthru = true;
break;
case LFUN_SPECIALCHAR_INSERT:
code = SPECIALCHAR_CODE;
case LFUN_CHANGE_ACCEPT:
case LFUN_CHANGE_REJECT:
- // In principle, these LFUNs should only be enabled if there
- // is a change at the current position/in the current selection.
- // However, without proper optimizations, this will inevitably
- // result in unacceptable performance - just imagine a user who
- // wants to select the complete content of a long document.
if (!cur.selection())
enable = cur.paragraph().isChanged(cur.pos());
- else
- // TODO: context-sensitive enabling of LFUN_CHANGE_ACCEPT/REJECT
- // for selections.
- enable = true;
+ else {
+ // will enable if there is a change in the selection
+ enable = false;
+
+ // cheap improvement for efficiency: using cached
+ // buffer variable, if there is no change in the
+ // document, no need to check further.
+ if (!cur.buffer()->areChangesPresent())
+ break;
+
+ for (DocIterator it = cur.selectionBegin(); it < cur.selectionEnd(); it.forwardPar()) {
+ pos_type const beg = it.pos();
+ pos_type end;
+ if (it.paragraph().id() == cur.selectionEnd().paragraph().id())
+ end = cur.selectionEnd().pos();
+ else
+ end = it.paragraph().size();
+ if (beg != end && it.paragraph().isChanged(beg, end)) {
+ enable = true;
+ break;
+ }
+ }
+ }
break;
case LFUN_OUTLINE_UP:
enable = cur.paragraph().isPassThru();
break;
- case LFUN_SET_GRAPHICS_GROUP: {
+ case LFUN_GRAPHICS_SET_GROUP: {
InsetGraphics * ins = graphics::getCurrentGraphicsInset(cur);
if (!ins)
enable = false;
}
break;
- case LFUN_LAYOUT: {
- enable = !cur.inset().forcePlainLayout();
+ case LFUN_LAYOUT:
+ case LFUN_LAYOUT_TOGGLE: {
+ bool const ignoreautonests = cmd.getArg(1) == "ignoreautonests";
+ docstring const req_layout = ignoreautonests ? from_utf8(cmd.getArg(0)) : cmd.argument();
+ docstring const layout = resolveLayout(req_layout, cur);
- docstring layout = cmd.argument();
- if (layout.empty()) {
- DocumentClass const & tclass = cur.buffer()->params().documentClass();
- layout = tclass.defaultLayoutName();
- }
- flag.setOnOff(layout == cur.paragraph().layout().name());
+ enable = !owner_->forcePlainLayout() && !layout.empty();
+ flag.setOnOff(isAlreadyLayout(layout, cur));
break;
}
enable = res;
break;
}
+ else if (cmd.argument() == "previous") {
+ // look if we have an environment in the previous par
+ pit_type pit = cur.pit();
+ Paragraph cpar = pars_[pit];
+ if (pit > 0) {
+ --pit;
+ cpar = pars_[pit];
+ enable = cpar.layout().isEnvironment();
+ break;
+ }
+ enable = false;
+ break;
+ }
else if (cur.paragraph().layout().isEnvironment()) {
- enable = true;
+ enable = cmd.argument() == "before"
+ || cur.pos() > 0 || !isFirstInSequence(cur.pit());
break;
}
enable = false;
case LFUN_PARAGRAPH_PARAMS:
case LFUN_PARAGRAPH_PARAMS_APPLY:
case LFUN_PARAGRAPH_UPDATE:
- enable = cur.inset().allowParagraphCustomization();
+ enable = owner_->allowParagraphCustomization();
break;
// FIXME: why are accent lfuns forbidden with pass_thru layouts?
+ // Because they insert COMBINING DIACRITICAL Unicode characters,
+ // that cannot be handled by LaTeX but must be converted according
+ // to the definition in lib/unicodesymbols?
case LFUN_ACCENT_ACUTE:
case LFUN_ACCENT_BREVE:
case LFUN_ACCENT_CARON:
case LFUN_ACCENT_OGONEK:
case LFUN_ACCENT_TIE:
case LFUN_ACCENT_TILDE:
+ case LFUN_ACCENT_PERISPOMENI:
case LFUN_ACCENT_UMLAUT:
case LFUN_ACCENT_UNDERBAR:
case LFUN_ACCENT_UNDERDOT:
case LFUN_FONT_STATE:
case LFUN_FONT_UNDERLINE:
case LFUN_FONT_STRIKEOUT:
+ case LFUN_FONT_CROSSOUT:
case LFUN_FONT_UNDERUNDERLINE:
case LFUN_FONT_UNDERWAVE:
case LFUN_TEXTSTYLE_APPLY:
projects / lyx.git / blobdiff