X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FCutAndPaste.C;h=af8912c0fdb78b3f5f791c07f3100d3440f25f78;hb=87cd77d1fc819bc8f14982fc6b20091720c011f5;hp=627067bcee7ae07c9e1d535cabe92596084643ce;hpb=b881ed2d5a4d26b062556d6d417c8f4624741878;p=lyx.git

diff --git a/src/CutAndPaste.C b/src/CutAndPaste.C
index 627067bcee..af8912c0fd 100644
--- a/src/CutAndPaste.C
+++ b/src/CutAndPaste.C
@@ -3,7 +3,7 @@
  * This file is part of LyX, the document processor.
  * Licence details can be found in the file COPYING.
  *
- * \author Juergen Vigna
+ * \author Jürgen Vigna
  * \author Lars Gullik Bjønnes
  * \author Alfredo Braunstein
  *
@@ -13,127 +13,278 @@
 #include <config.h>
 
 #include "CutAndPaste.h"
-#include "BufferView.h"
+
 #include "buffer.h"
+#include "buffer_funcs.h"
+#include "bufferparams.h"
+#include "BufferView.h"
+#include "cursor.h"
+#include "debug.h"
 #include "errorlist.h"
-#include "paragraph.h"
-#include "ParagraphParameters.h"
+#include "funcrequest.h"
+#include "gettext.h"
+#include "lfuns.h"
+#include "lyxrc.h"
 #include "lyxtext.h"
-#include "lyxcursor.h"
-#include "iterators.h"
 #include "lyxtextclasslist.h"
-#include "undo_funcs.h"
-#include "gettext.h"
+#include "paragraph.h"
 #include "paragraph_funcs.h"
-#include "debug.h"
-#include "insets/insetinclude.h"
+#include "ParagraphParameters.h"
+#include "ParagraphList_fwd.h"
+#include "pariterator.h"
+#include "undo.h"
+
 #include "insets/insettabular.h"
 
-#include "support/LAssert.h"
+#include "mathed/math_data.h"
+#include "mathed/math_inset.h"
+#include "mathed/math_support.h"
+
 #include "support/lstrings.h"
-#include "support/limited_stack.h"
+
+#include <boost/tuple/tuple.hpp>
+
+using lyx::pos_type;
+using lyx::pit_type;
+using lyx::textclass_type;
+
+using lyx::support::bformat;
 
 using std::endl;
-using std::pair;
-using std::make_pair;
 using std::for_each;
+using std::make_pair;
+using std::pair;
 using std::vector;
+using std::string;
 
-using namespace lyx::support;
-using lyx::pos_type;
-using lyx::textclass_type;
 
