X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Ftext2.C;h=97fc51aa5b048f91b88c6b82dfdd8765816c54b7;hb=c96136c04080415efdfb6df9b3d25f9e2e732782;hp=cbb515d11666fbe1c5af2021f3840617713fb60a;hpb=ebdfad1c623d046f545fe06d080025a62ecc403d;p=lyx.git

diff --git a/src/text2.C b/src/text2.C
index cbb515d116..97fc51aa5b 100644
--- a/src/text2.C
+++ b/src/text2.C
@@ -1,22 +1,35 @@
-/* This file is part of
- * ======================================================
+/**
+ * \file text2.C
+ * This file is part of LyX, the document processor.
+ * Licence details can be found in the file COPYING.
  *
- *           LyX, The Document Processor
+ * \author Asger Alstrup
+ * \author Lars Gullik Bjønnes
+ * \author Alfredo Braunstein
+ * \author Jean-Marc Lasgouttes
+ * \author Angus Leeming
+ * \author John Levon
+ * \author André Pönitz
+ * \author Allan Rae
+ * \author Dekel Tsur
+ * \author Jürgen Vigna
  *
- *           Copyright 1995 Matthias Ettrich
- *           Copyright 1995-2001 The LyX Team.
- *
- * ====================================================== */
+ * Full author contact details are available in file CREDITS.
+ */
 
 #include <config.h>
 
 #include "lyxtext.h"
 #include "LString.h"
+#include "Lsstream.h"
 #include "paragraph.h"
+#include "funcrequest.h"
 #include "frontends/LyXView.h"
 #include "undo_funcs.h"
 #include "buffer.h"
+#include "buffer_funcs.h"
 #include "bufferparams.h"
+#include "errorlist.h"
 #include "gettext.h"
 #include "BufferView.h"
 #include "CutAndPaste.h"
@@ -24,15 +37,16 @@
 #include "frontends/font_metrics.h"
 #include "debug.h"
 #include "lyxrc.h"
-#include "lyxrow.h"
 #include "FloatList.h"
 #include "language.h"
 #include "ParagraphParameters.h"
 #include "counters.h"
 #include "lyxrow_funcs.h"
+#include "metricsinfo.h"
 #include "paragraph_funcs.h"
 
 #include "insets/insetbibitem.h"
+#include "insets/insetenv.h"
 #include "insets/insetfloat.h"
 #include "insets/insetwrap.h"
 
@@ -40,9 +54,12 @@
 #include "support/textutils.h"
 #include "support/lstrings.h"
 
-#include "support/BoostFormat.h"
 #include <boost/tuple/tuple.hpp>
 
+#include <algorithm>
+
+using namespace lyx::support;
+
 using std::vector;
 using std::copy;
 using std::endl;
@@ -51,50 +68,33 @@ using std::pair;
 using lyx::pos_type;
 
 
-LyXText::LyXText(BufferView * bv)
-	: height(0), width(0), anchor_row_offset_(0),
-	  inset_owner(0), the_locking_inset(0), bv_owner(bv)
+LyXText::LyXText(BufferView * bv, InsetText * inset, bool ininset,
+	  ParagraphList & paragraphs)
+	: height(0), width(0), anchor_y_(0),
+	  inset_owner(inset), the_locking_inset(0), bv_owner(bv),
+	  in_inset_(ininset), paragraphs_(paragraphs)
 {
-	anchor_row_ = rows().end();
-	need_break_row = rows().end();
-	refresh_row = rows().end();
-
-	clearPaint();
 }
 
 
-LyXText::LyXText(BufferView * bv, InsetText * inset)
-	: height(0), width(0), anchor_row_offset_(0),
-	  inset_owner(inset), the_locking_inset(0), bv_owner(bv)
+void LyXText::init(BufferView * bview)
 {
-	anchor_row_ = rows().end();
-	need_break_row = rows().end();
-	refresh_row = rows().end();
+	bv_owner = bview;
 
-	clearPaint();
-}
+	ParagraphList::iterator const beg = ownerParagraphs().begin();
+	ParagraphList::iterator const end = ownerParagraphs().end();
+	for (ParagraphList::iterator pit = beg; pit != end; ++pit)
+		pit->rows.clear();
 
+	width = 0;
+	height = 0;
 
