#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 "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;
};
-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));
case LFUN_NEWLINE_INSERT: {
InsetNewlineParams inp;
- docstring arg = cmd.argument();
+ docstring const & arg = cmd.argument();
if (arg == "linebreak")
inp.kind = InsetNewlineParams::LINEBREAK;
else
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)
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()))
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)) {
- depth_type const olddepth = cur.paragraph().params().depth();
- lyx::dispatch(FuncRequest(LFUN_DEPTH_INCREMENT));
- if (olddepth == cur.paragraph().params().depth())
- // leave loop if no incrementation happens
- break;
+ depth_type max_depth = cur.paragraph().params().depth() + 1;
+ for (auto nextpar_depth : nextpars_depth) {
+ cur.forwardPar();
+ while (cur.paragraph().params().depth() < min(nextpar_depth, max_depth)) {
+ depth_type const olddepth = cur.paragraph().params().depth();
+ lyx::dispatch(FuncRequest(LFUN_DEPTH_INCREMENT));
+ if (olddepth == cur.paragraph().params().depth())
+ // leave loop if no incrementation happens
+ break;
+ }
+ max_depth = cur.paragraph().params().depth() + 1;
}
cur.setCursor(scur);
}
}
}
}
- 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();
// 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())
+ if (lyxrc.auto_region_delete && cur.selection()) {
cutSelection(cur, false);
+ cur.setCurrentFont();
+ }
cur.clearSelection();
for (char_type c : cmd.argument())
// inside it.
doInsertInset(cur, this, cmd, true, true);
cur.posForward();
- if (act == LFUN_SCRIPT_INSERT) {
- /* Script insets change the font style in metrics(), and
- * this is used to compute the height of the caret
- * (because the font is stored in TextMetrics::font_).
- * When we insert, we have to make sure that metrics are
- * computed so that the caret height is wrong. Arguably,
- * this is hackish.*/
- bv->processUpdateFlags(Update::SinglePar);
- }
+ /* The font of the inset is computed in metrics(), and this is
+ * used to compute the height of the caret (because the font
+ * is stored in TextMetrics::font_). When we insert, we have
+ * to make sure that metrics are computed so that the caret
+ * height is correct. Arguably, this is hackish.*/
+ bv->processUpdateFlags(Update::SinglePar);
cur.setCurrentFont();
// Some insets are numbered, others are shown in the outline pane so
// let's update the labels and the toc backend.
// 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();
break;
int const r = convert<int>(rows);
int const c = convert<int>(cols);
-
+
string suffix;
if (r == 1)
suffix = "_1x1";
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
bool Text::getStatus(Cursor & cur, FuncRequest const & cmd,
- FuncStatus & flag) const
+ FuncStatus & status) const
{
LBUFERR(this == cur.text());
bool enable = true;
bool allow_in_passthru = false;
InsetCode code = NO_CODE;
-
+
switch (cmd.action()) {
case LFUN_DEPTH_DECREMENT:
// 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:
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::STANDARD)
+ if (il.lyxtype() != InsetLyXType::CHARSTYLE &&
+ il.lyxtype() != InsetLyXType::CUSTOM &&
+ il.lyxtype ()!= InsetLyXType::STANDARD)
enable = false;
break;
}
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;
if (!ins)
enable = false;
else
- flag.setOnOff(to_utf8(cmd.argument()) == ins->getParams().groupId);
+ status.setOnOff(to_utf8(cmd.argument()) == ins->getParams().groupId);
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:
docstring const layout = resolveLayout(req_layout, cur);
enable = !owner_->forcePlainLayout() && !layout.empty();
- flag.setOnOff(isAlreadyLayout(layout, cur));
+ status.setOnOff(isAlreadyLayout(layout, cur));
break;
}
|| (cur.paragraph().layout().pass_thru && !allow_in_passthru)))
enable = false;
- flag.setEnabled(enable);
+ status.setEnabled(enable);
return true;
}