namespace {
typedef pair<pit_type, int> PitPosPair;
+typedef pair<DocumentClassConstPtr, AuthorList > DocInfoPair;
-typedef limited_stack<pair<ParagraphList, DocumentClassConstPtr> > CutStack;
+typedef limited_stack<pair<ParagraphList, DocInfoPair > > CutStack;
CutStack theCuts(10);
// persistent selection, cleared until the next selection
bool needupdate;
};
+
+/// return true if the whole ParagraphList is deleted
+static bool isFullyDeleted(ParagraphList const & pars)
+{
+ pit_type const pars_size = static_cast<pit_type>(pars.size());
+
+ // check all paragraphs
+ for (pit_type pit = 0; pit < pars_size; ++pit) {
+ if (!pars[pit].empty()) // prevent assertion failure
+ if (!pars[pit].isDeleted(0, pars[pit].size()))
+ return false;
+ }
+ return true;
+}
+
PasteReturnValue
pasteSelectionHelper(DocIterator const & cur, ParagraphList const & parlist,
DocumentClassConstPtr oldDocClass, cap::BranchAction branchAction,
if (!target_inset->insetAllowed(inset->lyxCode()))
tmpbuf->eraseChar(i--, false);
}
-
- if (lyxrc.ct_markup_copied) {
- // Only change to inserted if ct is active,
- // otherwise leave markup as is
- if (buffer.params().track_changes)
- tmpbuf->setChange(Change(Change::INSERTED));
- } else
- // Resolve all markup to inserted or unchanged
- tmpbuf->setChange(Change(buffer.params().track_changes ?
- Change::INSERTED : Change::UNCHANGED));
}
- bool const empty = pars[pit].empty();
- if (!empty) {
- // Make the buf exactly the same layout as the cursor
- // paragraph.
+ bool const target_empty = pars[pit].empty();
+ // Use the paste content's layout, if...
+ bool const paste_layout =
+ // if target paragraph is empty
+ (target_empty
+ // ... and its layout is default
+ && (pars[pit].layout() == defaultLayout
+ // ... or plain
+ || pars[pit].layout() == plainLayout
+ // ... or the paste content spans several paragraphs
+ || insertion.size() > 1))
+ // or if pasting is done at the beginning of paragraph
+ || (pos == 0
+ // and the paste content spans several paragraphs
+ && insertion.size() > 1);
+ if (!paste_layout)
+ // Give the first paragraph to insert the same layout as the
+ // target paragraph.
insertion.begin()->makeSameLayout(pars[pit]);
- }
// Prepare the paragraphs and insets for insertion.
insertion.swap(in.paragraphs());
}
insertion.swap(in.paragraphs());
+ // We need to do this here, after the inset handling above,
+ // as acceptChanges() and rejectChanges() might access inset buffers.
+ tmpbuf = insertion.begin();
+ for (; tmpbuf != insertion.end(); ++tmpbuf) {
+ if (lyxrc.ct_markup_copied) {
+ // Only remove deleted text and change
+ // the rest to inserted if ct is active,
+ // otherwise leave markup as is
+ if (buffer.params().track_changes) {
+ if (tmpbuf->size() > 0) {
+ if (!isFullyDeleted(insertion))
+ tmpbuf->acceptChanges(0, tmpbuf->size());
+ else
+ tmpbuf->rejectChanges(0, tmpbuf->size());
+ }
+ tmpbuf->setChange(Change(Change::INSERTED));
+ }
+ } else
+ // Resolve all markup to inserted or unchanged
+ // Deleted text has already been removed on copy
+ // (copySelectionHelper)
+ tmpbuf->setChange(Change(buffer.params().track_changes ?
+ Change::INSERTED : Change::UNCHANGED));
+ }
+
// Split the paragraph for inserting the buf if necessary.
- if (!empty)
+ if (!target_empty)
breakParagraphConservative(buffer.params(), pars, pit, pos);
+ // If multiple paragraphs are inserted before the target paragraph,
+ // the cursor is now in a new paragraph before it,
+ // so use layout from paste content in that case.
+ if (pos == 0 && insertion.size() > 1)
+ pars[pit].makeSameLayout(* insertion.begin());
+
// Paste it!
- if (empty) {
+ if (target_empty) {
pars.insert(pars.iterator_at(pit),
insertion.begin(), insertion.end());
// Join (conditionally) last pasted paragraph with next one, i.e.,
// the tail of the spliced document paragraph
- if (!empty && last_paste + 1 != pit_type(pars.size())) {
+ if (!target_empty && last_paste + 1 != pit_type(pars.size())) {
if (pars[last_paste + 1].hasSameLayout(pars[last_paste])) {
mergeParagraph(buffer.params(), pars, last_paste);
} else if (pars[last_paste + 1].empty()) {
pars[pit].eraseChars(left, right, params.track_changes);
// Separate handling of paragraph break:
- if (merge && pit != endpit &&
- (pit + 1 != endpit
- || pars[pit].hasSameLayout(pars[endpit])
- || pars[endpit].size() == endpos)) {
+ if (merge && pit != endpit) {
if (pit + 1 == endpit)
endpos += pars[pit].size();
mergeParagraph(params, pars, pit);
void putClipboard(ParagraphList const & paragraphs,
- DocumentClassConstPtr docclass, docstring const & plaintext,
+ DocInfoPair docinfo, docstring const & plaintext,
BufferParams const & bp)
{
- Buffer * buffer = copyToTempBuffer(paragraphs, docclass);
+ Buffer * buffer = copyToTempBuffer(paragraphs, docinfo.first);
if (!buffer) // already asserted in copyToTempBuffer()
return;
// applications, the number that can parse it should go up in the future.
buffer->params().html_math_output = BufferParams::MathML;
- if (lyxrc.ct_markup_copied) {
- // Copy authors to the params. We need those pointers.
- for (Author const & a : bp.authors())
- buffer->params().authors().record(a);
- }
+ // Copy authors to the params. We need those pointers.
+ for (Author const & a : bp.authors())
+ buffer->params().authors().record(a);
// Make sure MarkAsExporting is deleted before buffer is
{
}
-/// return true if the whole ParagraphList is deleted
-static bool isFullyDeleted(ParagraphList const & pars)
-{
- pit_type const pars_size = static_cast<pit_type>(pars.size());
-
- // check all paragraphs
- for (pit_type pit = 0; pit < pars_size; ++pit) {
- if (!pars[pit].empty()) // prevent assertion failure
- if (!pars[pit].isDeleted(0, pars[pit].size()))
- return false;
- }
- return true;
-}
-
-
void copySelectionHelper(Buffer const & buf, Text const & text,
pit_type startpit, pit_type endpit,
int start, int end, DocumentClassConstPtr dc, CutStack & cutstack)
par.setInsetOwner(nullptr);
}
- cutstack.push(make_pair(copy_pars, dc));
+ cutstack.push(make_pair(copy_pars, make_pair(dc, buf.params().authors())));
}
} // namespace
}
+void switchBetweenClasses(DocumentClassConstPtr oldone,
+ DocumentClassConstPtr newone, InsetText & in) {
+ ErrorList el = {};
+ switchBetweenClasses(oldone, newone, in, el);
+}
+
+
void switchBetweenClasses(DocumentClassConstPtr oldone,
DocumentClassConstPtr newone, InsetText & in, ErrorList & errorlist)
{
docstring const & n = newone->insetLayout(layoutName).name();
bool const is_undefined = n.empty() ||
n == DocumentClass::plainInsetLayout().name();
- if (!is_undefined)
+ docstring const & oldn = oldone->insetLayout(layoutName).name();
+ bool const was_undefined = oldn.empty() ||
+ oldn == DocumentClass::plainInsetLayout().name();
+ if (!is_undefined || was_undefined)
continue;
// The flex inset is undefined in newtc
if (begpit != endpit)
cur.screenUpdateFlags(Update::Force | Update::FitCursor);
+ else
+ cur.screenUpdateFlags(Update::SinglePar | Update::FitCursor);
tie(endpit, endpos) =
eraseSelectionHelper(bp, text->paragraphs(), begpit, endpit,
}
-void copyInset(Cursor const & cur, Inset * inset, docstring const & plaintext)
+namespace {
+
+void copyInsetToStack(Cursor const & cur, CutStack & cutstack, Inset * inset)
{
ParagraphList pars;
Paragraph par;
Font font(inherit_font, bp.language);
par.insertInset(0, inset, font, Change(Change::UNCHANGED));
pars.push_back(par);
- theCuts.push(make_pair(pars, bp.documentClassPtr()));
+ cutstack.push(make_pair(pars, make_pair(bp.documentClassPtr(), bp.authors())));
+}
+
+}
+
+
+void copyInset(Cursor const & cur, Inset * inset, docstring const & plaintext)
+{
+ copyInsetToStack(cur, theCuts, inset);
// stuff the selection onto the X clipboard, from an explicit copy request
+ BufferParams const & bp = cur.buffer()->params();
putClipboard(theCuts[0].first, theCuts[0].second, plaintext, bp);
}
+void copyInsetToTemp(Cursor const & cur, Inset * inset)
+{
+ copyInsetToStack(cur, tempCut, inset);
+}
+
+
namespace {
void copySelectionToStack(CursorData const & cur, CutStack & cutstack)
par.insert(0, grabSelection(cur), Font(sane_font, par.getParLanguage(bp)),
Change(Change::UNCHANGED));
pars.push_back(par);
- cutstack.push(make_pair(pars, bp.documentClassPtr()));
+ cutstack.push(make_pair(pars, make_pair(bp.documentClassPtr(), bp.authors())));
}
}
while (pars.size() > 1)
mergeParagraph(bp, pars, 0);
}
- theCuts.push(make_pair(pars, bp.documentClassPtr()));
+ theCuts.push(make_pair(pars, make_pair(bp.documentClassPtr(), bp.authors())));
} else {
copySelectionToStack(cur, theCuts);
}
}
-docstring selection(size_t sel_index, DocumentClassConstPtr docclass)
+docstring selection(size_t sel_index, DocInfoPair docinfo, bool for_math)
{
if (sel_index >= theCuts.size())
return docstring();
unique_ptr<Buffer> buffer(copyToTempBuffer(theCuts[sel_index].first,
- docclass));
+ docinfo.first));
if (!buffer)
return docstring();
- return buffer->paragraphs().back().asString(AS_STR_INSETS | AS_STR_NEWLINES);
+ int options = AS_STR_INSETS | AS_STR_NEWLINES;
+ if (for_math)
+ options |= AS_STR_MATHED;
+
+ return buffer->paragraphs().back().asString(options);
}
void pasteParagraphList(Cursor & cur, ParagraphList const & parlist,
- DocumentClassConstPtr docclass, ErrorList & errorList,
+ DocumentClassConstPtr docclass, AuthorList const & authors,
+ ErrorList & errorList,
cap::BranchAction branchAction)
{
+ // Copy authors to the params. We need those pointers.
+ for (Author const & a : authors)
+ cur.buffer()->params().authors().record(a);
+
if (cur.inTexted()) {
Text * text = cur.text();
LBUFERR(text);
cur.recordUndo();
pasteParagraphList(cur, theCuts[sel_index].first,
- theCuts[sel_index].second, errorList, BRANCH_ASK);
+ theCuts[sel_index].second.first, theCuts[sel_index].second.second,
+ errorList, BRANCH_ASK);
return true;
}
cur.recordUndo();
pasteParagraphList(cur, tempCut[0].first,
- tempCut[0].second, errorList, BRANCH_IGNORE);
+ tempCut[0].second.first, tempCut[0].second.second,
+ errorList, BRANCH_IGNORE);
return true;
}
string lyx = theClipboard().getAsLyX();
if (!lyx.empty()) {
Buffer buffer(string(), false);
+ buffer.setInternal(true);
buffer.setUnnamed(true);
if (buffer.readString(lyx)) {
cur.recordUndo();
pasteParagraphList(cur, buffer.paragraphs(),
- buffer.params().documentClassPtr(), errorList);
+ buffer.params().documentClassPtr(),
+ buffer.params().authors(),
+ errorList);
return true;
}
}
available = !text.empty();
if (available) {
Buffer buffer(string(), false);
+ buffer.setInternal(true);
buffer.setUnnamed(true);
+ buffer.params() = cur.buffer()->params();
available = buffer.importString(names[i], text, errorList);
if (available)
available = !buffer.paragraphs().empty();
buffer.changeLanguage(buffer.language(), cur.getFont().language());
cur.recordUndo();
pasteParagraphList(cur, buffer.paragraphs(),
- buffer.params().documentClassPtr(), errorList);
+ buffer.params().documentClassPtr(),
+ buffer.params().authors(),
+ errorList);
return true;
}
}
return;
cur.recordUndo();
pasteParagraphList(cur, selectionBuffer[0].first,
- selectionBuffer[0].second, errorList);
+ selectionBuffer[0].second.first,
+ selectionBuffer[0].second.second,
+ errorList);
}