X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FCutAndPaste.C;h=e554ac6311098839dcff14ca605c8e4445001370;hb=52eb91c94fb70d58dceef430659c8781de2eccda;hp=da644856b9e3bb06563eca21ce621699e131d7b3;hpb=b2126408cfeaa251bc966e3df49a7000a202add3;p=lyx.git diff --git a/src/CutAndPaste.C b/src/CutAndPaste.C index da644856b9..e554ac6311 100644 --- a/src/CutAndPaste.C +++ b/src/CutAndPaste.C @@ -26,13 +26,13 @@ #include "insetiterator.h" #include "language.h" #include "lfuns.h" +#include "lyxfunc.h" #include "lyxrc.h" #include "lyxtext.h" #include "lyxtextclasslist.h" #include "paragraph.h" #include "paragraph_funcs.h" #include "ParagraphParameters.h" -#include "ParagraphList_fwd.h" #include "pariterator.h" #include "undo.h" @@ -46,14 +46,12 @@ #include "support/lstrings.h" #include "frontends/Clipboard.h" +#include "frontends/Selection.h" +#include #include - -namespace lyx { - -using support::bformat; -using frontend::Clipboard; +#include using std::endl; using std::for_each; @@ -63,6 +61,11 @@ using std::vector; using std::string; +namespace lyx { + +using support::bformat; +using frontend::Clipboard; + namespace { typedef std::pair PitPosPair; @@ -70,11 +73,13 @@ typedef std::pair PitPosPair; typedef limited_stack > CutStack; CutStack theCuts(10); +// persistent selection, cleared until the next selection +CutStack selectionBuffer(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, // when we (hopefully) have a one-for-all paste mechanism. -bool dirty_tabular_stack_; +bool dirty_tabular_stack_ = false; void region(CursorSlice const & i1, CursorSlice const & i2, @@ -268,7 +273,7 @@ pasteSelectionHelper(LCursor & cur, ParagraphList const & parlist, pars[last_paste].makeSameLayout(pars[last_paste + 1]); mergeParagraph(buffer.params(), pars, last_paste); } else { - pars[last_paste + 1].stripLeadingSpaces(); + pars[last_paste + 1].stripLeadingSpaces(buffer.params().trackChanges); ++last_paste; } } @@ -307,7 +312,7 @@ PitPosPair eraseSelectionHelper(BufferParams const & params, (pit + 1 != endpit || pars[pit].hasSameLayout(pars[pit + 1]))) { pos_type const thissize = pars[pit].size(); if (doclear) - pars[pit + 1].stripLeadingSpaces(); + pars[pit + 1].stripLeadingSpaces(params.trackChanges); mergeParagraph(params, pars, pit); --endpit; if (pit == endpit) @@ -323,20 +328,45 @@ PitPosPair eraseSelectionHelper(BufferParams const & params, } +void putClipboard(ParagraphList const & paragraphs, textclass_type textclass, + docstring const & plaintext) +{ + // For some strange reason gcc 3.2 and 3.3 do not accept + // Buffer buffer(string(), false); + Buffer buffer("", false); + buffer.setUnnamed(true); + buffer.paragraphs() = paragraphs; + buffer.params().textclass = textclass; + std::ostringstream lyx; + if (buffer.write(lyx)) + theClipboard().put(lyx.str(), plaintext); + else + theClipboard().put(string(), plaintext); +} + + void copySelectionHelper(Buffer const & buf, ParagraphList & pars, pit_type startpit, pit_type endpit, - int start, int end, textclass_type tc) + int start, int end, textclass_type tc, CutStack & cutstack) { BOOST_ASSERT(0 <= start && start <= pars[startpit].size()); BOOST_ASSERT(0 <= end && end <= pars[endpit].size()); BOOST_ASSERT(startpit != endpit || start <= end); // Clone the paragraphs within the selection. - ParagraphList paragraphs(boost::next(pars.begin(), startpit), - boost::next(pars.begin(), endpit + 1)); + ParagraphList copy_pars(boost::next(pars.begin(), startpit), + boost::next(pars.begin(), endpit + 1)); - ParagraphList::iterator it = paragraphs.begin(); - ParagraphList::iterator it_end = paragraphs.end(); + // Remove the end of the last paragraph; afterwards, remove the beginning + // of the first paragraph. Keep this order - there may only be one paragraph! + // Do not track deletions here; this is an internal action not visible to the user + Paragraph & back = copy_pars.back(); + back.eraseChars(end, back.size(), false); + 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++) { // ERT paragraphs have the Language latex_language. @@ -349,17 +379,15 @@ void copySelectionHelper(Buffer const & buf, ParagraphList & pars, it->setInsetOwner(0); } - // Cut out the end of the last paragraph. - Paragraph & back = paragraphs.back(); - // do not track deletion here; it is an internal action not visible to the user - back.eraseChars(end, back.size(), false); + // do not copy text (also nested in insets) which is marked as deleted + // acceptChanges() is defined for LyXText rather than ParagraphList + // Thus we must wrap copy_pars into a LyXText object and cross our fingers + LyXText lt; + copy_pars.swap(lt.paragraphs()); + lt.acceptChanges(buf.params()); + copy_pars.swap(lt.paragraphs()); - // Cut out the begin of the first paragraph - Paragraph & front = paragraphs.front(); - // again, do not track deletion - front.eraseChars(0, start, false); - - theCuts.push(make_pair(paragraphs, tc)); + cutstack.push(make_pair(copy_pars, tc)); } } // namespace anon @@ -492,16 +520,6 @@ void cutSelection(LCursor & cur, bool doclear, bool realcut) if (cur.inTexted()) { LyXText * text = cur.text(); BOOST_ASSERT(text); - // Stuff what we got on the clipboard. Even if there is no selection. - - // There is a problem with having the stuffing here in that the - // larger the selection the slower LyX will get. This can be - // solved by running the line below only when the selection has - // finished. The solution used currently just works, to make it - // faster we need to be more clever and probably also have more - // calls to theSelection().put. (Lgb) -// theSelection().put(cur.selectionAsString(true)); - // make sure that the depth behind the selection are restored, too recordUndoSelection(cur); @@ -516,7 +534,11 @@ void cutSelection(LCursor & cur, bool doclear, bool realcut) text->paragraphs(), begpit, endpit, cur.selBegin().pos(), endpos, - bp.textclass); + bp.textclass, theCuts); + // Stuff what we got on the clipboard. + // Even if there is no selection. + putClipboard(theCuts[0].first, theCuts[0].second, + cur.selectionAsString(true)); } boost::tie(endpit, endpos) = @@ -526,19 +548,21 @@ void cutSelection(LCursor & cur, bool doclear, bool realcut) cur.selBegin().pos(), endpos, doclear); - // sometimes necessary - if (doclear) - text->paragraphs()[begpit].stripLeadingSpaces(); - // cutSelection can invalidate the cursor so we need to set // it anew. (Lgb) // we prefer the end for when tracking changes 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(); updateLabels(cur.buffer()); + theSelection().haveSelection(false); // tell tabular that a recent copy happened dirtyTabularStack(false); @@ -563,9 +587,14 @@ void cutSelection(LCursor & cur, bool doclear, bool realcut) void copySelection(LCursor & cur) { - // stuff the selection onto the X clipboard, from an explicit copy request - theClipboard().put(cur.selectionAsString(true)); + copySelection(cur, cur.selectionAsString(true)); +} + +namespace { + +void copySelectionToStack(LCursor & cur, CutStack & cutstack) +{ // this doesn't make sense, if there is no selection if (!cur.selection()) return; @@ -580,13 +609,13 @@ void copySelection(LCursor & cur) 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())) + while (pos < pars[par].size() && + pars[par].isLineSeparator(pos) && + (par != cur.selEnd().pit() || pos < cur.selEnd().pos())) ++pos; copySelectionHelper(cur.buffer(), pars, par, cur.selEnd().pit(), - pos, cur.selEnd().pos(), cur.buffer().params().textclass); + pos, cur.selEnd().pos(), cur.buffer().params().textclass, cutstack); } if (cur.inMathed()) { @@ -597,10 +626,65 @@ void copySelection(LCursor & cur) par.layout(bp.getLyXTextClass().defaultLayout()); par.insert(0, grabSelection(cur), LyXFont(), Change(Change::UNCHANGED)); pars.push_back(par); - theCuts.push(make_pair(pars, bp.textclass)); + cutstack.push(make_pair(pars, bp.textclass)); } - // tell tabular that a recent copy happened - dirtyTabularStack(false); +} + +} + + +void copySelectionToStack() +{ + if (!selectionBuffer.empty()) + theCuts.push(selectionBuffer[0]); +} + + +void copySelection(LCursor & cur, docstring const & plaintext) +{ + // In tablemode, because copy and paste actually use special table stack + // we do not attemp 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. + if (cur.selBegin().idx() != cur.selEnd().idx()) { + ParagraphList pars; + Paragraph par; + BufferParams const & bp = cur.buffer().params(); + par.layout(bp.getLyXTextClass().defaultLayout()); + par.insert(0, plaintext, LyXFont(), Change(Change::UNCHANGED)); + pars.push_back(par); + theCuts.push(make_pair(pars, bp.textclass)); + } else + copySelectionToStack(cur, theCuts); + + // stuff the selection onto the X clipboard, from an explicit copy request + putClipboard(theCuts[0].first, theCuts[0].second, plaintext); +} + + +void saveSelection(LCursor & cur) +{ + if (lyxerr.debugging(Debug::ACTION)) + lyxerr << BOOST_CURRENT_FUNCTION << ": `" + << to_utf8(cur.selectionAsString(true)) << "'." + << endl; + + if (cur.selection()) + copySelectionToStack(cur, selectionBuffer); + // tell X whether we now have a valid selection + theSelection().haveSelection(cur.selection()); +} + + +bool selection() +{ + return !selectionBuffer.empty(); +} + + +void clearSelection() +{ + selectionBuffer.clear(); } @@ -635,7 +719,7 @@ void pasteParagraphList(LCursor & cur, ParagraphList const & parlist, } -void pasteSelection(LCursor & cur, ErrorList & errorList, size_t sel_index) +void pasteFromStack(LCursor & cur, ErrorList & errorList, size_t sel_index) { // this does not make sense, if there is nothing to paste if (!checkPastePossible(sel_index)) @@ -645,10 +729,59 @@ void pasteSelection(LCursor & cur, ErrorList & errorList, size_t sel_index) pasteParagraphList(cur, theCuts[sel_index].first, theCuts[sel_index].second, errorList); cur.setSelection(); + saveSelection(cur); +} + + +void pasteClipboard(LCursor & cur, ErrorList & errorList, bool asParagraphs) +{ + // Use internal clipboard if it is the most recent one + if (theClipboard().isInternal()) { + pasteFromStack(cur, errorList, 0); + return; + } + + // First try LyX format + if (theClipboard().hasLyXContents()) { + 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.setUnnamed(true); + if (buffer.readString(lyx)) { + recordUndo(cur); + pasteParagraphList(cur, buffer.paragraphs(), + buffer.params().textclass, errorList); + cur.setSelection(); + return; + } + } + } + + // Then try plain text + docstring const text = theClipboard().getAsText(); + if (text.empty()) + return; + recordUndo(cur); + if (asParagraphs) + cur.text()->insertStringAsParagraphs(cur, text); + else + cur.text()->insertStringAsLines(cur, text); +} + + +void pasteSelection(LCursor & cur, ErrorList & errorList) +{ + if (selectionBuffer.empty()) + return; + recordUndo(cur); + pasteParagraphList(cur, selectionBuffer[0].first, + selectionBuffer[0].second, errorList); + cur.setSelection(); } -// simple replacing. The font of the first selected character is used void replaceSelectionWithString(LCursor & cur, docstring const & str, bool backwards) { recordUndo(cur); @@ -675,6 +808,7 @@ void replaceSelectionWithString(LCursor & cur, docstring const & str, bool backw cur.setSelection(selbeg, -int(str.length())); } else cur.setSelection(selbeg, str.length()); + saveSelection(cur); } @@ -687,7 +821,7 @@ void replaceSelection(LCursor & cur) void eraseSelection(LCursor & cur) { - //lyxerr << "LCursor::eraseSelection begin: " << cur << endl; + //lyxerr << "cap::eraseSelection begin: " << cur << endl; CursorSlice const & i1 = cur.selBegin(); CursorSlice const & i2 = cur.selEnd(); if (i1.inset().asInsetMath()) { @@ -711,16 +845,17 @@ void eraseSelection(LCursor & cur) } // need a valid cursor. (Lgb) cur.clearSelection(); + theSelection().haveSelection(false); } else { lyxerr << "can't erase this selection 1" << endl; } - //lyxerr << "LCursor::eraseSelection end: " << cur << endl; + //lyxerr << "cap::eraseSelection end: " << cur << endl; } void selDel(LCursor & cur) { - //lyxerr << "LCursor::selDel" << endl; + //lyxerr << "cap::selDel" << endl; if (cur.selection()) eraseSelection(cur); } @@ -728,7 +863,7 @@ void selDel(LCursor & cur) void selClearOrDel(LCursor & cur) { - //lyxerr << "LCursor::selClearOrDel" << endl; + //lyxerr << "cap::selClearOrDel" << endl; if (lyxrc.auto_region_delete) selDel(cur); else