+namespace {
+
+typedef std::pair<lyx::pit_type, int> PitPosPair;
 
 typedef limited_stack<pair<ParagraphList, textclass_type> > CutStack;
 
-namespace {
+CutStack theCuts(10);
 
-CutStack cuts(10);
+class resetOwnerAndChanges : public std::unary_function<Paragraph, void> {
+public:
+	void operator()(Paragraph & p) const {
+		p.cleanChanges();
+		p.setInsetOwner(0);
+	}
+};
 
-} // namespace anon
 
+void region(CursorSlice const & i1, CursorSlice const & i2,
+	InsetBase::row_type & r1, InsetBase::row_type & r2,
+	InsetBase::col_type & c1, InsetBase::col_type & c2)
+{
+	InsetBase & p = i1.inset();
+	c1 = p.col(i1.idx());
+	c2 = p.col(i2.idx());
+	if (c1 > c2)
+		std::swap(c1, c2);
+	r1 = p.row(i1.idx());
+	r2 = p.row(i2.idx());
+	if (r1 > r2)
+		std::swap(r1, r2);
+}
 
-std::vector<string>
-CutAndPaste::availableSelections(Buffer const & buffer)
+
+bool checkPastePossible(int index)
 {
-	vector<string> selList;
+	return size_t(index) < theCuts.size() && !theCuts[index].first.empty();
+}
 
-	CutStack::const_iterator cit = cuts.begin();
-	CutStack::const_iterator end = cuts.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;
-		string asciiSel;
-		ParagraphList::const_iterator pit = pars.begin();
-		ParagraphList::const_iterator pend = pars.end();
-		for (; pit != pend; ++pit) {
-			asciiSel += pit->asString(buffer, false);
-			if (asciiSel.size() > 25) {
-				asciiSel.replace(22, string::npos, "...");
+
+pair<PitPosPair, pit_type>
+pasteSelectionHelper(Buffer const & buffer, ParagraphList & pars,
+	pit_type pit, int pos,
+	textclass_type tc, size_t cut_index, ErrorList & errorlist)
+{
+	if (!checkPastePossible(cut_index))
+		return make_pair(PitPosPair(pit, pos), pit);
+
+	BOOST_ASSERT (pos <= pars[pit].size());
+
+	// Make a copy of the CaP paragraphs.
+	ParagraphList insertion = theCuts[cut_index].first;
+	textclass_type const textclass = theCuts[cut_index].second;
+
+	// Now remove all out of the pars which is NOT allowed in the
+	// new environment and set also another font if that is required.
+
+	// Convert newline to paragraph break in ERT inset.
+	// This should not be here!
+	if (pars[pit].inInset() &&
+	    pars[pit].inInset()->lyxCode() == InsetBase::ERT_CODE) {
+		for (ParagraphList::size_type i = 0; i < insertion.size(); ++i) {
+			for (pos_type j = 0; j < insertion[i].size(); ++j) {
+				if (insertion[i].isNewline(j)) {
+					insertion[i].erase(j);
+					breakParagraphConservative(
+							buffer.params(),
+							insertion, i, j);
+				}
+			}
+		}
+	}
+
+	// Make sure there is no class difference.
+	lyx::cap::SwitchLayoutsBetweenClasses(textclass, tc, insertion,
+				    errorlist);
+
+	ParagraphList::iterator tmpbuf = insertion.begin();
+	int depth_delta = pars[pit].params().depth() - tmpbuf->params().depth();
+
+	Paragraph::depth_type max_depth = pars[pit].getMaxDepthAfter();
+
+	for (; tmpbuf != insertion.end(); ++tmpbuf) {
+		// If we have a negative jump so that the depth would
+		// go below 0 depth then we have to redo the delta to
+		// this new max depth level so that subsequent
+		// paragraphs are aligned correctly to this paragraph
+		// at level 0.
+		if (int(tmpbuf->params().depth()) + depth_delta < 0)
+			depth_delta = 0;
+
+		// Set the right depth so that we are not too deep or shallow.
+		tmpbuf->params().depth(tmpbuf->params().depth() + depth_delta);
+		if (tmpbuf->params().depth() > max_depth)
+			tmpbuf->params().depth(max_depth);
+
+		// Only set this from the 2nd on as the 2nd depends
+		// for maxDepth still on pit.
+		if (tmpbuf != insertion.begin())
+			max_depth = tmpbuf->getMaxDepthAfter();
+
+		// Set the inset owner of this paragraph.
+		tmpbuf->setInsetOwner(pars[pit].inInset());
+		for (pos_type i = 0; i < tmpbuf->size(); ++i) {
+			if (tmpbuf->getChar(i) == Paragraph::META_INSET &&
+			    !pars[pit].insetAllowed(tmpbuf->getInset(i)->lyxCode()))
+				tmpbuf->erase(i--);
+		}
+	}
+
+	bool const empty = pars[pit].empty();
+	if (!empty) {
+		// Make the buf exactly the same layout as the cursor
+		// paragraph.
+		insertion.begin()->makeSameLayout(pars[pit]);
+	}
+
+	// Prepare the paragraphs and insets for insertion.
+	// A couple of insets store buffer references so need updating.
+	InsetText in;
+	std::swap(in.paragraphs(), insertion);
+
+	ParIterator fpit = par_iterator_begin(in);
+	ParIterator fend = par_iterator_end(in);
+
+	for (; fpit != fend; ++fpit) {
+		InsetList::iterator lit = fpit->insetlist.begin();
+		InsetList::iterator eit = fpit->insetlist.end();
+
+		for (; lit != eit; ++lit) {
+			switch (lit->inset->lyxCode()) {
+			case InsetBase::TABULAR_CODE: {
+				InsetTabular * it = static_cast<InsetTabular*>(lit->inset);
+				it->buffer(&buffer);
 				break;
 			}
+
+			default:
+				break; // nothing
+			}
 		}
+	}
+	std::swap(in.paragraphs(), insertion);
 
-		selList.push_back(asciiSel);
+	// Split the paragraph for inserting the buf if necessary.
+	if (!empty)
+		breakParagraphConservative(buffer.params(), pars, pit, pos);
+
+	// Paste it!
+	if (empty) {
+		pars.insert(pars.begin() + 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(pars.begin() + pit + 1, insertion.begin(),
+		            insertion.end());
+
+		// merge the first par of the insertion with the current par
+		mergeParagraph(buffer.params(), pars, pit);
 	}
 
-	return selList;
-}
+	pit_type last_paste = pit + insertion.size() - 1;
 
+	// Store the new cursor position.
+	pit = last_paste;
+	pos = pars[last_paste].size();
 
-PitPosPair CutAndPaste::cutSelection(BufferParams const & params,
-				     ParagraphList & pars,
-				     ParagraphList::iterator startpit,
-				     ParagraphList::iterator endpit,
-				     int startpos, int endpos,
-				     textclass_type tc, bool doclear)
-{
-	copySelection(startpit, endpit, startpos, endpos, tc);
-	return eraseSelection(params, pars, startpit, endpit, startpos,
-			      endpos, doclear);
+	// Maybe some pasting.
+	if (!empty && last_paste + 1 != pit_type(pars.size())) {
+		if (pars[last_paste + 1].hasSameLayout(pars[last_paste])) {
+			mergeParagraph(buffer.params(), pars, last_paste);
+		} else if (pars[last_paste + 1].empty()) {
+			pars[last_paste + 1].makeSameLayout(pars[last_paste]);
+			mergeParagraph(buffer.params(), pars, last_paste);
+		} else if (pars[last_paste].empty()) {
+			pars[last_paste].makeSameLayout(pars[last_paste + 1]);
+			mergeParagraph(buffer.params(), pars, last_paste);
+		} else {
+			pars[last_paste + 1].stripLeadingSpaces();
+			++last_paste;
+		}
+	}
+
+	return make_pair(PitPosPair(pit, pos), last_paste + 1);
 }
 
 
-PitPosPair CutAndPaste::eraseSelection(BufferParams const & params,
-				       ParagraphList & pars,
-				       ParagraphList::iterator startpit,
-				       ParagraphList::iterator endpit,
-				       int startpos, int endpos, bool doclear)
+PitPosPair eraseSelectionHelper(BufferParams const & params,
+	ParagraphList & pars,
+	pit_type startpit, pit_type endpit,
+	int startpos, int endpos, bool doclear)
 {
-	if (startpit == pars.end() || (startpos > startpit->size()))
+	if (startpit == pit_type(pars.size()) ||
+	    (startpos > pars[startpit].size()))
 		return PitPosPair(endpit, endpos);
 
-	if (endpit == pars.end() || startpit == endpit) {
-		endpos -= startpit->erase(startpos, endpos);
+	if (endpit == pit_type(pars.size()) ||
+	    startpit == endpit) {
+		endpos -= pars[startpit].erase(startpos, endpos);
 		return PitPosPair(endpit, endpos);
 	}
 
 	// clear end/begin fragments of the first/last par in selection
 	bool all_erased = true;
 
-	startpit->erase(startpos, startpit->size());
-	if (startpit->size() != startpos)
+	pars[startpit].erase(startpos, pars[startpit].size());
+	if (pars[startpit].size() != startpos)
 		all_erased = false;
 
-	endpos -= endpit->erase(0, endpos);
+	endpos -= pars[endpit].erase(0, endpos);
 	if (endpos != 0)
 		all_erased = false;
 
 	// Loop through the deleted pars if any, erasing as needed
-
-	ParagraphList::iterator pit = boost::next(startpit);
-
-	while (pit != endpit && pit != pars.end()) {
-		ParagraphList::iterator const next = boost::next(pit);
+	for (pit_type pit = startpit + 1; pit != endpit;) {
 		// "erase" the contents of the par
-		pit->erase(0, pit->size());
-		if (!pit->size()) {
+		pars[pit].erase(0, pars[pit].size());
+		if (!pars[pit].size()) {
 			// remove the par if it's now empty
-			pars.erase(pit);
-		} else
+			pars.erase(pars.begin() + pit);
+			--endpit;
+		} else {
+			++pit;
 			all_erased = false;
-		pit = next;
+		}
 	}
 
 #if 0 // FIXME: why for cut but not copy ?
@@ -145,17 +296,17 @@ PitPosPair CutAndPaste::eraseSelection(BufferParams const & params,
 	}
 #endif
 
-	if (boost::next(startpit) == pars.end())
+	if (startpit + 1 == pit_type(pars.size()))
 		return PitPosPair(endpit, endpos);
 
 	if (doclear) {
-		boost::next(startpit)->stripLeadingSpaces();
+		pars[startpit + 1].stripLeadingSpaces();
 	}
 
 	// paste the paragraphs again, if possible
 	if (all_erased &&
-	    (startpit->hasSameLayout(*boost::next(startpit)) ||
-	     boost::next(startpit)->empty())) {
+	    (pars[startpit].hasSameLayout(pars[startpit + 1]) ||
+	     pars[startpit + 1].empty())) {
 		mergeParagraph(params, pars, startpit);
 		// this because endpar gets deleted here!
 		endpit = startpit;
@@ -167,31 +318,16 @@ PitPosPair CutAndPaste::eraseSelection(BufferParams const & params,
 }
 
 
-namespace {
-
-struct resetOwnerAndChanges {
-	void operator()(Paragraph & p) {
-		p.cleanChanges();
-		p.setInsetOwner(0);
-	}
-};
-
-} // anon namespace
-
-bool CutAndPaste::copySelection(ParagraphList::iterator startpit,
-				ParagraphList::iterator endpit,
-				int start, int end, textclass_type tc)
+void copySelectionHelper(ParagraphList & pars,
+	pit_type startpit, pit_type endpit,
+	int start, int end, textclass_type tc)
 {
-	Assert(0 <= start && start <= startpit->size());
-	Assert(0 <= end && end <= endpit->size());
-	Assert(startpit != endpit || start <= end);
-
-	ParagraphList paragraphs;
+	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::iterator postend = boost::next(endpit);
-
-	paragraphs.assign(startpit, postend);
+	ParagraphList paragraphs(pars.begin() + startpit, pars.begin() + endpit + 1);
 	for_each(paragraphs.begin(), paragraphs.end(), resetOwnerAndChanges());
 
 	// Cut out the end of the last paragraph.
@@ -202,223 +338,418 @@ bool CutAndPaste::copySelection(ParagraphList::iterator startpit,
 	Paragraph & front = paragraphs.front();
 	front.erase(0, start);
 
-	cuts.push(make_pair(paragraphs, tc));
-
-	return true;
+	theCuts.push(make_pair(paragraphs, tc));
 }
 
 
-pair<PitPosPair, ParagraphList::iterator>
-CutAndPaste::pasteSelection(Buffer const & buffer,
-			    ParagraphList & pars,
-			    ParagraphList::iterator pit, int pos,
-			    textclass_type tc,
-			    ErrorList & errorlist)
+
+PitPosPair cutSelectionHelper(BufferParams const & params,
+	ParagraphList & pars, pit_type startpit, pit_type endpit,
+	int startpos, int endpos, textclass_type tc, bool doclear)
 {
-	return pasteSelection(buffer, pars, pit, pos, tc, 0, errorlist);
+	copySelectionHelper(pars, startpit, endpit, startpos, endpos, tc);
+	return eraseSelectionHelper(params, pars, startpit, endpit,
+		startpos, endpos, doclear);
 }
 
 
-pair<PitPosPair, ParagraphList::iterator>
-CutAndPaste::pasteSelection(Buffer const & buffer,
-			    ParagraphList & pars,
-			    ParagraphList::iterator pit, int pos,
-			    textclass_type tc, size_t cut_index,
-			    ErrorList & errorlist)
-{
-	if (!checkPastePossible())
-		return make_pair(PitPosPair(pit, pos), pit);
+} // namespace anon
 
-	Assert (pos <= pit->size());
 
-	// Make a copy of the CaP paragraphs.
-	ParagraphList simple_cut_clone = cuts[cut_index].first;
-	textclass_type const textclass = cuts[cut_index].second;
 
-	// Now remove all out of the pars which is NOT allowed in the
-	// new environment and set also another font if that is required.
 
-	// Make sure there is no class difference.
-	SwitchLayoutsBetweenClasses(textclass, tc, simple_cut_clone,
-				    errorlist);
+namespace lyx {
+namespace cap {
 
-	ParagraphList::iterator tmpbuf = simple_cut_clone.begin();
-	int depth_delta = pit->params().depth() - tmpbuf->params().depth();
+string grabAndEraseSelection(LCursor & cur)
+{
+	if (!cur.selection())
+		return string();
+	string res = grabSelection(cur);
+	eraseSelection(cur);
+	cur.selection() = false;
+	return res;
+}
 
-	Paragraph::depth_type max_depth = pit->getMaxDepthAfter();
 
-	for (; tmpbuf != simple_cut_clone.end(); ++tmpbuf) {
-		// If we have a negative jump so that the depth would
-		// go below 0 depth then we have to redo the delta to
-		// this new max depth level so that subsequent
-		// paragraphs are aligned correctly to this paragraph
-		// at level 0.
-		if ((int(tmpbuf->params().depth()) + depth_delta) < 0)
-			depth_delta = 0;
+int SwitchLayoutsBetweenClasses(textclass_type c1, textclass_type c2,
+	ParagraphList & pars, ErrorList & errorlist)
+{
+	BOOST_ASSERT(!pars.empty());
+	int ret = 0;
+	if (c1 == c2)
+		return ret;
 
-		// Set the right depth so that we are not too deep or shallow.
-		tmpbuf->params().depth(tmpbuf->params().depth() + depth_delta);
-		if (tmpbuf->params().depth() > max_depth)
-			tmpbuf->params().depth(max_depth);
+	LyXTextClass const & tclass1 = textclasslist[c1];
+	LyXTextClass const & tclass2 = textclasslist[c2];
 
-		// Only set this from the 2nd on as the 2nd depends
-		// for maxDepth still on pit.
-		if (tmpbuf != simple_cut_clone.begin())
-			max_depth = tmpbuf->getMaxDepthAfter();
+	InsetText in;
+	std::swap(in.paragraphs(), pars);
 
-		// Set the inset owner of this paragraph.
-		tmpbuf->setInsetOwner(pit->inInset());
-		for (pos_type i = 0; i < tmpbuf->size(); ++i) {
-			if (tmpbuf->getChar(i) == Paragraph::META_INSET) {
-				if (!pit->insetAllowed(tmpbuf->getInset(i)->lyxCode())) {
-					tmpbuf->erase(i--);
-				}
-			} else {
-				LyXFont f1 = tmpbuf->getFont(buffer.params, i, outerFont(pit, pars));
-				LyXFont f2 = f1;
-				if (!pit->checkInsertChar(f1)) {
-					tmpbuf->erase(i--);
-				} else if (f1 != f2) {
-					tmpbuf->setFont(i, f1);
-				}
-			}
+	ParIterator end = par_iterator_end(in);
+	for (ParIterator it = par_iterator_begin(in); it != end; ++it) {
+		string const name = it->layout()->name();
+		bool hasLayout = tclass2.hasLayout(name);
+
+		if (hasLayout)
+			it->layout(tclass2[name]);
+		else
+			it->layout(tclass2.defaultLayout());
+
+		if (!hasLayout && name != tclass1.defaultLayoutName()) {
+			++ret;
+			string const s = bformat(
+				_("Layout had to be changed from\n%1$s to %2$s\n"
+				"because of class conversion from\n%3$s to %4$s"),
+			 name, it->layout()->name(), tclass1.name(), tclass2.name());
+			// To warn the user that something had to be done.
+			errorlist.push_back(ErrorItem("Changed Layout", s,
+						      it->id(), 0,
+						      it->size()));
 		}
 	}
+	std::swap(in.paragraphs(), pars);
+	return ret;
+}
 
-	// Make the buf exactly the same layout than
-	// the cursor paragraph.
-	simple_cut_clone.begin()->makeSameLayout(*pit);
-
-	// Prepare the paragraphs and insets for insertion
-	// A couple of insets store buffer references so need
-	// updating
-	ParIterator fpit(simple_cut_clone.begin(), simple_cut_clone);
-	ParIterator fend(simple_cut_clone.end(), simple_cut_clone);
 
-	for (; fpit != fend; ++fpit) {
-		InsetList::iterator lit = fpit->insetlist.begin();
-		InsetList::iterator eit = fpit->insetlist.end();
+std::vector<string> const availableSelections(Buffer const & buffer)
+{
+	vector<string> selList;
 
-		for (; lit != eit; ++lit) {
-			switch (lit->inset->lyxCode()) {
-			case InsetOld::INCLUDE_CODE: {
-				InsetInclude * ii = static_cast<InsetInclude*>(lit->inset);
-				InsetInclude::Params ip = ii->params();
-				ip.masterFilename_ = buffer.fileName();
-				ii->set(ip);
+	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;
+		string asciiSel;
+		ParagraphList::const_iterator pit = pars.begin();
+		ParagraphList::const_iterator pend = pars.end();
+		for (; pit != pend; ++pit) {
+			asciiSel += pit->asString(buffer, false);
+			if (asciiSel.size() > 25) {
+				asciiSel.replace(22, string::npos, "...");
 				break;
 			}
+		}
 
-			case InsetOld::TABULAR_CODE: {
-				InsetTabular * it = static_cast<InsetTabular*>(lit->inset);
-				it->buffer(const_cast<Buffer*>(&buffer));
-				break;
-			}
+		selList.push_back(asciiSel);
+	}
 
-			default:
-				break; // nothing
-			}
+	return selList;
+}
+
+
+int nrOfParagraphs()
+{
+	return theCuts.empty() ? 0 : theCuts[0].first.size();
+}
+
+
+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 stuffClipboard. (Lgb)
+		cur.bv().stuffClipboard(cur.selectionAsString(true));
+
+		// This doesn't make sense, if there is no selection
+		if (!cur.selection())
+			return;
+
+		// OK, we have a selection. This is always between cur.selBegin()
+		// and cur.selEnd()
+
+		// make sure that the depth behind the selection are restored, too
+		recordUndoSelection(cur);
+		pit_type begpit = cur.selBegin().pit();
+		pit_type endpit = cur.selEnd().pit();
+
+		int endpos = cur.selEnd().pos();
+
+		BufferParams const & bp = cur.buffer().params();
+		if (realcut) {
+			copySelectionHelper(text->paragraphs(),
+				begpit, endpit,
+				cur.selBegin().pos(), endpos,
+				bp.textclass);
 		}
-	}
 
-	bool paste_the_end = false;
+		boost::tie(endpit, endpos) =
+			eraseSelectionHelper(bp,
+				text->paragraphs(),
+				begpit, endpit,
+				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;
+
+		// need a valid cursor. (Lgb)
+		cur.clearSelection();
+		updateCounters(cur.buffer());
+	}
 
-	// Open the paragraph for inserting the buf
-	// if necessary.
-	if (pit->size() > pos || boost::next(pit) == pars.end()) {
-		breakParagraphConservative(buffer.params,
-					   pars, pit, pos);
-		paste_the_end = true;
+	if (cur.inMathed()) {
+		lyxerr << "cutSelection in mathed" << endl;
+		LCursor tmp = cur;
+		copySelection(cur);
+		cur.selection() = false;
+		eraseSelection(tmp);
 	}
+}
 
-	// Set the end for redoing later.
-	ParagraphList::iterator endpit = boost::next(boost::next(pit));
 
-	// Paste it!
+void copySelection(LCursor & cur)
+{
+	// stuff the selection onto the X clipboard, from an explicit copy request
+	cur.bv().stuffClipboard(cur.selectionAsString(true));
+
+	// this doesn't make sense, if there is no selection
+	if (!cur.selection())
+		return;
+
+	if (cur.inTexted()) {
+		LyXText * text = cur.text();
+		BOOST_ASSERT(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(pars, par, cur.selEnd().pit(),
+			pos, cur.selEnd().pos(), cur.buffer().params().textclass);
+	}
 
-	ParagraphList::iterator past_pit = boost::next(pit);
-	pars.splice(past_pit, simple_cut_clone);
-	ParagraphList::iterator last_paste = boost::prior(past_pit);
+	if (cur.inMathed()) {
+		lyxerr << "copySelection in mathed" << endl;
+		ParagraphList pars;
+		pars.push_back(Paragraph());
+		BufferParams const & bp = cur.buffer().params();
+		pars.back().layout(bp.getLyXTextClass().defaultLayout());
+		for_each(pars.begin(), pars.end(), resetOwnerAndChanges());
+		pars.back().insert(0, grabSelection(cur), LyXFont());
+		theCuts.push(make_pair(pars, bp.textclass));
+	}
+}
 
-	// If we only inserted one paragraph.
-	if (boost::next(pit) == last_paste)
-		last_paste = pit;
 
-	mergeParagraph(buffer.params, pars, pit);
+std::string getSelection(Buffer const & buf, size_t sel_index)
+{
+	return sel_index < theCuts.size()
+		? theCuts[sel_index].first.back().asString(buf, false)
+		: string();
+}
 
-	// Store the new cursor position.
-	pit = last_paste;
-	pos = last_paste->size();
 
-	// Maybe some pasting.
-#warning CHECK! Are we comparing last_paste to the wrong list here? (Lgb)
-	if (boost::next(last_paste) != pars.end() &&
-	    paste_the_end) {
-		if (boost::next(last_paste)->hasSameLayout(*last_paste)) {
-			mergeParagraph(buffer.params, pars,
-				       last_paste);
-		} else if (boost::next(last_paste)->empty()) {
-			boost::next(last_paste)->makeSameLayout(*last_paste);
-			mergeParagraph(buffer.params, pars,
-				       last_paste);
-		} else if (last_paste->empty()) {
-			last_paste->makeSameLayout(*boost::next(last_paste));
-			mergeParagraph(buffer.params, pars,
-				       last_paste);
-		} else
-			boost::next(last_paste)->stripLeadingSpaces();
+void pasteSelection(LCursor & cur, size_t sel_index)
+{
+	// this does not make sense, if there is nothing to paste
+	lyxerr << "#### pasteSelection " << sel_index << endl;
+	if (!checkPastePossible(sel_index))
+		return;
+
+	if (cur.inTexted()) {
+		LyXText * text = cur.text();
+		BOOST_ASSERT(text);
+
+		recordUndo(cur);
+
+		pit_type endpit;
+		PitPosPair ppp;
+
+		ErrorList el;
+
+		boost::tie(ppp, endpit) =
+			pasteSelectionHelper(cur.buffer(),
+								text->paragraphs(),
+								cur.pit(), cur.pos(),
+								cur.buffer().params().textclass,
+								sel_index, el);
+		bufferErrors(cur.buffer(), el);
+		cur.bv().showErrorList(_("Paste"));
+
+		cur.clearSelection();
+		cur.resetAnchor();
+		text->setCursor(cur, ppp.first, ppp.second);
+		cur.setSelection();
+		updateCounters(cur.buffer());
 	}
 
-	return make_pair(PitPosPair(pit, pos), endpit);
+	if (cur.inMathed()) {
+		lyxerr << "### should be handled in MathNest/GridInset" << endl;
+	}
 }
 
 
-int CutAndPaste::nrOfParagraphs()
+void setSelectionRange(LCursor & cur, pos_type length)
 {
-	return cuts.empty() ? 0 : cuts[0].first.size();
+	LyXText * text = cur.text();
+	BOOST_ASSERT(text);
+	if (!length)
+		return;
+	cur.resetAnchor();
+	while (length--)
+		text->cursorRight(cur);
+	cur.setSelection();
 }
 
 
-int CutAndPaste::SwitchLayoutsBetweenClasses(textclass_type c1,
-					     textclass_type c2,
-					     ParagraphList & pars,
-					     ErrorList & errorlist)
+// simple replacing. The font of the first selected character is used
+void replaceSelectionWithString(LCursor & cur, string const & str)
 {
-	Assert(!pars.empty());
+	LyXText * text = cur.text();
+	BOOST_ASSERT(text);
+	recordUndo(cur);
+
+	// Get font setting before we cut
+	pos_type pos = cur.selEnd().pos();
+	Paragraph & par = text->getPar(cur.selEnd().pit());
+	LyXFont const font =
+		par.getFontSettings(cur.buffer().params(), cur.selBegin().pos());
+
+	// Insert the new string
+	string::const_iterator cit = str.begin();
+	string::const_iterator end = str.end();
+	for (; cit != end; ++cit, ++pos)
+		par.insertChar(pos, (*cit), font);
+
+	// Cut the selection
+	cutSelection(cur, true, false);
+}
 
-	int ret = 0;
-	if (c1 == c2)
-		return ret;
 
-	LyXTextClass const & tclass1 = textclasslist[c1];
-	LyXTextClass const & tclass2 = textclasslist[c2];
-	ParIterator end = ParIterator(pars.end(), pars);
-	for (ParIterator it = ParIterator(pars.begin(), pars); it != end; ++it) {
-		string const name = it->layout()->name();
-		bool hasLayout = tclass2.hasLayout(name);
+void replaceSelection(LCursor & cur)
+{
+	if (cur.selection())
+		cutSelection(cur, true, false);
+}
 
-		if (hasLayout)
-			it->layout(tclass2[name]);
-		else
-			it->layout(tclass2.defaultLayout());
 
-		if (!hasLayout && name != tclass1.defaultLayoutName()) {
-			++ret;
-			string const s = bformat(
-				_("Layout had to be changed from\n%1$s to %2$s\n"
-				"because of class conversion from\n%3$s to %4$s"),
-			 name, it->layout()->name(), tclass1.name(), tclass2.name());
-			// To warn the user that something had to be done.
-			errorlist.push_back(ErrorItem("Changed Layout", s,
-						      it->id(), 0,
-						      it->size()));
+// only used by the spellchecker
+void replaceWord(LCursor & cur, string const & replacestring)
+{
+	LyXText * text = cur.text();
+	BOOST_ASSERT(text);
+
+	replaceSelectionWithString(cur, replacestring);
+	setSelectionRange(cur, replacestring.length());
+
+	// Go back so that replacement string is also spellchecked
+	for (string::size_type i = 0; i < replacestring.length() + 1; ++i)
+		text->cursorLeft(cur);
+}
+
+
+void eraseSelection(LCursor & cur)
+{
+	//lyxerr << "LCursor::eraseSelection begin: " << cur << endl;
+	CursorSlice const & i1 = cur.selBegin();
+	CursorSlice const & i2 = cur.selEnd();
+	if (i1.inset().asMathInset()) {
+		if (i1.idx() == i2.idx()) {
+			i1.cell().erase(i1.pos(), i2.pos());
+		} else {
+			MathInset * p = i1.asMathInset();
+			InsetBase::row_type r1, r2;
+			InsetBase::col_type c1, c2;
+			region(i1, i2, r1, r2, c1, c2);
+			for (InsetBase::row_type row = r1; row <= r2; ++row)
+				for (InsetBase::col_type col = c1; col <= c2; ++col)
+					p->cell(p->index(row, col)).clear();
 		}
+		cur.top() = i1;
+		cur.pos() = 0; // We've deleted the whole cell. Only pos 0 is valid.
+		cur.resetAnchor();
+	} else {
+		lyxerr << "can't erase this selection 1" << endl;
 	}
-	return ret;
+	//lyxerr << "LCursor::eraseSelection end: " << cur << endl;
 }
 
 
-bool CutAndPaste::checkPastePossible()
+void selDel(LCursor & cur)
 {
-	return !cuts.empty() && !cuts[0].first.empty();
+	//lyxerr << "LCursor::selDel" << endl;
+	if (cur.selection()) {
+		eraseSelection(cur);
+		cur.selection() = false;
+	}
+}
+
+
+void selClearOrDel(LCursor & cur)
+{
+	//lyxerr << "LCursor::selClearOrDel" << endl;
+	if (lyxrc.auto_region_delete)
+		selDel(cur);
+	else
+		cur.selection() = false;
 }
+
+
+string grabSelection(LCursor & cur)
+{
+	if (!cur.selection())
+		return string();
+
+	CursorSlice i1 = cur.selBegin();
+	CursorSlice i2 = cur.selEnd();
+
+	if (i1.idx() == i2.idx()) {
+		if (i1.inset().asMathInset()) {
+			MathArray::const_iterator it = i1.cell().begin();
+			return asString(MathArray(it + i1.pos(), it + i2.pos()));
+		} else {
+			return "unknown selection 1";
+		}
+	}
+
+	InsetBase::row_type r1, r2;
+	InsetBase::col_type c1, c2;
+	region(i1, i2, r1, r2, c1, c2);
+
+	string data;
+	if (i1.inset().asMathInset()) {
+		for (InsetBase::row_type row = r1; row <= r2; ++row) {
+			if (row > r1)
+				data += "\\\\";
+			for (InsetBase::col_type col = c1; col <= c2; ++col) {
+				if (col > c1)
+					data += '&';
+				data += asString(i1.asMathInset()->
+					cell(i1.asMathInset()->index(row, col)));
+			}
+		}
+	} else {
+		data = "unknown selection 2";
+	}
+	return data;
+}
+
+
+} // namespace cap
+} // namespace lyx