#include "CutAndPaste.h"
+#include "Author.h"
#include "BranchList.h"
#include "Buffer.h"
-#include "buffer_funcs.h"
#include "BufferList.h"
#include "BufferParams.h"
#include "BufferView.h"
#include "FuncCode.h"
#include "FuncRequest.h"
#include "InsetIterator.h"
-#include "InsetList.h"
#include "Language.h"
#include "LyX.h"
#include "LyXRC.h"
#include "insets/InsetBranch.h"
#include "insets/InsetCitation.h"
#include "insets/InsetCommand.h"
-#include "insets/InsetFlex.h"
#include "insets/InsetGraphics.h"
#include "insets/InsetGraphicsParams.h"
#include "insets/InsetInclude.h"
#include "support/lassert.h"
#include "support/limited_stack.h"
#include "support/lstrings.h"
-#include "support/lyxalgo.h"
#include "support/TempFile.h"
#include "support/unique_ptr.h"
#include "frontends/alert.h"
#include "frontends/Clipboard.h"
-#include "frontends/Selection.h"
#include <string>
#include <tuple>
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
// set the paragraphs to plain layout if necessary
DocumentClassConstPtr newDocClass = buffer.params().documentClassPtr();
+ Layout const & plainLayout = newDocClass->plainLayout();
+ Layout const & defaultLayout = newDocClass->defaultLayout();
if (cur.inset().usePlainLayout()) {
bool forcePlainLayout = target_inset->forcePlainLayout();
- Layout const & plainLayout = newDocClass->plainLayout();
- Layout const & defaultLayout = newDocClass->defaultLayout();
for (auto & par : insertion) {
Layout const & parLayout = par.layout();
if (forcePlainLayout || parLayout == defaultLayout)
}
} else {
// check if we need to reset from plain layout
- Layout const & defaultLayout = newDocClass->defaultLayout();
- Layout const & plainLayout = newDocClass->plainLayout();
for (auto & par : insertion) {
Layout const & parLayout = par.layout();
if (parLayout == plainLayout)
tmpbuf->eraseChar(i--, false);
}
- if (lyxrc.ct_markup_copied)
+ 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());
- InsetIterator const i_end = inset_iterator_end(in);
- for (InsetIterator it = inset_iterator_begin(in); it != i_end; ++it) {
+ InsetIterator const i_end = end(in);
+ for (InsetIterator it = begin(in); it != i_end; ++it) {
// Even though this will also be done later, it has to be done here
// since some inset might try to access the buffer() member.
it->setBuffer(const_cast<Buffer &>(buffer));
if (oldname == newname)
continue;
// adapt the references
- for (InsetIterator itt = inset_iterator_begin(in);
+ for (InsetIterator itt = begin(in);
itt != i_end; ++itt) {
if (itt->lyxCode() == REF_CODE) {
InsetCommand * ref = itt->asInsetCommand();
if (oldname == newname)
break;
// adapt the references
- for (InsetIterator itt = inset_iterator_begin(in); itt != i_end; ++itt) {
+ for (InsetIterator itt = begin(in); itt != i_end; ++itt) {
if (itt->lyxCode() == REF_CODE) {
InsetCommand & ref = static_cast<InsetCommand &>(*itt);
if (ref.getParam("reference") == oldname)
if (oldkey == newkey)
break;
// adapt the references
- for (InsetIterator itt = inset_iterator_begin(in);
+ for (InsetIterator itt = begin(in);
itt != i_end; ++itt) {
if (itt->lyxCode() == CITE_CODE) {
InsetCommand * ref = itt->asInsetCommand();
insertion.swap(in.paragraphs());
// 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
{
par.setInsetOwner(nullptr);
}
- cutstack.push(make_pair(copy_pars, dc));
+ cutstack.push(make_pair(copy_pars, make_pair(dc, buf.params().authors())));
}
} // namespace
namespace cap {
void region(CursorSlice const & i1, CursorSlice const & i2,
- Inset::row_type & r1, Inset::row_type & r2,
- Inset::col_type & c1, Inset::col_type & c2)
+ row_type & r1, row_type & r2,
+ col_type & c1, col_type & c2)
{
Inset const & p = i1.inset();
c1 = p.col(i1.idx());
}
+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)
{
// layouts
ParIterator it = par_iterator_begin(in);
- ParIterator end = par_iterator_end(in);
+ ParIterator pend = par_iterator_end(in);
// for remembering which layouts we've had to add
set<docstring> newlayouts;
- for (; it != end; ++it) {
+ for (; it != pend; ++it) {
docstring const name = it->layout().name();
// the pasted text will keep their own layout name. If this layout does
}
// character styles and hidden table cells
- InsetIterator const i_end = inset_iterator_end(in);
- for (InsetIterator iit = inset_iterator_begin(in); iit != i_end; ++iit) {
+ InsetIterator const i_end = end(in);
+ for (InsetIterator iit = begin(in); iit != i_end; ++iit) {
InsetCode const code = iit->lyxCode();
if (code == FLEX_CODE) {
// FIXME: Should we verify all InsetCollapsible?
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
}
-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())));
}
}
void copySelection(Cursor const & cur, docstring const & plaintext)
{
// In tablemode, because copy and paste actually use a special table stack,
- // we need to go through the cells and collect the paragraphs.
+ // we need to go through the cells and collect the paragraphs.
// In math matrices, we generate a plain text version.
if (cur.selBegin().idx() != cur.selEnd().idx()) {
ParagraphList pars;
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);
}
cur.pos() = cur.lastpos();
} else if (p->nrows() > 0 && p->ncols() > 0) {
// This is a grid, delete a nice square region
- Inset::row_type r1, r2;
- Inset::col_type c1, c2;
+ row_type r1, r2;
+ col_type c1, c2;
region(i1, i2, r1, r2, c1, c2);
- for (Inset::row_type row = r1; row <= r2; ++row)
- for (Inset::col_type col = c1; col <= c2; ++col)
+ for (row_type row = r1; row <= r2; ++row)
+ for (col_type col = c1; col <= c2; ++col)
p->cell(p->index(row, col)).clear();
// We've deleted the whole cell. Only pos 0 is valid.
cur.pos() = 0;
} else {
- Inset::idx_type idx1 = i1.idx();
- Inset::idx_type idx2 = i2.idx();
+ idx_type idx1 = i1.idx();
+ idx_type idx2 = i2.idx();
if (idx1 > idx2)
swap(idx1, idx2);
- for (Inset::idx_type idx = idx1 ; idx <= idx2; ++idx)
+ for (idx_type idx = idx1 ; idx <= idx2; ++idx)
p->cell(idx).clear();
// We've deleted the whole cell. Only pos 0 is valid.
cur.pos() = 0;
}
}
- Inset::row_type r1, r2;
- Inset::col_type c1, c2;
+ row_type r1, r2;
+ col_type c1, c2;
region(i1, i2, r1, r2, c1, c2);
docstring data;
if (i1.inset().asInsetMath()) {
- for (Inset::row_type row = r1; row <= r2; ++row) {
+ for (row_type row = r1; row <= r2; ++row) {
if (row > r1)
data += "\\\\";
- for (Inset::col_type col = c1; col <= c2; ++col) {
+ for (col_type col = c1; col <= c2; ++col) {
if (col > c1)
data += '&';
data += asString(i1.asInsetMath()->
projects / lyx.git / blobdiff