#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;
}
bool gotsel = false;
+ bool move_layout = false;
if (cur.selection()) {
if (cmd.action() == LFUN_INDEX_INSERT)
copySelectionToTemp(cur);
* FIXME: this does not work as expected when change tracking is on
* However, we do not really know what to do in this case.
*/
- if (cur.paragraph().empty() && !inset->forcePlainLayout())
+ if (cur.paragraph().empty() && !inset->forcePlainLayout()) {
cur.paragraph().setPlainOrDefaultLayout(bparams.documentClass());
+ move_layout = true;
+ }
}
cur.clearSelection();
gotsel = true;
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;
};
-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;
}
}
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();
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();
case LFUN_NEWLINE_INSERT: {
InsetNewlineParams inp;
- docstring arg = cmd.argument();
+ docstring const & arg = cmd.argument();
if (arg == "linebreak")
inp.kind = InsetNewlineParams::LINEBREAK;
else
cur.resetAnchor();
} else {
cutSelection(cur, false);
+ cur.setCurrentFont();
singleParUpdate = false;
}
moveCursor(cur, false);
// 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()
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)
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()
if (inautoarg) {
cur.leaveInset(cur.inset());
cur.posForward();
- inautoarg = false;
}
FuncRequest const cmd2(LFUN_ARGUMENT_INSERT, la_pair.first);
lyx::dispatch(cmd2);
}
}
}
- 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();
// "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())
bool const sel = cur.selection();
doInsertInset(cur, this, cmd, true, true);
// Insert auto-insert arguments
- bool autoargs, inautoarg = false;
+ bool autoargs = false, inautoarg = false;
Layout::LaTeXArgMap args = cur.inset().getLayout().args();
- Layout::LaTeXArgMap::const_iterator lait = args.begin();
- Layout::LaTeXArgMap::const_iterator const laend = args.end();
- for (; lait != laend; ++lait) {
- Layout::latexarg arg = (*lait).second;
+ 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 (inautoarg) {
cur.leaveInset(cur.inset());
cur.posForward();
- inautoarg = false;
if (arg.insertonnewline && cur.pos() > 0) {
FuncRequest cmd2(LFUN_PARAGRAPH_BREAK);
lyx::dispatch(cmd2);
}
}
- FuncRequest cmd2(LFUN_ARGUMENT_INSERT, (*lait).first);
+ FuncRequest cmd2(LFUN_ARGUMENT_INSERT, argt.first);
lyx::dispatch(cmd2);
autoargs = true;
inautoarg = true;
}
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);
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:
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_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;
enable = true;
break;
}
+ if (beg != end && it.paragraph().hasChangedInsets(beg, end)) {
+ enable = true;
+ break;
+ }
if (in_last_par)
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:
case LFUN_SPELLING_ADD:
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;
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;
}
// 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();
{
vector<docstring> ffList;
- FontStack::const_iterator cit = freeFonts.begin();
- FontStack::const_iterator end = freeFonts.end();
- for (; cit != end; ++cit)
- // we do not use cit-> here because gcc 2.9x does not
- // like it (JMarc)
- ffList.push_back((*cit).first);
+ for (auto const & f : freeFonts)
+ ffList.push_back(f.first);
return ffList;
}
projects / lyx.git / blobdiff