X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Ftext2.C;h=f2480b9adb984bc00add5f0562449687c2c655dc;hb=86e0dfa3e11957318ca4f3f549248326aa806eb4;hp=50169bc3b84cf7d312a277b9490ff40bac844f8b;hpb=39bccdb268eaee47c3443cc031607aa514a4a5da;p=lyx.git

diff --git a/src/text2.C b/src/text2.C
index 50169bc3b8..f2480b9adb 100644
--- a/src/text2.C
+++ b/src/text2.C
@@ -44,7 +44,6 @@
 #include "paragraph.h"
 #include "paragraph_funcs.h"
 #include "ParagraphParameters.h"
-#include "PosIterator.h"
 #include "undo.h"
 #include "vspace.h"
 
@@ -61,8 +60,7 @@
 #include "support/tostr.h"
 #include "support/std_sstream.h"
 
-#include <boost/tuple/tuple.hpp>
-
+using lyx::par_type;
 using lyx::pos_type;
 using lyx::support::bformat;
 
@@ -71,54 +69,57 @@ using std::ostringstream;
 using std::string;
 
 
-LyXText::LyXText(BufferView * bv, bool in_inset)
+LyXText::LyXText(BufferView * bv)
 	: width_(0), maxwidth_(bv ? bv->workWidth() : 100), height_(0),
 	  background_color_(LColor::background),
-	  bv_owner(bv), in_inset_(in_inset), xo_(0), yo_(0)
+	  bv_owner(bv), xo_(0), yo_(0)
 {}
 
 
 void LyXText::init(BufferView * bv)
 {
+	BOOST_ASSERT(bv);
 	bv_owner = bv;
-
-	ParagraphList::iterator const beg = paragraphs().begin();
-	ParagraphList::iterator const end = paragraphs().end();
-	for (ParagraphList::iterator pit = beg; pit != end; ++pit)
-		pit->rows.clear();
-
 	maxwidth_ = bv->workWidth();
 	width_ = maxwidth_;
 	height_ = 0;
 
-	current_font = getFont(beg, 0);
-
-	redoParagraphs(beg, end);
-	// why?
-	bv->cursor().resetAnchor();
+	par_type const end = paragraphs().size();
+	for (par_type pit = 0; pit != end; ++pit)
+		pars_[pit].rows.clear();
 
+	current_font = getFont(0, 0);
+	redoParagraphs(0, end);
 	updateCounters();
 }
 
 
+bool LyXText::isMainText() const
+{
+	return &bv()->buffer()->text() == this;
+}
+
+
 // Gets the fully instantiated font at a given position in a paragraph
 // Basically the same routine as Paragraph::getFont() in paragraph.C.
 // The difference is that this one is used for displaying, and thus we
 // are allowed to make cosmetic improvements. For instance make footnotes
 // smaller. (Asger)
