X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Finsets%2Finsettext.C;h=f22c7cf84ed01192d1363747486308be32f285e3;hb=dbd7a961fc46bb10c85bdd8c7fb6626477ae63d8;hp=73c43939e226c1afa8d08114ca1d70ecdd441cdc;hpb=fcb37cc69357d839ede582145c0538886d040e70;p=lyx.git

diff --git a/src/insets/insettext.C b/src/insets/insettext.C
index 73c43939e2..f22c7cf84e 100644
--- a/src/insets/insettext.C
+++ b/src/insets/insettext.C
@@ -10,12 +10,6 @@
 
 #include <config.h>
 
-#include <fstream>
-#include <algorithm>
-
-#include <cstdlib>
-//#include <signal.h>
-
 #ifdef __GNUG__
 #pragma implementation
 #endif
@@ -29,18 +23,14 @@
 #include "buffer.h"
 #include "LyXView.h"
 #include "BufferView.h"
-#include "layout.h"
+#include "lyxtextclasslist.h"
 #include "LaTeXFeatures.h"
 #include "Painter.h"
-#include "frontends/Alert.h"
 #include "lyxtext.h"
 #include "lyxcursor.h"
 #include "CutAndPaste.h"
 #include "font.h"
 #include "LColor.h"
-#include "support/textutils.h"
-#include "support/LAssert.h"
-#include "support/lstrings.h"
 #include "lyxrow.h"
 #include "lyxrc.h"
 #include "intl.h"
@@ -53,6 +43,18 @@
 #include "undo_funcs.h"
 #include "lyxfind.h"
 
+#include "frontends/Alert.h"
+
+#include "support/textutils.h"
+#include "support/LAssert.h"
+#include "support/lstrings.h"
+#include "support/lyxalgo.h" // lyx::count
+
+#include <fstream>
+#include <algorithm>
+#include <cstdlib>
+//#include <csignal>
+
 using std::ostream;
 using std::ifstream;
 using std::endl;
@@ -60,8 +62,10 @@ using std::min;
 using std::max;
 using std::make_pair;
 using std::vector;
+using std::pair;
 
 using lyx::pos_type;
+using lyx::textclass_type;
 
 extern unsigned char getCurrentTextClass(Buffer *);
 extern bool math_insert_greek(BufferView *, char);
