namespace lyx {
using cap::copySelection;
+using cap::copySelectionToTemp;
using cap::cutSelection;
using cap::cutSelectionToTemp;
using cap::pasteFromStack;
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();
bool gotsel = false;
if (cur.selection()) {
- cutSelectionToTemp(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();
- gotsel = true;
}
text->insertInset(cur, inset);
};
-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();
// 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;
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);
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)
needsUpdate |= erase(cur);
cur.resetAnchor();
} else {
- cutSelection(cur, true, false);
+ cutSelection(cur, false);
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);
singleParUpdate = false;
}
break;
pit_type prev = pit > 0 ? depthHook(pit, par.getDepth()) : pit;
if (prev < pit && cur.pos() == par.beginOfBody()
&& !par.size() && !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())
}
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()))
if ((outer || normal) && nextpar_depth > 0) {
// restore nesting of following paragraph
DocIterator scur = cur;
- depth_type const max_depth = cur.paragraph().getMaxDepthAfter();
+ depth_type const max_depth = cur.paragraph().params().depth() + 1;
cur.forwardPar();
- while (cur.paragraph().params().depth() <= min(nextpar_depth, max_depth))
+ 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;
+ }
cur.setCursor(scur);
}
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();
// 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);
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 {
// 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;
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_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;
break;
case LFUN_CUT:
- case LFUN_COPY:
enable = cur.selection();
break;
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.forwardPar()) {
+ pos_type const beg = it.pos();
+ pos_type end;
+ bool const in_last_par = (it.pit() == cur.selectionEnd().pit() &&
+ it.idx() == cur.selectionEnd().idx());
+ if (in_last_par)
+ end = cur.selectionEnd().pos();
+ else
+ // 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 (in_last_par)
+ break;
+ }
+ }
break;
case LFUN_OUTLINE_UP:
projects / lyx.git / blobdiff