-void LyXText::init(BufferView * bview, bool reinit)
-{
-	if (reinit) {
-		rowlist_.clear();
-		need_break_row = rows().end();
-		width = height = 0;
-		top_y(0);
-		clearPaint();
-	} else if (!rowlist_.empty())
-		return;
-
-	ParagraphList::iterator pit = ownerParagraphs().begin();
-	ParagraphList::iterator end = ownerParagraphs().end();
+	anchor_y_ = 0;
 
-	current_font = getFont(bview->buffer(), pit, 0);
+	current_font = getFont(beg, 0);
 
-	for (; pit != end; ++pit) {
-		insertParagraph(pit, rowlist_.end());
-	}
-	setCursorIntern(rowlist_.begin()->par(), 0);
+	redoParagraphs(beg, end);
+	setCursorIntern(beg, 0);
 	selection.cursor = cursor;
 
 	updateCounters();
@@ -106,26 +106,25 @@ void LyXText::init(BufferView * bview, bool reinit)
 // 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)
-// If position is -1, we get the layout font of the paragraph.
-// If position is -2, we get the font of the manual label of the paragraph.
-LyXFont const LyXText::getFont(Buffer const * buf, ParagraphList::iterator pit,
-			       pos_type pos) const
+LyXFont LyXText::getFont(ParagraphList::iterator pit, pos_type pos) const
 {
-	lyx::Assert(pos >= 0);
+	Assert(pos >= 0);
 
 	LyXLayout_ptr const & layout = pit->layout();
+#warning broken?
+	BufferParams const & params = bv()->buffer()->params;
 
 	// We specialize the 95% common case:
 	if (!pit->getDepth()) {
 		if (layout->labeltype == LABEL_MANUAL
 		    && pos < pit->beginningOfBody()) {
 			// 1% goes here
-			LyXFont f = pit->getFontSettings(buf->params, pos);
+			LyXFont f = pit->getFontSettings(params, pos);
 			if (pit->inInset())
 				pit->inInset()->getDrawFont(f);
 			return f.realize(layout->reslabelfont);
 		} else {
-			LyXFont f = pit->getFontSettings(buf->params, pos);
+			LyXFont f = pit->getFontSettings(params, pos);
 			if (pit->inInset())
 				pit->inInset()->getDrawFont(f);
 			return f.realize(layout->resfont);
@@ -144,7 +143,7 @@ LyXFont const LyXText::getFont(Buffer const * buf, ParagraphList::iterator pit,
 		layoutfont = layout->font;
 	}
 
-	LyXFont tmpfont = pit->getFontSettings(buf->params, pos);
+	LyXFont tmpfont = pit->getFontSettings(params, pos);
 	tmpfont.realize(layoutfont);
 
 	if (pit->inInset())
@@ -152,42 +151,41 @@ LyXFont const LyXText::getFont(Buffer const * buf, ParagraphList::iterator pit,
 
 	// Realize with the fonts of lesser depth.
 	tmpfont.realize(outerFont(pit, ownerParagraphs()));
+	tmpfont.realize(defaultfont_);
 
-	return realizeFont(tmpfont, buf->params);
+	return tmpfont;
 }
 
 
-LyXFont const LyXText::getLayoutFont(Buffer const * buf,
-				     ParagraphList::iterator pit) const
+LyXFont LyXText::getLayoutFont(ParagraphList::iterator pit) const
 {
 	LyXLayout_ptr const & layout = pit->layout();
 
-	if (!pit->getDepth()) {
+	if (!pit->getDepth())
 		return layout->resfont;
-	}
 
-	LyXFont font(layout->font);
+	LyXFont font = layout->font;
 	// Realize with the fonts of lesser depth.
 	font.realize(outerFont(pit, ownerParagraphs()));
+	font.realize(defaultfont_);
 
-	return realizeFont(font, buf->params);
+	return font;
 }
 
 
-LyXFont const LyXText::getLabelFont(Buffer const * buf,
-				    ParagraphList::iterator pit) const
+LyXFont LyXText::getLabelFont(ParagraphList::iterator pit) const
 {
 	LyXLayout_ptr const & layout = pit->layout();
 
-	if (!pit->getDepth()) {
+	if (!pit->getDepth())
 		return layout->reslabelfont;
-	}
 
-	LyXFont font(layout->labelfont);
+	LyXFont font = layout->labelfont;
 	// Realize with the fonts of lesser depth.
 	font.realize(outerFont(pit, ownerParagraphs()));
+	font.realize(defaultfont_);
 
-	return realizeFont(layout->labelfont, buf->params);
+	return font;
 }
 
 
@@ -195,30 +193,27 @@ void LyXText::setCharFont(ParagraphList::iterator pit,
 			  pos_type pos, LyXFont const & fnt,
 			  bool toggleall)
 {
-	Buffer const * buf = bv()->buffer();
-	LyXFont font = getFont(buf, pit, pos);
-	font.update(fnt, buf->params.language, toggleall);
+	BufferParams const & params = bv()->buffer()->params;
+	LyXFont font = getFont(pit, pos);
+	font.update(fnt, params.language, toggleall);
 	// Let the insets convert their font
 	if (pit->isInset(pos)) {
-		Inset * inset = pit->getInset(pos);
+		InsetOld * inset = pit->getInset(pos);
 		if (isEditableInset(inset)) {
-			UpdatableInset * uinset =
-				static_cast<UpdatableInset *>(inset);
-			uinset->setFont(bv(), fnt, toggleall, true);
+			static_cast<UpdatableInset *>(inset)
+				->setFont(bv(), fnt, toggleall, true);
 		}
 	}
 
-	// Plug thru to version below:
-	setCharFont(buf, pit, pos, font);
+	// Plug through to version below:
+	setCharFont(pit, pos, font);
 }
 
 
-void LyXText::setCharFont(Buffer const * buf, ParagraphList::iterator pit,
-			  pos_type pos, LyXFont const & fnt)
+void LyXText::setCharFont(
+	ParagraphList::iterator pit, pos_type pos, LyXFont const & fnt)
 {
-	LyXFont font(fnt);
-
-	LyXTextClass const & tclass = buf->params.getLyXTextClass();
+	LyXFont font = fnt;
 	LyXLayout_ptr const & layout = pit->layout();
 
 	// Get concrete layout font to reduce against
@@ -241,7 +236,7 @@ void LyXText::setCharFont(Buffer const * buf, ParagraphList::iterator pit,
 		}
 	}
 
-	layoutfont.realize(tclass.defaultfont());
+	layoutfont.realize(defaultfont_);
 
 	// Now, reduce font against full layout font
 	font.reduce(layoutfont);
@@ -250,64 +245,7 @@ void LyXText::setCharFont(Buffer const * buf, ParagraphList::iterator pit,
 }
 
 
-// removes the row and reset the touched counters
-void LyXText::removeRow(RowList::iterator rit)
-{
-	/* FIXME: when we cache the bview, this should just
-	 * become a postPaint(), I think */
-	if (refresh_row == rit) {
-		if (rit == rows().begin())
-			refresh_row = boost::next(rit);
-		else
-			refresh_row = boost::prior(rit);
-
-		// what about refresh_y
-	}
-
-	if (anchor_row_ == rit) {
-		if (rit != rows().begin()) {
-			anchor_row_ = boost::prior(rit);
-			anchor_row_offset_ += anchor_row_->height();
-		} else {
-			anchor_row_ = boost::next(rit);
-			anchor_row_offset_ -= rit->height();
-		}
-	}
-
-	// the text becomes smaller
-	height -= rit->height();
-
-	rowlist_.erase(rit);
-}
-
-
-// remove all following rows of the paragraph of the specified row.
-void LyXText::removeParagraph(RowList::iterator rit)
-{
-	ParagraphList::iterator tmppit = rit->par();
-	++rit;
-
-	while (rit != rows().end() && rit->par() == tmppit) {
-		RowList::iterator tmprit = boost::next(rit);
-		removeRow(rit);
-		rit = tmprit;
-	}
-}
-
-
-void LyXText::insertParagraph(ParagraphList::iterator pit,
-			      RowList::iterator rowit)
-{
-	// insert a new row, starting at position 0
-	Row newrow(pit, 0);
-	RowList::iterator rit = rowlist_.insert(rowit, newrow);
-
-	// and now append the whole paragraph before the new row
-	appendParagraph(rit);
-}
-
-
-Inset * LyXText::getInset() const
+InsetOld * LyXText::getInset() const
 {
 	ParagraphList::iterator pit = cursor.par();
 	pos_type const pos = cursor.pos();
@@ -321,13 +259,13 @@ Inset * LyXText::getInset() const
 
 void LyXText::toggleInset()
 {
-	Inset * inset = getInset();
+	InsetOld * inset = getInset();
 	// is there an editable inset at cursor position?
 	if (!isEditableInset(inset)) {
 		// No, try to see if we are inside a collapsable inset
 		if (inset_owner && inset_owner->owner()
 		    && inset_owner->owner()->isOpen()) {
-			bv()->unlockInset(static_cast<UpdatableInset *>(inset_owner->owner()));
+			bv()->unlockInset(inset_owner->owner());
 			inset_owner->owner()->close(bv());
 			bv()->getLyXText()->cursorRight(bv());
 		}
@@ -337,13 +275,12 @@ void LyXText::toggleInset()
 
 	// do we want to keep this?? (JMarc)
 	if (!isHighlyEditableInset(inset))
-		setCursorParUndo(bv());
+		recordUndo(bv(), Undo::ATOMIC);
 
-	if (inset->isOpen()) {
+	if (inset->isOpen())
 		inset->close(bv());
-	} else {
+	else
 		inset->open(bv());
-	}
 
 	bv()->updateInset(inset);
 }
@@ -351,7 +288,7 @@ void LyXText::toggleInset()
 
 /* used in setlayout */
 // Asger is not sure we want to do this...
-void LyXText::makeFontEntriesLayoutSpecific(Buffer const & buf,
+void LyXText::makeFontEntriesLayoutSpecific(BufferParams const & params,
 					    Paragraph & par)
 {
 	LyXLayout_ptr const & layout = par.layout();
@@ -364,7 +301,7 @@ void LyXText::makeFontEntriesLayoutSpecific(Buffer const & buf,
 		else
 			layoutfont = layout->font;
 
-		LyXFont tmpfont = par.getFontSettings(buf.params, pos);
+		LyXFont tmpfont = par.getFontSettings(params, pos);
 		tmpfont.reduce(layoutfont);
 		par.setFont(pos, tmpfont);
 	}
@@ -390,7 +327,7 @@ LyXText::setLayout(LyXCursor & cur, LyXCursor & sstart_cur,
 		++endpit;
 	}
 
-	setUndo(bv(), Undo::EDIT, sstart_cur.par(), undoendpit);
+	recordUndo(bv(), Undo::ATOMIC, sstart_cur.par(), boost::prior(undoendpit));
 
 	// ok we have a selection. This is always between sstart_cur
 	// and sel_end cursor
@@ -403,12 +340,11 @@ LyXText::setLayout(LyXCursor & cur, LyXCursor & sstart_cur,
 
 	do {
 		pit->applyLayout(lyxlayout);
-		makeFontEntriesLayoutSpecific(*bv()->buffer(), *pit);
-		ParagraphList::iterator fppit = pit;
-		fppit->params().spaceTop(lyxlayout->fill_top ?
+		makeFontEntriesLayoutSpecific(bv()->buffer()->params, *pit);
+		pit->params().spaceTop(lyxlayout->fill_top ?
 					 VSpace(VSpace::VFILL)
 					 : VSpace(VSpace::NONE));
-		fppit->params().spaceBottom(lyxlayout->fill_bottom ?
+		pit->params().spaceBottom(lyxlayout->fill_bottom ?
 					    VSpace(VSpace::VFILL)
 					    : VSpace(VSpace::NONE));
 		if (lyxlayout->margintype == MARGIN_MANUAL)
@@ -424,22 +360,41 @@ LyXText::setLayout(LyXCursor & cur, LyXCursor & sstart_cur,
 // set layout over selection and make a total rebreak of those paragraphs
 void LyXText::setLayout(string const & layout)
 {
-	LyXCursor tmpcursor = cursor;  /* store the current cursor  */
+	LyXCursor tmpcursor = cursor;  // store the current cursor
 
 	// if there is no selection just set the layout
-	// of the current paragraph  */
+	// of the current paragraph
 	if (!selection.set()) {
 		selection.start = cursor;  // dummy selection
 		selection.end = cursor;
 	}
+
+	// special handling of new environment insets
+	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));
+		InsetOld * inset = new InsetEnvironment(params, layout);
+		if (bv()->insertInset(inset)) {
+			//inset->edit(bv());
+			//bv()->owner()->dispatch(FuncRequest(LFUN_PASTE));
+		}
+		else
+			delete inset;
+		return;
+	}
+
 	ParagraphList::iterator endpit = setLayout(cursor, selection.start,
 						   selection.end, layout);
-	redoParagraphs(selection.start, endpit);
+	redoParagraphs(selection.start.par(), endpit);
 
 	// we have to reset the selection, because the
 	// geometry could have changed
-	setCursor(selection.start.par(),
-		  selection.start.pos(), false);
+	setCursor(selection.start.par(), selection.start.pos(), false);
 	selection.cursor = cursor;
 	setCursor(selection.end.par(), selection.end.pos(), false);
 	updateCounters();
@@ -451,8 +406,8 @@ void LyXText::setLayout(string const & layout)
 
 bool LyXText::changeDepth(bv_funcs::DEPTH_CHANGE type, bool test_only)
 {
-	ParagraphList::iterator pit(cursor.par());
-	ParagraphList::iterator end(cursor.par());
+	ParagraphList::iterator pit = cursor.par();
+	ParagraphList::iterator end = cursor.par();
 	ParagraphList::iterator start = pit;
 
 	if (selection.set()) {
@@ -464,7 +419,7 @@ bool LyXText::changeDepth(bv_funcs::DEPTH_CHANGE type, bool test_only)
 	ParagraphList::iterator pastend = boost::next(end);
 
 	if (!test_only)
-		setUndo(bv(), Undo::EDIT, start, pastend);
+		recordUndo(bv(), Undo::ATOMIC, start, end);
 
 	bool changed = false;
 
@@ -480,10 +435,8 @@ bool LyXText::changeDepth(bv_funcs::DEPTH_CHANGE type, bool test_only)
 			if (depth < prev_after_depth
 			    && pit->layout()->labeltype != LABEL_BIBLIO) {
 				changed = true;
-				if (!test_only) {
+				if (!test_only)
 					pit->params().depth(depth + 1);
-				}
-
 			}
 		} else if (depth) {
 			changed = true;
@@ -503,16 +456,11 @@ bool LyXText::changeDepth(bv_funcs::DEPTH_CHANGE type, bool test_only)
 	if (test_only)
 		return changed;
 
-	// Wow, redoParagraphs is stupid.
-	LyXCursor tmpcursor;
-	setCursor(tmpcursor, &(*start), 0);
-
-	//redoParagraphs(tmpcursor, &(*pastend));
-	redoParagraphs(tmpcursor, &(*pastend));
+	redoParagraphs(start, pastend);
 
 	// We need to actually move the text->cursor. I don't
 	// understand why ...
-	tmpcursor = cursor;
+	LyXCursor tmpcursor = cursor;
 
 	// we have to reset the visual selection because the
 	// geometry could have changed
@@ -541,11 +489,9 @@ void LyXText::setFont(LyXFont const & font, bool toggleall)
 		// Determine basis font
 		LyXFont layoutfont;
 		if (cursor.pos() < cursor.par()->beginningOfBody()) {
-			layoutfont = getLabelFont(bv()->buffer(),
-						  cursor.par());
+			layoutfont = getLabelFont(cursor.par());
 		} else {
-			layoutfont = getLayoutFont(bv()->buffer(),
-						   cursor.par());
+			layoutfont = getLayoutFont(cursor.par());
 		}
 		// Update current font
 		real_current_font.update(font,
@@ -566,8 +512,7 @@ void LyXText::setFont(LyXFont const & font, bool toggleall)
 	// ok we have a selection. This is always between sel_start_cursor
 	// and sel_end cursor
 
-	setUndo(bv(), Undo::EDIT,
-		selection.start.par(), boost::next(selection.end.par()));
+	recordUndo(bv(), Undo::ATOMIC, selection.start.par(), selection.end.par());
 	freezeUndo();
 	cursor = selection.start;
 	while (cursor.par() != selection.end.par() ||
@@ -585,7 +530,7 @@ void LyXText::setFont(LyXFont const & font, bool toggleall)
 	}
 	unFreezeUndo();
 
-	redoParagraphs(selection.start, boost::next(selection.end.par()));
+	redoParagraph(selection.start.par());
 
 	// we have to reset the selection, because the
 	// geometry could have changed, but we keep
@@ -599,121 +544,97 @@ void LyXText::setFont(LyXFont const & font, bool toggleall)
 }
 
 
-void LyXText::redoHeightOfParagraph()
+int LyXText::redoParagraphInternal(ParagraphList::iterator pit)
 {
-	RowList::iterator tmprow = cursor.row();
-	int y = cursor.y() - tmprow->baseline();
+	RowList::iterator rit = pit->rows.begin();
+	RowList::iterator end = pit->rows.end();
 
-	setHeightOfRow(tmprow);
+	// remove rows of paragraph, keep track of height changes
+	for (int i = 0; rit != end; ++rit, ++i)
+		height -= rit->height();
+	pit->rows.clear();
 
-	while (tmprow != rows().begin()
-	       && boost::prior(tmprow)->par() == tmprow->par()) {
-		--tmprow;
-		y -= tmprow->height();
-		setHeightOfRow(tmprow);
+	// redo insets
+	InsetList::iterator ii = pit->insetlist.begin();
+	InsetList::iterator iend = pit->insetlist.end();
+	for (; ii != iend; ++ii) {
+		Dimension dim;
+		MetricsInfo mi(bv(), getFont(pit, ii->pos), workWidth());
+		ii->inset->metrics(mi, dim);
 	}
 
-	postPaint(y);
-
-	setCursor(cursor.par(), cursor.pos(), false, cursor.boundary());
-}
-
-
-void LyXText::redoDrawingOfParagraph(LyXCursor const & cur)
-{
-	RowList::iterator tmprow = cur.row();
-
-	int y = cur.y() - tmprow->baseline();
-	setHeightOfRow(tmprow);
+	// rebreak the paragraph
+	for (pos_type z = 0; z < pit->size() + 1; ) {
+		Row row(z);
+		z = rowBreakPoint(pit, row) + 1;
+		row.end(z);
+		pit->rows.push_back(row);
+	}
 
-	while (tmprow != rows().begin()
-	       && boost::prior(tmprow)->par() == tmprow->par())  {
-		--tmprow;
-		y -= tmprow->height();
+	int par_width = 0;
+	// set height and fill and width of rows
+	int const ww = workWidth();
+	for (rit = pit->rows.begin(); rit != end; ++rit) {
+		int const f = fill(pit, rit, ww);
+		int const w = ww - f;
+		par_width = std::max(par_width, w);
+		rit->fill(f);
+		rit->width(w);
+		prepareToPrint(pit, rit);
+		setHeightOfRow(pit, rit);
+		height += rit->height();
 	}
 
-	postPaint(y);
-	setCursor(cur.par(), cur.pos());
+	//lyxerr << "redoParagraph: " << pit->rows.size() << " rows\n";
+	return par_width;
 }
 
 
-// deletes and inserts again all paragaphs between the cursor
-// and the specified par
-// This function is needed after SetLayout and SetFont etc.
-void LyXText::redoParagraphs(LyXCursor const & cur,
-			     ParagraphList::iterator endpit)
+int LyXText::redoParagraphs(ParagraphList::iterator start,
+  ParagraphList::iterator end)
 {
-	RowList::iterator tmprit = cur.row();
-	int y = cur.y() - tmprit->baseline();
-
-	ParagraphList::iterator first_phys_pit;
-	RowList::iterator prevrit;
-	if (tmprit == rows().begin()) {
-		// A trick/hack for UNDO.
-		// This is needed because in an UNDO/REDO we could have
-		// changed the ownerParagrah() so the paragraph inside
-		// the row is NOT my really first par anymore.
-		// Got it Lars ;) (Jug 20011206)
-		first_phys_pit = ownerParagraphs().begin();
-		prevrit = rows().end();
-	} else {
-		first_phys_pit = tmprit->par();
-		while (tmprit != rows().begin()
-		       && boost::prior(tmprit)->par() == first_phys_pit)
-		{
-			--tmprit;
-			y -= tmprit->height();
-		}
-		prevrit = boost::prior(tmprit);
+	int pars_width = 0;
+	for ( ; start != end; ++start) {
+		int par_width = redoParagraphInternal(start);
+		pars_width = std::max(par_width, pars_width);
 	}
+	updateRowPositions();
+	return pars_width;
+}
 
-	// remove it
-	while (tmprit != rows().end() && tmprit->par() != endpit) {
-		RowList::iterator tmprit2 = tmprit++;
-		removeRow(tmprit2);
-	}
 
-	// Reinsert the paragraphs.
-	ParagraphList::iterator tmppit = first_phys_pit;
+void LyXText::redoParagraph(ParagraphList::iterator pit)
+{
+	redoParagraphInternal(pit);
+	updateRowPositions();
+}
 
-	while (tmppit != ownerParagraphs().end()) {
-		insertParagraph(tmppit, tmprit);
-		while (tmprit != rows().end()
-		       && tmprit->par() == tmppit) {
-			++tmprit;
-		}
-		++tmppit;
-		if (tmppit == endpit)
-			break;
-	}
-	if (prevrit != rows().end()) {
-		setHeightOfRow(prevrit);
-		const_cast<LyXText *>(this)->postPaint(y - prevrit->height());
-	} else {
-		setHeightOfRow(rows().begin());
-		const_cast<LyXText *>(this)->postPaint(0);
-	}
-	if (tmprit != rows().end())
-		setHeightOfRow(tmprit);
 
-	updateCounters();
+void LyXText::fullRebreak()
+{
+	redoParagraphs(ownerParagraphs().begin(), ownerParagraphs().end());
+	redoCursor();
+	selection.cursor = cursor;
 }
 
 
-void LyXText::fullRebreak()
+void LyXText::metrics(MetricsInfo & mi, Dimension & dim)
 {
-	if (rows().empty()) {
-		init(bv());
-		return;
-	}
+	//lyxerr << "LyXText::metrics: width: " << mi.base.textwidth
+	//	<< " workWidth: " << workWidth() << endl;
+	//Assert(mi.base.textwidth);
 
-	RowList::iterator rows_end = rows().end();
+	// rebuild row cache
+	width  = 0;
+	///height = 0;
 
-	if (need_break_row != rows_end) {
-		breakAgain(need_break_row);
-		need_break_row = rows_end;
-		return;
-	}
+	//anchor_y_ = 0;
+	width = redoParagraphs(ownerParagraphs().begin(), ownerParagraphs().end());
+
+	// final dimension
+	dim.asc = firstRow()->ascent_of_text();
+	dim.des = height - dim.asc;
+	dim.wid = std::max(mi.base.textwidth, int(width));
 }
 
 
@@ -727,98 +648,15 @@ void LyXText::fullRebreak()
 // need the selection cursor:
 void LyXText::setSelection()
 {
-	bool const lsel = selection.set();
-
-	if (!selection.set()) {
-		last_sel_cursor = selection.cursor;
-		selection.start = selection.cursor;
-		selection.end = selection.cursor;
-	}
-
-	selection.set(true);
-
-	// first the toggling area
-	if (cursor.y() < last_sel_cursor.y()
-	    || (cursor.y() == last_sel_cursor.y()
-		&& cursor.x() < last_sel_cursor.x())) {
-		toggle_end_cursor = last_sel_cursor;
-		toggle_cursor = cursor;
-	} else {
-		toggle_end_cursor = cursor;
-		toggle_cursor = last_sel_cursor;
-	}
-
-	last_sel_cursor = cursor;
-
-	// and now the whole selection
-
-	if (selection.cursor.par() == cursor.par())
-		if (selection.cursor.pos() < cursor.pos()) {
-			selection.end = cursor;
-			selection.start = selection.cursor;
-		} else {
-			selection.end = selection.cursor;
-			selection.start = cursor;
-		}
-	else if (selection.cursor.y() < cursor.y() ||
-		 (selection.cursor.y() == cursor.y()
-		  && selection.cursor.x() < cursor.x())) {
-		selection.end = cursor;
-		selection.start = selection.cursor;
-	}
-	else {
-		selection.end = selection.cursor;
-		selection.start = cursor;
-	}
-
-	// a selection with no contents is not a selection
-	if (selection.start.par() == selection.end.par() &&
-	    selection.start.pos() == selection.end.pos())
-		selection.set(false);
-
-	if (inset_owner && (selection.set() || lsel))
-		inset_owner->setUpdateStatus(bv(), InsetText::SELECTION);
+	TextCursor::setSelection();
 }
 
 
-string const LyXText::selectionAsString(Buffer const * buffer,
-					bool label) const
-{
-	if (!selection.set()) return string();
-
-	// should be const ...
-	ParagraphList::iterator startpit = selection.start.par();
-	ParagraphList::iterator endpit = selection.end.par();
-	pos_type const startpos(selection.start.pos());
-	pos_type const endpos(selection.end.pos());
-
-	if (startpit == endpit) {
-		return startpit->asString(buffer, startpos, endpos, label);
-	}
-
-	string result;
-
-	// First paragraph in selection
-	result += startpit->asString(buffer, startpos, startpit->size(), label) + "\n\n";
-
-	// The paragraphs in between (if any)
-	ParagraphList::iterator pit = boost::next(startpit);
-	for (; pit != endpit; ++pit) {
-		result += pit->asString(buffer, 0, pit->size(), label) + "\n\n";
-	}
-
-	// Last paragraph in selection
-	result += endpit->asString(buffer, 0, endpos, label);
-
-	return result;
-}
-
 
 void LyXText::clearSelection()
 {
-	selection.set(false);
-	selection.mark(false);
-	last_sel_cursor = selection.end = selection.start = selection.cursor = cursor;
+	TextCursor::clearSelection();
+
 	// reset this in the bv_owner!
 	if (bv_owner && bv_owner->text)
 		bv_owner->text->xsel_cache.set(false);
@@ -827,7 +665,7 @@ void LyXText::clearSelection()
 
 void LyXText::cursorHome()
 {
-	setCursor(cursor.par(), cursor.row()->pos());
+	setCursor(cursor.par(), cursorRow()->pos());
 }
 
 
@@ -836,21 +674,13 @@ void LyXText::cursorEnd()
 	if (cursor.par()->empty())
 		return;
 
-	RowList::iterator rit = cursor.row();
-	RowList::iterator next_rit = boost::next(rit);
-	ParagraphList::iterator pit = rit->par();
-	pos_type last_pos = lastPos(*this, rit);
-
-	if (next_rit == rows().end() || next_rit->par() != pit) {
-		++last_pos;
-	} else {
-		if (pit->empty() ||
-		    (pit->getChar(last_pos) != ' ' && !pit->isNewline(last_pos))) {
-			++last_pos;
-		}
-	}
-
-	setCursor(pit, last_pos);
+	RowList::iterator rit = cursorRow();
+	ParagraphList::iterator pit = cursor.par();
+	pos_type pos = lastPos(*pit, rit);
+	/* cursor should be before a hard newline only */
+	if (!pit->isNewline(pos))
+		++pos;
+	setCursor(pit, pos);
 }
 
 
@@ -862,12 +692,9 @@ void LyXText::cursorTop()
 
 void LyXText::cursorBottom()
 {
-#warning FIXME
-	// This is how it should be:
-	// ParagraphList::iterator lastpit = boost::prior(ownerParagraphs().end());
-	ParagraphList::iterator lastpit = &ownerParagraphs().back();
-	int pos = lastpit->size();
-	setCursor(lastpit, pos);
+	ParagraphList::iterator lastpit =
+		boost::prior(ownerParagraphs().end());
+	setCursor(lastpit, lastpit->size());
 }
 
 
@@ -886,7 +713,7 @@ void LyXText::toggleFree(LyXFont const & font, bool toggleall)
 	LyXCursor resetCursor = cursor;
 	bool implicitSelection = (font.language() == ignore_language
 				  && font.number() == LyXFont::IGNORE)
-		? selectWordWhenUnderCursor(WHOLE_WORD_STRICT) : false;
+		? selectWordWhenUnderCursor(lyx::WHOLE_WORD_STRICT) : false;
 
 	// Set font
 	setFont(font, toggleall);
@@ -899,8 +726,6 @@ void LyXText::toggleFree(LyXFont const & font, bool toggleall)
 		setCursor(cursor.par(), cursor.pos());
 		selection.cursor = cursor;
 	}
-	if (inset_owner)
-		inset_owner->setUpdateStatus(bv(), InsetText::CURSOR_PAR);
 }
 
 
@@ -910,7 +735,8 @@ string LyXText::getStringToIndex()
 	// If there is a change in the language the implicit word selection
 	// is disabled.
 	LyXCursor const reset_cursor = cursor;
-	bool const implicitSelection = selectWordWhenUnderCursor(PREVIOUS_WORD);
+	bool const implicitSelection =
+		selectWordWhenUnderCursor(lyx::PREVIOUS_WORD);
 
 	string idxstring;
 	if (!selection.set())
@@ -918,7 +744,7 @@ string LyXText::getStringToIndex()
 	else if (selection.start.par() != selection.end.par())
 		bv()->owner()->message(_("Cannot index more than one paragraph!"));
 	else
-		idxstring = selectionAsString(bv()->buffer(), false);
+		idxstring = selectionAsString(*bv()->buffer(), false);
 
 	// Reset cursors to their original position.
 	cursor = reset_cursor;
@@ -934,8 +760,8 @@ string LyXText::getStringToIndex()
 
 
 // the DTP switches for paragraphs. LyX will store them in the first
-// physicla paragraph. When a paragraph is broken, the top settings rest,
-// the bottom settings are given to the new one. So I can make shure,
+// 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 cannnot make dirty things with
 // them!
 
@@ -969,14 +795,14 @@ void LyXText::setParagraph(bool line_top, bool line_bottom,
 		++endpit;
 	}
 
-	setUndo(bv(), Undo::EDIT, selection.start.par(), undoendpit);
+	recordUndo(bv(), Undo::ATOMIC, selection.start.par(),
+		boost::prior(undoendpit));
 
 
 	ParagraphList::iterator tmppit = selection.end.par();
 
 	while (tmppit != boost::prior(selection.start.par())) {
 		setCursor(tmppit, 0);
-		postPaint(cursor.y() - cursor.row()->baseline());
 
 		ParagraphList::iterator pit = cursor.par();
 		ParagraphParameters & params = pit->params();
@@ -1004,7 +830,7 @@ void LyXText::setParagraph(bool line_top, bool line_bottom,
 		tmppit = boost::prior(pit);
 	}
 
-	redoParagraphs(selection.start, endpit);
+	redoParagraphs(selection.start.par(), endpit);
 
 	clearSelection();
 	setCursor(selection.start.par(), selection.start.pos());
@@ -1018,9 +844,9 @@ void LyXText::setParagraph(bool line_top, bool line_bottom,
 
 
 // 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, ParagraphList::iterator pit)
 {
-	LyXTextClass const & textclass = buf->params.getLyXTextClass();
+	LyXTextClass const & textclass = buf.params.getLyXTextClass();
 	LyXLayout_ptr const & layout = pit->layout();
 
 	if (pit != ownerParagraphs().begin()) {
@@ -1039,13 +865,12 @@ void LyXText::setCounter(Buffer const * buf, ParagraphList::iterator pit)
 		pit->itemdepth = 0;
 	}
 
-	/* Maybe we have to increment the enumeration depth.
-	 * BUT, enumeration in a footnote is considered in isolation from its
-	 *	surrounding paragraph so don't increment if this is the
-	 *	first line of the footnote
-	 * AND, bibliographies can't have their depth changed ie. they
-	 *	are always of depth 0
-	 */
+	// Maybe we have to increment the enumeration depth.
+	// BUT, enumeration in a footnote is considered in isolation from its
+	//	surrounding paragraph so don't increment if this is the
+	//	first line of the footnote
+	// AND, bibliographies can't have their depth changed ie. they
+	//	are always of depth 0
 	if (pit != ownerParagraphs().begin()
 	    && boost::prior(pit)->getDepth() < pit->getDepth()
 	    && boost::prior(pit)->layout()->labeltype == LABEL_COUNTER_ENUMI
@@ -1067,9 +892,8 @@ void LyXText::setCounter(Buffer const * buf, ParagraphList::iterator pit)
 	}
 
 	if (layout->margintype == MARGIN_MANUAL) {
-		if (pit->params().labelWidthString().empty()) {
+		if (pit->params().labelWidthString().empty())
 			pit->setLabelWidthString(layout->labelstring());
-		}
 	} else {
 		pit->setLabelWidthString(string());
 	}
@@ -1080,7 +904,7 @@ void LyXText::setCounter(Buffer const * buf, ParagraphList::iterator pit)
 
 		ostringstream s;
 
-		if (i >= 0 && i <= buf->params.secnumdepth) {
+		if (i >= 0 && i <= buf.params.secnumdepth) {
 			string numbertype;
 			string langtype;
 
@@ -1088,9 +912,9 @@ void LyXText::setCounter(Buffer const * buf, ParagraphList::iterator pit)
 
 			// Is there a label? Useful for Chapter layout
 			if (!pit->params().appendix()) {
-				s << buf->B_(layout->labelstring());
+				s << buf.B_(layout->labelstring());
 			} else {
-				s << buf->B_(layout->labelstring_appendix());
+				s << buf.B_(layout->labelstring_appendix());
 			}
 
 			// Use of an integer is here less than elegant. For now.
@@ -1099,7 +923,7 @@ void LyXText::setCounter(Buffer const * buf, ParagraphList::iterator pit)
 				numbertype = "sectioning";
 			} else {
 				numbertype = "appendix";
-				if (pit->isRightToLeftPar(buf->params))
+				if (pit->isRightToLeftPar(buf.params))
 					langtype = "hebrew";
 				else
 					langtype = "latin";
@@ -1153,52 +977,47 @@ void LyXText::setCounter(Buffer const * buf, ParagraphList::iterator pit)
 		}
 		// In biblio should't be following counters but...
 	} else {
-		string s = buf->B_(layout->labelstring());
+		string s = buf.B_(layout->labelstring());
 
 		// the caption hack:
 		if (layout->labeltype == LABEL_SENSITIVE) {
+			ParagraphList::iterator end = ownerParagraphs().end();
 			ParagraphList::iterator tmppit = pit;
-			Inset * in = 0;
+			InsetOld * in = 0;
 			bool isOK = false;
-			while (tmppit != ownerParagraphs().end() &&
-			       tmppit->inInset()
+			while (tmppit != end && tmppit->inInset()
 			       // the single '=' is intended below
-			       && (in = tmppit->inInset()->owner())) {
-				if (in->lyxCode() == Inset::FLOAT_CODE ||
-				    in->lyxCode() == Inset::WRAP_CODE) {
+			       && (in = tmppit->inInset()->owner()))
+			{
+				if (in->lyxCode() == InsetOld::FLOAT_CODE ||
+				    in->lyxCode() == InsetOld::WRAP_CODE) {
 					isOK = true;
 					break;
 				} else {
-					tmppit = in->parOwner();
+					Paragraph const * owner = &ownerPar(buf, in);
+					tmppit = ownerParagraphs().begin();
+					for ( ; tmppit != end; ++tmppit)
+						if (&*tmppit == owner)
+							break;
 				}
 			}
 
 			if (isOK) {
 				string type;
 
-				if (in->lyxCode() == Inset::FLOAT_CODE)
+				if (in->lyxCode() == InsetOld::FLOAT_CODE)
 					type = static_cast<InsetFloat*>(in)->params().type;
-				else if (in->lyxCode() == Inset::WRAP_CODE)
+				else if (in->lyxCode() == InsetOld::WRAP_CODE)
 					type = static_cast<InsetWrap*>(in)->params().type;
 				else
-					lyx::Assert(0);
+					Assert(0);
 
 				Floating const & fl = textclass.floats().getType(type);
 
 				textclass.counters().step(fl.type());
 
 				// Doesn't work... yet.
-#if USE_BOOST_FORMAT
-				s = boost::io::str(boost::format(_("%1$s #:")) % buf->B_(fl.name()));
-				// s << boost::format(_("%1$s %1$d:")
-				//        % fl.name()
-				//	  % buf->counters().value(fl.name());
-#else
-				ostringstream o;
-				//o << fl.name() << ' ' << buf->counters().value(fl.name()) << ":";
-				o << buf->B_(fl.name()) << " #:";
-				s = STRCONV(o.str());
-#endif
+				s = bformat(_("%1$s #:"), buf.B_(fl.name()));
 			} else {
 				// par->SetLayout(0);
 				// s = layout->labelstring;
@@ -1228,57 +1047,48 @@ void LyXText::setCounter(Buffer const * buf, ParagraphList::iterator pit)
 // Updates all counters. Paragraphs with changed label string will be rebroken
 void LyXText::updateCounters()
 {
-	RowList::iterator rowit = rows().begin();
-	ParagraphList::iterator pit = rowit->par();
-
-	// CHECK if this is really needed. (Lgb)
+	// start over
 	bv()->buffer()->params.getLyXTextClass().counters().reset();
 
-	for (; pit != ownerParagraphs().end(); ++pit) {
-		while (rowit->par() != pit)
-			++rowit;
-
+	ParagraphList::iterator beg = ownerParagraphs().begin();
+	ParagraphList::iterator end = ownerParagraphs().end();
+	for (ParagraphList::iterator pit = beg; pit != end; ++pit) {
 		string const oldLabel = pit->params().labelString();
 
-		int maxdepth = 0;
-		if (pit != ownerParagraphs().begin())
+		size_t maxdepth = 0;
+		if (pit != beg)
 			maxdepth = boost::prior(pit)->getMaxDepthAfter();
 
 		if (pit->params().depth() > maxdepth)
 			pit->params().depth(maxdepth);
 
 		// setCounter can potentially change the labelString.
-		setCounter(bv()->buffer(), pit);
+		setCounter(*bv()->buffer(), pit);
 
 		string const & newLabel = pit->params().labelString();
 
-		if (oldLabel.empty() && !newLabel.empty()) {
-			removeParagraph(rowit);
-			appendParagraph(rowit);
-		}
+		if (oldLabel != newLabel)
+			redoParagraph(pit);
 	}
 }
 
 
-void LyXText::insertInset(Inset * inset)
+void LyXText::insertInset(InsetOld * inset)
 {
 	if (!cursor.par()->insetAllowed(inset->lyxCode()))
 		return;
-	setUndo(bv(), Undo::FINISH, cursor.par(),
-		boost::next(cursor.par()));
+	recordUndo(bv(), Undo::ATOMIC, cursor.par());
 	freezeUndo();
 	cursor.par()->insertInset(cursor.pos(), inset);
 	// Just to rebreak and refresh correctly.
 	// The character will not be inserted a second time
 	insertChar(Paragraph::META_INSET);
-	// If we enter a highly editable inset the cursor should be to before
-	// the inset. This couldn't happen before as Undo was not handled inside
-	// inset now after the Undo LyX tries to call inset->Edit(...) again
-	// and cannot do this as the cursor is behind the inset and GetInset
+	// If we enter a highly editable inset the cursor should be before
+	// the inset. After an Undo LyX tries to call inset->edit(...)
+	// and fails if the cursor is behind the inset and getInset
 	// does not return the inset!
-	if (isHighlyEditableInset(inset)) {
+	if (isHighlyEditableInset(inset))
 		cursorLeft(true);
-	}
 	unFreezeUndo();
 }
 
@@ -1293,7 +1103,7 @@ void LyXText::cutSelection(bool doclear, bool realcut)
 	// 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(selectionAsString(bv()->buffer(), true));
+	bv()->stuffClipboard(selectionAsString(*bv()->buffer(), true));
 
 	// This doesn't make sense, if there is no selection
 	if (!selection.set())
@@ -1317,19 +1127,21 @@ void LyXText::cutSelection(bool doclear, bool realcut)
 		++endpit;
 	}
 
-	setUndo(bv(), Undo::DELETE, selection.start.par(), undoendpit);
-
+	recordUndo(bv(), Undo::DELETE, selection.start.par(),
+		   boost::prior(undoendpit));
 
 	endpit = selection.end.par();
 	int endpos = selection.end.pos();
 
 	boost::tie(endpit, endpos) = realcut ?
-		CutAndPaste::cutSelection(ownerParagraphs(),
+		CutAndPaste::cutSelection(bv()->buffer()->params,
+					  ownerParagraphs(),
 					  selection.start.par(), endpit,
 					  selection.start.pos(), endpos,
 					  bv()->buffer()->params.textclass,
 					  doclear)
-		: CutAndPaste::eraseSelection(ownerParagraphs(),
+		: CutAndPaste::eraseSelection(bv()->buffer()->params,
+					      ownerParagraphs(),
 					      selection.start.par(), endpit,
 					      selection.start.pos(), endpos,
 					      doclear);
@@ -1337,11 +1149,7 @@ void LyXText::cutSelection(bool doclear, bool realcut)
 	if (doclear)
 		selection.start.par()->stripLeadingSpaces();
 
-	redoParagraphs(selection.start, boost::next(endpit));
-#warning FIXME latent bug
-	// endpit will be invalidated on redoParagraphs once ParagraphList
-	// becomes a std::list? There are maybe other places on which this
-	// can happend? (Ab)
+	redoParagraphs(selection.start.par(), boost::next(endpit));
 	// cutSelection can invalidate the cursor so we need to set
 	// it anew. (Lgb)
 	// we prefer the end for when tracking changes
@@ -1360,7 +1168,7 @@ void LyXText::cutSelection(bool doclear, bool realcut)
 void LyXText::copySelection()
 {
 	// stuff the selection onto the X clipboard, from an explicit copy request
-	bv()->stuffClipboard(selectionAsString(bv()->buffer(), true));
+	bv()->stuffClipboard(selectionAsString(*bv()->buffer(), true));
 
 	// this doesnt make sense, if there is no selection
 	if (!selection.set())
@@ -1383,24 +1191,29 @@ void LyXText::copySelection()
 }
 
 
-void LyXText::pasteSelection()
+void LyXText::pasteSelection(size_t sel_index)
 {
 	// this does not make sense, if there is nothing to paste
 	if (!CutAndPaste::checkPastePossible())
 		return;
 
-	setUndo(bv(), Undo::INSERT,
-		cursor.par(), boost::next(cursor.par()));
+	recordUndo(bv(), Undo::INSERT, cursor.par());
 
 	ParagraphList::iterator endpit;
 	PitPosPair ppp;
 
-	boost::tie(ppp, endpit) = 
-		CutAndPaste::pasteSelection(ownerParagraphs(), 
-					    cursor.par(), cursor.pos(), 
-					    bv()->buffer()->params.textclass);
-	
-	redoParagraphs(cursor, endpit);
+	ErrorList el;
+
+	boost::tie(ppp, endpit) =
+		CutAndPaste::pasteSelection(*bv()->buffer(),
+					    ownerParagraphs(),
+					    cursor.par(), cursor.pos(),
+					    bv()->buffer()->params.textclass,
+					    sel_index, el);
+	bufferErrors(*bv()->buffer(), el);
+	bv()->showErrorList(_("Paste"));
+
+	redoParagraphs(cursor.par(), endpit);
 
 	setCursor(cursor.par(), cursor.pos());
 	clearSelection();
@@ -1427,7 +1240,7 @@ void LyXText::setSelectionRange(lyx::pos_type length)
 // simple replacing. The font of the first selected character is used
 void LyXText::replaceSelectionWithString(string const & str)
 {
-	setCursorParUndo(bv());
+	recordUndo(bv(), Undo::ATOMIC);
 	freezeUndo();
 
 	if (!selection.set()) { // create a dummy selection
@@ -1442,7 +1255,9 @@ void LyXText::replaceSelectionWithString(string const & str)
 				  selection.start.pos());
 
 	// Insert the new string
-	for (string::const_iterator cit = str.begin(); cit != str.end(); ++cit) {
+	string::const_iterator cit = str.begin();
+	string::const_iterator end = str.end();
+	for (; cit != end; ++cit) {
 		selection.end.par()->insertChar(pos, (*cit), font);
 		++pos;
 	}
@@ -1461,14 +1276,14 @@ void LyXText::insertStringAsLines(string const & str)
 	pos_type pos = cursor.pos();
 	ParagraphList::iterator endpit = boost::next(cursor.par());
 
-	setCursorParUndo(bv());
+	recordUndo(bv(), Undo::ATOMIC);
 
 	// only to be sure, should not be neccessary
 	clearSelection();
 
 	bv()->buffer()->insertStringAsLines(pit, pos, current_font, str);
 
-	redoParagraphs(cursor, endpit);
+	redoParagraphs(cursor.par(), endpit);
 	setCursor(cursor.par(), cursor.pos());
 	selection.cursor = cursor;
 	setCursor(pit, pos);
@@ -1482,7 +1297,9 @@ void LyXText::insertStringAsParagraphs(string const & str)
 {
 	string linestr(str);
 	bool newline_inserted = false;
-	for (string::size_type i = 0; i < linestr.length(); ++i) {
+	string::size_type const siz = linestr.length();
+
+	for (string::size_type i = 0; i < siz; ++i) {
 		if (linestr[i] == '\n') {
 			if (newline_inserted) {
 				// we know that \r will be ignored by
@@ -1502,109 +1319,6 @@ void LyXText::insertStringAsParagraphs(string const & str)
 }
 
 
-void LyXText::checkParagraph(ParagraphList::iterator pit, pos_type pos)
-{
-	LyXCursor tmpcursor;
-
-	int y = 0;
-	pos_type z;
-	RowList::iterator row = getRow(pit, pos, y);
-	RowList::iterator beg = rows().begin();
-
-	// is there a break one row above
-	if (row != beg
-	    && boost::prior(row)->par() == row->par()) {
-		z = rowBreakPoint(*boost::prior(row));
-		if (z >= row->pos()) {
-			// set the dimensions of the row above
-			y -= boost::prior(row)->height();
-			postPaint(y);
-
-			breakAgain(boost::prior(row));
-
-			// set the cursor again. Otherwise
-			// dangling pointers are possible
-			setCursor(cursor.par(), cursor.pos(),
-				  false, cursor.boundary());
-			selection.cursor = cursor;
-			return;
-		}
-	}
-
-	int const tmpheight = row->height();
-	pos_type const tmplast = lastPos(*this, row);
-
-	breakAgain(row);
-	if (row->height() == tmpheight && lastPos(*this, row) == tmplast) {
-		postRowPaint(row, y);
-	} else {
-		postPaint(y);
-	}
-
-	// check the special right address boxes
-	if (pit->layout()->margintype == MARGIN_RIGHT_ADDRESS_BOX) {
-		tmpcursor.par(pit);
-		tmpcursor.row(row);
-		tmpcursor.y(y);
-		tmpcursor.x(0);
-		tmpcursor.x_fix(0);
-		tmpcursor.pos(pos);
-		redoDrawingOfParagraph(tmpcursor);
-	}
-
-	// set the cursor again. Otherwise dangling pointers are possible
-	// also set the selection
-
-	if (selection.set()) {
-		tmpcursor = cursor;
-		setCursorIntern(selection.cursor.par(), selection.cursor.pos(),
-				false, selection.cursor.boundary());
-		selection.cursor = cursor;
-		setCursorIntern(selection.start.par(),
-				selection.start.pos(),
-				false, selection.start.boundary());
-		selection.start = cursor;
-		setCursorIntern(selection.end.par(),
-				selection.end.pos(),
-				false, selection.end.boundary());
-		selection.end = cursor;
-		setCursorIntern(last_sel_cursor.par(),
-				last_sel_cursor.pos(),
-				false, last_sel_cursor.boundary());
-		last_sel_cursor = cursor;
-		cursor = tmpcursor;
-	}
-	setCursorIntern(cursor.par(), cursor.pos(),
-			false, cursor.boundary());
-}
-
-
-// returns false if inset wasn't found
-bool LyXText::updateInset(Inset * inset)
-{
-	// first check the current paragraph
-	int pos = cursor.par()->getPositionOfInset(inset);
-	if (pos != -1) {
-		checkParagraph(cursor.par(), pos);
-		return true;
-	}
-
-	// check every paragraph
-
-	ParagraphList::iterator par = ownerParagraphs().begin();
-	ParagraphList::iterator end = ownerParagraphs().end();
-	for (; par != end; ++par) {
-		pos = par->getPositionOfInset(inset);
-		if (pos != -1) {
-			checkParagraph(par, pos);
-			return true;
-		}
-	};
-
-	return false;
-}
-
-
 bool LyXText::setCursor(ParagraphList::iterator pit,
 			pos_type pos,
 			bool setfont, bool boundary)
@@ -1615,49 +1329,45 @@ bool LyXText::setCursor(ParagraphList::iterator pit,
 }
 
 
+void LyXText::redoCursor()
+{
+#warning maybe the same for selections?
+	setCursor(cursor, cursor.par(), cursor.pos(), cursor.boundary());
+}
+
+
 void LyXText::setCursor(LyXCursor & cur, ParagraphList::iterator pit,
 			pos_type pos, bool boundary)
 {
-	lyx::Assert(pit != ownerParagraphs().end());
+	Assert(pit != ownerParagraphs().end());
 
 	cur.par(pit);
 	cur.pos(pos);
 	cur.boundary(boundary);
+	if (noRows())
+		return;
 
 	// get the cursor y position in text
-	int y = 0;
-	RowList::iterator row = getRow(pit, pos, y);
-	RowList::iterator beg = rows().begin();
+
+	RowList::iterator row = getRow(pit, pos);
+	int y = row->y();
 
 	RowList::iterator old_row = row;
-	cur.irow(row);
 	// if we are before the first char of this row and are still in the
 	// same paragraph and there is a previous row then put the cursor on
 	// the end of the previous row
 	cur.iy(y + row->baseline());
-	if (row != beg &&
-	    pos &&
-	    boost::prior(row)->par() == row->par() &&
-	    pos < pit->size() &&
-	    pit->getChar(pos) == Paragraph::META_INSET) {
-		Inset * ins = pit->getInset(pos);
-		if (ins && (ins->needFullRow() || ins->display())) {
-			--row;
-			y -= row->height();
-		}
-	}
 
-	cur.row(row);
 	// y is now the beginning of the cursor row
 	y += row->baseline();
 	// y is now the cursor baseline
 	cur.y(y);
 
-	pos_type last = lastPrintablePos(*this, old_row);
+	pos_type last = lastPrintablePos(*pit, old_row);
 
 	// None of these should happen, but we're scaredy-cats
 	if (pos > pit->size()) {
-		lyxerr << "dont like 1 please report" << endl;
+		lyxerr << "dont like 1, pos: " << pos << " size: " << pit->size() << endl;
 		pos = 0;
 		cur.pos(0);
 	} else if (pos > last + 1) {
@@ -1672,60 +1382,44 @@ void LyXText::setCursor(LyXCursor & cur, ParagraphList::iterator pit,
 	}
 
 	// now get the cursors x position
-	float x = getCursorX(row, pos, last, boundary);
+	float x = getCursorX(pit, row, pos, last, boundary);
 	cur.x(int(x));
 	cur.x_fix(cur.x());
 	if (old_row != row) {
-		x = getCursorX(old_row, pos, last, boundary);
+		x = getCursorX(pit, old_row, pos, last, boundary);
 		cur.ix(int(x));
 	} else
 		cur.ix(cur.x());
-/* We take out this for the time being because 1) the redraw code is not
-   prepared to this yet and 2) because some good policy has yet to be decided
-   while editting: for instance how to act on rows being created/deleted
-   because of DEPM.
-*/
-#if 0
-	//if the cursor is in a visible row, anchor to it
-	int topy = top_y();
-	if (topy < y && y < topy + bv()->workHeight())
-		anchor_row(row);
-#endif
 }
 
 
-float LyXText::getCursorX(RowList::iterator rit,
+float LyXText::getCursorX(ParagraphList::iterator pit, RowList::iterator rit,
 			  pos_type pos, pos_type last, bool boundary) const
 {
-	pos_type cursor_vpos = 0;
-	float x;
-	float fill_separator;
-	float fill_hfill;
-	float fill_label_hfill;
-	// This call HAS to be here because of the BidiTables!!!
-	prepareToPrint(rit, x, fill_separator, fill_hfill,
-		       fill_label_hfill);
-
-	ParagraphList::iterator rit_par = rit->par();
-	pos_type const rit_pos = rit->pos();
+	pos_type cursor_vpos    = 0;
+	double x                = rit->x();
+	double fill_separator   = rit->fill_separator();
+	double fill_hfill       = rit->fill_hfill();
+	double fill_label_hfill = rit->fill_label_hfill();
+	pos_type const rit_pos  = rit->pos();
 
 	if (last < rit_pos)
 		cursor_vpos = rit_pos;
 	else if (pos > last && !boundary)
-		cursor_vpos = (rit_par->isRightToLeftPar(bv()->buffer()->params))
+		cursor_vpos = (pit->isRightToLeftPar(bv()->buffer()->params))
 			? rit_pos : last + 1;
 	else if (pos > rit_pos && (pos > last || boundary))
-		/// Place cursor after char at (logical) position pos - 1
+		// Place cursor after char at (logical) position pos - 1
 		cursor_vpos = (bidi_level(pos - 1) % 2 == 0)
 			? log2vis(pos - 1) + 1 : log2vis(pos - 1);
 	else
-		/// Place cursor before char at (logical) position pos
+		// Place cursor before char at (logical) position pos
 		cursor_vpos = (bidi_level(pos) % 2 == 0)
 			? log2vis(pos) : log2vis(pos) + 1;
 
-	pos_type body_pos = rit_par->beginningOfBody();
-	if ((body_pos > 0) &&
-	    ((body_pos - 1 > last) || !rit_par->isLineSeparator(body_pos - 1)))
+	pos_type body_pos = pit->beginningOfBody();
+	if (body_pos > 0 &&
+	    (body_pos - 1 > last || !pit->isLineSeparator(body_pos - 1)))
 		body_pos = 0;
 
 	for (pos_type vpos = rit_pos; vpos < cursor_vpos; ++vpos) {
@@ -1733,24 +1427,23 @@ float LyXText::getCursorX(RowList::iterator rit,
 		if (body_pos > 0 && pos == body_pos - 1) {
 			x += fill_label_hfill +
 				font_metrics::width(
-					rit_par->layout()->labelsep,
-					getLabelFont(bv()->buffer(), rit_par));
-			if (rit_par->isLineSeparator(body_pos - 1))
-				x -= singleWidth(rit_par, body_pos - 1);
+					pit->layout()->labelsep, getLabelFont(pit));
+			if (pit->isLineSeparator(body_pos - 1))
+				x -= singleWidth(pit, body_pos - 1);
 		}
 
-		if (hfillExpansion(*this, rit, pos)) {
-			x += singleWidth(rit_par, pos);
+		if (hfillExpansion(*pit, rit, pos)) {
+			x += singleWidth(pit, pos);
 			if (pos >= body_pos)
 				x += fill_hfill;
 			else
 				x += fill_label_hfill;
-		} else if (rit_par->isSeparator(pos)) {
-			x += singleWidth(rit_par, pos);
+		} else if (pit->isSeparator(pos)) {
+			x += singleWidth(pit, pos);
 			if (pos >= body_pos)
 				x += fill_separator;
 		} else
-			x += singleWidth(rit_par, pos);
+			x += singleWidth(pit, pos);
 	}
 	return x;
 }
@@ -1759,32 +1452,6 @@ float LyXText::getCursorX(RowList::iterator rit,
 void LyXText::setCursorIntern(ParagraphList::iterator pit,
 			      pos_type pos, bool setfont, bool boundary)
 {
-	InsetText * it = static_cast<InsetText *>(pit->inInset());
-	if (it) {
-		if (it != inset_owner) {
-			lyxerr[Debug::INSETS] << "InsetText   is " << it
-					      << endl
-					      << "inset_owner is "
-					      << inset_owner << endl;
-#ifdef WITH_WARNINGS
-#warning I believe this code is wrong. (Lgb)
-#warning Jürgen, have a look at this. (Lgb)
-#warning Hmmm, I guess you are right but we
-#warning should verify when this is needed
-#endif
-			// Jürgen, would you like to have a look?
-			// I guess we need to move the outer cursor
-			// and open and lock the inset (bla bla bla)
-			// stuff I don't know... so can you have a look?
-			// (Lgb)
-			// I moved the lyxerr stuff in here so we can see if
-			// this is actually really needed and where!
-			// (Jug)
-			// it->getLyXText(bv())->setCursorIntern(bv(), par, pos, setfont, boundary);
-			return;
-		}
-	}
-
 	setCursor(cursor, pit, pos, boundary);
 	if (setfont)
 		setCurrentFont();
@@ -1804,7 +1471,7 @@ void LyXText::setCurrentFont()
 			--pos;
 		else // potentional bug... BUG (Lgb)
 			if (pit->isSeparator(pos)) {
-				if (pos > cursor.row()->pos() &&
+				if (pos > cursorRow()->pos() &&
 				    bidi_level(pos) % 2 ==
 				    bidi_level(pos - 1) % 2)
 					--pos;
@@ -1813,12 +1480,11 @@ void LyXText::setCurrentFont()
 			}
 	}
 
-	current_font =
-		pit->getFontSettings(bv()->buffer()->params, pos);
-	real_current_font = getFont(bv()->buffer(), pit, pos);
+	current_font = pit->getFontSettings(bv()->buffer()->params, pos);
+	real_current_font = getFont(pit, pos);
 
 	if (cursor.pos() == pit->size() &&
-	    isBoundary(bv()->buffer(), *pit, cursor.pos()) &&
+	    isBoundary(*bv()->buffer(), *pit, cursor.pos()) &&
 	    !cursor.boundary()) {
 		Language const * lang =
 			pit->getParLanguage(bv()->buffer()->params);
@@ -1832,36 +1498,31 @@ void LyXText::setCurrentFont()
 
 // 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(RowList::iterator rit, int & x, bool & boundary) const
+pos_type LyXText::getColumnNearX(ParagraphList::iterator pit,
+	RowList::iterator rit, int & x, bool & boundary) const
 {
-	float tmpx = 0.0;
-	float fill_separator;
-	float fill_hfill;
-	float fill_label_hfill;
-
-	prepareToPrint(rit, tmpx, fill_separator,
-		       fill_hfill, fill_label_hfill);
+	double tmpx             = rit->x();
+	double fill_separator   = rit->fill_separator();
+	double fill_hfill       = rit->fill_hfill();
+	double fill_label_hfill = rit->fill_label_hfill();
 
 	pos_type vc = rit->pos();
-	pos_type last = lastPrintablePos(*this, rit);
+	pos_type last = lastPrintablePos(*pit, rit);
 	pos_type c = 0;
-
-	ParagraphList::iterator rit_par = rit->par();
-	LyXLayout_ptr const & layout = rit->par()->layout();
+	LyXLayout_ptr const & layout = pit->layout();
 
 	bool left_side = false;
 
-	pos_type body_pos = rit_par->beginningOfBody();
-	float last_tmpx = tmpx;
+	pos_type body_pos = pit->beginningOfBody();
+	double last_tmpx = tmpx;
 
 	if (body_pos > 0 &&
 	    (body_pos - 1 > last ||
-	     !rit_par->isLineSeparator(body_pos - 1)))
+	     !pit->isLineSeparator(body_pos - 1)))
 		body_pos = 0;
 
 	// check for empty row
-	if (!rit_par->size()) {
+	if (!pit->size()) {
 		x = int(tmpx);
 		return 0;
 	}
@@ -1871,24 +1532,23 @@ LyXText::getColumnNearX(RowList::iterator rit, int & x, bool & boundary) const
 		last_tmpx = tmpx;
 		if (body_pos > 0 && c == body_pos - 1) {
 			tmpx += fill_label_hfill +
-				font_metrics::width(layout->labelsep,
-					       getLabelFont(bv()->buffer(), &*rit_par));
-			if (rit_par->isLineSeparator(body_pos - 1))
-				tmpx -= singleWidth(rit_par, body_pos - 1);
+				font_metrics::width(layout->labelsep, getLabelFont(pit));
+			if (pit->isLineSeparator(body_pos - 1))
+				tmpx -= singleWidth(pit, body_pos - 1);
 		}
 
-		if (hfillExpansion(*this, rit, c)) {
-			tmpx += singleWidth(rit_par, c);
+		if (hfillExpansion(*pit, rit, c)) {
+			tmpx += singleWidth(pit, c);
 			if (c >= body_pos)
 				tmpx += fill_hfill;
 			else
 				tmpx += fill_label_hfill;
-		} else if (rit_par->isSeparator(c)) {
-			tmpx += singleWidth(rit_par, c);
+		} else if (pit->isSeparator(c)) {
+			tmpx += singleWidth(pit, c);
 			if (c >= body_pos)
-				tmpx+= fill_separator;
+				tmpx += fill_separator;
 		} else {
-			tmpx += singleWidth(rit_par, c);
+			tmpx += singleWidth(pit, c);
 		}
 		++vc;
 	}
@@ -1903,18 +1563,18 @@ LyXText::getColumnNearX(RowList::iterator rit, int & x, bool & boundary) const
 
 	boundary = false;
 	// This (rtl_support test) is not needed, but gives
-	// some speedup if rtl_support=false
-	bool const lastrow = lyxrc.rtl_support &&
-		(boost::next(rit) == rowlist_.end() ||
-		 boost::next(rit)->par() != rit_par);
+	// some speedup if rtl_support == false
+	bool const lastrow = lyxrc.rtl_support
+			&& boost::next(rit) == pit->rows.end();
+
 	// If lastrow is false, we don't need to compute
 	// the value of rtl.
 	bool const rtl = (lastrow)
-		? rit_par->isRightToLeftPar(bv()->buffer()->params)
+		? pit->isRightToLeftPar(bv()->buffer()->params)
 		: false;
 	if (lastrow &&
-		 ((rtl &&  left_side && vc == rit->pos() && x < tmpx - 5) ||
-		   (!rtl && !left_side && vc == last + 1   && x > tmpx + 5)))
+		 ((rtl  &&  left_side && vc == rit->pos() && x < tmpx - 5) ||
+		  (!rtl && !left_side && vc == last + 1   && x > tmpx + 5)))
 		c = last + 1;
 	else if (vc == rit->pos()) {
 		c = vis2log(vc);
@@ -1925,16 +1585,15 @@ LyXText::getColumnNearX(RowList::iterator rit, int & x, bool & boundary) const
 		bool const rtl = (bidi_level(c) % 2 == 1);
 		if (left_side == rtl) {
 			++c;
-			boundary = isBoundary(bv()->buffer(), *rit_par, c);
+			boundary = isBoundary(*bv()->buffer(), *pit, c);
 		}
 	}
 
-	if (rit->pos() <= last && c > last
-	    && rit_par->isNewline(last)) {
+	if (rit->pos() <= last && c > last && pit->isNewline(last)) {
 		if (bidi_level(last) % 2 == 0)
-			tmpx -= singleWidth(rit_par, last);
+			tmpx -= singleWidth(pit, last);
 		else
-			tmpx += singleWidth(rit_par, last);
+			tmpx += singleWidth(pit, last);
 		c = last;
 	}
 
@@ -1947,64 +1606,29 @@ LyXText::getColumnNearX(RowList::iterator rit, int & x, bool & boundary) const
 void LyXText::setCursorFromCoordinates(int x, int y)
 {
 	LyXCursor old_cursor = cursor;
-
 	setCursorFromCoordinates(cursor, x, y);
 	setCurrentFont();
 	deleteEmptyParagraphMechanism(old_cursor);
 }
 
 
-namespace {
-
-	/**
-	 * return true if the cursor given is at the end of a row,
-	 * and the next row is filled by an inset that spans an entire
-	 * row.
-	 */
-	bool beforeFullRowInset(LyXText & lt, LyXCursor const & cur) {
-		RowList::iterator row = cur.row();
-		if (boost::next(row) == lt.rows().end())
-			return false;
-		Row const & next = *boost::next(row);
-
-		if (next.pos() != cur.pos() || next.par() != cur.par())
-			return false;
-
-		if (cur.pos() == cur.par()->size()
-		    || !cur.par()->isInset(cur.pos()))
-			return false;
-		Inset const * inset = cur.par()->getInset(cur.pos());
-		if (inset->needFullRow() || inset->display())
-			return true;
-		return false;
-	}
-}
-
-
 void LyXText::setCursorFromCoordinates(LyXCursor & cur, int x, int y)
 {
 	// Get the row first.
+	ParagraphList::iterator pit;
+	RowList::iterator rit = getRowNearY(y, pit);
+	y = rit->y();
 
-	RowList::iterator row = getRowNearY(y);
 	bool bound = false;
-	pos_type const column = getColumnNearX(row, x, bound);
-	cur.par(row->par());
-	cur.pos(row->pos() + column);
+	pos_type const column = getColumnNearX(pit, rit, x, bound);
+	cur.par(pit);
+	cur.pos(rit->pos() + column);
 	cur.x(x);
-	cur.y(y + row->baseline());
-	cur.row(row);
+	cur.y(y + rit->baseline());
+
+	cur.iy(cur.y());
+	cur.ix(cur.x());
 
-	if (beforeFullRowInset(*this, cur)) {
-		pos_type last = lastPrintablePos(*this, row);
-		float x = getCursorX(boost::next(row), cur.pos(), last, bound);
-		cur.ix(int(x));
-		cur.iy(y + row->height() + boost::next(row)->baseline());
-		cur.irow(boost::next(row));
-	} else {
-		cur.iy(cur.y());
-		cur.ix(cur.x());
-		cur.irow(row);
-	}
 	cur.boundary(bound);
 }
 
@@ -2015,9 +1639,10 @@ void LyXText::cursorLeft(bool internal)
 		bool boundary = cursor.boundary();
 		setCursor(cursor.par(), cursor.pos() - 1, true, false);
 		if (!internal && !boundary &&
-		    isBoundary(bv()->buffer(), *cursor.par(), cursor.pos() + 1))
+		    isBoundary(*bv()->buffer(), *cursor.par(), cursor.pos() + 1))
 			setCursor(cursor.par(), cursor.pos() + 1, true, true);
-	} else if (cursor.par() != ownerParagraphs().begin()) { // steps into the above paragraph.
+	} else if (cursor.par() != ownerParagraphs().begin()) {
+		// steps into the paragraph above
 		ParagraphList::iterator pit = boost::prior(cursor.par());
 		setCursor(pit, pit->size());
 	}
@@ -2035,7 +1660,7 @@ void LyXText::cursorRight(bool internal)
 	else if (!at_end) {
 		setCursor(cursor.par(), cursor.pos() + 1, true, false);
 		if (!internal &&
-		    isBoundary(bv()->buffer(), *cursor.par(), cursor.pos()))
+		    isBoundary(*bv()->buffer(), *cursor.par(), cursor.pos()))
 			setCursor(cursor.par(), cursor.pos(), true, true);
 	} else if (boost::next(cursor.par()) != ownerParagraphs().end())
 		setCursor(boost::next(cursor.par()), 0);
@@ -2046,21 +1671,24 @@ void LyXText::cursorUp(bool selecting)
 {
 #if 1
 	int x = cursor.x_fix();
-	int y = cursor.y() - cursor.row()->baseline() - 1;
+	int y = cursor.y() - cursorRow()->baseline() - 1;
 	setCursorFromCoordinates(x, y);
 	if (!selecting) {
-		int topy = top_y();
+		int topy = bv_owner->top_y();
 		int y1 = cursor.iy() - topy;
 		int y2 = y1;
 		y -= topy;
-		Inset * inset_hit = checkInsetHit(x, y1);
+		InsetOld * inset_hit = checkInsetHit(x, y1);
 		if (inset_hit && isHighlyEditableInset(inset_hit)) {
-			inset_hit->edit(bv(), x, y - (y2 - y1), mouse_button::none);
+			inset_hit->localDispatch(
+				FuncRequest(bv(), LFUN_INSET_EDIT, x, y - (y2 - y1), mouse_button::none));
 		}
 	}
 #else
-	setCursorFromCoordinates(bv(), cursor.x_fix(),
-				 cursor.y() - cursor.row()->baseline() - 1);
+	lyxerr << "cursorUp: y " << cursor.y() << " bl: " <<
+		cursorRow()->baseline() << endl;
+	setCursorFromCoordinates(cursor.x_fix(),
+		cursor.y() - cursorRow()->baseline() - 1);
 #endif
 }
 
@@ -2069,51 +1697,50 @@ void LyXText::cursorDown(bool selecting)
 {
 #if 1
 	int x = cursor.x_fix();
-	int y = cursor.y() - cursor.row()->baseline() +
-		cursor.row()->height() + 1;
+	int y = cursor.y() - cursorRow()->baseline() + cursorRow()->height() + 1;
 	setCursorFromCoordinates(x, y);
-	if (!selecting && cursor.row() == cursor.irow()) {
-		int topy = top_y();
+	if (!selecting && cursorRow() == cursorIRow()) {
+		int topy = bv_owner->top_y();
 		int y1 = cursor.iy() - topy;
 		int y2 = y1;
 		y -= topy;
-		Inset * inset_hit = checkInsetHit(x, y1);
+		InsetOld * inset_hit = checkInsetHit(x, y1);
 		if (inset_hit && isHighlyEditableInset(inset_hit)) {
-			inset_hit->edit(bv(), x, y - (y2 - y1), mouse_button::none);
+			FuncRequest cmd(bv(), LFUN_INSET_EDIT, x, y - (y2 - y1), mouse_button::none);
+			inset_hit->localDispatch(cmd);
 		}
 	}
 #else
-	setCursorFromCoordinates(bv(), cursor.x_fix(),
-				 cursor.y() - cursor.row()->baseline()
-				 + cursor.row()->height() + 1);
+	setCursorFromCoordinates(cursor.x_fix(),
+		 cursor.y() - cursorRow()->baseline() + cursorRow()->height() + 1);
 #endif
 }
 
 
 void LyXText::cursorUpParagraph()
 {
-	if (cursor.pos() > 0) {
+	if (cursor.pos() > 0)
 		setCursor(cursor.par(), 0);
-	}
-	else if (cursor.par() != ownerParagraphs().begin()) {
+	else if (cursor.par() != ownerParagraphs().begin())
 		setCursor(boost::prior(cursor.par()), 0);
-	}
 }
 
 
 void LyXText::cursorDownParagraph()
 {
-	if (boost::next(cursor.par()) != ownerParagraphs().end()) {
-		setCursor(boost::next(cursor.par()), 0);
-	} else {
-		setCursor(cursor.par(), cursor.par()->size());
-	}
+	ParagraphList::iterator par = cursor.par();
+	ParagraphList::iterator next_par = boost::next(par);
+
+	if (next_par != ownerParagraphs().end())
+		setCursor(next_par, 0);
+	else
+		setCursor(par, par->size());
 }
 
+
 // fix the cursor `cur' after a characters has been deleted at `where'
 // position. Called by deleteEmptyParagraphMechanism
-void LyXText::fixCursorAfterDelete(LyXCursor & cur,
-				   LyXCursor const & where)
+void LyXText::fixCursorAfterDelete(LyXCursor & cur, LyXCursor const & where)
 {
 	// if cursor is not in the paragraph where the delete occured,
 	// do nothing
@@ -2142,10 +1769,8 @@ bool LyXText::deleteEmptyParagraphMechanism(LyXCursor const & old_cursor)
 		return false;
 
 	// We allow all kinds of "mumbo-jumbo" when freespacing.
-	if (old_cursor.par()->layout()->free_spacing
-	    || old_cursor.par()->isFreeSpacing()) {
+	if (old_cursor.par()->isFreeSpacing())
 		return false;
-	}
 
 	/* Ok I'll put some comments here about what is missing.
 	   I have fixed BackSpace (and thus Delete) to not delete
@@ -2154,7 +1779,7 @@ bool LyXText::deleteEmptyParagraphMechanism(LyXCursor const & old_cursor)
 	   There are still some small problems that can lead to
 	   double spaces stored in the document file or space at
 	   the beginning of paragraphs. This happens if you have
-	   the cursor betwenn to spaces and then save. Or if you
+	   the cursor between to spaces and then save. Or if you
 	   cut and paste and the selection have a space at the
 	   beginning and then save right after the paste. I am
 	   sure none of these are very hard to fix, but I will
@@ -2173,15 +1798,17 @@ bool LyXText::deleteEmptyParagraphMechanism(LyXCursor const & old_cursor)
 	// If the pos around the old_cursor were spaces, delete one of them.
 	if (old_cursor.par() != cursor.par()
 	    || old_cursor.pos() != cursor.pos()) {
-		// Only if the cursor has really moved
 
+		// Only if the cursor has really moved
 		if (old_cursor.pos() > 0
 		    && old_cursor.pos() < old_cursor.par()->size()
 		    && old_cursor.par()->isLineSeparator(old_cursor.pos())
 		    && old_cursor.par()->isLineSeparator(old_cursor.pos() - 1)) {
-			old_cursor.par()->erase(old_cursor.pos() - 1);
-			redoParagraphs(old_cursor, boost::next(old_cursor.par()));
+			bool erased = old_cursor.par()->erase(old_cursor.pos() - 1);
+			redoParagraph(old_cursor.par());
 
+			if (!erased)
+				return false;
 #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
@@ -2190,16 +1817,9 @@ bool LyXText::deleteEmptyParagraphMechanism(LyXCursor const & old_cursor)
 #endif
 			// correct all cursors held by the LyXText
 			fixCursorAfterDelete(cursor, old_cursor);
-			fixCursorAfterDelete(selection.cursor,
-					     old_cursor);
-			fixCursorAfterDelete(selection.start,
-					     old_cursor);
+			fixCursorAfterDelete(selection.cursor, old_cursor);
+			fixCursorAfterDelete(selection.start, old_cursor);
 			fixCursorAfterDelete(selection.end, old_cursor);
-			fixCursorAfterDelete(last_sel_cursor,
-					     old_cursor);
-			fixCursorAfterDelete(toggle_cursor, old_cursor);
-			fixCursorAfterDelete(toggle_end_cursor,
-					     old_cursor);
 			return false;
 		}
 	}
@@ -2209,7 +1829,7 @@ bool LyXText::deleteEmptyParagraphMechanism(LyXCursor const & old_cursor)
 		return false;
 
 	// Do not delete empty paragraphs with keepempty set.
-	if (old_cursor.par()->layout()->keepempty)
+	if (old_cursor.par()->allowEmpty())
 		return false;
 
 	// only do our magic if we changed paragraph
@@ -2223,7 +1843,7 @@ bool LyXText::deleteEmptyParagraphMechanism(LyXCursor const & old_cursor)
 	if (old_cursor.par()->empty() ||
 	    (old_cursor.par()->size() == 1 &&
 	     old_cursor.par()->isLineSeparator(0))) {
-		// ok, we will delete anything
+		// ok, we will delete something
 		LyXCursor tmpcursor;
 
 		deleted = true;
@@ -2232,67 +1852,19 @@ bool LyXText::deleteEmptyParagraphMechanism(LyXCursor const & old_cursor)
 			selection.cursor.par()  == old_cursor.par()
 			&& selection.cursor.pos() == old_cursor.pos());
 
-		if (old_cursor.row() != rows().begin()) {
-			RowList::iterator
-				prevrow = boost::prior(old_cursor.row());
-			const_cast<LyXText *>(this)->postPaint(old_cursor.y() - old_cursor.row()->baseline() - prevrow->height());
-			tmpcursor = cursor;
-			cursor = old_cursor; // that undo can restore the right cursor position
-			#warning FIXME. --end() iterator is usable here
-			ParagraphList::iterator endpit = boost::next(old_cursor.par());
-			while (endpit != ownerParagraphs().end() &&
-			       endpit->getDepth()) {
-				++endpit;
-			}
+		tmpcursor = cursor;
+		cursor = old_cursor; // that undo can restore the right cursor position
 
-			setUndo(bv(), Undo::DELETE, old_cursor.par(), endpit);
-			cursor = tmpcursor;
-
-			// delete old row
-			removeRow(old_cursor.row());
-			// delete old par
-			ownerParagraphs().erase(old_cursor.par());
-
-			/* Breakagain the next par. Needed because of
-			 * the parindent that can occur or dissappear.
-			 * The next row can change its height, if
-			 * there is another layout before */
-			if (boost::next(prevrow) != rows().end()) {
-				breakAgain(boost::next(prevrow));
-				updateCounters();
-			}
-			setHeightOfRow(prevrow);
-		} else {
-			RowList::iterator nextrow = boost::next(old_cursor.row());
-			const_cast<LyXText *>(this)->postPaint(
-				old_cursor.y() - old_cursor.row()->baseline());
-
-			tmpcursor = cursor;
-			cursor = old_cursor; // that undo can restore the right cursor position
-#warning FIXME. --end() iterator is usable here
-			ParagraphList::iterator endpit = boost::next(old_cursor.par());
-			while (endpit != ownerParagraphs().end() &&
-			       endpit->getDepth()) {
-				++endpit;
-			}
+		ParagraphList::iterator endpit = boost::next(old_cursor.par());
+		while (endpit != ownerParagraphs().end() && endpit->getDepth())
+			++endpit;
 
-			setUndo(bv(), Undo::DELETE, old_cursor.par(), endpit);
-			cursor = tmpcursor;
-
-			// delete old row
-			removeRow(old_cursor.row());
-			// delete old par
-			ownerParagraphs().erase(old_cursor.par());
-
-			/* Breakagain the next par. Needed because of
-			   the parindent that can occur or dissappear.
-			   The next row can change its height, if
-			   there is another layout before */
-			if (nextrow != rows().end()) {
-				breakAgain(nextrow);
-				updateCounters();
-			}
-		}
+		recordUndo(bv(), Undo::DELETE, old_cursor.par(), boost::prior(endpit));
+		cursor = tmpcursor;
+
+		// delete old par
+		ownerParagraphs().erase(old_cursor.par());
+		redoParagraph();
 
 		// correct cursor y
 		setCursorIntern(cursor.par(), cursor.pos());
@@ -2304,7 +1876,7 @@ bool LyXText::deleteEmptyParagraphMechanism(LyXCursor const & old_cursor)
 	}
 	if (!deleted) {
 		if (old_cursor.par()->stripLeadingSpaces()) {
-			redoParagraphs(old_cursor, boost::next(old_cursor.par()));
+			redoParagraph(old_cursor.par());
 			// correct cursor y
 			setCursorIntern(cursor.par(), cursor.pos());
 			selection.cursor = cursor;
@@ -2316,81 +1888,14 @@ bool LyXText::deleteEmptyParagraphMechanism(LyXCursor const & old_cursor)
 
 ParagraphList & LyXText::ownerParagraphs() const
 {
-	if (inset_owner) {
-		return inset_owner->paragraphs;
-	}
-	return bv_owner->buffer()->paragraphs;
-}
-
-
-LyXText::refresh_status LyXText::refreshStatus() const
-{
-	return refresh_status_;
-}
-
-
-void LyXText::clearPaint()
-{
-	refresh_status_ = REFRESH_NONE;
-	refresh_row = rows().end();
-	refresh_y = 0;
-}
-
-
-void LyXText::postPaint(int start_y)
-{
-	refresh_status old = refresh_status_;
-
-	refresh_status_ = REFRESH_AREA;
-	refresh_row = rows().end();
-
-	if (old != REFRESH_NONE && refresh_y < start_y)
-		return;
-
-	refresh_y = start_y;
-
-	if (!inset_owner)
-		return;
-
-	// We are an inset's lyxtext. Tell the top-level lyxtext
-	// it needs to update the row we're in.
-	LyXText * t = bv()->text;
-	t->postRowPaint(t->cursor.row(), t->cursor.y() - t->cursor.row()->baseline());
-}
-
-
-// FIXME: we should probably remove this y parameter,
-// make refresh_y be 0, and use row->y etc.
-void LyXText::postRowPaint(RowList::iterator rit, int start_y)
-{
-	if (refresh_status_ != REFRESH_NONE && refresh_y < start_y) {
-		refresh_status_ = REFRESH_AREA;
-		return;
-	} else {
-		refresh_y = start_y;
-	}
-
-	if (refresh_status_ == REFRESH_AREA)
-		return;
-
-	refresh_status_ = REFRESH_ROW;
-	refresh_row = rit;
-
-	if (!inset_owner)
-		return;
-
-	// We are an inset's lyxtext. Tell the top-level lyxtext
-	// it needs to update the row we're in.
-	LyXText * t = bv()->text;
-	t->postRowPaint(t->cursor.row(), t->cursor.y() - t->cursor.row()->baseline());
+	return paragraphs_;
 }
 
 
 bool LyXText::isInInset() const
 {
-	// Sub-level has non-null bv owner and
-	// non-null inset owner.
-	return inset_owner != 0 && bv_owner != 0;
+	// Sub-level has non-null bv owner and non-null inset owner.
+	return inset_owner != 0;
 }