X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FCutAndPaste.cpp;h=cad8c943deeb8cf5550092e49c20198bd133eeb7;hb=a128c373f9e3563a52405a485d9a672e210208b0;hp=9e7ddd31feaf3987bc393ec33b7fa572e48f2cd2;hpb=270201ed67f6aec9a075f7dae65085ac64b5a36d;p=lyx.git diff --git a/src/CutAndPaste.cpp b/src/CutAndPaste.cpp index 9e7ddd31fe..cad8c943de 100644 --- a/src/CutAndPaste.cpp +++ b/src/CutAndPaste.cpp @@ -40,6 +40,7 @@ #include "insets/InsetBibitem.h" #include "insets/InsetBranch.h" +#include "insets/InsetCitation.h" #include "insets/InsetCommand.h" #include "insets/InsetFlex.h" #include "insets/InsetGraphics.h" @@ -60,15 +61,16 @@ #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 +#include using namespace std; using namespace lyx::support; @@ -85,6 +87,8 @@ 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, @@ -99,44 +103,53 @@ bool checkPastePossible(int index) struct PasteReturnValue { - PasteReturnValue(pit_type r_par, pos_type r_pos, bool r_nu) : - par(r_par), pos(r_pos), needupdate(r_nu) + PasteReturnValue(pit_type r_pit, pos_type r_pos, bool r_nu) : + pit(r_pit), pos(r_pos), needupdate(r_nu) {} - pit_type par; + pit_type pit; pos_type pos; bool needupdate; }; PasteReturnValue pasteSelectionHelper(DocIterator const & cur, ParagraphList const & parlist, - DocumentClassConstPtr oldDocClass, Buffer * tmpbuffer, + DocumentClassConstPtr oldDocClass, cap::BranchAction branchAction, ErrorList & errorlist) { Buffer const & buffer = *cur.buffer(); pit_type pit = cur.pit(); pos_type pos = cur.pos(); bool need_update = false; + + if (parlist.empty()) + return PasteReturnValue(pit, pos, need_update); + 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() : 0; } LASSERT(target_inset, return PasteReturnValue(pit, pos, need_update)); - ParagraphList & pars = target_inset->paragraphs(); - - if (parlist.empty()) - return PasteReturnValue(pit, pos, need_update); - BOOST_ASSERT (pos <= pars[pit].size()); + ParagraphList & pars = target_inset->paragraphs(); + LASSERT(pos <= pars[pit].size(), + return PasteReturnValue(pit, pos, need_update)); // Make a copy of the CaP paragraphs. ParagraphList insertion = parlist; - DocumentClassConstPtr newDocClass = buffer.params().documentClassPtr(); // 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) { @@ -155,9 +168,45 @@ 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(); if (cur.inset().usePlainLayout()) { - bool forcePlainLayout = cur.inset().forcePlainLayout(); + bool forcePlainLayout = target_inset->forcePlainLayout(); Layout const & plainLayout = newDocClass->plainLayout(); Layout const & defaultLayout = newDocClass->defaultLayout(); ParagraphList::iterator const end = insertion.end(); @@ -167,7 +216,8 @@ pasteSelectionHelper(DocIterator const & cur, ParagraphList const & parlist, if (forcePlainLayout || parLayout == defaultLayout) par->setLayout(plainLayout); } - } else { // check if we need to reset from plain layout + } 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(); @@ -188,6 +238,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(); @@ -221,7 +274,7 @@ pasteSelectionHelper(DocIterator const & cur, ParagraphList const & parlist, tmpbuf->eraseChar(i--, false); } - tmpbuf->setChange(Change(buffer.params().trackChanges ? + tmpbuf->setChange(Change(buffer.params().track_changes ? Change::INSERTED : Change::UNCHANGED)); } @@ -237,7 +290,7 @@ pasteSelectionHelper(DocIterator const & cur, ParagraphList const & parlist, 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 + // 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. it->setBuffer(const_cast(buffer)); @@ -316,6 +369,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); @@ -351,12 +414,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?"), @@ -365,6 +431,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; @@ -383,7 +453,7 @@ pasteSelectionHelper(DocIterator const & cur, ParagraphList const & parlist, // Paste it! if (empty) { - pars.insert(boost::next(pars.begin(), pit), + pars.insert(lyx::next(pars.begin(), pit), insertion.begin(), insertion.end()); @@ -391,7 +461,7 @@ pasteSelectionHelper(DocIterator const & cur, ParagraphList const & parlist, mergeParagraph(buffer.params(), pars, pit + insertion.size() - 1); } else { - pars.insert(boost::next(pars.begin(), pit + 1), + pars.insert(lyx::next(pars.begin(), pit + 1), insertion.begin(), insertion.end()); @@ -423,7 +493,7 @@ pasteSelectionHelper(DocIterator const & cur, ParagraphList const & parlist, pars[last_paste].makeSameLayout(pars[last_paste + 1]); mergeParagraph(buffer.params(), pars, last_paste); } else { - pars[last_paste + 1].stripLeadingSpaces(buffer.params().trackChanges); + pars[last_paste + 1].stripLeadingSpaces(buffer.params().track_changes); ++last_paste; } } @@ -444,21 +514,21 @@ PitPosPair eraseSelectionHelper(BufferParams const & params, // Start and end is inside same paragraph if (endpit == pit_type(pars.size()) || startpit == endpit) { - endpos -= pars[startpit].eraseChars(startpos, endpos, params.trackChanges); + endpos -= pars[startpit].eraseChars(startpos, endpos, params.track_changes); return PitPosPair(endpit, endpos); } for (pit_type pit = startpit; pit != endpit + 1;) { pos_type const left = (pit == startpit ? startpos : 0); pos_type right = (pit == endpit ? endpos : pars[pit].size() + 1); - bool const merge = pars[pit].isMergedOnEndOfParDeletion(params.trackChanges); + bool const merge = pars[pit].isMergedOnEndOfParDeletion(params.track_changes); // Logically erase only, including the end-of-paragraph character - pars[pit].eraseChars(left, right, params.trackChanges); + pars[pit].eraseChars(left, right, params.track_changes); // Separate handling of paragraph break: if (merge && pit != endpit && - (pit + 1 != endpit + (pit + 1 != endpit || pars[pit].hasSameLayout(pars[endpit]) || pars[endpit].size() == endpos)) { if (pit + 1 == endpit) @@ -476,33 +546,59 @@ PitPosPair eraseSelectionHelper(BufferParams const & params, } -void putClipboard(ParagraphList const & paragraphs, - DocumentClassConstPtr docclass, docstring const & plaintext) +Buffer * copyToTempBuffer(ParagraphList const & paragraphs, DocumentClassConstPtr docclass) { // This used to need to be static to avoid a memory leak. It no longer needs // 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. - static Buffer * staticbuffer = theBufferList().newInternalBuffer( - FileName::tempName("clipboard.internal").absFileName()); - - // These two things only really need doing the first time. - staticbuffer->setUnnamed(true); - staticbuffer->inset().setBuffer(*staticbuffer); - + static TempFile tempfile("clipboard.internal"); + tempfile.setAutoRemove(false); + // 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); + LASSERT(buffer, return 0); // This needs doing every time. + // Since setDocumentClass() causes deletion of the old document class + // we need to reset all layout pointers in paragraphs (otherwise they + // would be dangling). + ParIterator const end = buffer->par_iterator_end(); + for (ParIterator it = buffer->par_iterator_begin(); it != end; ++it) { + docstring const name = it->layout().name(); + if (docclass->hasLayout(name)) + it->setLayout((*docclass)[name]); + else + it->setPlainOrDefaultLayout(*docclass); + } buffer->params().setDocumentClass(docclass); // we will use pasteSelectionHelper to copy the paragraphs into the // 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) +{ + Buffer * buffer = copyToTempBuffer(paragraphs, docclass); + if (!buffer) // already asserted in copyToTempBuffer() + return; // We don't want to produce images that are not used. Therefore, // output formulas as MathML. Even if this is not understood by all @@ -571,8 +667,8 @@ void copySelectionHelper(Buffer const & buf, Text const & text, LASSERT(startpit != endpit || start <= end, return); // Clone the paragraphs within the selection. - ParagraphList copy_pars(boost::next(pars.begin(), startpit), - boost::next(pars.begin(), endpit + 1)); + ParagraphList copy_pars(lyx::next(pars.begin(), startpit), + lyx::next(pars.begin(), endpit + 1)); // Remove the end of the last paragraph; afterwards, remove the // beginning of the first paragraph. Keep this order - there may only @@ -597,7 +693,7 @@ void copySelectionHelper(Buffer const & buf, Text const & text, // latex_language. This is invalid for others, so we // need to change it to the buffer language. if (it->isPassThru()) - it->changeLanguage(buf.params(), + it->changeLanguage(buf.params(), latex_language, buf.language()); } @@ -613,16 +709,14 @@ void copySelectionHelper(Buffer const & buf, Text const & text, // are not linked to something else. it = copy_pars.begin(); for (; it != it_end; ++it) { - it->setBuffer(*static_cast(0)); + it->resetBuffer(); it->setInsetOwner(0); } cutstack.push(make_pair(copy_pars, dc)); } -} // namespace anon - - +} // namespace namespace cap { @@ -666,11 +760,11 @@ 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; } @@ -679,15 +773,15 @@ bool multipleCellsSelected(Cursor 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; } @@ -700,7 +794,7 @@ void switchBetweenClasses(DocumentClassConstPtr oldone, LBUFERR(!in.paragraphs().empty()); if (oldone == newone) return; - + DocumentClass const & oldtc = *oldone; DocumentClass const & newtc = *newone; @@ -721,8 +815,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()) @@ -731,35 +825,43 @@ void switchBetweenClasses(DocumentClassConstPtr oldone, it->setLayout(newtc[name]); } - // character styles + // 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) { - if (it->lyxCode() != FLEX_CODE) - // FIXME: Should we verify all InsetCollapsable? - continue; - - docstring const layoutName = it->layoutName(); - docstring const & n = newone->insetLayout(layoutName).name(); - bool const is_undefined = n.empty() || - n == DocumentClass::plainInsetLayout().name(); - if (!is_undefined) - continue; - - // The flex inset is undefined in newtc - docstring const oldname = from_utf8(oldtc.name()); - docstring const newname = from_utf8(newtc.name()); - docstring s; - if (oldname == newname) - s = bformat(_("Flex inset %1$s is undefined after " - "reloading `%2$s' layout."), layoutName, oldname); - else - s = bformat(_("Flex inset %1$s is undefined because of " - "conversion from `%2$s' layout to `%3$s'."), - 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)); + for (InsetIterator iit = inset_iterator_begin(in); iit != i_end; ++iit) { + InsetCode const code = iit->lyxCode(); + if (code == FLEX_CODE) { + // 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) + continue; + + // The flex inset is undefined in newtc + docstring const oldname = from_utf8(oldtc.name()); + docstring const newname = from_utf8(newtc.name()); + docstring s; + if (oldname == newname) + s = bformat(_("Flex inset %1$s is undefined after " + "reloading `%2$s' layout."), layoutName, oldname); + else + s = bformat(_("Flex inset %1$s is undefined because of " + "conversion from `%2$s' layout to `%3$s'."), + layoutName, oldname, newname); + // To warn the user that something had to be done. + errorlist.push_back(ErrorItem( + _("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 = iit->asInsetTabular(); + table->setLayoutForHiddenCells(newtc); + } } } @@ -776,22 +878,20 @@ vector availableSelections(Buffer const * buf) // we do not use cit-> here because gcc 2.9x does not // like it (JMarc) ParagraphList const & pars = (*cit).first; - docstring asciiSel; + docstring textSel; ParagraphList::const_iterator pit = pars.begin(); ParagraphList::const_iterator pend = pars.end(); for (; pit != pend; ++pit) { - Paragraph par(*pit, 0, 26); + Paragraph par(*pit, 0, 46); // adapt paragraph to current buffer. par.setBuffer(const_cast(*buf)); - asciiSel += par.asString(AS_STR_INSETS); - if (asciiSel.size() > 25) { - asciiSel.replace(22, docstring::npos, - from_ascii("...")); + textSel += par.asString(AS_STR_INSETS); + if (textSel.size() > 45) { + support::truncateWithEllipsis(textSel,45); break; } } - - selList.push_back(asciiSel); + selList.push_back(textSel); } return selList; @@ -803,8 +903,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()) @@ -832,21 +933,20 @@ 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)); } if (begpit != endpit) cur.screenUpdateFlags(Update::Force | 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) @@ -854,11 +954,6 @@ void cutSelection(Cursor & cur, bool doclear, bool realcut) cur.pos() = endpos; cur.pit() = endpit; - // sometimes necessary - if (doclear - && text->paragraphs()[begpit].stripLeadingSpaces(bp.trackChanges)) - cur.fixIfBroken(); - // need a valid cursor. (Lgb) cur.clearSelection(); @@ -888,6 +983,19 @@ 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) { @@ -928,20 +1036,11 @@ void copySelectionToStack(Cursor const & cur, CutStack & cutstack) LBUFERR(text); // ok we have a selection. This is always between cur.selBegin() // and sel_end cursor - - // copy behind a space if there is one - ParagraphList & pars = text->paragraphs(); - pos_type pos = cur.selBegin().pos(); - pit_type par = cur.selBegin().pit(); - while (pos < pars[par].size() && - pars[par].isLineSeparator(pos) && - (par != cur.selEnd().pit() || pos < cur.selEnd().pos())) - ++pos; - - copySelectionHelper(*cur.buffer(), *text, par, cur.selEnd().pit(), - pos, cur.selEnd().pos(), - cur.buffer()->params().documentClassPtr(), cutstack); - + copySelectionHelper(*cur.buffer(), *text, + cur.selBegin().pit(), cur.selEnd().pit(), + cur.selBegin().pos(), cur.selEnd().pos(), + cur.buffer()->params().documentClassPtr(), + cutstack); // Reset the dirty_tabular_stack_ flag only when something // is copied to the clipboard (not to the selectionBuffer). if (&cutstack == &theCuts) @@ -955,13 +1054,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())); } } -} +} // namespace void copySelectionToStack() @@ -971,6 +1073,12 @@ void copySelectionToStack() } +void copySelectionToTemp(Cursor & cur) +{ + copySelectionToStack(cur, tempCut); +} + + void copySelection(Cursor const & cur, docstring const & plaintext) { // In tablemode, because copy and paste actually use special table stack @@ -982,7 +1090,12 @@ void copySelection(Cursor const & cur, docstring const & plaintext) Paragraph par; BufferParams const & bp = cur.buffer()->params(); par.setLayout(bp.documentClass().plainLayout()); - par.insert(0, plaintext, Font(), Change(Change::UNCHANGED)); + // 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); theCuts.push(make_pair(pars, bp.documentClassPtr())); } else { @@ -999,7 +1112,7 @@ 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) << "'"); @@ -1023,29 +1136,37 @@ void clearSelection() void clearCutStack() { theCuts.clear(); + tempCut.clear(); } -docstring selection(size_t sel_index) +docstring selection(size_t sel_index, DocumentClassConstPtr docclass) { - return sel_index < theCuts.size() - ? theCuts[sel_index].first.back().asString(AS_STR_INSETS | AS_STR_NEWLINES) - : docstring(); + if (sel_index >= theCuts.size()) + return docstring(); + + unique_ptr buffer(copyToTempBuffer(theCuts[sel_index].first, + docclass)); + if (!buffer) + return docstring(); + + return buffer->paragraphs().back().asString(AS_STR_INSETS | AS_STR_NEWLINES); } void pasteParagraphList(Cursor & cur, ParagraphList const & parlist, - DocumentClassConstPtr docclass, ErrorList & errorList) + DocumentClassConstPtr docclass, ErrorList & errorList, + cap::BranchAction branchAction) { 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.par, prv.pos); + text->setCursor(cur, prv.pit, prv.pos); } // mathed is handled in InsetMathNest/InsetMathGrid @@ -1061,7 +1182,20 @@ 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, 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, errorList, BRANCH_IGNORE); return true; } @@ -1122,6 +1256,10 @@ bool pasteClipboardText(Cursor & cur, ErrorList & errorList, bool asParagraphs, 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); @@ -1140,6 +1278,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; } @@ -1169,7 +1308,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 @@ -1222,17 +1361,17 @@ void replaceSelectionWithString(Cursor & cur, docstring const & str) 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().trackChanges); + par.insertChar(pos, *cit, font, cur.buffer()->params().track_changes); // Cut the selection - cutSelection(cur, true, false); + cutSelection(cur, false); } void replaceSelection(Cursor & cur) { if (cur.selection()) - cutSelection(cur, true, false); + cutSelection(cur, false); } @@ -1241,31 +1380,43 @@ void eraseSelection(Cursor & cur) //lyxerr << "cap::eraseSelection begin: " << cur << endl; CursorSlice const & i1 = cur.selBegin(); CursorSlice const & i2 = cur.selEnd(); - if (i1.inset().asInsetMath()) { - saveSelection(cur); - cur.top() = i1; - if (i1.idx() == i2.idx()) { - i1.cell().erase(i1.pos(), i2.pos()); - // We may have deleted i1.cell(cur.pos()). - // Make sure that pos is valid. - if (cur.pos() > cur.lastpos()) - cur.pos() = cur.lastpos(); - } else { - InsetMath * p = i1.asInsetMath(); - Inset::row_type r1, r2; - Inset::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) - p->cell(p->index(row, col)).clear(); - // We've deleted the whole cell. Only pos 0 is valid. - cur.pos() = 0; - } - // need a valid cursor. (Lgb) - cur.clearSelection(); + if (!i1.asInsetMath()) { + LYXERR0("Can't erase this selection"); + return; + } + + saveSelection(cur); + cur.top() = i1; + InsetMath * p = i1.asInsetMath(); + if (i1.idx() == i2.idx()) { + i1.cell().erase(i1.pos(), i2.pos()); + // We may have deleted i1.cell(cur.pos()). + // Make sure that pos is valid. + if (cur.pos() > cur.lastpos()) + 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; + 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) + p->cell(p->index(row, col)).clear(); + // We've deleted the whole cell. Only pos 0 is valid. + cur.pos() = 0; } else { - lyxerr << "can't erase this selection 1" << endl; + Inset::idx_type idx1 = i1.idx(); + Inset::idx_type idx2 = i2.idx(); + if (idx1 > idx2) + swap(idx1, idx2); + for (Inset::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; } + + // need a valid cursor. (Lgb) + cur.clearSelection(); //lyxerr << "cap::eraseSelection end: " << cur << endl; } @@ -1284,7 +1435,7 @@ void selClearOrDel(Cursor & cur) if (lyxrc.auto_region_delete) selDel(cur); else - cur.setSelection(false); + cur.selection(false); }