X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FCutAndPaste.cpp;h=abed1567d7fa289520784322cba948e8f0367b88;hb=26ba2a65838731ce639a09539f617cb0f0be3b22;hp=4d90c6c120daacaf2dcbe3ea9fc3561cc4120605;hpb=ca8709aaf5f5f14aae1978403e13aac3a93506aa;p=lyx.git diff --git a/src/CutAndPaste.cpp b/src/CutAndPaste.cpp index 4d90c6c120..abed1567d7 100644 --- a/src/CutAndPaste.cpp +++ b/src/CutAndPaste.cpp @@ -15,9 +15,9 @@ #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" @@ -28,7 +28,6 @@ #include "FuncCode.h" #include "FuncRequest.h" #include "InsetIterator.h" -#include "InsetList.h" #include "Language.h" #include "LyX.h" #include "LyXRC.h" @@ -40,8 +39,8 @@ #include "insets/InsetBibitem.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" @@ -60,17 +59,14 @@ #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 #include +#include using namespace std; using namespace lyx::support; @@ -81,12 +77,15 @@ namespace lyx { namespace { typedef pair PitPosPair; +typedef pair DocInfoPair; -typedef limited_stack > CutStack; +typedef limited_stack > CutStack; CutStack theCuts(10); // persistent selection, cleared until the next selection CutStack selectionBuffer(1); +// temporary scratch area +CutStack tempCut(1); // store whether the tabular stack is newer than the normal copy stack // FIXME: this is a workaround for bug 1919. Should be removed for 1.5, @@ -110,9 +109,24 @@ struct PasteReturnValue { bool needupdate; }; + +/// return true if the whole ParagraphList is deleted +static bool isFullyDeleted(ParagraphList const & pars) +{ + pit_type const pars_size = static_cast(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, Buffer * tmpbuffer, + DocumentClassConstPtr oldDocClass, cap::BranchAction branchAction, ErrorList & errorlist) { Buffer const & buffer = *cur.buffer(); @@ -123,10 +137,23 @@ pasteSelectionHelper(DocIterator const & cur, ParagraphList const & parlist, if (parlist.empty()) return PasteReturnValue(pit, pos, need_update); + // Check whether we paste into an inset that does not + // produce output (needed for label duplicate check) + bool in_active_inset = cur.paragraph().inInset().producesOutput(); + if (in_active_inset) { + for (size_type sl = 0 ; sl < cur.depth() ; ++sl) { + Paragraph const & outer_par = cur[sl].paragraph(); + if (!outer_par.inInset().producesOutput()) { + in_active_inset = false; + break; + } + } + } + InsetText * target_inset = cur.inset().asInsetText(); if (!target_inset) { InsetTabular * it = cur.inset().asInsetTabular(); - target_inset = it ? it->cell(cur.idx())->asInsetText() : 0; + target_inset = it ? it->cell(cur.idx())->asInsetText() : nullptr; } LASSERT(target_inset, return PasteReturnValue(pit, pos, need_update)); @@ -140,6 +167,14 @@ pasteSelectionHelper(DocIterator const & cur, ParagraphList const & parlist, // Now remove all out of the pars which is NOT allowed in the // new environment and set also another font if that is required. + // Merge paragraphs that are to be pasted into a text inset + // that does not allow multiple pars. + InsetText * inset_text = target_inset->asInsetText(); + if (inset_text && !inset_text->allowMultiPar()) { + while (insertion.size() > 1) + mergeParagraph(buffer.params(), insertion, 0); + } + // Convert newline to paragraph break in ParbreakIsNewline if (target_inset->getLayout().parbreakIsNewline() || pars[pit].layout().parbreak_is_newline) { @@ -158,29 +193,58 @@ pasteSelectionHelper(DocIterator const & cur, ParagraphList const & parlist, } } + // Prevent to paste uncodable characters in verbatim and ERT. + // The encoding is inherited from the context here. + docstring uncodable_content; + if (target_inset->getLayout().isPassThru() && cur.getEncoding()) { + odocstringstream res; + Encoding const * e = cur.getEncoding(); + for (size_t i = 0; i != insertion.size(); ++i) { + pos_type end = insertion[i].size(); + for (pos_type j = 0; j != end; ++j) { + // skip insets + if (insertion[i].isInset(j)) + continue; + char_type const c = insertion[i].getChar(j); + if (!e->encodable(c)) { + // do not track deletion + res.put(c); + insertion[i].eraseChar(j, false); + --end; + --j; + } + } + } + docstring const uncodable = res.str(); + if (!uncodable.empty()) { + if (uncodable.size() == 1) + uncodable_content = bformat(_("The character \"%1$s\" is uncodable in this verbatim context " + "and thus has not been pasted."), + uncodable); + else + uncodable_content = bformat(_("The characters \"%1$s\" are uncodable in this verbatim context " + "and thus have not been pasted."), + uncodable); + } + } + // 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 = cur.inset().forcePlainLayout(); - Layout const & plainLayout = newDocClass->plainLayout(); - Layout const & defaultLayout = newDocClass->defaultLayout(); - ParagraphList::iterator const end = insertion.end(); - ParagraphList::iterator par = insertion.begin(); - for (; par != end; ++par) { - Layout const & parLayout = par->layout(); + bool forcePlainLayout = target_inset->forcePlainLayout(); + for (auto & par : insertion) { + Layout const & parLayout = par.layout(); if (forcePlainLayout || parLayout == defaultLayout) - par->setLayout(plainLayout); + par.setLayout(plainLayout); } } else { // check if we need to reset from plain layout - Layout const & defaultLayout = newDocClass->defaultLayout(); - Layout const & plainLayout = newDocClass->plainLayout(); - ParagraphList::iterator const end = insertion.end(); - ParagraphList::iterator par = insertion.begin(); - for (; par != end; ++par) { - Layout const & parLayout = par->layout(); + for (auto & par : insertion) { + Layout const & parLayout = par.layout(); if (parLayout == plainLayout) - par->setLayout(defaultLayout); + par.setLayout(defaultLayout); } } @@ -193,6 +257,9 @@ pasteSelectionHelper(DocIterator const & cur, ParagraphList const & parlist, // want to invalidate them. insertion.swap(in.paragraphs()); cap::switchBetweenClasses(oldDocClass, newDocClass, in, errorlist); + // Do this here since switchBetweenClasses clears the errorlist + if (!uncodable_content.empty()) + errorlist.push_back(ErrorItem(_("Uncodable content"), uncodable_content)); insertion.swap(in.paragraphs()); ParagraphList::iterator tmpbuf = insertion.begin(); @@ -225,26 +292,35 @@ pasteSelectionHelper(DocIterator const & cur, ParagraphList const & parlist, if (!target_inset->insetAllowed(inset->lyxCode())) tmpbuf->eraseChar(i--, false); } - - 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) { - // Even though this will also be done later, it has to be done here - // since some inset might going to try to access - // the buffer() member. + 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)); switch (it->lyxCode()) { @@ -257,14 +333,14 @@ pasteSelectionHelper(DocIterator const & cur, ParagraphList const & parlist, continue; InsetLabel * lab = labels[i]; docstring const oldname = lab->getParam("name"); - lab->updateLabel(oldname); + lab->updateLabel(oldname, in_active_inset); // We need to update the buffer reference cache. need_update = true; docstring const newname = lab->getParam("name"); 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(); @@ -288,14 +364,14 @@ pasteSelectionHelper(DocIterator const & cur, ParagraphList const & parlist, // check for duplicates InsetLabel & lab = static_cast(*it); docstring const oldname = lab.getParam("name"); - lab.updateLabel(oldname); + lab.updateLabel(oldname, in_active_inset); // We need to update the buffer reference cache. need_update = true; docstring const newname = lab.getParam("name"); 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(*itt); if (ref.getParam("reference") == oldname) @@ -321,6 +397,16 @@ pasteSelectionHelper(DocIterator const & cur, ParagraphList const & parlist, break; } + case CITE_CODE: { + InsetCitation & cit = static_cast(*it); + // This actually only needs to be done if the cite engine + // differs, but we do it in general. + cit.redoLabel(); + // We need to update the list of citations. + need_update = true; + break; + } + case BIBITEM_CODE: { // check for duplicates InsetBibitem & bib = static_cast(*it); @@ -332,7 +418,7 @@ pasteSelectionHelper(DocIterator const & cur, ParagraphList const & parlist, 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(); @@ -356,12 +442,15 @@ pasteSelectionHelper(DocIterator const & cur, ParagraphList const & parlist, || (is_child && (branchlist.find(name) || buffer.masterBuffer()->params().branchlist().find(name)))) break; - if (tmpbuffer) { + switch(branchAction) { + case cap::BRANCH_ADD: { // This is for a temporary buffer, so simply create the branch. // Must not use lyx::dispatch(), since tmpbuffer has no view. DispatchResult dr; - tmpbuffer->dispatch(FuncRequest(LFUN_BRANCH_ADD, name), dr); - } else { + const_cast(buffer).dispatch(FuncRequest(LFUN_BRANCH_ADD, name), dr); + break; + } + case cap::BRANCH_ASK: { docstring text = bformat( _("The pasted branch \"%1$s\" is undefined.\n" "Do you want to add it to the document's branch list?"), @@ -370,6 +459,10 @@ pasteSelectionHelper(DocIterator const & cur, ParagraphList const & parlist, text, 0, 1, _("&Add"), _("&Don't Add")) != 0) break; lyx::dispatch(FuncRequest(LFUN_BRANCH_ADD, name)); + break; + } + case cap::BRANCH_IGNORE: + break; } // We need to update the list of branches. need_update = true; @@ -382,23 +475,52 @@ pasteSelectionHelper(DocIterator const & cur, ParagraphList const & parlist, } 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) { - pars.insert(lyx::next(pars.begin(), pit), - insertion.begin(), - insertion.end()); + if (target_empty) { + pars.insert(pars.iterator_at(pit), + insertion.begin(), insertion.end()); // merge the empty par with the last par of the insertion mergeParagraph(buffer.params(), pars, pit + insertion.size() - 1); } else { - pars.insert(lyx::next(pars.begin(), pit + 1), - insertion.begin(), - insertion.end()); + pars.insert(pars.iterator_at(pit + 1), + insertion.begin(), insertion.end()); // merge the first par of the insertion with the current par mergeParagraph(buffer.params(), pars, pit); @@ -414,11 +536,11 @@ pasteSelectionHelper(DocIterator const & cur, ParagraphList const & parlist, // Set paragraph buffers. It's important to do this right away // before something calls Inset::buffer() and causes a crash. for (pit_type p = startpit; p <= pit; ++p) - pars[p].setBuffer(const_cast(buffer)); + pars[p].setInsetBuffers(const_cast(buffer)); // 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()) { @@ -462,10 +584,7 @@ PitPosPair eraseSelectionHelper(BufferParams const & params, 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); @@ -487,20 +606,22 @@ Buffer * copyToTempBuffer(ParagraphList const & paragraphs, DocumentClassConstPt // to be so, but the alternative is to construct a new one of these (with a // new temporary directory, etc) every time, and then to destroy it. So maybe // it's worth just keeping this one around. - // FIXME THREAD static TempFile tempfile("clipboard.internal"); tempfile.setAutoRemove(false); - static Buffer * staticbuffer = theBufferList().newInternalBuffer( - tempfile.name().absFileName()); - - // These two things only really need doing the first time. - staticbuffer->setUnnamed(true); - staticbuffer->inset().setBuffer(*staticbuffer); - + // The initialization of staticbuffer is thread-safe. Using a lambda + // guarantees that the properties are set only once. + static Buffer * staticbuffer = [&](){ + Buffer * b = + theBufferList().newInternalBuffer(tempfile.name().absFileName()); + b->setUnnamed(true); + b->inset().setBuffer(*b); + //initialize staticbuffer with b + return b; + }(); // Use a clone for the complicated stuff so that we do not need to clean // up in order to avoid a crash. Buffer * buffer = staticbuffer->cloneBufferOnly(); - LASSERT(buffer, return 0); + LASSERT(buffer, return nullptr); // This needs doing every time. // Since setDocumentClass() causes deletion of the old document class @@ -520,16 +641,17 @@ Buffer * copyToTempBuffer(ParagraphList const & paragraphs, DocumentClassConstPt // temporary Buffer, since it does a lot of things to fix them up. DocIterator dit = doc_iterator_begin(buffer, &buffer->inset()); ErrorList el; - pasteSelectionHelper(dit, paragraphs, docclass, buffer, el); + pasteSelectionHelper(dit, paragraphs, docclass, cap::BRANCH_ADD, el); return buffer; } -void putClipboard(ParagraphList const & paragraphs, - DocumentClassConstPtr docclass, docstring const & plaintext) +void putClipboard(ParagraphList const & paragraphs, + 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; @@ -538,6 +660,10 @@ void putClipboard(ParagraphList const & paragraphs, // applications, the number that can parse it should go up in the future. buffer->params().html_math_output = BufferParams::MathML; + // 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 { // The Buffer is being used to export. This is necessary so that the @@ -571,21 +697,6 @@ void putClipboard(ParagraphList const & paragraphs, } -/// return true if the whole ParagraphList is deleted -static bool isFullyDeleted(ParagraphList const & pars) -{ - pit_type const pars_size = static_cast(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) @@ -600,8 +711,8 @@ void copySelectionHelper(Buffer const & buf, Text const & text, LASSERT(startpit != endpit || start <= end, return); // Clone the paragraphs within the selection. - ParagraphList copy_pars(lyx::next(pars.begin(), startpit), - lyx::next(pars.begin(), endpit + 1)); + ParagraphList copy_pars(pars.iterator_at(startpit), + pars.iterator_at(endpit + 1)); // Remove the end of the last paragraph; afterwards, remove the // beginning of the first paragraph. Keep this order - there may only @@ -613,54 +724,50 @@ void copySelectionHelper(Buffer const & buf, Text const & text, Paragraph & front = copy_pars.front(); front.eraseChars(0, start, false); - ParagraphList::iterator it = copy_pars.begin(); - ParagraphList::iterator it_end = copy_pars.end(); - - for (; it != it_end; ++it) { + for (auto & par : copy_pars) { // Since we have a copy of the paragraphs, the insets // do not have a proper buffer reference. It makes // sense to add them temporarily, because the // operations below depend on that (acceptChanges included). - it->setBuffer(const_cast(buf)); + par.setInsetBuffers(const_cast(buf)); // PassThru paragraphs have the Language // latex_language. This is invalid for others, so we // need to change it to the buffer language. - if (it->isPassThru()) - it->changeLanguage(buf.params(), + if (par.isPassThru()) + par.changeLanguage(buf.params(), latex_language, buf.language()); } // do not copy text (also nested in insets) which is marked as // deleted, unless the whole selection was deleted - if (!isFullyDeleted(copy_pars)) - acceptChanges(copy_pars, buf.params()); - else - rejectChanges(copy_pars, buf.params()); + if (!lyxrc.ct_markup_copied) { + if (!isFullyDeleted(copy_pars)) + acceptChanges(copy_pars, buf.params()); + else + rejectChanges(copy_pars, buf.params()); + } // do some final cleanup now, to make sure that the paragraphs // are not linked to something else. - it = copy_pars.begin(); - for (; it != it_end; ++it) { - it->setBuffer(*static_cast(0)); - it->setInsetOwner(0); + for (auto & par : copy_pars) { + par.resetBuffer(); + par.setInsetOwner(nullptr); } - cutstack.push(make_pair(copy_pars, dc)); + cutstack.push(make_pair(copy_pars, make_pair(dc, buf.params().authors()))); } -} // namespace anon - - +} // 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 & p = i1.inset(); + Inset const & p = i1.inset(); c1 = p.col(i1.idx()); c2 = p.col(i2.idx()); if (c1 > c2) @@ -682,7 +789,7 @@ docstring grabAndEraseSelection(Cursor & cur) } -bool reduceSelectionToOneCell(Cursor & cur) +bool reduceSelectionToOneCell(CursorData & cur) { if (!cur.selection() || !cur.inMathed()) return false; @@ -695,32 +802,39 @@ bool reduceSelectionToOneCell(Cursor & cur) // the easy case: do nothing if only one cell is selected if (i1.idx() == i2.idx()) return true; - + cur.top().pos() = 0; cur.resetAnchor(); cur.top().pos() = cur.top().lastpos(); - + return true; } -bool multipleCellsSelected(Cursor const & cur) +bool multipleCellsSelected(CursorData const & cur) { if (!cur.selection() || !cur.inMathed()) return false; - + CursorSlice i1 = cur.selBegin(); CursorSlice i2 = cur.selEnd(); if (!i1.inset().asInsetMath()) return false; - + if (i1.idx() == i2.idx()) return false; - + return true; } +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) { @@ -729,16 +843,16 @@ void switchBetweenClasses(DocumentClassConstPtr oldone, LBUFERR(!in.paragraphs().empty()); if (oldone == newone) return; - + DocumentClass const & oldtc = *oldone; DocumentClass const & newtc = *newone; // 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 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 @@ -750,8 +864,8 @@ void switchBetweenClasses(DocumentClassConstPtr oldone, if (added_one || newlayouts.find(name) != newlayouts.end()) { // Warn the user. docstring const s = bformat(_("Layout `%1$s' was not found."), name); - errorlist.push_back( - ErrorItem(_("Layout Not Found"), s, it->id(), 0, it->size())); + errorlist.push_back(ErrorItem(_("Layout Not Found"), s, + {it->id(), 0}, {it->id(), -1})); } if (in.usePlainLayout()) @@ -761,18 +875,21 @@ void switchBetweenClasses(DocumentClassConstPtr oldone, } // character styles and hidden table cells - InsetIterator const i_end = inset_iterator_end(in); - for (InsetIterator it = inset_iterator_begin(in); it != i_end; ++it) { - InsetCode const code = it->lyxCode(); + 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 InsetCollapsable? - docstring const layoutName = it->layoutName(); + // FIXME: Should we verify all InsetCollapsible? + docstring const layoutName = iit->layoutName(); 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 docstring const oldname = from_utf8(oldtc.name()); docstring const newname = from_utf8(newtc.name()); @@ -786,14 +903,15 @@ void switchBetweenClasses(DocumentClassConstPtr oldone, layoutName, oldname, newname); // To warn the user that something had to be done. errorlist.push_back(ErrorItem( - _("Undefined flex inset"), - s, it.paragraph().id(), it.pos(), it.pos() + 1)); + _("Undefined flex inset"), s, + {iit.paragraph().id(), iit.pos()}, + {iit.paragraph().id(), iit.pos() + 1})); } else if (code == TABULAR_CODE) { // The recursion above does not catch paragraphs in "hidden" cells, // i.e., ones that are part of a multirow or multicolum. So we need // to handle those separately. // This is the cause of bug #9049. - InsetTabular * table = it->asInsetTabular(); + InsetTabular * table = iit->asInsetTabular(); table->setLayoutForHiddenCells(newtc); } } @@ -806,19 +924,13 @@ vector availableSelections(Buffer const * buf) if (!buf) return selList; - CutStack::const_iterator cit = theCuts.begin(); - CutStack::const_iterator end = theCuts.end(); - for (; cit != end; ++cit) { - // we do not use cit-> here because gcc 2.9x does not - // like it (JMarc) - ParagraphList const & pars = (*cit).first; + for (auto const & cut : theCuts) { + ParagraphList const & pars = cut.first; docstring textSel; - ParagraphList::const_iterator pit = pars.begin(); - ParagraphList::const_iterator pend = pars.end(); - for (; pit != pend; ++pit) { - Paragraph par(*pit, 0, 46); + for (auto const & para : pars) { + Paragraph par(para, 0, 46); // adapt paragraph to current buffer. - par.setBuffer(const_cast(*buf)); + par.setInsetBuffers(const_cast(*buf)); textSel += par.asString(AS_STR_INSETS); if (textSel.size() > 45) { support::truncateWithEllipsis(textSel,45); @@ -837,8 +949,9 @@ size_type numberOfSelections() return theCuts.size(); } +namespace { -void cutSelection(Cursor & cur, bool doclear, bool realcut) +void cutSelectionHelper(Cursor & cur, CutStack & cuts, bool realcut, bool putclip) { // This doesn't make sense, if there is no selection if (!cur.selection()) @@ -866,21 +979,22 @@ void cutSelection(Cursor & cur, bool doclear, bool realcut) *text, begpit, endpit, cur.selBegin().pos(), endpos, - bp.documentClassPtr(), theCuts); + bp.documentClassPtr(), cuts); // Stuff what we got on the clipboard. // Even if there is no selection. - putClipboard(theCuts[0].first, theCuts[0].second, - cur.selectionAsString(true)); + if (putclip) + putClipboard(cuts[0].first, cuts[0].second, + cur.selectionAsString(true, true), bp); } if (begpit != endpit) cur.screenUpdateFlags(Update::Force | Update::FitCursor); + else + cur.screenUpdateFlags(Update::SinglePar | Update::FitCursor); - boost::tie(endpit, endpos) = - eraseSelectionHelper(bp, - text->paragraphs(), - begpit, endpit, - cur.selBegin().pos(), endpos); + tie(endpit, endpos) = + eraseSelectionHelper(bp, text->paragraphs(), begpit, endpit, + cur.selBegin().pos(), endpos); // cutSelection can invalidate the cursor so we need to set // it anew. (Lgb) @@ -888,11 +1002,6 @@ void cutSelection(Cursor & cur, bool doclear, bool realcut) cur.pos() = endpos; cur.pit() = endpit; - // sometimes necessary - if (doclear - && text->paragraphs()[begpit].stripLeadingSpaces(bp.track_changes)) - cur.fixIfBroken(); - // need a valid cursor. (Lgb) cur.clearSelection(); @@ -922,14 +1031,29 @@ void cutSelection(Cursor & cur, bool doclear, bool realcut) } } +} // namespace + +void cutSelection(Cursor & cur, bool realcut) +{ + cutSelectionHelper(cur, theCuts, realcut, true); +} + + +void cutSelectionToTemp(Cursor & cur, bool realcut) +{ + cutSelectionHelper(cur, tempCut, realcut, false); +} + void copySelection(Cursor const & cur) { - copySelection(cur, cur.selectionAsString(true)); + copySelection(cur, cur.selectionAsString(true, true)); } -void copyInset(Cursor const & cur, Inset * inset, docstring const & plaintext) +namespace { + +void copyInsetToStack(Cursor const & cur, CutStack & cutstack, Inset * inset) { ParagraphList pars; Paragraph par; @@ -938,16 +1062,31 @@ void copyInset(Cursor const & cur, Inset * inset, docstring const & plaintext) 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 - putClipboard(theCuts[0].first, theCuts[0].second, plaintext); + 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(Cursor const & cur, CutStack & cutstack) +void copySelectionToStack(CursorData const & cur, CutStack & cutstack) { // this doesn't make sense, if there is no selection if (!cur.selection()) @@ -964,7 +1103,7 @@ void copySelectionToStack(Cursor const & cur, CutStack & cutstack) // and sel_end cursor copySelectionHelper(*cur.buffer(), *text, cur.selBegin().pit(), cur.selEnd().pit(), - cur.selBegin().pos(), cur.selEnd().pos(), + cur.selBegin().pos(), cur.selEnd().pos(), cur.buffer()->params().documentClassPtr(), cutstack); // Reset the dirty_tabular_stack_ flag only when something @@ -980,13 +1119,16 @@ void copySelectionToStack(Cursor const & cur, CutStack & cutstack) BufferParams const & bp = cur.buffer()->params(); // FIXME This should be the plain layout...right? par.setLayout(bp.documentClass().plainLayout()); - par.insert(0, grabSelection(cur), Font(), Change(Change::UNCHANGED)); + // For pasting into text, we set the language to the paragraph language + // (rather than the default_language which is always English; see #2596) + 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()))); } } -} +} // namespace void copySelectionToStack() @@ -996,26 +1138,58 @@ void copySelectionToStack() } +void copySelectionToTemp(Cursor const & cur) +{ + copySelectionToStack(cur, tempCut); +} + + void copySelection(Cursor const & cur, docstring const & plaintext) { - // In tablemode, because copy and paste actually use special table stack - // we do not attempt to get selected paragraphs under cursor. Instead, a - // paragraph with the plain text version is generated so that table cells - // can be pasted as pure text somewhere else. + // In tablemode, because copy and paste actually use a special table stack, + // 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; - Paragraph par; BufferParams const & bp = cur.buffer()->params(); - par.setLayout(bp.documentClass().plainLayout()); - par.insert(0, plaintext, Font(), Change(Change::UNCHANGED)); - pars.push_back(par); - theCuts.push(make_pair(pars, bp.documentClassPtr())); + if (cur.inMathed()) { + Paragraph par; + par.setLayout(bp.documentClass().plainLayout()); + // Replace (column-separating) tabs by space (#4449) + docstring const clean_text = subst(plaintext, '\t', ' '); + // For pasting into text, we set the language to the paragraph language + // (rather than the default_language which is always English; see #11898) + par.insert(0, clean_text, Font(sane_font, par.getParLanguage(bp)), + Change(Change::UNCHANGED)); + pars.push_back(par); + } else { + // Get paragraphs from all cells + InsetTabular * table = cur.inset().asInsetTabular(); + LASSERT(table, return); + ParagraphList tplist = table->asParList(cur.selBegin().idx(), cur.selEnd().idx()); + for (auto & cpar : tplist) { + cpar.setLayout(bp.documentClass().plainLayout()); + pars.push_back(cpar); + // since the pars are merged later, we separate them by blank + Paragraph epar; + epar.insert(0, from_ascii(" "), Font(sane_font, epar.getParLanguage(bp)), + Change(Change::UNCHANGED)); + pars.push_back(epar); + } + // remove last empty par + pars.pop_back(); + // merge all paragraphs to one + while (pars.size() > 1) + mergeParagraph(bp, pars, 0); + } + theCuts.push(make_pair(pars, make_pair(bp.documentClassPtr(), bp.authors()))); } else { copySelectionToStack(cur, theCuts); } // stuff the selection onto the X clipboard, from an explicit copy request - putClipboard(theCuts[0].first, theCuts[0].second, plaintext); + putClipboard(theCuts[0].first, theCuts[0].second, plaintext, + cur.buffer()->params()); } @@ -1024,10 +1198,10 @@ void saveSelection(Cursor const & cur) // This function is called, not when a selection is formed, but when // a selection is cleared. Therefore, multiple keyboard selection // will not repeatively trigger this function (bug 3877). - if (cur.selection() + if (cur.selection() && cur.selBegin() == cur.bv().cursor().selBegin() && cur.selEnd() == cur.bv().cursor().selEnd()) { - LYXERR(Debug::SELECTION, "saveSelection: '" << cur.selectionAsString(true) << "'"); + LYXERR(Debug::SELECTION, "saveSelection: '" << cur.selectionAsString(true, true) << "'"); copySelectionToStack(cur, selectionBuffer); } } @@ -1048,32 +1222,43 @@ void clearSelection() void clearCutStack() { theCuts.clear(); + tempCut.clear(); } -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(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); PasteReturnValue prv = - pasteSelectionHelper(cur, parlist, docclass, 0, errorList); + pasteSelectionHelper(cur, parlist, docclass, branchAction, errorList); cur.forceBufferUpdate(); cur.clearSelection(); text->setCursor(cur, prv.pit, prv.pos); @@ -1092,7 +1277,22 @@ bool pasteFromStack(Cursor & cur, ErrorList & errorList, size_t sel_index) cur.recordUndo(); pasteParagraphList(cur, theCuts[sel_index].first, - theCuts[sel_index].second, errorList); + theCuts[sel_index].second.first, theCuts[sel_index].second.second, + errorList, BRANCH_ASK); + return true; +} + + +bool pasteFromTemp(Cursor & cur, ErrorList & errorList) +{ + // this does not make sense, if there is nothing to paste + if (tempCut.empty() || tempCut[0].first.empty()) + return false; + + cur.recordUndo(); + pasteParagraphList(cur, tempCut[0].first, + tempCut[0].second.first, tempCut[0].second.second, + errorList, BRANCH_IGNORE); return true; } @@ -1112,14 +1312,15 @@ bool pasteClipboardText(Cursor & cur, ErrorList & errorList, bool asParagraphs, theClipboard().hasTextContents(Clipboard::LyXTextType)) { string lyx = theClipboard().getAsLyX(); if (!lyx.empty()) { - // For some strange reason gcc 3.2 and 3.3 do not accept - // Buffer buffer(string(), false); - Buffer buffer("", false); + 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; } } @@ -1145,17 +1346,23 @@ bool pasteClipboardText(Cursor & cur, ErrorList & errorList, bool asParagraphs, docstring text = theClipboard().getAsText(types[i]); available = !text.empty(); if (available) { - // For some strange reason gcc 3.2 and 3.3 do not accept - // Buffer buffer(string(), false); - Buffer buffer("", false); + 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(); if (available && !buffer.paragraphs()[0].empty()) { + // TeX2lyx (also used in the HTML chain) assumes English as document language + // if no language is explicitly set (as is the case here). + // We thus reset the temp buffer's language to the context language + 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; } } @@ -1171,6 +1378,7 @@ bool pasteClipboardText(Cursor & cur, ErrorList & errorList, bool asParagraphs, cur.text()->insertStringAsParagraphs(cur, text, cur.current_font); else cur.text()->insertStringAsLines(cur, text, cur.current_font); + cur.forceBufferUpdate(); return true; } @@ -1200,7 +1408,7 @@ void pasteSimpleText(Cursor & cur, bool asParagraphs) return; cur.recordUndo(); - cutSelection(cur, true, false); + cutSelection(cur, false); if (asParagraphs) cur.text()->insertStringAsParagraphs(cur, text, cur.current_font); else @@ -1234,7 +1442,9 @@ void pasteSelection(Cursor & cur, ErrorList & errorList) return; cur.recordUndo(); pasteParagraphList(cur, selectionBuffer[0].first, - selectionBuffer[0].second, errorList); + selectionBuffer[0].second.first, + selectionBuffer[0].second.second, + errorList); } @@ -1250,20 +1460,20 @@ void replaceSelectionWithString(Cursor & cur, docstring const & str) // Insert the new string pos_type pos = cur.selEnd().pos(); Paragraph & par = cur.selEnd().paragraph(); - docstring::const_iterator cit = str.begin(); - docstring::const_iterator end = str.end(); - for (; cit != end; ++cit, ++pos) - par.insertChar(pos, *cit, font, cur.buffer()->params().track_changes); + for (auto const & c : str) { + par.insertChar(pos, c, font, cur.buffer()->params().track_changes); + ++pos; + } // Cut the selection - cutSelection(cur, true, false); + cutSelection(cur, false); } void replaceSelection(Cursor & cur) { if (cur.selection()) - cutSelection(cur, true, false); + cutSelection(cur, false); } @@ -1288,20 +1498,20 @@ void eraseSelection(Cursor & cur) 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; @@ -1331,7 +1541,7 @@ void selClearOrDel(Cursor & cur) } -docstring grabSelection(Cursor const & cur) +docstring grabSelection(CursorData const & cur) { if (!cur.selection()) return docstring(); @@ -1360,16 +1570,16 @@ docstring grabSelection(Cursor const & cur) } } - 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()->