X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FCutAndPaste.C;h=e554ac6311098839dcff14ca605c8e4445001370;hb=52eb91c94fb70d58dceef430659c8781de2eccda;hp=bc9afbe980afb2b18f7ae7034cb49720b82ce296;hpb=2c0d4b31ee7b27ba9273211d76c910d8420259f0;p=lyx.git

diff --git a/src/CutAndPaste.C b/src/CutAndPaste.C
index bc9afbe980..e554ac6311 100644
--- a/src/CutAndPaste.C
+++ b/src/CutAndPaste.C
@@ -6,6 +6,7 @@
  * \author Jürgen Vigna
  * \author Lars Gullik Bjønnes
  * \author Alfredo Braunstein
+ * \author Michael Gerz
  *
  * Full author contact details are available in file CREDITS.
  */
@@ -25,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"
 
@@ -45,14 +46,12 @@
 #include "support/lstrings.h"
 
 #include "frontends/Clipboard.h"
+#include "frontends/Selection.h"
 
+#include <boost/current_function.hpp>
 #include <boost/tuple/tuple.hpp>
 
-
-namespace lyx {
-
-using support::bformat;
-using frontend::Clipboard;
+#include <string>
 
 using std::endl;
 using std::for_each;
@@ -62,6 +61,11 @@ using std::vector;
 using std::string;
 
 
+namespace lyx {
+
+using support::bformat;
+using frontend::Clipboard;
+
 namespace {
 
 typedef std::pair<pit_type, int> PitPosPair;
@@ -69,31 +73,13 @@ typedef std::pair<pit_type, int> PitPosPair;
 typedef limited_stack<pair<ParagraphList, textclass_type> > 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_;
-
-class resetParagraph : public std::unary_function<Paragraph, Buffer const &> {
-public:
-	resetParagraph(Buffer const & b) : buffer_(b) {}
-	void operator()(Paragraph & p) const {
-		// FIXME: change tracking (MG)
-		// set p's text to INSERTED in CT mode; clear CT info otherwise
-
-		// ERT paragraphs have the Language latex_language.
-		// This is invalid outside of ERT, so we need to change it
-		// to the buffer language.
-		if (p.ownerCode() == InsetBase::ERT_CODE) {
-			p.changeLanguage(buffer_.params(), latex_language,
-					 buffer_.getLanguage());
-		}
-		p.setInsetOwner(0);
-	}
-private:
-	Buffer const & buffer_;
-};
+bool dirty_tabular_stack_ = false;
 
 
 void region(CursorSlice const & i1, CursorSlice const & i2,
@@ -147,7 +133,7 @@ pasteSelectionHelper(LCursor & cur, ParagraphList const & parlist,
 			for (pos_type j = 0; j < insertion[i].size(); ++j) {
 				if (insertion[i].isNewline(j)) {
 					// do not track deletion of newline
-					insertion[i].erase(j, false);
+					insertion[i].eraseChar(j, false);
 					breakParagraphConservative(
 							buffer.params(),
 							insertion, i, j);
@@ -207,11 +193,11 @@ pasteSelectionHelper(LCursor & cur, ParagraphList const & parlist,
 			if (tmpbuf->getChar(i) == Paragraph::META_INSET &&
 			    !pars[pit].insetAllowed(tmpbuf->getInset(i)->lyxCode()))
 				// do not track deletion of invalid insets
-				tmpbuf->erase(i--, false);
+				tmpbuf->eraseChar(i--, false);
 		}
 
-		// FIXME: Change tracking (MG)
-		// set tmpbuf's text to INSERTED in CT mode; clear CT info otherwise
+		tmpbuf->setChange(Change(buffer.params().trackChanges ?
+		                         Change::INSERTED : Change::UNCHANGED));
 	}
 
 	bool const empty = pars[pit].empty();
@@ -229,8 +215,8 @@ pasteSelectionHelper(LCursor & cur, ParagraphList const & parlist,
 	ParIterator fend = par_iterator_end(in);
 
 	for (; fpit != fend; ++fpit) {
-		InsetList::iterator lit = fpit->insetlist.begin();
-		InsetList::iterator eit = fpit->insetlist.end();
+		InsetList::const_iterator lit = fpit->insetlist.begin();
+		InsetList::const_iterator eit = fpit->insetlist.end();
 
 		for (; lit != eit; ++lit) {
 			switch (lit->inset->lyxCode()) {
@@ -287,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,31 +293,26 @@ PitPosPair eraseSelectionHelper(BufferParams const & params,
 		return PitPosPair(endpit, endpos);
 
 	// Start and end is inside same paragraph
-	if (endpit == pit_type(pars.size()) ||
-	    startpit == endpit) {
-		endpos -= pars[startpit].erase(startpos, endpos);
+	if (endpit == pit_type(pars.size()) || startpit == endpit) {
+		endpos -= pars[startpit].eraseChars(startpos, endpos, params.trackChanges);
 		return PitPosPair(endpit, endpos);
 	}
 
-	// A paragraph break has to be physically removed by merging, but
-	// only if either (1) change tracking is off, or (2) the para break
-	// is "blue"
 	for (pit_type pit = startpit; pit != endpit + 1;) {
-		// FIXME: Change tracking (MG)
-		bool const merge = !params.trackChanges ||
-			pars[pit].lookupChange(pars[pit].size()) ==
-			Change(Change::INSERTED);
-		pos_type const left  = ( pit == startpit ? startpos : 0 );
-		pos_type const right = ( pit == endpit ? endpos :
-				pars[pit].size() + 1 );
-		// Logical erase only:
-		pars[pit].erase(left, right);
-		// Separate handling of para break:
+		pos_type const left  = (pit == startpit ? startpos : 0);
+		pos_type const right = (pit == endpit ? endpos : pars[pit].size() + 1);
+
+		bool const merge = pars[pit].isMergedOnEndOfParDeletion(params.trackChanges);
+
+		// Logically erase only, including the end-of-paragraph character
+		pars[pit].eraseChars(left, right, params.trackChanges);
+
+		// Separate handling of paragraph break:
 		if (merge && pit != endpit &&
-		   (pit + 1 != endpit || pars[pit].hasSameLayout(pars[pit + 1]))) {
+		    (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)
@@ -347,29 +328,66 @@ 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));
+
+	// 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);
 
-	for_each(paragraphs.begin(), paragraphs.end(), resetParagraph(buf));
+	ParagraphList::iterator it = copy_pars.begin();
+	ParagraphList::iterator it_end = copy_pars.end();
 
-	// Cut out the end of the last paragraph.
-	Paragraph & back = paragraphs.back();
-	back.erase(end, back.size());
+	for (; it != it_end; it++) {
+		// ERT paragraphs have the Language latex_language.
+		// This is invalid outside of ERT, so we need to change it
+		// to the buffer language.
+		if (it->ownerCode() == InsetBase::ERT_CODE) {
+			it->changeLanguage(buf.params(), latex_language,
+			                   buf.getLanguage());
+		}
+		it->setInsetOwner(0);
+	}
 
-	// Cut out the begin of the first paragraph
-	Paragraph & front = paragraphs.front();
-	front.erase(0, start);
+	// 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());
 
-	theCuts.push(make_pair(paragraphs, tc));
+	cutstack.push(make_pair(copy_pars, tc));
 }
 
 } // namespace anon
@@ -379,11 +397,11 @@ void copySelectionHelper(Buffer const & buf, ParagraphList & pars,
 
 namespace cap {
 
-string grabAndEraseSelection(LCursor & cur)
+docstring grabAndEraseSelection(LCursor & cur)
 {
 	if (!cur.selection())
-		return string();
-	string res = grabSelection(cur);
+		return docstring();
+	docstring res = grabSelection(cur);
 	eraseSelection(cur);
 	return res;
 }
@@ -502,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);
@@ -526,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) =
@@ -536,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);
@@ -573,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;
@@ -590,28 +609,82 @@ 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()) {
 		//lyxerr << "copySelection in mathed" << endl;
 		ParagraphList pars;
-		pars.push_back(Paragraph());
+		Paragraph par;
 		BufferParams const & bp = cur.buffer().params();
-		pars.back().layout(bp.getLyXTextClass().defaultLayout());
-		for_each(pars.begin(), pars.end(), resetParagraph(cur.buffer()));
-		// FIXME: change tracking (MG)
-		pars.back().insert(0, grabSelection(cur), LyXFont(), Change(Change::UNCHANGED));
-		theCuts.push(make_pair(pars, bp.textclass));
+		par.layout(bp.getLyXTextClass().defaultLayout());
+		par.insert(0, grabSelection(cur), LyXFont(), Change(Change::UNCHANGED));
+		pars.push_back(par);
+		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();
 }
 
 
@@ -630,8 +703,6 @@ void pasteParagraphList(LCursor & cur, ParagraphList const & parlist,
 		LyXText * text = cur.text();
 		BOOST_ASSERT(text);
 
-		recordUndo(cur);
-
 		pit_type endpit;
 		PitPosPair ppp;
 
@@ -640,7 +711,7 @@ void pasteParagraphList(LCursor & cur, ParagraphList const & parlist,
 					     textclass, errorList);
 		updateLabels(cur.buffer());
 		cur.clearSelection();
-		text->setCursor(cur, ppp.first, ppp.second);
+		text->setCursor(cur.top(), ppp.first, ppp.second);
 	}
 
 	// mathed is handled in InsetMathNest/InsetMathGrid
@@ -648,20 +719,70 @@ 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))
 		return;
 
+	recordUndo(cur);
 	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, string const & str, bool backwards)
+void replaceSelectionWithString(LCursor & cur, docstring const & str, bool backwards)
 {
 	recordUndo(cur);
 	DocIterator selbeg = cur.selectionBegin();
@@ -673,10 +794,10 @@ void replaceSelectionWithString(LCursor & cur, string const & str, bool backward
 	// Insert the new string
 	pos_type pos = cur.selEnd().pos();
 	Paragraph & par = cur.selEnd().paragraph();
-	string::const_iterator cit = str.begin();
-	string::const_iterator end = str.end();
+	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().trackChanges);
 
 	// Cut the selection
 	cutSelection(cur, true, false);
@@ -687,6 +808,7 @@ void replaceSelectionWithString(LCursor & cur, string const & str, bool backward
 		cur.setSelection(selbeg, -int(str.length()));
 	} else
 		cur.setSelection(selbeg, str.length());
+	saveSelection(cur);
 }
 
 
@@ -699,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()) {
@@ -723,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);
 }
@@ -740,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
@@ -748,10 +871,10 @@ void selClearOrDel(LCursor & cur)
 }
 
 
-string grabSelection(LCursor const & cur)
+docstring grabSelection(LCursor const & cur)
 {
 	if (!cur.selection())
-		return string();
+		return docstring();
 
 	// FIXME: What is wrong with the following?
 #if 0
@@ -770,7 +893,7 @@ string grabSelection(LCursor const & cur)
 			MathArray::const_iterator it = i1.cell().begin();
 			return asString(MathArray(it + i1.pos(), it + i2.pos()));
 		} else {
-			return "unknown selection 1";
+			return from_ascii("unknown selection 1");
 		}
 	}
 
@@ -778,7 +901,7 @@ string grabSelection(LCursor const & cur)
 	InsetBase::col_type c1, c2;
 	region(i1, i2, r1, r2, c1, c2);
 
-	string data;
+	docstring data;
 	if (i1.inset().asInsetMath()) {
 		for (InsetBase::row_type row = r1; row <= r2; ++row) {
 			if (row > r1)
@@ -791,7 +914,7 @@ string grabSelection(LCursor const & cur)
 			}
 		}
 	} else {
-		data = "unknown selection 2";
+		data = from_ascii("unknown selection 2");
 	}
 	return data;
 }