-LyXFont LyXText::getFont(ParagraphList::iterator pit, pos_type pos) const
+LyXFont LyXText::getFont(par_type pit, pos_type pos) const
 {
 	BOOST_ASSERT(pos >= 0);
 
-	LyXLayout_ptr const & layout = pit->layout();
+	LyXLayout_ptr const & layout = pars_[pit].layout();
+#ifdef WITH_WARNINGS
 #warning broken?
+#endif
 	BufferParams const & params = bv()->buffer()->params();
-	pos_type const body_pos = pit->beginOfBody();
+	pos_type const body_pos = pars_[pit].beginOfBody();
 
 	// We specialize the 95% common case:
-	if (!pit->getDepth()) {
-		LyXFont f = pit->getFontSettings(params, pos);
-		if (in_inset_)
+	if (!pars_[pit].getDepth()) {
+		LyXFont f = pars_[pit].getFontSettings(params, pos);
+		if (!isMainText())
 			f.realize(font_);
 		if (layout->labeltype == LABEL_MANUAL && pos < body_pos)
 			return f.realize(layout->reslabelfont);
@@ -133,10 +134,10 @@ LyXFont LyXText::getFont(ParagraphList::iterator pit, pos_type pos) const
 	else
 		layoutfont = layout->font;
 
-	LyXFont font = pit->getFontSettings(params, pos);
+	LyXFont font = pars_[pit].getFontSettings(params, pos);
 	font.realize(layoutfont);
 
-	if (in_inset_)
+	if (!isMainText())
 		font.realize(font_);
 
 	// Realize with the fonts of lesser depth.
@@ -147,11 +148,11 @@ LyXFont LyXText::getFont(ParagraphList::iterator pit, pos_type pos) const
 }
 
 
-LyXFont LyXText::getLayoutFont(ParagraphList::iterator pit) const
+LyXFont LyXText::getLayoutFont(par_type pit) const
 {
-	LyXLayout_ptr const & layout = pit->layout();
+	LyXLayout_ptr const & layout = pars_[pit].layout();
 
-	if (!pit->getDepth())
+	if (!pars_[pit].getDepth())
 		return layout->resfont;
 
 	LyXFont font = layout->font;
@@ -163,11 +164,11 @@ LyXFont LyXText::getLayoutFont(ParagraphList::iterator pit) const
 }
 
 
-LyXFont LyXText::getLabelFont(ParagraphList::iterator pit) const
+LyXFont LyXText::getLabelFont(par_type pit) const
 {
-	LyXLayout_ptr const & layout = pit->layout();
+	LyXLayout_ptr const & layout = pars_[pit].layout();
 
-	if (!pit->getDepth())
+	if (!pars_[pit].getDepth())
 		return layout->reslabelfont;
 
 	LyXFont font = layout->labelfont;
@@ -179,29 +180,28 @@ LyXFont LyXText::getLabelFont(ParagraphList::iterator pit) const
 }
 
 
-void LyXText::setCharFont(
-	ParagraphList::iterator pit, pos_type pos, LyXFont const & fnt)
+void LyXText::setCharFont(par_type pit, pos_type pos, LyXFont const & fnt)
 {
 	LyXFont font = fnt;
-	LyXLayout_ptr const & layout = pit->layout();
+	LyXLayout_ptr const & layout = pars_[pit].layout();
 
 	// Get concrete layout font to reduce against
 	LyXFont layoutfont;
 
-	if (pos < pit->beginOfBody())
+	if (pos < pars_[pit].beginOfBody())
 		layoutfont = layout->labelfont;
 	else
 		layoutfont = layout->font;
 
 	// Realize against environment font information
-	if (pit->getDepth()) {
-		ParagraphList::iterator tp = pit;
+	if (pars_[pit].getDepth()) {
+		par_type tp = pit;
 		while (!layoutfont.resolved() &&
-		       tp != paragraphs().end() &&
-		       tp->getDepth()) {
+		       tp != par_type(paragraphs().size()) &&
+		       pars_[tp].getDepth()) {
 			tp = outerHook(tp, paragraphs());
-			if (tp != paragraphs().end())
-				layoutfont.realize(tp->layout()->font);
+			if (tp != par_type(paragraphs().size()))
+				layoutfont.realize(pars_[tp].layout()->font);
 		}
 	}
 
@@ -210,7 +210,7 @@ void LyXText::setCharFont(
 	// Now, reduce font against full layout font
 	font.reduce(layoutfont);
 
-	pit->setFont(pos, font);
+	pars_[pit].setFont(pos, font);
 }
 
 
@@ -237,42 +237,38 @@ void LyXText::makeFontEntriesLayoutSpecific(BufferParams const & params,
 
 
 // return past-the-last paragraph influenced by a layout change on pit
-ParagraphList::iterator LyXText::undoSpan(ParagraphList::iterator pit)
+par_type LyXText::undoSpan(par_type pit)
 {
-	ParagraphList::iterator end = paragraphs().end();
-	ParagraphList::iterator nextpit = boost::next(pit);
+	par_type end = paragraphs().size();
+	par_type nextpit = pit + 1;
 	if (nextpit == end)
 		return nextpit;
 	//because of parindents
-	if (!pit->getDepth())
+	if (!pars_[pit].getDepth())
 		return boost::next(nextpit);
 	//because of depth constrains
 	for (; nextpit != end; ++pit, ++nextpit) {
-		if (!pit->getDepth())
+		if (!pars_[pit].getDepth())
 			break;
 	}
 	return nextpit;
 }
 
 
-ParagraphList::iterator
-LyXText::setLayout(ParagraphList::iterator start,
-		   ParagraphList::iterator end,
-		   string const & layout)
+par_type LyXText::setLayout(par_type start, par_type end, string const & layout)
 {
 	BOOST_ASSERT(start != end);
-	ParagraphList::iterator undopit = undoSpan(boost::prior(end));
-	recUndo(parOffset(start), parOffset(undopit) - 1);
+	par_type undopit = undoSpan(end - 1);
+	recUndo(start, undopit - 1);
 
 	BufferParams const & bufparams = bv()->buffer()->params();
-	LyXLayout_ptr const & lyxlayout =
-		bufparams.getLyXTextClass()[layout];
+	LyXLayout_ptr const & lyxlayout = bufparams.getLyXTextClass()[layout];
 
-	for (ParagraphList::iterator pit = start; pit != end; ++pit) {
-		pit->applyLayout(lyxlayout);
-		makeFontEntriesLayoutSpecific(bufparams, *pit);
+	for (par_type pit = start; pit != end; ++pit) {
+		pars_[pit].applyLayout(lyxlayout);
+		makeFontEntriesLayoutSpecific(bufparams, pars_[pit]);
 		if (lyxlayout->margintype == MARGIN_MANUAL)
-			pit->setLabelWidthString(lyxlayout->labelstring());
+			pars_[pit].setLabelWidthString(lyxlayout->labelstring());
 	}
 
 	return undopit;
@@ -284,24 +280,25 @@ void LyXText::setLayout(LCursor & cur, string const & layout)
 {
 	BOOST_ASSERT(this == cur.text());
 	// special handling of new environment insets
-	BufferParams const & params = bv()->buffer()->params();
+	BufferView & bv = cur.bv();
+	BufferParams const & params = bv.buffer()->params();
 	LyXLayout_ptr const & lyxlayout = params.getLyXTextClass()[layout];
 	if (lyxlayout->is_environment) {
 		// move everything in a new environment inset
 		lyxerr << "setting layout " << layout << endl;
-		bv()->owner()->dispatch(FuncRequest(LFUN_HOME));
-		bv()->owner()->dispatch(FuncRequest(LFUN_ENDSEL));
-		bv()->owner()->dispatch(FuncRequest(LFUN_CUT));
+		bv.owner()->dispatch(FuncRequest(LFUN_HOME));
+		bv.owner()->dispatch(FuncRequest(LFUN_ENDSEL));
+		bv.owner()->dispatch(FuncRequest(LFUN_CUT));
 		InsetBase * inset = new InsetEnvironment(params, layout);
 		insertInset(cur, inset);
 		//inset->edit(cur, true);
-		//bv()->owner()->dispatch(FuncRequest(LFUN_PASTE));
+		//bv.owner()->dispatch(FuncRequest(LFUN_PASTE));
 		return;
 	}
 
-	ParagraphList::iterator start = getPar(cur.selBegin().par());
-	ParagraphList::iterator end = boost::next(getPar(cur.selEnd().par()));
-	ParagraphList::iterator endpit = setLayout(start, end, layout);
+	par_type start = cur.selBegin().par();
+	par_type end = cur.selEnd().par() + 1;
+	par_type endpit = setLayout(start, end, layout);
 	redoParagraphs(start, endpit);
 	updateCounters();
 }
@@ -310,30 +307,27 @@ void LyXText::setLayout(LCursor & cur, string const & layout)
 namespace {
 
 
-void getSelectionSpan(LCursor & cur, LyXText & text,
-	ParagraphList::iterator & beg,
-	ParagraphList::iterator & end)
+void getSelectionSpan(LCursor & cur, par_type & beg, par_type & end)
 {
 	if (!cur.selection()) {
-		beg = text.getPar(cur.par());
-		end = boost::next(beg);
+		beg = cur.par();
+		end = cur.par() + 1;
 	} else {
-		beg = text.getPar(cur.selBegin());
-		end = boost::next(text.getPar(cur.selEnd()));
+		beg = cur.selBegin().par();
+		end = cur.selEnd().par() + 1;
 	}
 }
 
 
-bool changeDepthAllowed(bv_funcs::DEPTH_CHANGE type,
-			Paragraph const & par,
-			int max_depth)
+bool changeDepthAllowed(LyXText::DEPTH_CHANGE type,
+	Paragraph const & par, int max_depth)
 {
 	if (par.layout()->labeltype == LABEL_BIBLIO)
 		return false;
 	int const depth = par.params().depth();
-	if (type == bv_funcs::INC_DEPTH && depth < max_depth)
+	if (type == LyXText::INC_DEPTH && depth < max_depth)
 		return true;
-	if (type == bv_funcs::DEC_DEPTH && depth > 0)
+	if (type == LyXText::DEC_DEPTH && depth > 0)
 		return true;
 	return false;
 }
@@ -342,44 +336,44 @@ bool changeDepthAllowed(bv_funcs::DEPTH_CHANGE type,
 }
 
 
-bool LyXText::changeDepthAllowed(LCursor & cur, bv_funcs::DEPTH_CHANGE type)
+bool LyXText::changeDepthAllowed(LCursor & cur, DEPTH_CHANGE type) const
 {
 	BOOST_ASSERT(this == cur.text());
-	ParagraphList::iterator beg, end; 
-	getSelectionSpan(cur, *this, beg, end);
+	par_type beg, end;
+	getSelectionSpan(cur, beg, end);
 	int max_depth = 0;
-	if (beg != paragraphs().begin())
-		max_depth = boost::prior(beg)->getMaxDepthAfter();
+	if (beg != 0)
+		max_depth = pars_[beg - 1].getMaxDepthAfter();
 
-	for (ParagraphList::iterator pit = beg; pit != end; ++pit) {
-		if (::changeDepthAllowed(type, *pit, max_depth))
+	for (par_type pit = beg; pit != end; ++pit) {
+		if (::changeDepthAllowed(type, pars_[pit], max_depth))
 			return true;
-		max_depth = pit->getMaxDepthAfter();
+		max_depth = pars_[pit].getMaxDepthAfter();
 	}
 	return false;
 }
 
 
-void LyXText::changeDepth(LCursor & cur, bv_funcs::DEPTH_CHANGE type)
+void LyXText::changeDepth(LCursor & cur, DEPTH_CHANGE type)
 {
 	BOOST_ASSERT(this == cur.text());
-	ParagraphList::iterator beg, end;
-	getSelectionSpan(cur, *this, beg, end);
+	par_type beg, end;
+	getSelectionSpan(cur, beg, end);
 	recordUndoSelection(cur);
 
 	int max_depth = 0;
-	if (beg != paragraphs().begin())
-		max_depth = boost::prior(beg)->getMaxDepthAfter();
-
-	for (ParagraphList::iterator pit = beg; pit != end; ++pit) {
-		if (::changeDepthAllowed(type, *pit, max_depth)) {
-			int const depth = pit->params().depth();
-			if (type == bv_funcs::INC_DEPTH)
-				pit->params().depth(depth + 1);
+	if (beg != 0)
+		max_depth = pars_[beg - 1].getMaxDepthAfter();
+
+	for (par_type pit = beg; pit != end; ++pit) {
+		if (::changeDepthAllowed(type, pars_[pit], max_depth)) {
+			int const depth = pars_[pit].params().depth();
+			if (type == INC_DEPTH)
+				pars_[pit].params().depth(depth + 1);
 			else
-				pit->params().depth(depth - 1);
+				pars_[pit].params().depth(depth - 1);
 		}
-		max_depth = pit->getMaxDepthAfter();
+		max_depth = pars_[pit].getMaxDepthAfter();
 	}
 	// this handles the counter labels, and also fixes up
 	// depth values for follow-on (child) paragraphs
@@ -387,7 +381,7 @@ void LyXText::changeDepth(LCursor & cur, bv_funcs::DEPTH_CHANGE type)
 }
 
 
-// set font over selection and make a total rebreak of those paragraphs
+// set font over selection
 void LyXText::setFont(LCursor & cur, LyXFont const & font, bool toggleall)
 {
 	BOOST_ASSERT(this == cur.text());
@@ -395,15 +389,15 @@ void LyXText::setFont(LCursor & cur, LyXFont const & font, bool toggleall)
 	if (!cur.selection()) {
 		// Determine basis font
 		LyXFont layoutfont;
-		ParagraphList::iterator pit = getPar(cur.par());
-		if (cur.pos() < pit->beginOfBody())
+		par_type pit = cur.par();
+		if (cur.pos() < pars_[pit].beginOfBody())
 			layoutfont = getLabelFont(pit);
 		else
 			layoutfont = getLayoutFont(pit);
 
 		// Update current font
 		real_current_font.update(font,
-					 bv()->buffer()->params().language,
+					 cur.buffer().params().language,
 					 toggleall);
 
 		// Reduce to implicit settings
@@ -418,21 +412,27 @@ void LyXText::setFont(LCursor & cur, LyXFont const & font, bool toggleall)
 	// Ok, we have a selection.
 	recordUndoSelection(cur);
 
-	ParagraphList::iterator beg = getPar(cur.selBegin().par());
-	ParagraphList::iterator end = getPar(cur.selEnd().par());
-	
-	PosIterator pos(&paragraphs(), beg, cur.selBegin().pos());
-	PosIterator posend(&paragraphs(), end, cur.selEnd().pos());
+	par_type const beg = cur.selBegin().par();
+	par_type const end = cur.selEnd().par();
 
-	BufferParams const & params = bv()->buffer()->params();
+	DocIterator pos = cur.selectionBegin();
+	DocIterator posend = cur.selectionEnd();
 
-	for (; pos != posend; ++pos) {
-		LyXFont f = getFont(pos.pit(), pos.pos());
-		f.update(font, params.language, toggleall);
-		setCharFont(pos.pit(), pos.pos(), f);
+	lyxerr << "pos: " << pos << " posend: " << posend << endl;
+
+	BufferParams const & params = cur.buffer().params();
+
+	// Don't use forwardChar here as posend might have
+	// pos() == lastpos() and forwardChar would miss it.
+	for (; pos != posend; pos.forwardPos()) {
+		if (pos.pos() != pos.lastpos()) {
+			LyXFont f = getFont(pos.par(), pos.pos());
+			f.update(font, params.language, toggleall);
+			setCharFont(pos.par(), pos.pos(), f);
+		}
 	}
-	
-	redoParagraphs(beg, ++end);
+
+	redoParagraphs(beg, end + 1);
 }
 
 
@@ -533,30 +533,23 @@ string LyXText::getStringToIndex(LCursor & cur)
 }
 
 
-// the DTP switches for paragraphs(). LyX will store them in the first
-// physical paragraph. When a paragraph is broken, the top settings rest,
-// the bottom settings are given to the new one. So I can make sure,
-// they do not duplicate themself and you cannot play dirty tricks with
-// them!
-
 void LyXText::setParagraph(LCursor & cur,
 	Spacing const & spacing, LyXAlignment align,
 	string const & labelwidthstring, bool noindent)
 {
 	BOOST_ASSERT(cur.text());
 	// make sure that the depth behind the selection are restored, too
-	ParagraphList::iterator undopit = undoSpan(getPar(cur.selEnd()));
-	recUndo(cur.selBegin().par(), parOffset(undopit) - 1);
+	par_type undopit = undoSpan(cur.selEnd().par());
+	recUndo(cur.selBegin().par(), undopit - 1);
 
-	ParagraphList::reverse_iterator pit(getPar(cur.selEnd().par()));
-	ParagraphList::reverse_iterator beg(getPar(cur.selBegin().par()));
-
-	for (--pit; pit != beg; ++pit) {
-		ParagraphParameters & params = pit->params();
+	for (par_type pit = cur.selBegin().par(), end = cur.selEnd().par();
+			pit <= end; ++pit) {
+		Paragraph & par = pars_[pit];
+		ParagraphParameters & params = par.params();
 		params.spacing(spacing);
 
 		// does the layout allow the new alignment?
-		LyXLayout_ptr const & layout = pit->layout();
+		LyXLayout_ptr const & layout = par.layout();
 
 		if (align == LYX_ALIGN_LAYOUT)
 			align = layout->align;
@@ -566,11 +559,11 @@ void LyXText::setParagraph(LCursor & cur,
 			else
 				params.align(align);
 		}
-		pit->setLabelWidthString(labelwidthstring);
+		par.setLabelWidthString(labelwidthstring);
 		params.noindent(noindent);
 	}
 
-	redoParagraphs(getPar(cur.selBegin()), undopit);
+	redoParagraphs(cur.selBegin().par(), undopit);
 }
 
 
@@ -598,33 +591,32 @@ string expandLabel(LyXTextClass const & textclass,
 
 namespace {
 
-void incrementItemDepth(ParagraphList::iterator pit,
-			ParagraphList::iterator first_pit)
+void incrementItemDepth(ParagraphList & pars, par_type pit, par_type first_pit)
 {
-	int const cur_labeltype = pit->layout()->labeltype;
+	int const cur_labeltype = pars[pit].layout()->labeltype;
 
 	if (cur_labeltype != LABEL_ENUMERATE && cur_labeltype != LABEL_ITEMIZE)
 		return;
 
-	int const cur_depth = pit->getDepth();
+	int const cur_depth = pars[pit].getDepth();
 
-	ParagraphList::iterator prev_pit = boost::prior(pit);
+	par_type prev_pit = pit - 1;
 	while (true) {
-		int const prev_depth = prev_pit->getDepth();
-		int const prev_labeltype = prev_pit->layout()->labeltype;
+		int const prev_depth = pars[prev_pit].getDepth();
+		int const prev_labeltype = pars[prev_pit].layout()->labeltype;
 		if (prev_depth == 0 && cur_depth > 0) {
 			if (prev_labeltype == cur_labeltype) {
-				pit->itemdepth = prev_pit->itemdepth + 1;
+				pars[pit].itemdepth = pars[prev_pit].itemdepth + 1;
 			}
 			break;
 		} else if (prev_depth < cur_depth) {
 			if (prev_labeltype == cur_labeltype) {
-				pit->itemdepth = prev_pit->itemdepth + 1;
+				pars[pit].itemdepth = pars[prev_pit].itemdepth + 1;
 				break;
 			}
 		} else if (prev_depth == cur_depth) {
 			if (prev_labeltype == cur_labeltype) {
-				pit->itemdepth = prev_pit->itemdepth;
+				pars[pit].itemdepth = pars[prev_pit].itemdepth;
 				break;
 			}
 		}
@@ -636,21 +628,20 @@ void incrementItemDepth(ParagraphList::iterator pit,
 }
 
 
-void resetEnumCounterIfNeeded(ParagraphList::iterator pit,
-			      ParagraphList::iterator firstpit,
-			      Counters & counters)
+void resetEnumCounterIfNeeded(ParagraphList & pars, par_type pit,
+	par_type firstpit, Counters & counters)
 {
 	if (pit == firstpit)
 		return;
 
-	int const cur_depth = pit->getDepth();
-	ParagraphList::iterator prev_pit = boost::prior(pit);
+	int const cur_depth = pars[pit].getDepth();
+	par_type prev_pit = pit - 1;
 	while (true) {
-		int const prev_depth = prev_pit->getDepth();
-		int const prev_labeltype = prev_pit->layout()->labeltype;
+		int const prev_depth = pars[prev_pit].getDepth();
+		int const prev_labeltype = pars[prev_pit].layout()->labeltype;
 		if (prev_depth <= cur_depth) {
 			if (prev_labeltype != LABEL_ENUMERATE) {
-				switch (pit->itemdepth) {
+				switch (pars[pit].itemdepth) {
 				case 0:
 					counters.reset("enumi");
 				case 1:
@@ -675,39 +666,39 @@ void resetEnumCounterIfNeeded(ParagraphList::iterator pit,
 
 
 // set the counter of a paragraph. This includes the labels
-void LyXText::setCounter(Buffer const & buf, ParagraphList::iterator pit)
+void LyXText::setCounter(Buffer const & buf, par_type pit)
 {
 	BufferParams const & bufparams = buf.params();
 	LyXTextClass const & textclass = bufparams.getLyXTextClass();
-	LyXLayout_ptr const & layout = pit->layout();
-	ParagraphList::iterator first_pit = paragraphs().begin();
+	LyXLayout_ptr const & layout = pars_[pit].layout();
+	par_type first_pit = 0;
 	Counters & counters = textclass.counters();
 
 	// Always reset
-	pit->itemdepth = 0;
+	pars_[pit].itemdepth = 0;
 
 	if (pit == first_pit) {
-		pit->params().appendix(pit->params().startOfAppendix());
+		pars_[pit].params().appendix(pars_[pit].params().startOfAppendix());
 	} else {
-		pit->params().appendix(boost::prior(pit)->params().appendix());
-		if (!pit->params().appendix() &&
-		    pit->params().startOfAppendix()) {
-			pit->params().appendix(true);
+		pars_[pit].params().appendix(pars_[pit - 1].params().appendix());
+		if (!pars_[pit].params().appendix() &&
+		    pars_[pit].params().startOfAppendix()) {
+			pars_[pit].params().appendix(true);
 			textclass.counters().reset();
 		}
 
 		// Maybe we have to increment the item depth.
-		incrementItemDepth(pit, first_pit);
+		incrementItemDepth(pars_, pit, first_pit);
 	}
 
 	// erase what was there before
-	pit->params().labelString(string());
+	pars_[pit].params().labelString(string());
 
 	if (layout->margintype == MARGIN_MANUAL) {
-		if (pit->params().labelWidthString().empty())
-			pit->setLabelWidthString(layout->labelstring());
+		if (pars_[pit].params().labelWidthString().empty())
+			pars_[pit].setLabelWidthString(layout->labelstring());
 	} else {
-		pit->setLabelWidthString(string());
+		pars_[pit].setLabelWidthString(string());
 	}
 
 	// is it a layout that has an automatic label?
@@ -715,16 +706,16 @@ void LyXText::setCounter(Buffer const & buf, ParagraphList::iterator pit)
 		BufferParams const & bufparams = buf.params();
 		LyXTextClass const & textclass = bufparams.getLyXTextClass();
 		counters.step(layout->counter);
-		string label = expandLabel(textclass, layout, pit->params().appendix());
-		pit->params().labelString(label);
+		string label = expandLabel(textclass, layout, pars_[pit].params().appendix());
+		pars_[pit].params().labelString(label);
 	} else if (layout->labeltype == LABEL_ITEMIZE) {
 		// At some point of time we should do something more
 		// clever here, like:
-		//   pit->params().labelString(
-		//    bufparams.user_defined_bullet(pit->itemdepth).getText());
+		//   pars_[pit].params().labelString(
+		//    bufparams.user_defined_bullet(pars_[pit].itemdepth).getText());
 		// for now, use a simple hardcoded label
 		string itemlabel;
-		switch (pit->itemdepth) {
+		switch (pars_[pit].itemdepth) {
 		case 0:
 			itemlabel = "*";
 			break;
@@ -739,17 +730,17 @@ void LyXText::setCounter(Buffer const & buf, ParagraphList::iterator pit)
 			break;
 		}
 
-		pit->params().labelString(itemlabel);
+		pars_[pit].params().labelString(itemlabel);
 	} else if (layout->labeltype == LABEL_ENUMERATE) {
 		// Maybe we have to reset the enumeration counter.
-		resetEnumCounterIfNeeded(pit, first_pit, counters);
+		resetEnumCounterIfNeeded(pars_, pit, first_pit, counters);
 
 		// FIXME
 		// Yes I know this is a really, really! bad solution
 		// (Lgb)
 		string enumcounter = "enum";
 
-		switch (pit->itemdepth) {
+		switch (pars_[pit].itemdepth) {
 		case 2:
 			enumcounter += 'i';
 		case 1:
@@ -767,13 +758,13 @@ void LyXText::setCounter(Buffer const & buf, ParagraphList::iterator pit)
 
 		counters.step(enumcounter);
 
-		pit->params().labelString(counters.enumLabel(enumcounter));
+		pars_[pit].params().labelString(counters.enumLabel(enumcounter));
 	} else if (layout->labeltype == LABEL_BIBLIO) {// ale970302
 		counters.step("bibitem");
 		int number = counters.value("bibitem");
-		if (pit->bibitem()) {
-			pit->bibitem()->setCounter(number);
-			pit->params().labelString(layout->labelstring());
+		if (pars_[pit].bibitem()) {
+			pars_[pit].bibitem()->setCounter(number);
+			pars_[pit].params().labelString(layout->labelstring());
 		}
 		// In biblio should't be following counters but...
 	} else {
@@ -781,14 +772,12 @@ void LyXText::setCounter(Buffer const & buf, ParagraphList::iterator pit)
 
 		// the caption hack:
 		if (layout->labeltype == LABEL_SENSITIVE) {
-			ParagraphList::iterator end = paragraphs().end();
-			ParagraphList::iterator tmppit = pit;
+			par_type end = paragraphs().size();
+			par_type tmppit = pit;
 			InsetBase * in = 0;
 			bool isOK = false;
-			while (tmppit != end && tmppit->inInset()
-			       // the single '=' is intended below
-			       && (in = tmppit->inInset()->owner()))
-			{
+			while (tmppit != end) {
+				in = pars_[tmppit].inInset();
 				if (in->lyxCode() == InsetBase::FLOAT_CODE ||
 				    in->lyxCode() == InsetBase::WRAP_CODE) {
 					isOK = true;
@@ -797,7 +786,7 @@ void LyXText::setCounter(Buffer const & buf, ParagraphList::iterator pit)
 					Paragraph const * owner = &ownerPar(buf, in);
 					tmppit = first_pit;
 					for ( ; tmppit != end; ++tmppit)
-						if (&*tmppit == owner)
+						if (&pars_[tmppit] == owner)
 							break;
 				}
 			}
@@ -824,7 +813,7 @@ void LyXText::setCounter(Buffer const & buf, ParagraphList::iterator pit)
 				s = _("Senseless: ");
 			}
 		}
-		pit->params().labelString(s);
+		pars_[pit].params().labelString(s);
 
 	}
 }
@@ -837,26 +826,26 @@ void LyXText::updateCounters()
 	bv()->buffer()->params().getLyXTextClass().counters().reset();
 
 	bool update_pos = false;
-	
-	ParagraphList::iterator beg = paragraphs().begin();
-	ParagraphList::iterator end = paragraphs().end();
-	for (ParagraphList::iterator pit = beg; pit != end; ++pit) {
-		string const oldLabel = pit->params().labelString();
+
+	par_type end = paragraphs().size();
+	for (par_type pit = 0; pit != end; ++pit) {
+		string const oldLabel = pars_[pit].params().labelString();
 		size_t maxdepth = 0;
-		if (pit != beg)
-			maxdepth = boost::prior(pit)->getMaxDepthAfter();
+		if (pit != 0)
+			maxdepth = pars_[pit - 1].getMaxDepthAfter();
 
-		if (pit->params().depth() > maxdepth)
-			pit->params().depth(maxdepth);
+		if (pars_[pit].params().depth() > maxdepth)
+			pars_[pit].params().depth(maxdepth);
 
 		// setCounter can potentially change the labelString.
 		setCounter(*bv()->buffer(), pit);
-		string const & newLabel = pit->params().labelString();
+		string const & newLabel = pars_[pit].params().labelString();
 		if (oldLabel != newLabel) {
+			//lyxerr << "changing labels: old: " << oldLabel << " new: "
+			//	<< newLabel << endl;
 			redoParagraphInternal(pit);
 			update_pos = true;
 		}
-		
 	}
 	if (update_pos)
 		updateParPositions();
@@ -872,172 +861,19 @@ void LyXText::insertInset(LCursor & cur, InsetBase * inset)
 }
 
 
-void LyXText::cutSelection(LCursor & cur, bool doclear, bool realcut)
-{
-	BOOST_ASSERT(this == cur.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)
-	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);
-	ParagraphList::iterator begpit = getPar(cur.selBegin().par());
-	ParagraphList::iterator endpit = getPar(cur.selEnd().par());
-	ParagraphList::iterator undopit = undoSpan(endpit);
-
-	int endpos = cur.selEnd().pos();
-
-	BufferParams const & bufparams = bv()->buffer()->params();
-	boost::tie(endpit, endpos) = realcut ?
-		CutAndPaste::cutSelection(bufparams,
-					  paragraphs(),
-					  begpit, endpit,
-					  cur.selBegin().pos(), endpos,
-					  bufparams.textclass,
-					  doclear)
-		: CutAndPaste::eraseSelection(bufparams,
-					      paragraphs(),
-					      begpit, endpit,
-					      cur.selBegin().pos(), endpos,
-					      doclear);
-	// sometimes necessary
-	if (doclear)
-		begpit->stripLeadingSpaces();
-
-	redoParagraphs(begpit, undopit);
-	// 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.par() = parOffset(endpit);
-
-	// need a valid cursor. (Lgb)
-	cur.clearSelection();
-	updateCounters();
-}
-
-
-void LyXText::copySelection(LCursor & cur)
-{
-	BOOST_ASSERT(this == cur.text());
-	// stuff the selection onto the X clipboard, from an explicit copy request
-	bv()->stuffClipboard(cur.selectionAsString(true));
-
-	// this doesnt make sense, if there is no selection
-	if (!cur.selection())
-		return;
-
-	// ok we have a selection. This is always between cur.selBegin()
-	// and sel_end cursor
-
-	// copy behind a space if there is one
-	while (getPar(cur.selBegin())->size() > cur.selBegin().pos()
-	       && getPar(cur.selBegin())->isLineSeparator(cur.selBegin().pos())
-	       && (cur.selBegin().par() != cur.selEnd().par()
-		   || cur.selBegin().pos() < cur.selEnd().pos()))
-		++cur.selBegin().pos();
-
-	CutAndPaste::copySelection(getPar(cur.selBegin().par()),
-				   getPar(cur.selEnd().par()),
-				   cur.selBegin().pos(), 
-				   cur.selEnd().pos(),
-				   bv()->buffer()->params().textclass);
-}
-
-
-void LyXText::pasteSelection(LCursor & cur, size_t sel_index)
-{
-	// this does not make sense, if there is nothing to paste
-	if (!CutAndPaste::checkPastePossible())
-		return;
-
-	recordUndo(cur);
-
-	ParagraphList::iterator endpit;
-	PitPosPair ppp;
-
-	ErrorList el;
-
-	boost::tie(ppp, endpit) =
-		CutAndPaste::pasteSelection(*bv()->buffer(),
-					    paragraphs(),
-					    getPar(cur.par()), cur.pos(),
-					    bv()->buffer()->params().textclass,
-					    sel_index, el);
-	bufferErrors(*bv()->buffer(), el);
-	bv()->showErrorList(_("Paste"));
-
-	redoParagraphs(getPar(cur.par()), endpit);
-
-	cur.clearSelection();
-	cur.resetAnchor();
-	setCursor(cur, parOffset(ppp.first), ppp.second);
-	cur.setSelection();
-	updateCounters();
-}
-
-
-void LyXText::setSelectionRange(LCursor & cur, lyx::pos_type length)
-{
-	if (!length)
-		return;
-	cur.resetAnchor();
-	while (length--)
-		cursorRight(cur);
-	cur.setSelection();
-}
-
-
-// simple replacing. The font of the first selected character is used
-void LyXText::replaceSelectionWithString(LCursor & cur, string const & str)
-{
-	recordUndo(cur);
-
-	// Get font setting before we cut
-	pos_type pos = cur.selEnd().pos();
-	LyXFont const font = getPar(cur.selBegin())
-		->getFontSettings(bv()->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) {
-		getPar(cur.selEnd())->insertChar(pos, (*cit), font);
-		++pos;
-	}
-
-	// Cut the selection
-	cutSelection(cur, true, false);
-}
-
-
 // needed to insert the selection
 void LyXText::insertStringAsLines(LCursor & cur, string const & str)
 {
-	ParagraphList::iterator pit = getPar(cur.par());
-	ParagraphList::iterator endpit = boost::next(pit);
-	pos_type pos = cursor().pos();
+	par_type pit = cur.par();
+	par_type endpit = cur.par() + 1;
+	pos_type pos = cur.pos();
 	recordUndo(cur);
 
 	// only to be sure, should not be neccessary
 	cur.clearSelection();
-	bv()->buffer()->insertStringAsLines(pit, pos, current_font, str);
+	cur.buffer().insertStringAsLines(pars_, pit, pos, current_font, str);
 
-	redoParagraphs(getPar(cur.par()), endpit);
+	redoParagraphs(cur.par(), endpit);
 	cur.resetAnchor();
 	setCursor(cur, cur.par(), pos);
 	cur.setSelection();
@@ -1074,9 +910,9 @@ void LyXText::insertStringAsParagraphs(LCursor & cur, string const & str)
 bool LyXText::setCursor(LCursor & cur, par_type par, pos_type pos,
 	bool setfont, bool boundary)
 {
-	CursorSlice old_cursor = cur.top();
+	LCursor old = cur;
 	setCursorIntern(cur, par, pos, setfont, boundary);
-	return deleteEmptyParagraphMechanism(cur.top(), old_cursor);
+	return deleteEmptyParagraphMechanism(cur, old);
 }
 
 
@@ -1094,7 +930,7 @@ void LyXText::setCursor(CursorSlice & cur, par_type par,
 		return;
 
 	// now some strict checking
-	Paragraph & para = *getPar(par);
+	Paragraph & para = getPar(par);
 	Row const & row = *para.getRow(pos);
 	pos_type const end = row.endpos();
 
@@ -1120,7 +956,7 @@ void LyXText::setCursor(CursorSlice & cur, par_type par,
 		// This shouldn't happen.
 		BOOST_ASSERT(false);
 	}
-	
+
 	if (pos < row.pos()) {
 		lyxerr << "dont like 3 please report pos:" << pos
 		       << " size: " << para.size()
@@ -1145,7 +981,7 @@ void LyXText::setCurrentFont(LCursor & cur)
 {
 	BOOST_ASSERT(this == cur.text());
 	pos_type pos = cur.pos();
-	ParagraphList::iterator pit = getPar(cur.par());
+	par_type pit = cur.par();
 
 	if (cur.boundary() && pos > 0)
 		--pos;
@@ -1154,7 +990,7 @@ void LyXText::setCurrentFont(LCursor & cur)
 		if (pos == cur.lastpos())
 			--pos;
 		else // potentional bug... BUG (Lgb)
-			if (pit->isSeparator(pos)) {
+			if (pars_[pit].isSeparator(pos)) {
 				if (pos > cur.textRow().pos() &&
 				    bidi.level(pos) % 2 ==
 				    bidi.level(pos - 1) % 2)
@@ -1164,14 +1000,14 @@ void LyXText::setCurrentFont(LCursor & cur)
 			}
 	}
 
-	BufferParams const & bufparams = bv()->buffer()->params();
-	current_font = pit->getFontSettings(bufparams, pos);
+	BufferParams const & bufparams = cur.buffer().params();
+	current_font = pars_[pit].getFontSettings(bufparams, pos);
 	real_current_font = getFont(pit, pos);
 
 	if (cur.pos() == cur.lastpos()
-	    && bidi.isBoundary(*bv()->buffer(), *pit, cur.pos())
+	    && bidi.isBoundary(cur.buffer(), pars_[pit], cur.pos())
 	    && !cur.boundary()) {
-		Language const * lang = pit->getParLanguage(bufparams);
+		Language const * lang = pars_[pit].getParLanguage(bufparams);
 		current_font.setLanguage(lang);
 		current_font.setNumber(LyXFont::OFF);
 		real_current_font.setLanguage(lang);
@@ -1183,26 +1019,26 @@ void LyXText::setCurrentFont(LCursor & cur)
 // x is an absolute screen coord
 // returns the column near the specified x-coordinate of the row
 // x is set to the real beginning of this column
-pos_type LyXText::getColumnNearX(ParagraphList::iterator pit,
+pos_type LyXText::getColumnNearX(par_type pit,
 	Row const & row, int & x, bool & boundary) const
 {
 	x -= xo_;
 	RowMetrics const r = computeRowMetrics(pit, row);
-	
+
 	pos_type vc = row.pos();
 	pos_type end = row.endpos();
 	pos_type c = 0;
-	LyXLayout_ptr const & layout = pit->layout();
+	LyXLayout_ptr const & layout = pars_[pit].layout();
 
 	bool left_side = false;
 
-	pos_type body_pos = pit->beginOfBody();
+	pos_type body_pos = pars_[pit].beginOfBody();
 
 	double tmpx = r.x;
 	double last_tmpx = tmpx;
 
 	if (body_pos > 0 &&
-	    (body_pos > end || !pit->isLineSeparator(body_pos - 1)))
+	    (body_pos > end || !pars_[pit].isLineSeparator(body_pos - 1)))
 		body_pos = 0;
 
 	// check for empty row
@@ -1217,17 +1053,17 @@ pos_type LyXText::getColumnNearX(ParagraphList::iterator pit,
 		if (body_pos > 0 && c == body_pos - 1) {
 			tmpx += r.label_hfill +
 				font_metrics::width(layout->labelsep, getLabelFont(pit));
-			if (pit->isLineSeparator(body_pos - 1))
+			if (pars_[pit].isLineSeparator(body_pos - 1))
 				tmpx -= singleWidth(pit, body_pos - 1);
 		}
 
-		if (hfillExpansion(*pit, row, c)) {
+		if (hfillExpansion(pars_[pit], row, c)) {
 			tmpx += singleWidth(pit, c);
 			if (c >= body_pos)
 				tmpx += r.hfill;
 			else
 				tmpx += r.label_hfill;
-		} else if (pit->isSeparator(c)) {
+		} else if (pars_[pit].isSeparator(c)) {
 			tmpx += singleWidth(pit, c);
 			if (c >= body_pos)
 				tmpx += r.separator;
@@ -1247,11 +1083,11 @@ pos_type LyXText::getColumnNearX(ParagraphList::iterator pit,
 	boundary = false;
 	// This (rtl_support test) is not needed, but gives
 	// some speedup if rtl_support == false
-	bool const lastrow = lyxrc.rtl_support && row.endpos() == pit->size();
+	bool const lastrow = lyxrc.rtl_support && row.endpos() == pars_[pit].size();
 
 	// If lastrow is false, we don't need to compute
 	// the value of rtl.
-	bool const rtl = lastrow ? isRTL(*pit) : false;
+	bool const rtl = lastrow ? isRTL(pars_[pit]) : false;
 	if (lastrow &&
 		 ((rtl  &&  left_side && vc == row.pos() && x < tmpx - 5) ||
 		  (!rtl && !left_side && vc == end  && x > tmpx + 5)))
@@ -1265,11 +1101,11 @@ pos_type LyXText::getColumnNearX(ParagraphList::iterator pit,
 		bool const rtl = (bidi.level(c) % 2 == 1);
 		if (left_side == rtl) {
 			++c;
-			boundary = bidi.isBoundary(*bv()->buffer(), *pit, c);
+			boundary = bidi.isBoundary(*bv()->buffer(), pars_[pit], c);
 		}
 	}
 
-	if (row.pos() < end && c >= end && pit->isNewline(end - 1)) {
+	if (row.pos() < end && c >= end && pars_[pit].isNewline(end - 1)) {
 		if (bidi.level(end -1) % 2 == 0)
 			tmpx -= singleWidth(pit, end - 1);
 		else
@@ -1287,45 +1123,42 @@ void LyXText::setCursorFromCoordinates(LCursor & cur, int x, int y)
 {
 	x -= xo_;
 	y -= yo_;
-	CursorSlice old_cursor = cur.top();
-	ParagraphList::iterator pit;
-	Row const & row = *getRowNearY(y, pit);
-	lyxerr << "hit row at: " << row.pos() << endl;
+	par_type pit;
+	Row const & row = getRowNearY(y, pit);
+	lyxerr << "setCursorFromCoordinates:: hit row at: " << row.pos() << endl;
 	bool bound = false;
 	int xx = x + xo_; // getRowNearX get absolute x coords
 	pos_type const pos = row.pos() + getColumnNearX(pit, row, xx, bound);
-	cur.par() = parOffset(pit);
-	cur.pos() = pos;
-	cur.boundary() = bound;
-	deleteEmptyParagraphMechanism(cur.top(), old_cursor);
+	setCursor(cur, pit, pos, true, bound);
 }
 
 
 // x,y are absolute screen coordinates
 InsetBase * LyXText::editXY(LCursor & cur, int x, int y)
 {
-	ParagraphList::iterator pit;
-	Row const & row = *getRowNearY(y - yo_, pit);
+	par_type pit;
+	Row const & row = getRowNearY(y - yo_, pit);
 	bool bound = false;
 
 	int xx = x; // is modified by getColumnNearX
 	pos_type const pos = row.pos() + getColumnNearX(pit, row, xx, bound);
-	cur.par() = parOffset(pit);
+	cur.par() = pit;
 	cur.pos() = pos;
 	cur.boundary() = bound;
 
 	// try to descend into nested insets
 	InsetBase * inset = checkInsetHit(x, y);
+	lyxerr << "inset " << inset << " hit at x: " << x << " y: " << y << endl;
 	if (!inset)
 		return 0;
 
 	// This should be just before or just behind the
 	// cursor position set above.
-	BOOST_ASSERT((pos != 0 && inset == pit->getInset(pos - 1))
-	             || inset == pit->getInset(pos));
+	BOOST_ASSERT((pos != 0 && inset == pars_[pit].getInset(pos - 1))
+	             || inset == pars_[pit].getInset(pos));
 	// Make sure the cursor points to the position before
 	// this inset.
-	if (inset == pit->getInset(pos - 1))
+	if (inset == pars_[pit].getInset(pos - 1))
 		--cur.pos();
 	return inset->editXY(cur, x, y);
 }
@@ -1352,15 +1185,15 @@ void LyXText::cursorLeft(LCursor & cur)
 		setCursor(cur, cur.par(), cur.pos() - 1, true, false);
 		if (!checkAndActivateInset(cur, false)) {
 			if (false && !boundary &&
-					bidi.isBoundary(*bv()->buffer(), cur.paragraph(), cur.pos() + 1))
+					bidi.isBoundary(cur.buffer(), cur.paragraph(), cur.pos() + 1))
 				setCursor(cur, cur.par(), cur.pos() + 1, true, true);
-			return;
 		}
+		return;
 	}
 
 	if (cur.par() != 0) {
 		// steps into the paragraph above
-		setCursor(cur, cur.par() - 1, getPar(cur.par() - 1)->size());
+		setCursor(cur, cur.par() - 1, getPar(cur.par() - 1).size());
 	}
 }
 
@@ -1373,9 +1206,9 @@ void LyXText::cursorRight(LCursor & cur)
 	}
 
 	if (cur.pos() != cur.lastpos()) {
-		if (!checkAndActivateInset(cur, true)) { 
+		if (!checkAndActivateInset(cur, true)) {
 			setCursor(cur, cur.par(), cur.pos() + 1, true, false);
-			if (false && bidi.isBoundary(*bv()->buffer(), cur.paragraph(),
+			if (false && bidi.isBoundary(cur.buffer(), cur.paragraph(),
 							 cur.pos()))
 				setCursor(cur, cur.par(), cur.pos(), true, true);
 		}
@@ -1455,20 +1288,18 @@ void LyXText::fixCursorAfterDelete(CursorSlice & cur, CursorSlice const & where)
 }
 
 
-bool LyXText::deleteEmptyParagraphMechanism(CursorSlice & cur,
-	CursorSlice const & old_cursor)
+bool LyXText::deleteEmptyParagraphMechanism(LCursor & cur, LCursor const & old)
 {
-#warning Disabled as it crashes after the cursor data shift... (Andre)
-	return false;
-
+	BOOST_ASSERT(cur.size() == old.size());
 	// Would be wrong to delete anything if we have a selection.
-	//if (cur.selection())
-	//	return false;
+	if (cur.selection())
+		return false;
+
+	//lyxerr << "DEPM: cur:\n" << cur << "old:\n" << old << endl;
+	Paragraph const & oldpar = pars_[old.par()];
 
-#if 0
 	// We allow all kinds of "mumbo-jumbo" when freespacing.
-	ParagraphList::iterator const old_pit = getPar(old_cursor.par());
-	if (old_pit->isFreeSpacing())
+	if (oldpar.isFreeSpacing())
 		return false;
 
 	/* Ok I'll put some comments here about what is missing.
@@ -1486,104 +1317,101 @@ bool LyXText::deleteEmptyParagraphMechanism(CursorSlice & cur,
 	   that I can get some feedback. (Lgb)
 	*/
 
-	// If old_cursor.pos() == 0 and old_cursor.pos()(1) == LineSeparator
+	// If old.pos() == 0 and old.pos()(1) == LineSeparator
 	// delete the LineSeparator.
 	// MISSING
 
-	// If old_cursor.pos() == 1 and old_cursor.pos()(0) == LineSeparator
+	// If old.pos() == 1 and old.pos()(0) == LineSeparator
 	// delete the LineSeparator.
 	// MISSING
 
-	// If the pos around the old_cursor were spaces, delete one of them.
-	if (old_cursor.par() != cur.par() || old_cursor.pos() != cur.pos()) {
-
-		// Only if the cursor has really moved
-		if (old_cursor.pos() > 0
-		    && old_cursor.pos() < old_pit->size()
-		    && old_pit->isLineSeparator(old_cursor.pos())
-		    && old_pit->isLineSeparator(old_cursor.pos() - 1)) {
-			bool erased = old_pit->erase(old_cursor.pos() - 1);
-			redoParagraph(old_pit);
+	// If the chars around the old cursor were spaces, delete one of them.
+	if (old.par() != cur.par() || old.pos() != cur.pos()) {
 
-			if (!erased)
-				return false;
+		// Only if the cursor has really moved.
+		if (old.pos() > 0
+		    && old.pos() < oldpar.size()
+		    && oldpar.isLineSeparator(old.pos())
+		    && oldpar.isLineSeparator(old.pos() - 1)) {
+			pars_[old.par()].erase(old.pos() - 1);
 #ifdef WITH_WARNINGS
 #warning This will not work anymore when we have multiple views of the same buffer
 // In this case, we will have to correct also the cursors held by
 // other bufferviews. It will probably be easier to do that in a more
 // automated way in CursorSlice code. (JMarc 26/09/2001)
 #endif
-			// correct all cursors held by the LyXText
-			fixCursorAfterDelete(cursor(), old_cursor);
-			fixCursorAfterDelete(anchor(), old_cursor);
+			// correct all cursor parts
+			fixCursorAfterDelete(cur.top(), old.top());
+#ifdef WITH_WARNINGS
+#warning DEPM, look here
+#endif
+			//fixCursorAfterDelete(cur.anchor(), old.top());
 			return false;
 		}
 	}
 
-	// don't delete anything if this is the ONLY paragraph!
-	if (paragraphs().size() == 1)
+	// only do our magic if we changed paragraph
+	if (old.par() == cur.par())
 		return false;
 
-	// Do not delete empty paragraphs with keepempty set.
-	if (old_pit->allowEmpty())
+	// don't delete anything if this is the ONLY paragraph!
+	if (pars_.size() == 1)
 		return false;
 
-	// only do our magic if we changed paragraph
-	if (old_cursor.par() == cur.par())
+	// Do not delete empty paragraphs with keepempty set.
+	if (oldpar.allowEmpty())
 		return false;
 
 	// record if we have deleted a paragraph
 	// we can't possibly have deleted a paragraph before this point
 	bool deleted = false;
 
-	if (old_pit->empty()
-	    || (old_pit->size() == 1 && old_pit->isLineSeparator(0))) {
+	if (oldpar.empty() || (oldpar.size() == 1 && oldpar.isLineSeparator(0))) {
 		// ok, we will delete something
 		CursorSlice tmpcursor;
 
 		deleted = true;
 
 		bool selection_position_was_oldcursor_position =
-			anchor().par() == old_cursor.par()
-			&& anchor().pos() == old_cursor.pos();
+			cur.anchor().par() == old.par() && cur.anchor().pos() == old.pos();
 
-		tmpcursor = cursor();
-		cursor() = old_cursor; // that undo can restore the right cursor position
+		// This is a bit of a overkill. We change the old and the cur par
+		// at max, certainly not everything in between...
+		recUndo(old.par(), cur.par());
 
-		ParagraphList::iterator endpit = boost::next(old_pit);
-		while (endpit != paragraphs().end() && endpit->getDepth())
-			++endpit;
+		// Delete old par.
+		pars_.erase(pars_.begin() + old.par());
 
-		recUndo(parOffset(old_pit), parOffset(endpit) - 1);
-		cursor() = tmpcursor;
-
-		// delete old par
-		paragraphs().erase(old_pit);
-		// update cursor par offset
-		--cur.par();
-		redoParagraph();
+		// Update cursor par offset if necessary.
+		// Some 'iterator registration' would be nice that takes care of
+		// such events. Maybe even signal/slot?
+		if (cur.par() > old.par())
+			--cur.par();
+#ifdef WITH_WARNINGS
+#warning DEPM, look here
+#endif
+//		if (cur.anchor().par() > old.par())
+//			--cur.anchor().par();
 
 		if (selection_position_was_oldcursor_position) {
 			// correct selection
-			bv()->resetAnchor();
+			cur.resetAnchor();
 		}
 	}
 
 	if (deleted)
 		return true;
 
-	if (old_pit->stripLeadingSpaces()) {
-		redoParagraph(old_pit);
-		bv()->resetAnchor();
-	}
+	if (pars_[old.par()].stripLeadingSpaces())
+		cur.resetAnchor();
+
 	return false;
-#endif
 }
 
 
 ParagraphList & LyXText::paragraphs() const
 {
-	return const_cast<ParagraphList &>(paragraphs_);
+	return const_cast<ParagraphList &>(pars_);
 }
 
 
@@ -1599,32 +1427,6 @@ void LyXText::recUndo(par_type par) const
 }
 
 
-bool LyXText::isInInset() const
-{
-	return in_inset_;
-}
-
-
-bool LyXText::toggleInset(LCursor & cur)
-{
-	InsetBase * inset = cur.nextInset();
-	// is there an editable inset at cursor position?
-	if (!isEditableInset(inset))
-		return false;
-	cur.message(inset->editMessage());
-
-	// do we want to keep this?? (JMarc)
-	if (!isHighlyEditableInset(inset))
-		recordUndo(cur);
-
-	if (inset->isOpen())
-		inset->close();
-	else
-		inset->open();
-	return true;
-}
-
-
 int defaultRowHeight()
 {
 	return int(font_metrics::maxHeight(LyXFont(LyXFont::ALL_SANE)) *  1.2);