@@ -74,7 +78,7 @@ void InsetText::saveLyXTextState(LyXText * t) const
 {
 	// check if my paragraphs are still valid
 	Paragraph * p = par;
-	while(p) {
+	while (p) {
 		if (p == t->cursor.par())
 			break;
 		p = p->next();
@@ -159,7 +163,7 @@ InsetText & InsetText::operator=(InsetText const & it)
 void InsetText::init(InsetText const * ins, bool same_id)
 {
 	if (ins) {
-		setParagraphData(ins->par);
+		setParagraphData(ins->par, same_id);
 		autoBreakRows = ins->autoBreakRows;
 		drawFrame_ = ins->drawFrame_;
 		frame_color = ins->frame_color;
@@ -167,7 +171,7 @@ void InsetText::init(InsetText const * ins, bool same_id)
 			id_ = ins->id_;
 	} else {
 		Paragraph * p = par;
-		while(p) {
+		while (p) {
 			p->setInsetOwner(this);
 			p = p->next();
 		}
@@ -177,8 +181,6 @@ void InsetText::init(InsetText const * ins, bool same_id)
 		autoBreakRows = false;
 	}
 	top_y = 0;
-	last_width = 0;
-	last_height = 0;
 	insetAscent = 0;
 	insetDescent = 0;
 	insetWidth = 0;
@@ -194,6 +196,7 @@ void InsetText::init(InsetText const * ins, bool same_id)
 	frame_is_visible = false;
 	cached_bview = 0;
 	sstate.lpar = 0;
+	in_insetAllowed = false;
 }
 
 
@@ -260,7 +263,7 @@ void InsetText::read(Buffer const * buf, LyXLex & lex)
 			continue;
 		if (token == "\\end_inset") {
 #ifndef NO_COMPABILITY
-			const_cast<Buffer*>(buf)->insertErtContents(par, pos, font, false);
+			const_cast<Buffer*>(buf)->insertErtContents(par, pos, false);
 #endif
 			break;
 		}
@@ -276,7 +279,7 @@ void InsetText::read(Buffer const * buf, LyXLex & lex)
 	if (!return_par)
 		return_par = par;
 	par = return_par;
-	while(return_par) {
+	while (return_par) {
 		return_par->setInsetOwner(this);
 		return_par = return_par->next();
 	}
@@ -291,29 +294,17 @@ void InsetText::read(Buffer const * buf, LyXLex & lex)
 
 int InsetText::ascent(BufferView * bv, LyXFont const &) const
 {
-	bool clear = false;
-	if (!lt) {
-		lt = getLyXText(bv);
-		clear = true;
-	}
-	insetAscent = lt->firstRow()->ascent_of_text() + TEXT_TO_INSET_OFFSET;
-	if (clear)
-		lt = 0;
+	insetAscent = getLyXText(bv)->firstRow()->ascent_of_text() +
+		TEXT_TO_INSET_OFFSET;
 	return insetAscent;
 }
 
 
 int InsetText::descent(BufferView * bv, LyXFont const &) const
 {
-	bool clear = false;
-	if (!lt) {
-		lt = getLyXText(bv);
-		clear = true;
-	}
-	insetDescent = lt->height - lt->firstRow()->ascent_of_text() +
+	LyXText * llt = getLyXText(bv);
+	insetDescent = llt->height - llt->firstRow()->ascent_of_text() +
 		TEXT_TO_INSET_OFFSET;
-	if (clear)
-		lt = 0;
 	return insetDescent;
 }
 
@@ -359,29 +350,29 @@ void InsetText::draw(BufferView * bv, LyXFont const & f,
 	int old_x = top_x;
 	if (top_x != int(x)) {
 		top_x = int(x);
+		topx_set = true;
 		int nw = getMaxWidth(bv, this);
 		if (nw > 0 && old_max_width != nw) {
 			need_update = INIT;
 			old_max_width = nw;
 			bv->text->status(bv, LyXText::CHANGED_IN_DRAW);
-			topx_set = true;
 			return;
-		} else {
-			top_x = old_x;
 		}
 	}
 
+	// call these methods so that insetWidth, insetAscent and
+	// insetDescent have the right values. 
+	width(bv, f);
+	ascent(bv, f);
+	descent(bv, f);
+
 	// repaint the background if needed
 	if (cleared && backgroundColor() != LColor::background) {
-		top_x = int(x);
-		clearInset(pain, baseline, cleared);
-		top_x = old_x;
+		clearInset(bv, baseline, cleared);
 	}
 
 	// no draw is necessary !!!
 	if ((drawFrame_ == LOCKED) && !locked && !par->size()) {
-		top_x = int(x);
-		topx_set = true;
 		top_baseline = baseline;
 		x += width(bv, f);
 		if (need_update & CLEAR_FRAME)
@@ -395,14 +386,15 @@ void InsetText::draw(BufferView * bv, LyXFont const & f,
 		x += static_cast<float>(scroll());
 
 	// if top_x differs we did it already
-	if (!cleared && (top_x == int(x)) &&
-		((need_update&(INIT|FULL)) || (top_baseline!=baseline) ||
-		 (last_drawn_width!=insetWidth))) {
-		clearInset(pain, baseline, cleared);
+	if (!cleared && (old_x == int(x))
+	    && ((need_update&(INIT|FULL)) || (top_baseline != baseline)
+		||(last_drawn_width != insetWidth)))
+	{
+		// Condition necessary to eliminate bug 59 attachment 37
+		if (baseline > 0)
+			clearInset(bv, baseline, cleared);
 	}
 
-	top_x = int(x);
-	topx_set = true;
 	if (cleared)
 		frame_is_visible = false;
 
@@ -413,13 +405,11 @@ void InsetText::draw(BufferView * bv, LyXFont const & f,
 	}
 
 	top_baseline = baseline;
-	top_y = baseline - ascent(bv, f);
-	last_width = width(bv, f);
-	last_height = ascent(bv, f) + descent(bv, f);
+	top_y = baseline - insetAscent;
 
-	if (cleared || (last_drawn_width != insetWidth)) {
+	if (last_drawn_width != insetWidth) {
 		if (!cleared) 
-			clearInset(pain, baseline, cleared);
+			clearInset(bv, baseline, cleared);
 		need_update |= FULL;
 		last_drawn_width = insetWidth;
 	}
@@ -432,7 +422,7 @@ void InsetText::draw(BufferView * bv, LyXFont const & f,
 	if (!cleared && (need_update == CURSOR)
 	    && !getLyXText(bv)->selection.set()) {
 		drawFrame(pain, cleared);
-		x += last_width; // was width(bv, f);
+		x += insetWidth; 
 		need_update = NONE;
 		return;
 	}
@@ -495,14 +485,13 @@ void InsetText::draw(BufferView * bv, LyXFont const & f,
 		clearFrame(pain, cleared);
 	}
 	
-	x += last_width /* was width(bv, f) */ - TEXT_TO_INSET_OFFSET;
+	x += insetWidth - TEXT_TO_INSET_OFFSET;
 	
 	if (bv->text->status() == LyXText::CHANGED_IN_DRAW) {
 		need_update |= FULL;
 	} else if (need_update != INIT) {
 		need_update = NONE;
 	}
-	
 	if (clear)
 		lt = 0;
 }
@@ -514,10 +503,9 @@ void InsetText::drawFrame(Painter & pain, bool cleared) const
 	if (!frame_is_visible || cleared) {
 		frame_x = top_x + ttoD2;
 		frame_y = top_baseline - insetAscent + ttoD2;
-		frame_w = last_width - TEXT_TO_INSET_OFFSET;
+		frame_w = insetWidth - TEXT_TO_INSET_OFFSET;
 		frame_h = insetAscent + insetDescent - TEXT_TO_INSET_OFFSET;
-		pain.rectangle(frame_x, frame_y,
-			       frame_w, frame_h,
+		pain.rectangle(frame_x, frame_y, frame_w, frame_h,
 		               frame_color);
 		frame_is_visible = true;
 	}
@@ -566,18 +554,6 @@ void InsetText::update(BufferView * bv, LyXFont const & font, bool reinit)
 		lt = getLyXText(bv);
 		clear = true;
 	}
-#if 0
-	int oldw = insetWidth;
-	insetWidth = lt->width + (2 * TEXT_TO_INSET_OFFSET);
-	if (oldw != insetWidth) {
-		resizeLyXText(bv);
-		need_update |= FULL;
-		if (clear)
-			lt = 0;
-		in_update = false;
-		return;
-	}
-#endif
 	if ((need_update & CURSOR_PAR) && (lt->status() == LyXText::UNCHANGED) &&
 		the_locking_inset)
 	{
@@ -593,36 +569,34 @@ void InsetText::update(BufferView * bv, LyXFont const & font, bool reinit)
 
 void InsetText::setUpdateStatus(BufferView * bv, int what) const
 {
-	bool clear = false;
-	if (!lt) {
-		lt = getLyXText(bv);
-		clear = true;
-	}
+	// this does nothing dangerous so use only a localized buffer
+	LyXText * llt = getLyXText(bv);
+	
 	need_update |= what;
 	// we have to redraw us full if our LyXText NEEDS_MORE_REFRES or
 	// if we don't break row so that we only have one row to update!
-	if ((lt->status() == LyXText::NEED_MORE_REFRESH) ||
+	if ((llt->status() == LyXText::NEED_MORE_REFRESH) ||
 	    (!autoBreakRows &&
-	     (lt->status() == LyXText::NEED_VERY_LITTLE_REFRESH)))
+	     (llt->status() == LyXText::NEED_VERY_LITTLE_REFRESH)))
 	{
 		need_update |= FULL;
-	} else if (lt->status() == LyXText::NEED_VERY_LITTLE_REFRESH) {
+	} else if (llt->status() == LyXText::NEED_VERY_LITTLE_REFRESH) {
 		need_update |= CURSOR_PAR;
 	}
 
 	// this to not draw a selection when we redraw all of it!
 	if (need_update & CURSOR && !(need_update & SELECTION)) {
-		if (lt->selection.set())
+		if (llt->selection.set())
 			need_update = FULL;
-		lt->clearSelection();
+		llt->clearSelection();
 	}
-	if (clear)
-		lt = 0;
 }
 
 
 void InsetText::updateLocal(BufferView * bv, int what, bool mark_dirty) const
 {
+	if (!autoBreakRows && par->next())
+		collapseParagraphs(bv->buffer()->params);
 	bool clear = false;
 	if (!lt) {
 		lt = getLyXText(bv);
@@ -630,20 +604,24 @@ void InsetText::updateLocal(BufferView * bv, int what, bool mark_dirty) const
 	}
 	lt->fullRebreak(bv);
 	setUpdateStatus(bv, what);
-	if (((need_update != CURSOR) && (need_update != NONE)) ||
-	    (lt->status() != LyXText::UNCHANGED) || lt->selection.set())
-	{
+	bool flag = (((need_update != CURSOR) && (need_update != NONE)) ||
+	             (lt->status() != LyXText::UNCHANGED) || lt->selection.set());
+	if (clear)
+		lt = 0;
+	if (flag)
 		bv->updateInset(const_cast<InsetText *>(this), mark_dirty);
-	}
+	else
+		bv->fitCursor();
+	
 	if (need_update == CURSOR)
 		need_update = NONE;
 	bv->owner()->showState();
+	bv->owner()->updateMenubar();
+	bv->owner()->updateToolbar();
 	if (old_par != cpar(bv)) {
-		bv->owner()->setLayout(cpar(bv)->getLayout());
+		bv->owner()->setLayout(cpar(bv)->layout());
 		old_par = cpar(bv);
 	}
-	if (clear)
-		lt = 0;
 }
 
 
@@ -673,25 +651,28 @@ void InsetText::edit(BufferView * bv, int x, int y, unsigned int button)
 		lt = getLyXText(bv);
 		clear = true;
 	}
-
 	if (!checkAndActivateInset(bv, x, tmp_y, button))
 		lt->setCursorFromCoordinates(bv, x - drawTextXOffset,
 		                            y + insetAscent);
 	lt->clearSelection();
 	finishUndo();
-	showInsetCursor(bv);
-	updateLocal(bv, CURSOR, false);
-
 	// If the inset is empty set the language of the current font to the
 	// language to the surronding text (if different).
 	if (par->size() == 0 && !par->next() &&
-		bv->getParentLanguage(this) != lt->current_font.language()) {
+		bv->getParentLanguage(this) != lt->current_font.language())
+	{
 		LyXFont font(LyXFont::ALL_IGNORE);
 		font.setLanguage(bv->getParentLanguage(this));
 		setFont(bv, font, false);
 	}
+	showInsetCursor(bv);
 	if (clear)
 		lt = 0;
+	
+	int code = CURSOR;
+	if (drawFrame_ == LOCKED)
+		code = CURSOR|DRAW_FRAME;
+	updateLocal(bv, code, false);
 }
 
 
@@ -718,16 +699,13 @@ void InsetText::edit(BufferView * bv, bool front)
 		lt->setCursor(bv, par, 0);
 	else {
 		Paragraph * p = par;
-		while(p->next())
+		while (p->next())
 			p = p->next();
 //		int const pos = (p->size() ? p->size()-1 : p->size());
 		lt->setCursor(bv, p, p->size());
 	}
 	lt->clearSelection();
 	finishUndo();
-	showInsetCursor(bv);
-	updateLocal(bv, CURSOR, false);
-
 	// If the inset is empty set the language of the current font to the
 	// language to the surronding text (if different).
 	if (par->size() == 0 && !par->next() &&
@@ -736,8 +714,13 @@ void InsetText::edit(BufferView * bv, bool front)
 		font.setLanguage(bv->getParentLanguage(this));
 		setFont(bv, font, false);
 	}
+	showInsetCursor(bv);
 	if (clear)
 		lt = 0;
+	int code = CURSOR;
+	if (drawFrame_ == LOCKED)
+		code = CURSOR|DRAW_FRAME;
+	updateLocal(bv, code, false);
 }
 
 
@@ -765,14 +748,29 @@ void InsetText::insetUnlock(BufferView * bv)
 		code = FULL;
 	} else if (owner()) {
 		bv->owner()->setLayout(owner()->getLyXText(bv)
-		                       ->cursor.par()->getLayout());
+		                       ->cursor.par()->layout());
 	} else
-		bv->owner()->setLayout(bv->text->cursor.par()->getLayout());
+		bv->owner()->setLayout(bv->text->cursor.par()->layout());
 	// hack for deleteEmptyParMech
-	lt->setCursor(bv, par, 0);
-	updateLocal(bv, code, false);
+	if (par->size()) {
+		lt->setCursor(bv, par, 0);
+	} else if (par->next()) {
+		lt->setCursor(bv, par->next(), 0);
+	}
 	if (clear)
 		lt = 0;
+	updateLocal(bv, code, false);
+}
+
+void InsetText::lockInset(BufferView * bv, UpdatableInset * inset)
+{
+	the_locking_inset = inset;
+	inset_x = cx(bv) - top_x + drawTextXOffset;
+	inset_y = cy(bv) + drawTextYOffset;
+	inset_pos = cpos(bv);
+	inset_par = cpar(bv);
+	inset_boundary = cboundary(bv);
+	updateLocal(bv, CURSOR, false);
 }
 
 
@@ -782,15 +780,33 @@ bool InsetText::lockInsetInInset(BufferView * bv, UpdatableInset * inset)
 			      << inset << "): ";
 	if (!inset)
 		return false;
+	if (!the_locking_inset) {
+		Paragraph * p = par;
+		int const id = inset->id();
+		while(p) {
+			Paragraph::inset_iterator it =
+				p->inset_iterator_begin();
+			Paragraph::inset_iterator const end =
+				p->inset_iterator_end();
+			for (; it != end; ++it) {
+				if ((*it) == inset) {
+					getLyXText(bv)->setCursorIntern(bv, p, it.getPos());
+					lockInset(bv, inset);
+					return true;
+				}
+				if ((*it)->getInsetFromID(id)) {
+					getLyXText(bv)->setCursorIntern(bv, p, it.getPos());
+					(*it)->edit(bv);
+					return the_locking_inset->lockInsetInInset(bv, inset);
+				}
+			}
+			p = p->next();
+		}
+		return false;
+	}
 	if (inset == cpar(bv)->getInset(cpos(bv))) {
 		lyxerr[Debug::INSETS] << "OK" << endl;
-		the_locking_inset = inset;
-		inset_x = cx(bv) - top_x + drawTextXOffset;
-		inset_y = cy(bv) + drawTextYOffset;
-		inset_pos = cpos(bv);
-		inset_par = cpar(bv);
-		inset_boundary = cboundary(bv);
-		updateLocal(bv, CURSOR, false);
+		lockInset(bv, inset);
 		return true;
 	} else if (the_locking_inset && (the_locking_inset == inset)) {
 		if (cpar(bv) == inset_par && cpos(bv) == inset_pos) {
@@ -810,7 +826,7 @@ bool InsetText::lockInsetInInset(BufferView * bv, UpdatableInset * inset)
 
 
 bool InsetText::unlockInsetInInset(BufferView * bv, UpdatableInset * inset,
-				   bool lr)
+                                   bool lr)
 {
 	if (!the_locking_inset)
 		return false;
@@ -833,20 +849,42 @@ bool InsetText::unlockInsetInInset(BufferView * bv, UpdatableInset * inset,
 
 bool InsetText::updateInsetInInset(BufferView * bv, Inset * inset)
 {
-	if (!the_locking_inset)
-		return false;
+	if (!autoBreakRows && par->next())
+		collapseParagraphs(bv->buffer()->params);
+	if (inset == this)
+		return true;
+	bool clear = false;
+	if (!lt) {
+		lt = getLyXText(bv);
+		clear = true;
+	}
+	if (!the_locking_inset) {
+		bool found = lt->updateInset(bv, inset);
+		if (clear)
+			lt = 0;
+		if (found)
+			setUpdateStatus(bv, NONE);
+		return found;
+	}
 	if (the_locking_inset != inset) {
-		getLyXText(bv)->updateInset(bv, the_locking_inset);
-		setUpdateStatus(bv, CURSOR_PAR);
-		return the_locking_inset->updateInsetInInset(bv, inset);
+		bool found = the_locking_inset->updateInsetInInset(bv, inset);
+		if (clear)
+			lt = 0;
+		if (found)
+			setUpdateStatus(bv, CURSOR_PAR);
+		return found;
 	}
-	if (getLyXText(bv)->updateInset(bv, inset))
-		updateLocal(bv, CURSOR_PAR, false);
-	if (cpar(bv) == inset_par && cpos(bv) == inset_pos) {
-		inset_x = cx(bv) - top_x + drawTextXOffset;
-		inset_y = cy(bv) + drawTextYOffset;
+	bool found = lt->updateInset(bv, inset);
+	if (clear)
+		lt = 0;
+	if (found) {
+		setUpdateStatus(bv, CURSOR_PAR);
+		if (cpar(bv) == inset_par && cpos(bv) == inset_pos) {
+			inset_x = cx(bv) - top_x + drawTextXOffset;
+			inset_y = cy(bv) + drawTextYOffset;
+		}
 	}
-	return true;
+	return found;
 }
 
 
@@ -854,14 +892,21 @@ void InsetText::insetButtonPress(BufferView * bv, int x, int y, int button)
 {
 	no_selection = true;
 
+	// use this to check mouse motion for selection!
+	mouse_x = x;
+	mouse_y = y;
+
 	int tmp_x = x - drawTextXOffset;
 	int tmp_y = y + insetAscent - getLyXText(bv)->first;
-	Inset * inset = bv->checkInsetHit(getLyXText(bv), tmp_x, tmp_y, button);
+	Inset * inset = bv->checkInsetHit(getLyXText(bv), tmp_x, tmp_y);
 
 	hideInsetCursor(bv);
 	if (the_locking_inset) {
 		if (the_locking_inset == inset) {
-			the_locking_inset->insetButtonPress(bv,x-inset_x,y-inset_y,button);
+			the_locking_inset->insetButtonPress(bv,
+			                                    x - inset_x,
+			                                    y - inset_y,
+			                                    button);
 			no_selection = false;
 			return;
 		} else if (inset) {
@@ -869,8 +914,9 @@ void InsetText::insetButtonPress(BufferView * bv, int x, int y, int button)
 			the_locking_inset->insetUnlock(bv);
 			inset_x = cx(bv) - top_x + drawTextXOffset;
 			inset_y = cy(bv) + drawTextYOffset;
-			the_locking_inset = static_cast<UpdatableInset*>(inset);
-			inset->insetButtonPress(bv, x - inset_x, y - inset_y, button);
+			the_locking_inset = 0;
+			inset->insetButtonPress(bv, x - inset_x,
+			                        y - inset_y, button);
 			inset->edit(bv, x - inset_x, y - inset_y, button);
 			if (the_locking_inset)
 				updateLocal(bv, CURSOR, false);
@@ -910,14 +956,25 @@ void InsetText::insetButtonPress(BufferView * bv, int x, int y, int button)
 			lt = getLyXText(bv);
 			clear = true;
 		}
-		lt->setCursorFromCoordinates(bv, x-drawTextXOffset, y + insetAscent);
+
+		lt->setCursorFromCoordinates(bv, x - drawTextXOffset,
+		                             y + insetAscent);
+		// set the selection cursor!
+		lt->selection.cursor = lt->cursor;
+		lt->cursor.x_fix(lt->cursor.x());
+
 		if (lt->selection.set()) {
 			lt->clearSelection();
+			if (clear)
+				lt = 0;
 			updateLocal(bv, FULL, false);
 		} else {
 			lt->clearSelection();
+			if (clear)
+				lt = 0;
+			updateLocal(bv, CURSOR, false);
 		}
-		bv->owner()->setLayout(cpar(bv)->getLayout());
+		bv->owner()->setLayout(cpar(bv)->layout());
 		old_par = cpar(bv);
 		// Insert primary selection with middle mouse
 		// if there is a local selection in the current buffer,
@@ -929,61 +986,73 @@ void InsetText::insetButtonPress(BufferView * bv, int x, int y, int button)
 				localDispatch(bv, LFUN_PASTESELECTION,
 				              "paragraph");
 		}
-		if (clear)
-			lt = 0;
+	} else {
+		getLyXText(bv)->clearSelection();
 	}
 	showInsetCursor(bv);
 	no_selection = false;
 }
 
 
-void InsetText::insetButtonRelease(BufferView * bv, int x, int y, int button)
+bool InsetText::insetButtonRelease(BufferView * bv, int x, int y, int button)
 {
-	UpdatableInset * inset = 0;
-
 	if (the_locking_inset) {
-		the_locking_inset->insetButtonRelease(bv,
-						      x - inset_x, y - inset_y,
-						      button);
-	} else {
-		if (cpar(bv)->isInset(cpos(bv))) {
-			inset = static_cast<UpdatableInset*>(cpar(bv)->getInset(cpos(bv)));
-			if (isHighlyEditableInset(inset)) {
-				inset->insetButtonRelease(bv,
-							  x - inset_x,
-							  y - inset_y, button);
-			} else {
-				inset_x = cx(bv) - top_x + drawTextXOffset;
-				inset_y = cy(bv) + drawTextYOffset;
-				inset->insetButtonRelease(bv,
-							  x - inset_x,
-							  y - inset_y, button);
-				inset->edit(bv,
-					    x - inset_x, y - inset_y, button);
-			}
-			updateLocal(bv, CURSOR_PAR, false);
+		return the_locking_inset->insetButtonRelease(bv,
+		                                             x - inset_x, y - inset_y,
+		                                             button);
+	}
+	int tmp_x = x - drawTextXOffset;
+	int tmp_y = y + insetAscent - getLyXText(bv)->first;
+	Inset * inset = bv->checkInsetHit(getLyXText(bv), tmp_x, tmp_y);
+	bool ret = false;
+	if (inset) {
+		if (isHighlyEditableInset(inset)) {
+			ret = inset->insetButtonRelease(bv, x - inset_x,
+			                                y - inset_y, button);
+		} else {
+			inset_x = cx(bv) - top_x + drawTextXOffset;
+			inset_y = cy(bv) + drawTextYOffset;
+			ret = inset->insetButtonRelease(bv, x - inset_x,
+			                                y - inset_y, button);
+			inset->edit(bv, x - inset_x,
+			            y - inset_y, button);
 		}
+		updateLocal(bv, CURSOR_PAR, false);
 	}
-	no_selection = false;
+	return ret;
 }
 
 
 void InsetText::insetMotionNotify(BufferView * bv, int x, int y, int state)
 {
-	if (no_selection)
+	if (no_selection || ((mouse_x == x) && (mouse_y == y)))
 		return;
 	if (the_locking_inset) {
 		the_locking_inset->insetMotionNotify(bv, x - inset_x,
-						     y - inset_y,state);
+		                                     y - inset_y,state);
 		return;
 	}
-	LyXText * t = getLyXText(bv);
+	bool clear = false;
+	if (!lt) {
+		lt = getLyXText(bv);
+		clear = true;
+	}
 	hideInsetCursor(bv);
-	t->setCursorFromCoordinates(bv, x - drawTextXOffset, y + insetAscent);
-	t->setSelection(bv);
-	if (t->toggle_cursor.par() != t->toggle_end_cursor.par() ||
-		t->toggle_cursor.pos() != t->toggle_end_cursor.pos())
+	LyXCursor cur = lt->cursor;
+	lt->setCursorFromCoordinates(bv, x - drawTextXOffset, y + insetAscent);
+	if (cur == lt->cursor) {
+		if (clear)
+			lt = 0;
+		return;
+	}
+	lt->setSelection(bv);
+	bool flag = (lt->toggle_cursor.par() != lt->toggle_end_cursor.par() ||
+				 lt->toggle_cursor.pos() != lt->toggle_end_cursor.pos());
+	if (clear)
+		lt = 0;
+	if (flag) {
 		updateLocal(bv, SELECTION, false);
+	}
 	showInsetCursor(bv);
 }
 
@@ -1021,7 +1090,7 @@ InsetText::localDispatch(BufferView * bv,
 			updateLocal(bv, CURSOR_PAR, false);
 			return result;
 		} else if (result >= FINISHED) {
-			switch(result) {
+			switch (result) {
 			case FINISHED_RIGHT:
 				moveRightIntern(bv, false, false);
 				result = DISPATCHED;
@@ -1055,6 +1124,8 @@ InsetText::localDispatch(BufferView * bv,
 		lt = getLyXText(bv);
 		clear = true;
 	}
+	int updwhat = 0;
+	int updflag = false;
 	switch (action) {
 	// Normal chars
 	case LFUN_SELFINSERT:
@@ -1083,7 +1154,8 @@ InsetText::localDispatch(BufferView * bv,
 			}
 		}
 		lt->selection.cursor = lt->cursor;
-		updateLocal(bv, CURSOR_PAR, true);
+		updwhat = CURSOR_PAR;
+		updflag = true;
 		result = DISPATCHED_NOUPDATE;
 		break;
 		// --- Cursor Movements -----------------------------------
@@ -1091,54 +1163,54 @@ InsetText::localDispatch(BufferView * bv,
 		finishUndo();
 		moveRight(bv, false, true);
 		lt->setSelection(bv);
-		updateLocal(bv, SELECTION, false);
+		updwhat = SELECTION;
 		break;
 	case LFUN_RIGHT:
 		result = moveRight(bv);
 		finishUndo();
-		updateLocal(bv, CURSOR, false);
+		updwhat = CURSOR;
 		break;
 	case LFUN_LEFTSEL:
 		finishUndo();
 		moveLeft(bv, false, true);
 		lt->setSelection(bv);
-		updateLocal(bv, SELECTION, false);
+		updwhat = SELECTION;
 		break;
 	case LFUN_LEFT:
 		finishUndo();
 		result = moveLeft(bv);
-		updateLocal(bv, CURSOR, false);
+		updwhat = CURSOR;
 		break;
 	case LFUN_DOWNSEL:
 		finishUndo();
 		moveDown(bv);
 		lt->setSelection(bv);
-		updateLocal(bv, SELECTION, false);
+		updwhat = SELECTION;
 		break;
 	case LFUN_DOWN:
 		finishUndo();
 		result = moveDown(bv);
-		updateLocal(bv, CURSOR, false);
+		updwhat = CURSOR;
 		break;
 	case LFUN_UPSEL:
 		finishUndo();
 		moveUp(bv);
 		lt->setSelection(bv);
-		updateLocal(bv, SELECTION, false);
+		updwhat = SELECTION;
 		break;
 	case LFUN_UP:
 		finishUndo();
 		result = moveUp(bv);
-		updateLocal(bv, CURSOR, false);
+		updwhat = CURSOR;
 		break;
 	case LFUN_HOME:
 		finishUndo();
 		lt->cursorHome(bv);
-		updateLocal(bv, CURSOR, false);
+		updwhat = CURSOR;
 		break;
 	case LFUN_END:
 		lt->cursorEnd(bv);
-		updateLocal(bv, CURSOR, false);
+		updwhat = CURSOR;
 		break;
 	case LFUN_BACKSPACE: {
 		setUndo(bv, Undo::DELETE,
@@ -1147,7 +1219,8 @@ InsetText::localDispatch(BufferView * bv,
 			lt->cutSelection(bv);
 		else
 			lt->backspace(bv);
-		updateLocal(bv, CURSOR_PAR, true);
+		updwhat = CURSOR_PAR;
+		updflag = true;
 	}
 	break;
 	
@@ -1159,7 +1232,8 @@ InsetText::localDispatch(BufferView * bv,
 		} else {
 			lt->Delete(bv);
 		}
-		updateLocal(bv, CURSOR_PAR, true);
+		updwhat = CURSOR_PAR;
+		updflag = true;
 	}
 	break;
 	
@@ -1167,14 +1241,15 @@ InsetText::localDispatch(BufferView * bv,
 		setUndo(bv, Undo::DELETE,
 		        lt->cursor.par(), lt->cursor.par()->next());
 		lt->cutSelection(bv);
-		updateLocal(bv, CURSOR_PAR, true);
+		updwhat = CURSOR_PAR;
+		updflag = true;
 	}
 	break;
 
 	case LFUN_COPY:
 		finishUndo();
 		lt->copySelection(bv);
-		updateLocal(bv, CURSOR_PAR, false);
+		updwhat = CURSOR_PAR;
 		break;
 	case LFUN_PASTESELECTION:
 	{
@@ -1187,7 +1262,8 @@ InsetText::localDispatch(BufferView * bv,
 		} else {
 			lt->insertStringAsLines(bv, clip);
 		}
-		updateLocal(bv, CURSOR_PAR, true);
+		updwhat = CURSOR_PAR;
+		updflag = true;
 		break;
 	}
 	case LFUN_PASTE: {
@@ -1203,7 +1279,8 @@ InsetText::localDispatch(BufferView * bv,
 		setUndo(bv, Undo::INSERT,
 		        lt->cursor.par(), lt->cursor.par()->next());
 		lt->pasteSelection(bv);
-		updateLocal(bv, CURSOR_PAR, true);
+		updwhat = CURSOR_PAR;
+		updflag = true;
 	}
 	break;
 
@@ -1213,7 +1290,8 @@ InsetText::localDispatch(BufferView * bv,
 			break;
 		}
 		lt->breakParagraph(bv, 0);
-		updateLocal(bv, FULL, true);
+		updwhat = FULL;
+		updflag = true;
 		break;
 	case LFUN_BREAKPARAGRAPHKEEPLAYOUT:
 		if (!autoBreakRows) {
@@ -1221,7 +1299,8 @@ InsetText::localDispatch(BufferView * bv,
 			break;
 		}
 		lt->breakParagraph(bv, 1);
-		updateLocal(bv, FULL, true);
+		updwhat = FULL;
+		updflag = true;
 		break;
 
 	case LFUN_BREAKLINE: {
@@ -1232,46 +1311,48 @@ InsetText::localDispatch(BufferView * bv,
 		setUndo(bv, Undo::INSERT,
 		        lt->cursor.par(), lt->cursor.par()->next());
 		lt->insertChar(bv, Paragraph::META_NEWLINE);
-		updateLocal(bv, CURSOR_PAR, true);
+		updwhat = CURSOR_PAR;
+		updflag = true;
 	}
 	break;
 
 	case LFUN_LAYOUT:
 		// do not set layouts on non breakable textinsets
 		if (autoBreakRows) {
-			LyXTextClass::size_type cur_layout = cpar(bv)->layout;
+			string cur_layout = cpar(bv)->layout();
 	  
 			// Derive layout number from given argument (string)
 			// and current buffer's textclass (number). */    
-			LyXTextClassList::ClassList::size_type tclass =
-				bv->buffer()->params.textclass;
-			std::pair <bool, LyXTextClass::size_type> layout = 
-				textclasslist.NumberOfLayout(tclass, arg);
+			textclass_type tclass = bv->buffer()->params.textclass;
+			string layout = lowercase(arg);
+			bool hasLayout = textclasslist[tclass].hasLayout(layout);
 
 			// If the entry is obsolete, use the new one instead.
-			if (layout.first) {
-				string obs = textclasslist.Style(tclass,layout.second).
+			if (hasLayout) {
+				string const & obs =
+					textclasslist[tclass][layout].
 					obsoleted_by();
 				if (!obs.empty()) 
-					layout = textclasslist.NumberOfLayout(tclass, obs);
+					layout = lowercase(obs);
 			}
 
 			// see if we found the layout number:
-			if (!layout.first) {
+			if (!hasLayout) {
 				string const msg = string(N_("Layout ")) + arg + N_(" not known");
 				bv->owner()->getLyXFunc()->dispatch(LFUN_MESSAGE, msg);
 				break;
 			}
 
-			if (cur_layout != layout.second) {
-				cur_layout = layout.second;
-				lt->setLayout(bv, layout.second);
-				bv->owner()->setLayout(cpar(bv)->getLayout());
-				updateLocal(bv, CURSOR_PAR, true);
+			if (cur_layout != layout) {
+				cur_layout = layout;
+				lt->setLayout(bv, layout);
+				bv->owner()->setLayout(cpar(bv)->layout());
+				updwhat = CURSOR_PAR;
+				updflag = true;
 			}
 		} else {
 			// reset the layout box
-			bv->owner()->setLayout(cpar(bv)->getLayout());
+			bv->owner()->setLayout(cpar(bv)->layout());
 		}
 		break;
 	case LFUN_PARAGRAPH_SPACING:
@@ -1315,7 +1396,8 @@ InsetText::localDispatch(BufferView * bv,
 		}
 		if (cur_spacing != new_spacing || cur_value != new_value) {
 			par->params().spacing(Spacing(new_spacing, new_value));
-			updateLocal(bv, CURSOR_PAR, true);
+			updwhat = CURSOR_PAR;
+			updflag = true;
 		}
 	}
 	break;
@@ -1326,6 +1408,10 @@ InsetText::localDispatch(BufferView * bv,
 		break;
 	}
 
+	if (clear)
+		lt = 0;
+	if (updwhat > 0)
+		updateLocal(bv, updwhat, updflag);
 	/// If the action has deleted all text in the inset, we need to change the
 	// language to the language of the surronding text.
 	if (!was_empty && par->size() == 0 && !par->next()) {
@@ -1338,8 +1424,6 @@ InsetText::localDispatch(BufferView * bv,
 		showInsetCursor(bv);
 	} else
 		bv->unlockInset(this);
-	if (clear)
-		lt = 0;
 	return result;
 }
 
@@ -1358,8 +1442,8 @@ int InsetText::ascii(Buffer const * buf, ostream & os, int linelen) const
 	unsigned int lines = 0;
 	
 	while (p) {
-		string const tmp = buf->asciiParagraph(p, linelen);
-		lines += countChar(tmp, '\n');
+		string const tmp = buf->asciiParagraph(p, linelen, p->previous()==0);
+		lines += lyx::count(tmp.begin(), tmp.end(), '\n');
 		os << tmp;
 		p = p->next();
 	}
@@ -1385,8 +1469,7 @@ int InsetText::docbook(Buffer const * buf, ostream & os) const
 		int desc_on = 0; // description mode
 
 		LyXLayout const & style =
-			textclasslist.Style(buf->params.textclass,
-					    p->layout);
+			textclasslist[buf->params.textclass][p->layout()];
 
 		// environment tag closing
 		for (; depth > p->params().depth(); --depth) {
@@ -1445,7 +1528,7 @@ int InsetText::docbook(Buffer const * buf, ostream & os) const
 			}
 
 			if (environment_stack[depth] != style.latexname()) {
-				if(environment_stack.size() == depth + 1) {
+				if (environment_stack.size() == depth + 1) {
 					environment_stack.push_back("!-- --");
 					environment_inner.push_back("!-- --");
 				}
@@ -1468,7 +1551,7 @@ int InsetText::docbook(Buffer const * buf, ostream & os) const
 			
 			if (style.latextype == LATEX_ENVIRONMENT) {
 				if (!style.latexparam().empty()) {
-					if(style.latexparam() == "CDATA")
+					if (style.latexparam() == "CDATA")
 						os << "<![CDATA[";
 					else
 						buf->sgmlOpenTag(os, depth + command_depth,
@@ -1512,7 +1595,7 @@ int InsetText::docbook(Buffer const * buf, ostream & os) const
 		switch (style.latextype) {
 		case LATEX_ENVIRONMENT:
 			if (!style.latexparam().empty()) {
-				if(style.latexparam() == "CDATA")
+				if (style.latexparam() == "CDATA")
 					os << "]]>";
 				else
 					buf->sgmlCloseTag(os, depth + command_depth,
@@ -1566,8 +1649,7 @@ void InsetText::validate(LaTeXFeatures & features) const
 
 int InsetText::beginningOfMainBody(Buffer const * buf, Paragraph * p) const
 {
-	if (textclasslist.Style(buf->params.textclass,
-				p->getLayout()).labeltype != LABEL_MANUAL)
+	if (textclasslist[buf->params.textclass][p->layout()].labeltype != LABEL_MANUAL)
 		return 0;
 	else
 		return p->beginningOfMainBody();
@@ -1740,34 +1822,41 @@ bool InsetText::insertInset(BufferView * bv, Inset * inset)
 			return the_locking_inset->insertInset(bv, inset);
 		return false;
 	}
-	inset->setOwner(this);
-	hideInsetCursor(bv);
-
 	bool clear = false;
 	if (!lt) {
 		lt = getLyXText(bv);
 		clear = true;
 	}
+	setUndo(bv, Undo::FINISH, lt->cursor.par(), lt->cursor.par()->next());
+	freezeUndo();
+	inset->setOwner(this);
+	hideInsetCursor(bv);
 	lt->insertInset(bv, inset);
-#if 0
-	if ((!cpar(bv)->isInset(cpos(bv))) ||
-		(cpar(bv)->getInset(cpos(bv)) != inset))
-		lt->cursorLeft(bv);
-#endif
 	bv->fitCursor();
-	updateLocal(bv, CURSOR_PAR|CURSOR, true);
-	showInsetCursor(bv);
 	if (clear)
 		lt = 0;
+	updateLocal(bv, CURSOR_PAR|CURSOR, true);
+	unFreezeUndo();
 	return true;
 }
 
 
 bool InsetText::insetAllowed(Inset::Code code) const
 {
+	// in_insetAllowed is a really gross hack,
+	// to allow us to call the owner's insetAllowed
+	// without stack overflow, which can happen
+	// when the owner uses InsetCollapsable::insetAllowed()
+	bool ret = true;
+	if (in_insetAllowed)
+		return ret;
+	in_insetAllowed = true;
 	if (the_locking_inset)
-		return the_locking_inset->insetAllowed(code);
-	return true;
+		ret = the_locking_inset->insetAllowed(code);
+	else if (owner())
+		ret = owner()->insetAllowed(code);
+	in_insetAllowed = false;
+	return ret;
 }
 
 
@@ -1796,16 +1885,16 @@ bool InsetText::showInsetDialog(BufferView * bv) const
 }
 
 
-std::vector<string> const InsetText::getLabelList() const 
+vector<string> const InsetText::getLabelList() const 
 {
-	std::vector<string> label_list;
+	vector<string> label_list;
 
 	Paragraph * tpar = par;
 	while (tpar) {
 		Paragraph::inset_iterator beg = tpar->inset_iterator_begin();
 		Paragraph::inset_iterator end = tpar->inset_iterator_end();
 		for (; beg != end; ++beg) {
-			std::vector<string> const l = (*beg)->getLabelList();
+			vector<string> const l = (*beg)->getLabelList();
 			label_list.insert(label_list.end(), l.begin(), l.end());
 		}
 		tpar = tpar->next();
@@ -1839,12 +1928,13 @@ void InsetText::setFont(BufferView * bv, LyXFont const & font, bool toggleall,
 	if (selectall)
 		lt->clearSelection();
 	bv->fitCursor();
-	if (selectall || lt->selection.set())
+	bool flag = (selectall || lt->selection.set());
+	if (clear)
+		lt = 0;
+	if (flag)
 		updateLocal(bv, FULL, true);
 	else
 		updateLocal(bv, CURSOR_PAR, true);
-	if (clear)
-		lt = 0;
 }
 
 
@@ -1884,7 +1974,7 @@ bool InsetText::checkAndActivateInset(BufferView * bv, int x, int y,
 	x -= drawTextXOffset;
 	int dummyx = x;
 	int dummyy = y + insetAscent;
-	Inset * inset = bv->checkInsetHit(getLyXText(bv), dummyx, dummyy, button);
+	Inset * inset = bv->checkInsetHit(getLyXText(bv), dummyx, dummyy);
 
 	if (inset) {
 		if (x < 0)
@@ -1922,7 +2012,7 @@ int InsetText::getMaxWidth(BufferView * bv, UpdatableInset const * inset) const
 }
 
 
-void InsetText::setParagraphData(Paragraph * p)
+void InsetText::setParagraphData(Paragraph * p, bool same_id)
 {
 	// we have to unlock any locked inset otherwise we're in troubles
 	the_locking_inset = 0;
@@ -1932,12 +2022,12 @@ void InsetText::setParagraphData(Paragraph * p)
 		par = tmp;
 	}
 
-	par = new Paragraph(*p, false);
+	par = new Paragraph(*p, same_id);
 	par->setInsetOwner(this);
 	Paragraph * np = par;
 	while (p->next()) {
 		p = p->next();
-		np->next(new Paragraph(*p, false));
+		np->next(new Paragraph(*p, same_id));
 		np->next()->previous(np);
 		np = np->next();
 		np->setInsetOwner(this);
@@ -1989,21 +2079,15 @@ void InsetText::setFrameColor(BufferView * bv, LColor::color col)
 
 int InsetText::cx(BufferView * bv) const
 {
-	bool clear = false;
-	if (!lt) {
-		lt = getLyXText(bv);
-		clear = true;
-	}
-	int x = lt->cursor.x() + top_x + TEXT_TO_INSET_OFFSET;
+	// we do nothing dangerous so we use a local cache
+	LyXText * llt = getLyXText(bv);
+	int x = llt->cursor.x() + top_x + TEXT_TO_INSET_OFFSET;
 	if (the_locking_inset) {
-		LyXFont font = lt->getFont(bv->buffer(),
-					     lt->cursor.par(),
-					     lt->cursor.pos());
+		LyXFont font = llt->getFont(bv->buffer(), llt->cursor.par(),
+		                            llt->cursor.pos());
 		if (font.isVisibleRightToLeft())
 			x -= the_locking_inset->width(bv, font);
 	}
-	if (clear)
-		lt = 0;
 	return x;
 }
 
@@ -2045,7 +2129,7 @@ LyXText * InsetText::getLyXText(BufferView const * lbv,
 	if (!recursive && (cached_bview == lbv)) {
 		LyXText * lt = cached_text.get();
 		lyx::Assert(lt && lt->firstRow()->par() == par);
-		return cached_text.get();
+		return lt;
 	}
 	
 	// Super UGLY! (Lgb)
@@ -2055,26 +2139,41 @@ LyXText * InsetText::getLyXText(BufferView const * lbv,
 	Cache::iterator it = cache.find(bv);
 
 	if (it != cache.end()) {
-		if (do_reinit)
+		if (do_reinit) {
 			reinitLyXText();
-		else if (do_resize)
+		} else if (do_resize) {
 			resizeLyXText(do_resize);
-		if (lt || !it->second.remove) {
-			lyx::Assert(it->second.text.get());
-			cached_text = it->second.text;
-			if (recursive && the_locking_inset) {
-				return the_locking_inset->getLyXText(bv, true);
-			}
-			return cached_text.get();
-		} else if (it->second.remove) {
-			if (locked) {
-				saveLyXTextState(it->second.text.get());
-			} else {
-				sstate.lpar = 0;
+		} else {
+			if (lt || !it->second.remove) {
+				lyx::Assert(it->second.text.get());
+				cached_text = it->second.text;
+				if (recursive && the_locking_inset) {
+					return the_locking_inset->getLyXText(bv, true);
+				}
+				return cached_text.get();
+			} else if (it->second.remove) {
+				if (locked) {
+					saveLyXTextState(it->second.text.get());
+				} else {
+					sstate.lpar = 0;
+				}
 			}
+			//
+			// when we have to reinit the existing LyXText!
+			//
+			it->second.text->init(bv);
+			restoreLyXTextState(bv, it->second.text.get());
+			it->second.remove = false;
+		}
+		cached_text = it->second.text;
+		if (the_locking_inset && recursive) {
+			return the_locking_inset->getLyXText(bv);
 		}
+		return cached_text.get();
 	}
-	
+	///
+	// we are here only if we don't have a BufferView * in the cache!!!
+	///
 	cached_text.reset(new LyXText(const_cast<InsetText *>(this)));
 	cached_text->init(bv);
 	restoreLyXTextState(bv, cached_text.get());
@@ -2121,8 +2220,14 @@ void InsetText::resizeLyXText(BufferView * bv, bool force) const
 	}
 	do_resize = 0;
 //	lyxerr << "InsetText::resizeLyXText\n";
-	if (!par->next() && !par->size()) // no data, resize not neccessary!
+	if (!par->next() && !par->size()) { // no data, resize not neccessary!
+		// we have to do this as a fixed width may have changed!
+		LyXText * t = getLyXText(bv);
+		saveLyXTextState(t);
+		t->init(bv, true);
+		restoreLyXTextState(bv, t);
 		return;
+	}
 	// one endless line, resize normally not necessary
 	if (!force && getMaxWidth(bv, this) < 0)
 		return;
@@ -2201,12 +2306,18 @@ void InsetText::reinitLyXText() const
 
 void InsetText::removeNewlines()
 {
+	bool changed = false;
+	
 	for (Paragraph * p = par; p; p = p->next()) {
 		for (int i = 0; i < p->size(); ++i) {
-			if (p->getChar(i) == Paragraph::META_NEWLINE)
+			if (p->getChar(i) == Paragraph::META_NEWLINE) {
+				changed = true;
 				p->erase(i);
+			}
 		}
 	}
+	if (changed)
+		reinitLyXText();
 }
 
 
@@ -2250,8 +2361,9 @@ void InsetText::clearSelection(BufferView * bv)
 }
 
 
-void InsetText::clearInset(Painter & pain, int baseline, bool & cleared) const
+void InsetText::clearInset(BufferView * bv, int baseline, bool & cleared) const
 {
+	Painter & pain = bv->painter();
 	int w = insetWidth;
 	int h = insetAscent + insetDescent;
 	int ty = baseline - insetAscent;
@@ -2286,8 +2398,6 @@ Paragraph * InsetText::getParFromID(int id) const
 #else
 	Paragraph * tmp = par;
 	while (tmp) {
-		int tmp_id = tmp->id();
-		lyxerr << "Looking at paragraph: " << tmp_id << endl;
 		if (tmp->id() == id) {
 			return tmp;
 		}
@@ -2334,6 +2444,11 @@ Paragraph * InsetText::paragraph() const
 
 void InsetText::paragraph(Paragraph * p)
 {
+	// GENERAL COMMENT: We don't have to free the old paragraphs as the
+	// caller of this function has to take care of it. This IS important
+	// as we could have to insert a paragraph before this one and just
+	// link the actual to a new ones next and set it with this function
+	// and are done!
 	par = p;
 	// set ourself as owner for all the paragraphs inserted!
 	Paragraph * np = par;
@@ -2354,7 +2469,7 @@ Inset * InsetText::getInsetFromID(int id_arg) const
 
 	Paragraph * lp = par;
 
-	while(lp) {
+	while (lp) {
 		for (Paragraph::inset_iterator it = lp->inset_iterator_begin(),
 			 en = lp->inset_iterator_end();
 			 it != en; ++it)
@@ -2388,9 +2503,7 @@ string const InsetText::selectNextWordToSpellcheck(BufferView * bv, float & valu
 				lt = 0;
 			return str;
 		}
-#warning Dekel please have a look on this one RTL? (Jug)
-#warning DEKEL!
-		// we have to go on checking so move cusor to the right
+		// we have to go on checking so move cusor to the next char
 		lt->cursor.pos(lt->cursor.pos() + 1);
 	}
 	str = lt->selectNextWordToSpellcheck(bv, value);
@@ -2447,7 +2560,7 @@ void InsetText::toggleSelection(BufferView * bv, bool kill_selection)
 
 
 bool InsetText::searchForward(BufferView * bv, string const & str,
-                              bool const & cs, bool const & mw)
+                              bool cs, bool mw)
 {
 	if (the_locking_inset) {
 		if (the_locking_inset->searchForward(bv, str, cs, mw))
@@ -2485,7 +2598,7 @@ bool InsetText::searchForward(BufferView * bv, string const & str,
 }
 
 bool InsetText::searchBackward(BufferView * bv, string const & str,
-                               bool const & cs, bool const & mw)
+                               bool cs, bool mw)
 {
 	if (the_locking_inset)
 		if (the_locking_inset->searchBackward(bv, str, cs, mw))
@@ -2505,3 +2618,22 @@ bool InsetText::checkInsertChar(LyXFont & font)
 		return owner()->checkInsertChar(font);
 	return true;
 }
+
+
+void InsetText::collapseParagraphs(BufferParams const & bparams) const
+{
+	while(par->next()) {
+		if (!par->isSeparator(par->size()-1))
+			par->insertChar(par->size()-1, ' ');
+		par->pasteParagraph(bparams);
+	}
+	reinitLyXText();
+}
+
+
+void InsetText::getDrawFont(LyXFont & font) const
+{
+	if (!owner())
+		return;
+	owner()->getDrawFont(font);
+}