X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FBufferView_pimpl.C;h=a7afbd8b2a8367f9cbcb2774801c5b370416cb52;hb=dbd7a961fc46bb10c85bdd8c7fb6626477ae63d8;hp=6e58bf1141b223db6520a8df8f94e269ffdaa33f;hpb=85a5ea7bfc80e179a61a99f2955455e84d3384cc;p=lyx.git

diff --git a/src/BufferView_pimpl.C b/src/BufferView_pimpl.C
index 6e58bf1141..a7afbd8b2a 100644
--- a/src/BufferView_pimpl.C
+++ b/src/BufferView_pimpl.C
@@ -1,10 +1,5 @@
 #include <config.h>
 
-#include <ctime>
-#include <unistd.h>
-#include <sys/wait.h>
-#include <locale.h>
-
 #ifdef __GNUG__
 #pragma implementation
 #endif
@@ -14,34 +9,39 @@
 #include "lyxscreen.h"
 #include "lyxtext.h"
 #include "lyxrow.h"
+#include "paragraph.h"
 #include "LyXView.h"
 #include "commandtags.h"
 #include "lyxfunc.h"
+#include "debug.h"
 #include "font.h"
 #include "bufferview_funcs.h"
 #include "TextCache.h"
 #include "bufferlist.h"
-#include "lyx_gui_misc.h"
 #include "lyxrc.h"
 #include "intl.h"
-#include "support/LAssert.h"
-#include "frontends/Dialogs.h"
-#include "insets/insetbib.h"
-#include "insets/insettext.h"
-/// added for Dispatch functions
+// added for Dispatch functions
 #include "lyx_cb.h"
-#include "frontends/FileDialog.h"
 #include "lyx_main.h"
 #include "FloatList.h"
-#include "support/filetools.h"
-#include "support/lyxfunctional.h"
+#include "gettext.h"
+#include "ParagraphParameters.h"
+#include "undo_funcs.h"
+#include "lyxtextclasslist.h"
+
+#include "frontends/Dialogs.h"
+#include "frontends/Alert.h"
+#include "frontends/FileDialog.h"
+
+#include "insets/insetbib.h"
+#include "insets/insettext.h"
 #include "insets/inseturl.h"
 #include "insets/insetlatexaccent.h"
 #include "insets/insettoc.h"
 #include "insets/insetref.h"
 #include "insets/insetparent.h"
 #include "insets/insetindex.h"
-#include "insets/insetinfo.h"
+#include "insets/insetnote.h"
 #include "insets/insetinclude.h"
 #include "insets/insetcite.h"
 #include "insets/insetert.h"
@@ -51,19 +51,29 @@
 #include "insets/insetmarginal.h"
 #include "insets/insetminipage.h"
 #include "insets/insetfloat.h"
-#include "insets/insetlist.h"
 #include "insets/insettabular.h"
+#if 0
 #include "insets/insettheorem.h"
+#include "insets/insetlist.h"
+#endif
 #include "insets/insetcaption.h"
 #include "insets/insetfloatlist.h"
 #include "insets/insetspecialchar.h"
-#include "mathed/formulamacro.h"
-#include "mathed/formula.h"
-#include "gettext.h"
-#include "ParagraphParameters.h"
 
-extern LyXTextClass::size_type current_layout;
-extern int greek_kb_flag;
+#include "mathed/formulabase.h"
+
+#include "support/LAssert.h"
+#include "support/lstrings.h"
+#include "support/filetools.h"
+#include "support/lyxfunctional.h"
+
+#include <ctime>
+#include <unistd.h>
+#include <sys/wait.h>
+#include <clocale>
+
+
+extern string current_layout;
 
 using std::vector;
 using std::find_if;
@@ -74,6 +84,9 @@ using std::make_pair;
 using std::min;
 using SigC::slot;
 
+using lyx::pos_type;
+using lyx::textclass_type;
+
 /* the selection possible is needed, that only motion events are 
  * used, where the bottom press event was on the drawing area too */
 bool selection_possible = false;
@@ -81,10 +94,9 @@ bool selection_possible = false;
 extern BufferList bufferlist;
 extern char ascii_type;
 
-extern bool math_insert_greek(BufferView *, char);
-extern void sigchldhandler(pid_t pid, int * status);
 extern int bibitemMaxWidth(BufferView *, LyXFont const &);
 
+
 namespace {
 
 const unsigned int saved_positions_num = 20;
@@ -100,7 +112,7 @@ void SetXtermCursor(Window win)
 {
 	static Cursor cursor;
 	static bool cursor_undefined = true;
-	if (cursor_undefined){
+	if (cursor_undefined) {
 		cursor = XCreateFontCursor(fl_get_display(), XC_xterm);
 		XFlush(fl_get_display());
 		cursor_undefined = false;
@@ -140,6 +152,10 @@ BufferView::Pimpl::Pimpl(BufferView * b, LyXView * o,
 		.connect(slot(this, &BufferView::Pimpl::tripleClick));
 	workarea_.workAreaKeyPress
 		.connect(slot(this, &BufferView::Pimpl::workAreaKeyPress));
+	workarea_.selectionRequested
+		.connect(slot(this, &BufferView::Pimpl::selectionRequested)); 
+	workarea_.selectionLost
+		.connect(slot(this, &BufferView::Pimpl::selectionLost));
 	
 	cursor_timeout.timeout.connect(slot(this,
 					    &BufferView::Pimpl::cursorToggle));
@@ -198,7 +214,7 @@ void BufferView::Pimpl::buffer(Buffer * b)
 			updateScreen();
 			updateScrollbar();
 		}
-		bv_->text->first = screen_->TopCursorVisible(bv_->text);
+		bv_->text->first = screen_->topCursorVisible(bv_->text);
 		owner_->updateMenubar();
 		owner_->updateToolbar();
 		// Similarly, buffer-dependent dialogs should be updated or
@@ -251,13 +267,20 @@ void BufferView::Pimpl::redraw()
 }
 
 
-bool BufferView::Pimpl::fitCursor(LyXText * text)
+bool BufferView::Pimpl::fitCursor()
 {
 	lyx::Assert(screen_.get());
 
-	bv_->owner()->getDialogs()->updateParagraph();
+	bool ret;
 
-	bool const ret = screen_->FitCursor(text, bv_);
+	if (bv_->theLockingInset()) {
+		bv_->theLockingInset()->fitInsetCursor(bv_);
+		ret = true;
+	} else {
+		ret = screen_->fitCursor(bv_->text, bv_);
+	}
+
+	bv_->owner()->getDialogs()->updateParagraph();
 	if (ret)
 	    updateScrollbar();
 	return ret;
@@ -283,13 +306,13 @@ int BufferView::Pimpl::resizeCurrentBuffer()
 	Paragraph * selendpar = 0;
 	UpdatableInset * the_locking_inset = 0;
 	
-	Paragraph::size_type pos = 0;
-	Paragraph::size_type selstartpos = 0;
-	Paragraph::size_type selendpos = 0;
+	pos_type pos = 0;
+	pos_type selstartpos = 0;
+	pos_type selendpos = 0;
 	bool selection = false;
 	bool mark_set  = false;
 
-	ProhibitInput(bv_);
+	owner_->prohibitInput();
 
 	owner_->message(_("Formatting document..."));
 
@@ -305,6 +328,7 @@ int BufferView::Pimpl::resizeCurrentBuffer()
 		the_locking_inset = bv_->theLockingInset();
 		delete bv_->text;
 		bv_->text = new LyXText(bv_);
+		bv_->text->init(bv_);
 	} else {
 		// See if we have a text in TextCache that fits
 		// the new buffer_ with the correct width.
@@ -320,6 +344,7 @@ int BufferView::Pimpl::resizeCurrentBuffer()
 				textcache.show(lyxerr, "resizeCurrentBuffer");
 		} else {
 			bv_->text = new LyXText(bv_);
+			bv_->text->init(bv_);
 		}
 	}
 	updateScreen();
@@ -343,21 +368,20 @@ int BufferView::Pimpl::resizeCurrentBuffer()
 		// remake the inset locking
 		bv_->theLockingInset(the_locking_inset);
 	}
-	bv_->text->first = screen_->TopCursorVisible(bv_->text);
+	bv_->text->first = screen_->topCursorVisible(bv_->text);
+#if 0
 	buffer_->resizeInsets(bv_);
+#endif
 	// this will scroll the screen such that the cursor becomes visible
 	updateScrollbar();
 	redraw();
 
 	setState();
-	AllowInput(bv_);
+	owner_->allowInput();
 
 	/// clear the "Formatting Document" message 
 	owner_->message("");
- 
-	/// get rid of the splash screen if it's not gone already
-	owner_->getDialogs()->destroySplash();
- 
+
 	return 0;
 }
 
@@ -374,42 +398,44 @@ void BufferView::Pimpl::updateScrollbar()
 	/* If the text is smaller than the working area, the scrollbar
 	 * maximum must be the working area height. No scrolling will 
 	 * be possible */
-
 	if (!bv_->text) {
 		workarea_.setScrollbar(0, 1.0);
 		return;
 	}
 
-	static unsigned long text_height;
-	static unsigned long work_height;
+	long const text_height = bv_->text->height;
+	long const work_height = workarea_.height();
 
-	unsigned long const tmp_text_height = bv_->text->height;
-	long const tmp_scrollbar_value = bv_->text->first;
-	
-	// check if anything has changed.
-	if (text_height == tmp_text_height
-	    && work_height == workarea_.height()
-	    && current_scrollbar_value == tmp_scrollbar_value)
-		return; // no
-
-	// update values
-	text_height = tmp_text_height;
-	work_height = workarea_.height();
-	current_scrollbar_value = tmp_scrollbar_value;
-
-	long const height_diff = text_height - work_height;
-	
-	if (height_diff <= 0) {
-		workarea_.setScrollbar(0, 1.0);
+	if (text_height <= work_height) {
+		workarea_.setScrollbarBounds(0.0, 0.0);
+		current_scrollbar_value = bv_->text->first;
+		workarea_.setScrollbar(current_scrollbar_value, 1.0);
 		return;
 	}
-
 	
-	workarea_.setScrollbarBounds(0, height_diff);
 	double const lineh = bv_->text->defaultHeight();
-	workarea_.setScrollbarIncrements(lineh);
-	double const slider_size = 1.0 / double(height_diff) ;
-	workarea_.setScrollbar(current_scrollbar_value, slider_size);
+	double const slider_size =
+		(text_height == 0) ? 1.0 : 1.0 / double(text_height);
+	
+	static long old_text_height;
+	static double old_lineh;
+	static double old_slider_size;
+
+	if (text_height != old_text_height) {
+		workarea_.setScrollbarBounds(0.0,
+					     text_height - work_height);
+		old_text_height = text_height;
+	}
+	if (lineh != old_lineh) {
+		workarea_.setScrollbarIncrements(lineh);
+		old_lineh = lineh;
+	}
+	if (current_scrollbar_value != bv_->text->first
+	    || slider_size != old_slider_size) {
+		current_scrollbar_value = bv_->text->first;
+		workarea_.setScrollbar(current_scrollbar_value, slider_size);
+		old_slider_size = slider_size;
+	}
 }
 
 
@@ -419,13 +445,14 @@ void BufferView::Pimpl::scrollCB(double value)
 	if (!buffer_) return;
 
 	current_scrollbar_value = long(value);
+
 	if (current_scrollbar_value < 0)
 		current_scrollbar_value = 0;
    
 	if (!screen_.get())
 		return;
 
-	screen_->Draw(bv_->text, bv_, current_scrollbar_value);
+	screen_->draw(bv_->text, bv_, current_scrollbar_value);
 
 	if (!lyxrc.cursor_follows_scrollbar) {
 		waitForX();
@@ -542,7 +569,7 @@ void BufferView::Pimpl::workAreaMotionNotify(int x, int y, unsigned int state)
 	if (!selection_possible)
 		return;
  
-	screen_->HideCursor();
+	screen_->hideCursor();
 
 	bv_->text->setCursorFromCoordinates(bv_, x, y + bv_->text->first);
       
@@ -550,19 +577,19 @@ void BufferView::Pimpl::workAreaMotionNotify(int x, int y, unsigned int state)
 		update(bv_->text, BufferView::UPDATE); // Maybe an empty line was deleted
       
 	bv_->text->setSelection(bv_);
-	screen_->ToggleToggle(bv_->text, bv_);
-	fitCursor(bv_->text);
-	screen_->ShowCursor(bv_->text, bv_);
+	screen_->toggleToggle(bv_->text, bv_);
+	fitCursor();
+	showCursor();
 }
 
 
 // Single-click on work area
 void BufferView::Pimpl::workAreaButtonPress(int xpos, int ypos,
-					    unsigned int button)
+                                            unsigned int button)
 {
 	if (!buffer_ || !screen_.get()) return;
 
-	Inset * inset_hit = checkInsetHit(bv_->text, xpos, ypos, button);
+	Inset * inset_hit = checkInsetHit(bv_->text, xpos, ypos);
 
 	// ok ok, this is a hack.
 	if (button == 4 || button == 5) {
@@ -583,9 +610,7 @@ void BufferView::Pimpl::workAreaButtonPress(int xpos, int ypos,
 		   otherwise give the event to the inset */
 		if (inset_hit == bv_->theLockingInset()) {
 			bv_->theLockingInset()->
-				insetButtonPress(bv_,
-						 xpos, ypos,
-						 button);
+				insetButtonPress(bv_,xpos, ypos,button);
 			return;
 		} else {
 			bv_->unlockInset(bv_->theLockingInset());
@@ -594,7 +619,7 @@ void BufferView::Pimpl::workAreaButtonPress(int xpos, int ypos,
 	
 	if (!inset_hit)
 		selection_possible = true;
-	screen_->HideCursor();
+	screen_->hideCursor();
 
 	int const screen_first = bv_->text->first;
 	
@@ -602,27 +627,28 @@ void BufferView::Pimpl::workAreaButtonPress(int xpos, int ypos,
 	bool paste_internally = false;
 	if (button == 2
 	    && bv_->text->selection.set()) {
-		owner_->getLyXFunc()->Dispatch(LFUN_COPY);
+		owner_->getLyXFunc()->dispatch(LFUN_COPY);
 		paste_internally = true;
 	}
 	
 	// Clear the selection
-	screen_->ToggleSelection(bv_->text, bv_);
-	bv_->text->clearSelection(bv_);
+	screen_->toggleSelection(bv_->text, bv_);
+	bv_->text->clearSelection();
 	bv_->text->fullRebreak(bv_);
-	screen_->Update(bv_->text, bv_);
+	update();
 	updateScrollbar();
 	
 	// Single left click in math inset?
-	if ((inset_hit != 0) &&
-	    (inset_hit->editable()==Inset::HIGHLY_EDITABLE)) {
+	if (isHighlyEditableInset(inset_hit)) {
 		// Highly editable inset, like math
 		UpdatableInset * inset = static_cast<UpdatableInset *>(inset_hit);
 		selection_possible = false;
 		owner_->updateLayoutChoice();
 		owner_->message(inset->editMessage());
+		// IMO the inset has to be first in edit-mode and then we send the
+		// button press. (Jug 20020222)
+		inset->edit(bv_); //, xpos, ypos, button);
 		inset->insetButtonPress(bv_, xpos, ypos, button);
-		inset->edit(bv_, xpos, ypos, button);
 		return;
 	} 
 	
@@ -634,12 +660,12 @@ void BufferView::Pimpl::workAreaButtonPress(int xpos, int ypos,
 	
 	if (!inset_hit) // otherwise it was already set in checkInsetHit(...)
 		bv_->text->setCursorFromCoordinates(bv_, xpos, ypos + screen_first);
-	bv_->text->finishUndo();
+	finishUndo();
 	bv_->text->selection.cursor = bv_->text->cursor;
 	bv_->text->cursor.x_fix(bv_->text->cursor.x());
 	
 	owner_->updateLayoutChoice();
-	if (fitCursor(bv_->text)) {
+	if (fitCursor()) {
 		selection_possible = false;
 	}
 	
@@ -648,9 +674,9 @@ void BufferView::Pimpl::workAreaButtonPress(int xpos, int ypos,
 	// insert this
 	if (button == 2) {
 		if (paste_internally)
-			owner_->getLyXFunc()->Dispatch(LFUN_PASTE);
+			owner_->getLyXFunc()->dispatch(LFUN_PASTE);
 		else
-			owner_->getLyXFunc()->Dispatch(LFUN_PASTESELECTION,
+			owner_->getLyXFunc()->dispatch(LFUN_PASTESELECTION,
 						       "paragraph");
 		selection_possible = false;
 		return;
@@ -662,25 +688,25 @@ void BufferView::Pimpl::doubleClick(int /*x*/, int /*y*/, unsigned int button)
 {
 	// select a word
 	if (!buffer_)
-	    return;
+		return;
 
 	LyXText * text = bv_->getLyXText();
 
 	if (text->bv_owner && bv_->theLockingInset())
-	    return;
+		return;
 
 	if (screen_.get() && button == 1) {
-	    if (text->bv_owner) {
-		screen_->HideCursor();
-		screen_->ToggleSelection(text, bv_);
-		text->selectWord(bv_);
-		screen_->ToggleSelection(text, bv_, false);
-	    } else {
-		text->selectWord(bv_);
-	    }
-	    /* This will fit the cursor on the screen
-	     * if necessary */
-	    update(text, BufferView::SELECT|BufferView::FITCUR);
+		if (text->bv_owner) {
+			screen_->hideCursor();
+			screen_->toggleSelection(text, bv_);
+			text->selectWord(bv_, LyXText::WHOLE_WORD_STRICT);
+			screen_->toggleSelection(text, bv_, false);
+		} else {
+			text->selectWord(bv_, LyXText::WHOLE_WORD_STRICT);
+		}
+		/* This will fit the cursor on the screen
+		 * if necessary */
+		update(text, BufferView::SELECT|BufferView::FITCUR);
 	}
 }
 
@@ -688,7 +714,7 @@ void BufferView::Pimpl::doubleClick(int /*x*/, int /*y*/, unsigned int button)
 void BufferView::Pimpl::tripleClick(int /*x*/, int /*y*/, unsigned int button)
 {
 	// select a line
-	if (buffer_)
+	if (!buffer_)
 		return;
 
 	LyXText * text = bv_->getLyXText();
@@ -697,13 +723,17 @@ void BufferView::Pimpl::tripleClick(int /*x*/, int /*y*/, unsigned int button)
 	    return;
 
 	if (screen_.get() && (button == 1)) {
-		screen_->HideCursor();
-		screen_->ToggleSelection(text, bv_);
+		if (text->bv_owner) {
+			screen_->hideCursor();
+			screen_->toggleSelection(text, bv_);
+		}
 		text->cursorHome(bv_);
 		text->selection.cursor = text->cursor;
 		text->cursorEnd(bv_);
 		text->setSelection(bv_);
-		screen_->ToggleSelection(text, bv_, false);
+		if (text->bv_owner) {
+			screen_->toggleSelection(text, bv_, false);
+		}
 		/* This will fit the cursor on the screen
 		 * if necessary */
 		update(text, BufferView::SELECT|BufferView::FITCUR);
@@ -711,6 +741,28 @@ void BufferView::Pimpl::tripleClick(int /*x*/, int /*y*/, unsigned int button)
 }
 
 
+void BufferView::Pimpl::selectionRequested()
+{
+	if (!available())
+		return;
+ 
+	string const sel(bv_->getLyXText()->selectionAsString(bv_->buffer(),
+							      false)); 
+	if (!sel.empty()) {
+		workarea_.putClipboard(sel);
+	}
+}
+
+ 
+void BufferView::Pimpl::selectionLost()
+{
+	hideCursor();
+	toggleSelection();
+	bv_->getLyXText()->clearSelection();
+	showCursor(); 
+}
+
+ 
 void BufferView::Pimpl::enterView()
 {
 	if (active() && available()) {
@@ -737,7 +789,7 @@ void BufferView::Pimpl::workAreaButtonRelease(int x, int y,
 	// If we hit an inset, we have the inset coordinates in these
 	// and inset_hit points to the inset.  If we do not hit an
 	// inset, inset_hit is 0, and inset_x == x, inset_y == y.
-	Inset * inset_hit = checkInsetHit(bv_->text, x, y, button);
+	Inset * inset_hit = checkInsetHit(bv_->text, x, y);
 
 	if (bv_->theLockingInset()) {
 		// We are in inset locking mode.
@@ -755,15 +807,35 @@ void BufferView::Pimpl::workAreaButtonRelease(int x, int y,
 	if (button == 2)
 		return;
 
+	// finish selection
+	if (button == 1) {
+		workarea_.haveSelection(bv_->getLyXText()->selection.set());
+	}
+ 
 	setState();
 	owner_->showState();
+	owner_->updateMenubar();
+	owner_->updateToolbar();
 
 	// Did we hit an editable inset?
 	if (inset_hit) {
-		// Inset like error, notes and figures
 		selection_possible = false;
 
+		// if we reach this point with a selection, it
+		// must mean we are currently selecting.
+		// But we don't want to open the inset
+		// because that is annoying for the user. 
+		// So just pretend we didn't hit it.
+		// this is OK because a "kosher" ButtonRelease
+		// will follow a ButtonPress that clears
+		// the selection.
+		// Note this also fixes selection drawing
+		// problems if we end up opening an inset
+		if (bv_->getLyXText()->selection.set())
+			return;
+ 
 		// CHECK fix this proper in 0.13
+		// well, maybe 13.0 !!!!!!!!!
 
 		// Following a ref shouldn't issue
 		// a push on the undo-stack
@@ -779,12 +851,12 @@ void BufferView::Pimpl::workAreaButtonRelease(int x, int y,
 		// ...or maybe the SetCursorParUndo()
 		// below isn't necessary at all anylonger?
 		if (inset_hit->lyxCode() == Inset::REF_CODE) {
-			bv_->text->setCursorParUndo(buffer_);
+			setCursorParUndo(bv_);
 		}
 
 		owner_->message(inset_hit->editMessage());
 
-		if (inset_hit->editable()==Inset::HIGHLY_EDITABLE) {
+		if (isHighlyEditableInset(inset_hit)) {
 			// Highly editable inset, like math
 			UpdatableInset *inset = (UpdatableInset *)inset_hit;
 			inset->insetButtonRelease(bv_, x, y, button);
@@ -795,30 +867,9 @@ void BufferView::Pimpl::workAreaButtonRelease(int x, int y,
 		return;
 	}
 
-	// check whether we want to open a float
-	if (bv_->text) {
-		bool hit = false;
-		char c = ' ';
-		if (bv_->text->cursor.pos() <
-		    bv_->text->cursor.par()->size()) {
-			c = bv_->text->cursor.par()->
-				getChar(bv_->text->cursor.pos());
-		}
-			if (bv_->text->cursor.pos() - 1 >= 0) {
-			c = bv_->text->cursor.par()->
-				getChar(bv_->text->cursor.pos() - 1);
-		}
-		if (hit == true) {
-			selection_possible = false;
-			return;
-		}
-	}
-
 	// Maybe we want to edit a bibitem ale970302
 	if (bv_->text->cursor.par()->bibkey && x < 20 + 
-	    bibitemMaxWidth(bv_, textclasslist.
-			    TextClass(buffer_->
-				      params.textclass).defaultfont())) {
+	    bibitemMaxWidth(bv_, textclasslist[buffer_->params.textclass].defaultfont())) {
 		bv_->text->cursor.par()->bibkey->edit(bv_, 0, 0, 0);
 	}
 
@@ -826,78 +877,96 @@ void BufferView::Pimpl::workAreaButtonRelease(int x, int y,
 }
 
 
-/* 
- * Returns an inset if inset was hit. 0 otherwise.
- * If hit, the coordinates are changed relative to the inset. 
- * Otherwise coordinates are not changed, and false is returned.
- */
-Inset * BufferView::Pimpl::checkInsetHit(LyXText * text, int & x, int & y,
-					 unsigned int /* button */)
+Box BufferView::Pimpl::insetDimensions(LyXText const & text,
+				       LyXCursor const & cursor) const
+{
+	Paragraph /*const*/ & par = *cursor.par();
+	pos_type const pos = cursor.pos();
+
+	lyx::Assert(par.getInset(pos));
+ 
+	Inset const & inset(*par.getInset(pos));
+
+	LyXFont const & font = text.getFont(buffer_, &par, pos);
+ 
+	int const width = inset.width(bv_, font);
+	int const inset_x = font.isVisibleRightToLeft()
+		? (cursor.x() - width) : cursor.x();
+ 
+	return Box(
+		inset_x + inset.scroll(),
+		inset_x + width,
+		cursor.y() - inset.ascent(bv_, font),
+		cursor.y() + inset.descent(bv_, font));
+}
+ 
+ 
+Inset * BufferView::Pimpl::checkInset(LyXText const & text,
+				      LyXCursor const & cursor,
+				      int & x, int & y) const
+{
+	pos_type const pos(cursor.pos());
+	Paragraph /*const*/ & par(*cursor.par());
+
+	if (pos >= par.size() || !par.isInset(pos)) {
+		return 0;
+	}
+
+	Inset /*const*/ * inset = par.getInset(pos);
+ 
+	if (!isEditableInset(inset)) {
+		return 0;
+	}
+
+	Box b(insetDimensions(text, cursor));
+
+	if (!b.contained(x, y)) {
+		lyxerr[Debug::GUI] << "Missed inset at x,y " << x << "," << y 
+			<< " box " << b << endl;
+		return 0;
+	}
+ 
+	text.setCursor(bv_, &par, pos, true);
+ 
+	x -= b.x1;
+	// The origin of an inset is on the baseline
+	y -= (text.cursor.y());
+  
+	return inset;
+}
+
+ 
+Inset * BufferView::Pimpl::checkInsetHit(LyXText * text, int & x, int & y)
 {
 	if (!screen_.get())
 		return 0;
   
 	int y_tmp = y + text->first;
-  
+ 
 	LyXCursor cursor;
 	text->setCursorFromCoordinates(bv_, cursor, x, y_tmp);
-	text->setCursor(bv_, cursor, cursor.par(),cursor.pos(),true);
-
-
-	if (cursor.pos() < cursor.par()->size()
-	    && cursor.par()->getChar(cursor.pos()) == Paragraph::META_INSET
-	    && cursor.par()->getInset(cursor.pos())
-	    && cursor.par()->getInset(cursor.pos())->editable()) {
+ 
+	Inset * inset(checkInset(*text, cursor, x, y_tmp));
 
-		// Check whether the inset really was hit
-		Inset * tmpinset = cursor.par()->getInset(cursor.pos());
-		LyXFont font = text->getFont(buffer_,
-						  cursor.par(), cursor.pos());
-		int const width = tmpinset->width(bv_, font);
-		int const inset_x = font.isVisibleRightToLeft()
-			? cursor.x() - width : cursor.x();
-		int const start_x = inset_x + tmpinset->scroll();
-		int const end_x = inset_x + width;
-
-		if (x > start_x && x < end_x
-		    && y_tmp > cursor.y() - tmpinset->ascent(bv_, font)
-		    && y_tmp < cursor.y() + tmpinset->descent(bv_, font)) {
-			text->setCursor(bv_, cursor.par(),cursor.pos(), true);
-			x = x - start_x;
-			// The origin of an inset is on the baseline
-			y = y_tmp - (text->cursor.y()); 
-			return tmpinset;
-		}
+	if (inset) {
+		y = y_tmp;
+		return inset;
+	}
+ 
+	// look at previous position
+ 
+	if (cursor.pos() == 0) {
+		return 0;
 	}
 
-	if ((cursor.pos() - 1 >= 0) &&
-	    (cursor.par()->getChar(cursor.pos()-1) == Paragraph::META_INSET) &&
-	    (cursor.par()->getInset(cursor.pos() - 1)) &&
-	    (cursor.par()->getInset(cursor.pos() - 1)->editable())) {
-		Inset * tmpinset = cursor.par()->getInset(cursor.pos()-1);
-		LyXFont font = text->getFont(buffer_, cursor.par(),
-						  cursor.pos()-1);
-		int const width = tmpinset->width(bv_, font);
-		int const inset_x = font.isVisibleRightToLeft()
-			? cursor.x() : cursor.x() - width;
-		int const start_x = inset_x + tmpinset->scroll();
-		int const end_x = inset_x + width;
-
-		if (x > start_x && x < end_x
-		    && y_tmp > cursor.y() - tmpinset->ascent(bv_, font)
-		    && y_tmp < cursor.y() + tmpinset->descent(bv_, font)) {
-#if 0
-			if (move_cursor && (tmpinset != bv_->theLockingInset()))
-#endif
-				text->setCursor(bv_, cursor.par(),
-						cursor.pos() - 1, true);
-			x = x - start_x;
-			// The origin of an inset is on the baseline
-			y = y_tmp - (text->cursor.y()); 
-			return tmpinset;
-		}
+	// move back one
+	text->setCursor(bv_, cursor, cursor.par(), cursor.pos() - 1, true);
+
+	inset = checkInset(*text, cursor, x, y_tmp);
+	if (inset) {
+		y = y_tmp;
 	}
-	return 0;
+	return inset;
 }
 
 
@@ -932,12 +1001,12 @@ void BufferView::Pimpl::workAreaExpose()
 			// fitCursor() ensures we don't jump back
 			// to the start of the document on vertical
 			// resize
-			fitCursor(bv_->text);
+			fitCursor();
 
 			// The main window size has changed, repaint most stuff
 			redraw();
 		} else if (screen_.get())
-		    screen_->Redraw(bv_->text, bv_);
+		    screen_->redraw(bv_->text, bv_);
 	} else {
 		// Grey box when we don't have a buffer
 		workarea_.greyOut();
@@ -955,7 +1024,24 @@ void BufferView::Pimpl::update()
 	if (screen_.get() &&
 		(!bv_->theLockingInset() || !bv_->theLockingInset()->nodraw()))
 	{
-		screen_->Update(bv_->text, bv_);
+		LyXText::text_status st = bv_->text->status();
+		screen_->update(bv_->text, bv_);
+		bool fitc = false;
+		while (bv_->text->status() == LyXText::CHANGED_IN_DRAW) {
+			if (bv_->text->fullRebreak(bv_)) {
+				st = LyXText::NEED_MORE_REFRESH;
+				bv_->text->setCursor(bv_, bv_->text->cursor.par(),
+									 bv_->text->cursor.pos());
+				fitc = true;
+			}
+			bv_->text->status(bv_, st);
+			screen_->update(bv_->text, bv_);
+		}
+		// do this here instead of in the screen::update because of
+		// the above loop!
+		bv_->text->status(bv_, LyXText::UNCHANGED);
+		if (fitc)
+			fitCursor();
 	}
 }
 
@@ -1008,14 +1094,15 @@ void BufferView::Pimpl::update(LyXText * text, BufferView::UpdateCodes f)
 	text->fullRebreak(bv_);
 
 	if (text->inset_owner) {
-	    text->inset_owner->setUpdateStatus(bv_, InsetText::NONE);
-	    updateInset(text->inset_owner, true);
-	} else
+		text->inset_owner->setUpdateStatus(bv_, InsetText::NONE);
+	    updateInset(text->inset_owner, false);
+	} else {
 	    update();
-
+	}
+		
 	if ((f & FITCUR)) {
-		fitCursor(text);
-      	}
+		fitCursor();
+	}
 
 	if ((f & CHANGE)) {
 		buffer_->markDirty();
@@ -1026,29 +1113,22 @@ void BufferView::Pimpl::update(LyXText * text, BufferView::UpdateCodes f)
 // Callback for cursor timer
 void BufferView::Pimpl::cursorToggle()
 {
-	// Quite a nice place for asyncron Inset updating, isn't it?
-	// Actually no! This is run even if no buffer exist... so (Lgb)
 	if (!buffer_) {
 		cursor_timeout.restart();
 		return;
 	}
  
-	int status = 1;
-	int const pid = waitpid(static_cast<pid_t>(0), &status, WNOHANG);
-	if (pid == -1) // error find out what is wrong
-		; // ignore it for now.
-	else if (pid > 0)
-		sigchldhandler(pid, &status);
-
-	updatelist.update(bv_);
-	
 	if (!screen_.get()) {
 		cursor_timeout.restart();
 		return;
 	}
 
+	/* FIXME */
+	extern void reapSpellchecker(void);
+	reapSpellchecker();
+	 
 	if (!bv_->theLockingInset()) {
-		screen_->CursorToggle(bv_->text, bv_);
+		screen_->cursorToggle(bv_);
 	} else {
 		bv_->theLockingInset()->toggleInsetCursor(bv_);
 	}
@@ -1067,18 +1147,18 @@ void BufferView::Pimpl::cursorPrevious(LyXText * text)
 		y += bv_->text->first;
 	Row * cursorrow = text->cursor.row();
 	text->setCursorFromCoordinates(bv_, bv_->text->cursor.x_fix(), y);
-	bv_->text->finishUndo();
+	finishUndo();
 	// This is to allow jumping over large insets
 	if ((cursorrow == text->cursor.row()))
 		text->cursorUp(bv_);
 	
   	if (text->inset_owner ||
 	    text->cursor.row()->height() < workarea_.height())
-		screen_->Draw(bv_->text, bv_,
+		screen_->draw(bv_->text, bv_,
 			      text->cursor.y()
 			      - text->cursor.row()->baseline()
 			      + text->cursor.row()->height()
-			      - workarea_.height() + 1 );
+			      - workarea_.height() + 1);
 	updateScrollbar();
 }
 
@@ -1095,14 +1175,14 @@ void BufferView::Pimpl::cursorNext(LyXText * text)
     
 	Row * cursorrow = text->cursor.row();
 	text->setCursorFromCoordinates(bv_, text->cursor.x_fix(), y); // + workarea_->height());
-	bv_->text->finishUndo();
+	finishUndo();
 	// This is to allow jumping over large insets
 	if ((cursorrow == bv_->text->cursor.row()))
 		text->cursorDown(bv_);
 	
  	if (text->inset_owner ||
 	    text->cursor.row()->height() < workarea_.height())
-		screen_->Draw(bv_->text, bv_, text->cursor.y() -
+		screen_->draw(bv_->text, bv_, text->cursor.y() -
 			      text->cursor.row()->baseline());
 	updateScrollbar();
 }
@@ -1118,7 +1198,7 @@ bool BufferView::Pimpl::available() const
 void BufferView::Pimpl::beforeChange(LyXText * text)
 {
 	toggleSelection();
-	text->clearSelection(bv_);
+	text->clearSelection();
 }
 
 
@@ -1150,10 +1230,10 @@ void BufferView::Pimpl::restorePosition(unsigned int i)
 		Buffer * b = bufferlist.exists(fname) ?
 	 		bufferlist.getBuffer(fname) :
 			bufferlist.loadLyXFile(fname); // don't ask, just load it
-		if (b != 0 ) buffer(b);
+		if (b != 0) buffer(b);
 	}
 
-	Paragraph * par = bv_->text->getParFromID(saved_positions[i].par_id);
+	Paragraph * par = buffer_->getParFromID(saved_positions[i].par_id);
 	if (!par)
 		return;
 
@@ -1184,12 +1264,7 @@ void BufferView::Pimpl::setState()
 		return;
 
 	LyXText * text = bv_->getLyXText();
-	if (text->real_current_font.isRightToLeft()
-#ifndef NO_LATEX
-	    &&
-	    text->real_current_font.latex() != LyXFont::ON
-#endif
-		) {
+	if (text->real_current_font.isRightToLeft()) {
 		if (owner_->getIntl()->keymap == Intl::PRIMARY)
 			owner_->getIntl()->KeyMapSec();
 	} else {
@@ -1224,7 +1299,7 @@ void BufferView::Pimpl::insetUnlock()
 		if (!inset_slept)
 			bv_->theLockingInset()->insetUnlock(bv_);
 		bv_->theLockingInset(0);
-		bv_->text->finishUndo();
+		finishUndo();
 		inset_slept = false;
 	}
 }
@@ -1256,29 +1331,40 @@ bool BufferView::Pimpl::belowMouse() const
 
 void BufferView::Pimpl::showCursor()
 {
-	if (screen_.get())
-		screen_->ShowCursor(bv_->text, bv_);
+	if (screen_.get()) {
+		if (bv_->theLockingInset())
+			bv_->theLockingInset()->showInsetCursor(bv_);
+		else
+			screen_->showCursor(bv_->text, bv_);
+	}
 }
 
 
 void BufferView::Pimpl::hideCursor()
 {
-	if (screen_.get())
-		screen_->HideCursor();
+	if (screen_.get()) {
+		if (!bv_->theLockingInset())
+//			bv_->theLockingInset()->hideInsetCursor(bv_);
+//		else
+			screen_->hideCursor();
+	}
 }
 
 
 void BufferView::Pimpl::toggleSelection(bool b)
 {
-	if (screen_.get())
-		screen_->ToggleSelection(bv_->text, bv_, b);
+	if (screen_.get()) {
+		if (bv_->theLockingInset())
+			bv_->theLockingInset()->toggleSelection(bv_, b);
+		screen_->toggleSelection(bv_->text, bv_, b);
+	}
 }
 
 
 void BufferView::Pimpl::toggleToggle()
 {
 	if (screen_.get())
-		screen_->ToggleToggle(bv_->text, bv_);
+		screen_->toggleToggle(bv_->text, bv_);
 }
 
 
@@ -1286,9 +1372,9 @@ void BufferView::Pimpl::center()
 {
 	beforeChange(bv_->text);
 	if (bv_->text->cursor.y() > static_cast<int>((workarea_.height() / 2))) {
-		screen_->Draw(bv_->text, bv_, bv_->text->cursor.y() - workarea_.height() / 2);
+		screen_->draw(bv_->text, bv_, bv_->text->cursor.y() - workarea_.height() / 2);
 	} else {
-		screen_->Draw(bv_->text, bv_, 0);
+		screen_->draw(bv_->text, bv_, 0);
 	}
 	update(bv_->text, BufferView::SELECT|BufferView::FITCUR);
 	redraw();
@@ -1299,7 +1385,7 @@ void BufferView::Pimpl::pasteClipboard(bool asPara)
 {
 	if (!buffer_) return;
 
-	screen_->HideCursor();
+	screen_->hideCursor();
 	beforeChange(bv_->text);
 	
 	string const clip(workarea_.getClipboard());
@@ -1307,9 +1393,9 @@ void BufferView::Pimpl::pasteClipboard(bool asPara)
 	if (clip.empty()) return;
 
 	if (asPara) {
-		bv_->text->insertStringAsParagraphs(bv_, clip);
+		bv_->getLyXText()->insertStringAsParagraphs(bv_, clip);
 	} else {
-		bv_->text->insertStringAsLines(bv_, clip);
+		bv_->getLyXText()->insertStringAsLines(bv_, clip);
 	}
 	update(bv_->text, BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
 }
@@ -1368,18 +1454,18 @@ void BufferView::Pimpl::MenuInsertLyXFile(string const & filen)
 		string initpath = lyxrc.document_path;
 
 		if (available()) {
-			string const trypath = owner_->buffer()->filepath;
+			string const trypath = owner_->buffer()->filePath();
 			// If directory is writeable, use this as default.
-			if (IsDirWriteable(trypath) == 1)
+			if (IsDirWriteable(trypath))
 				initpath = trypath;
 		}
 
 		FileDialog fileDlg(bv_->owner(),
 				   _("Select LyX document to insert"),
 			LFUN_FILE_INSERT,
-			make_pair(string(_("Documents")),
+			make_pair(string(_("Documents|#o#O")),
 				  string(lyxrc.document_path)),
-			make_pair(string(_("Examples")),
+			make_pair(string(_("Examples|#E#e")),
 				  string(AddPath(system_lyxdir, "examples"))));
 
 		FileDialog::Result result =
@@ -1453,7 +1539,6 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument)
 		break;
 	}
 		
-	case LFUN_TABULAR_FEATURE:
 	case LFUN_SCROLL_INSET:
 		// this is not handled here as this funktion is only aktive
 		// if we have a locking_inset and that one is (or contains)
@@ -1468,7 +1553,7 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument)
 		} else {
 			// this is need because you don't use a inset->Edit()
 			updateInset(new_inset, true);
-			new_inset->edit(bv_, 0, 0, 0);
+			new_inset->edit(bv_);
 		}
 		break;
 	}
@@ -1481,7 +1566,8 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument)
 	case LFUN_PASTESELECTION:
 	{
 	        bool asPara = false;
-		if (argument == "paragraph") asPara = true;
+		if (argument == "paragraph")
+			asPara = true;
 		pasteClipboard(asPara);
 	}
 	break;
@@ -1521,19 +1607,23 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument)
 	}
 
 	case LFUN_HYPHENATION:
-		hyphenationPoint();
+		specialChar(InsetSpecialChar::HYPHENATION);
+		break;
+		
+	case LFUN_LIGATURE_BREAK:
+		specialChar(InsetSpecialChar::LIGATURE_BREAK);
 		break;
 		
 	case LFUN_LDOTS:
-		ldots();
+		specialChar(InsetSpecialChar::LDOTS);
 		break;
 		
 	case LFUN_END_OF_SENTENCE:
-		endOfSentenceDot();
+		specialChar(InsetSpecialChar::END_OF_SENTENCE);
 		break;
 
 	case LFUN_MENU_SEPARATOR:
-		menuSeparator();
+		specialChar(InsetSpecialChar::MENU_SEPARATOR);
 		break;
 		
 	case LFUN_HFILL:
@@ -1556,19 +1646,9 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument)
 		owner_->getDialogs()->setUserFreeFont();
 		break;
 
-#ifndef NO_LATEX
-	case LFUN_TEX:
-		Tex(bv_);
-		setState();
-		owner_->showState();
-		break;
-#endif
-		
 	case LFUN_FILE_INSERT:
-	{
 		MenuInsertLyXFile(argument);
-	}
-	break;
+		break;
 	
 	case LFUN_FILE_INSERT_ASCII_PARA:
 		InsertAsciiFile(bv_, argument, true);
@@ -1585,37 +1665,35 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument)
 		
 		// Derive layout number from given argument (string)
 		// and current buffer's textclass (number). */    
-		LyXTextClassList::ClassList::size_type tclass =
-			buffer_->params.textclass;
-		pair <bool, LyXTextClass::size_type> layout = 
-			textclasslist.NumberOfLayout(tclass, argument);
+		textclass_type tclass = buffer_->params.textclass;
+		bool hasLayout =
+			textclasslist[tclass].hasLayout(argument);
+		string layout = argument;
 
 		// 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 = obs;
 		}
 
-		// see if we found the layout number:
-		if (!layout.first) {
+		if (!hasLayout) {
 			owner_->getLyXFunc()->setErrorMessage(
 				string(N_("Layout ")) + argument +
 				N_(" not known"));
 			break;
 		}
 
-		if (current_layout != layout.second) {
+		if (current_layout != layout) {
 			LyXText * lt = bv_->getLyXText();
 			hideCursor();
-			current_layout = layout.second;
+			current_layout = layout;
 			update(lt,
 			       BufferView::SELECT
 			       | BufferView::FITCUR);
-			lt->setLayout(bv_, layout.second);
-			owner_->setLayout(layout.second);
+			lt->setLayout(bv_, layout);
+			owner_->setLayout(layout);
 			update(lt,
 			       BufferView::SELECT
 			       | BufferView::FITCUR
@@ -1626,58 +1704,58 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument)
 	break;
 
 	case LFUN_LANGUAGE:
-		Lang(bv_, argument);
+		lang(bv_, argument);
 		setState();
 		owner_->showState();
 		break;
 
 	case LFUN_EMPH:
-		Emph(bv_);
+		emph(bv_);
 		owner_->showState();
 		break;
 
 	case LFUN_BOLD:
-		Bold(bv_);
+		bold(bv_);
 		owner_->showState();
 		break;
 		
 	case LFUN_NOUN:
-		Noun(bv_);
+		noun(bv_);
 		owner_->showState();
 		break;
 		
 	case LFUN_CODE:
-		Code(bv_);
+		code(bv_);
 		owner_->showState();
 		break;
 		
 	case LFUN_SANS:
-		Sans(bv_);
+		sans(bv_);
 		owner_->showState();
 		break;
 		
 	case LFUN_ROMAN:
-		Roman(bv_);
+		roman(bv_);
 		owner_->showState();
 		break;
 		
 	case LFUN_DEFAULT:
-		StyleReset(bv_);
+		styleReset(bv_);
 		owner_->showState();
 		break;
 		
 	case LFUN_UNDERLINE:
-		Underline(bv_);
+		underline(bv_);
 		owner_->showState();
 		break;
 		
 	case LFUN_FONT_SIZE:
-		FontSize(bv_, argument);
+		fontSize(bv_, argument);
 		owner_->showState();
 		break;
 		
 	case LFUN_FONT_STATE:
-		owner_->getLyXFunc()->setMessage(CurrentState(bv_));
+		owner_->getLyXFunc()->setMessage(currentState(bv_));
 		break;
 		
 	case LFUN_UPCASE_WORD:
@@ -1746,7 +1824,7 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument)
 	case LFUN_INSERT_LABEL:
 		MenuInsertLabel(bv_, argument);
 		break;
-		
+
 	case LFUN_REF_INSERT:
 		if (argument.empty()) {
 			InsetCommandParams p("ref");
@@ -1786,7 +1864,7 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument)
 		if (!label.empty()) {
 			//bv_->savePosition(0);
 			if (!bv_->gotoLabel(label))
-				WriteAlert(_("Error"), 
+				Alert::alert(_("Error"), 
 					   _("Couldn't find this label"), 
 					   _("in current document."));
 		}
@@ -1805,26 +1883,19 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument)
 		if (is_rtl)
 			lt->cursorLeft(bv_, false);
 		if (lt->cursor.pos() < lt->cursor.par()->size()
-		    && lt->cursor.par()->getChar(lt->cursor.pos())
-		    == Paragraph::META_INSET
-		    && lt->cursor.par()->getInset(lt->cursor.pos())
-		    && lt->cursor.par()->getInset(lt->cursor.pos())->editable() == Inset::HIGHLY_EDITABLE){
+		    && lt->cursor.par()->isInset(lt->cursor.pos())
+		    && isHighlyEditableInset(lt->cursor.par()->getInset(lt->cursor.pos()))) {
 			Inset * tmpinset = lt->cursor.par()->getInset(lt->cursor.pos());
 			owner_->getLyXFunc()->setMessage(tmpinset->editMessage());
-			int y = 0;
-			if (is_rtl) {
-				LyXFont const font = 
-					lt->getFont(buffer_,
-						    lt->cursor.par(),
-						    lt->cursor.pos());	
-				y = tmpinset->descent(bv_,font);
-			}
-			tmpinset->edit(bv_, 0, y, 0);
+			if (is_rtl)
+				tmpinset->edit(bv_, false);
+			else
+				tmpinset->edit(bv_);
 			break;
 		}
 		if (!is_rtl)
 			lt->cursorRight(bv_, false);
-		lt->finishUndo();
+		finishUndo();
 		moveCursorUpdate(false);
 		owner_->showState();
 	}
@@ -1844,29 +1915,20 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument)
 			lt->cursorLeft(bv_, false);
 		if ((is_rtl || cur != lt->cursor) && // only if really moved!
 		    lt->cursor.pos() < lt->cursor.par()->size() &&
-		    (lt->cursor.par()->getChar(lt->cursor.pos()) ==
-		     Paragraph::META_INSET) &&
-		    lt->cursor.par()->getInset(lt->cursor.pos()) &&
-		    (lt->cursor.par()->getInset(lt->cursor.pos())->editable()
-		     == Inset::HIGHLY_EDITABLE))
-		{
+		    lt->cursor.par()->isInset(lt->cursor.pos()) &&
+		    isHighlyEditableInset(lt->cursor.par()->getInset(lt->cursor.pos()))) {
 			Inset * tmpinset = lt->cursor.par()->getInset(lt->cursor.pos());
 			owner_->getLyXFunc()->setMessage(tmpinset->editMessage());
-			LyXFont const font = lt->getFont(buffer_,
-							 lt->cursor.par(),
-							 lt->cursor.pos());
-			int y = is_rtl ? 0 
-				: tmpinset->descent(bv_,font);
-			tmpinset->edit(bv_,
-				       tmpinset->x() +
-				       tmpinset->width(bv_,font),
-				       y, 0);
+			if (is_rtl)
+				tmpinset->edit(bv_);
+			else
+				tmpinset->edit(bv_, false);
 			break;
 		}
 		if  (is_rtl)
 			lt->cursorRight(bv_, false);
 
-		lt->finishUndo();
+		finishUndo();
 		moveCursorUpdate(false);
 		owner_->showState();
 	}
@@ -1880,7 +1942,7 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument)
 			beforeChange(lt);
 		update(lt, BufferView::UPDATE);
 		lt->cursorUp(bv_);
-		lt->finishUndo();
+		finishUndo();
 		moveCursorUpdate(false);
 		owner_->showState();
 	}
@@ -1894,7 +1956,7 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument)
 			beforeChange(lt);
 		update(lt, BufferView::UPDATE);
 		lt->cursorDown(bv_);
-		lt->finishUndo();
+		finishUndo();
 		moveCursorUpdate(false);
 		owner_->showState();
 	}
@@ -1908,7 +1970,7 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument)
 			beforeChange(lt);
 		update(lt, BufferView::UPDATE);
 		lt->cursorUpParagraph(bv_);
-		lt->finishUndo();
+		finishUndo();
 		moveCursorUpdate(false);
 		owner_->showState();
 	}
@@ -1922,7 +1984,7 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument)
 			beforeChange(lt);
 		update(lt, BufferView::UPDATE);
 		lt->cursorDownParagraph(bv_);
-		lt->finishUndo();
+		finishUndo();
 		moveCursorUpdate(false);
 		owner_->showState();
 	}
@@ -1936,7 +1998,7 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument)
 			beforeChange(lt);
 		update(lt, BufferView::UPDATE);
 		cursorPrevious(lt);
-		lt->finishUndo();
+		finishUndo();
 		moveCursorUpdate(false);
 		owner_->showState();
 	}
@@ -1950,7 +2012,7 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument)
 			beforeChange(lt);
 		update(lt, BufferView::UPDATE);
 		cursorNext(lt);
-		lt->finishUndo();
+		finishUndo();
 		moveCursorUpdate(false);
 		owner_->showState();
 	}
@@ -1964,7 +2026,7 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument)
 			beforeChange(lt);
 		update(lt, BufferView::SELECT|BufferView::FITCUR);
 		lt->cursorHome(bv_);
-		lt->finishUndo();
+		finishUndo();
 		moveCursorUpdate(false);
 		owner_->showState();
 	}
@@ -1979,7 +2041,7 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument)
 		update(lt,
 		       BufferView::SELECT|BufferView::FITCUR);
 		lt->cursorEnd(bv_);
-		lt->finishUndo();
+		finishUndo();
 		moveCursorUpdate(false);
 		owner_->showState();
 	}
@@ -1995,7 +2057,7 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument)
 		update(lt,
 		       BufferView::SELECT|BufferView::FITCUR);
 		lt->cursorTab(bv_);
-		lt->finishUndo();
+		finishUndo();
 		moveCursorUpdate(false);
 		owner_->showState();
 	}
@@ -2012,7 +2074,7 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument)
 			lt->cursorLeftOneWord(bv_);
 		else
 			lt->cursorRightOneWord(bv_);
-		lt->finishUndo();
+		finishUndo();
 		moveCursorUpdate(false);
 		owner_->showState();
 	}
@@ -2029,7 +2091,7 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument)
 			lt->cursorRightOneWord(bv_);
 		else
 			lt->cursorLeftOneWord(bv_);
-		lt->finishUndo();
+		finishUndo();
 		moveCursorUpdate(false);
 		owner_->showState();
 	}
@@ -2044,7 +2106,7 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument)
 		update(lt,
 		       BufferView::SELECT|BufferView::FITCUR);
 		lt->cursorTop(bv_);
-		lt->finishUndo();
+		finishUndo();
 		moveCursorUpdate(false);
 		owner_->showState();
 	}
@@ -2059,7 +2121,7 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument)
 		update(lt,
 		       BufferView::SELECT|BufferView::FITCUR);
 		lt->cursorBottom(bv_);
-		lt->finishUndo();
+		finishUndo();
 		moveCursorUpdate(false);
 		owner_->showState();
 	}
@@ -2076,7 +2138,7 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument)
 			lt->cursorLeft(bv_);
 		else
 			lt->cursorRight(bv_);
-		lt->finishUndo();
+		finishUndo();
 		moveCursorUpdate(true);
 		owner_->showState();
 	}
@@ -2092,7 +2154,7 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument)
 			lt->cursorRight(bv_);
 		else
 			lt->cursorLeft(bv_);
-		lt->finishUndo();
+		finishUndo();
 		moveCursorUpdate(true);
 		owner_->showState();
 	}
@@ -2105,7 +2167,7 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument)
 		update(lt,
 		       BufferView::SELECT|BufferView::FITCUR);
 		lt->cursorUp(bv_);
-		lt->finishUndo();
+		finishUndo();
 		moveCursorUpdate(true);
 		owner_->showState();
 	}
@@ -2118,7 +2180,7 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument)
 		update(lt,
 		       BufferView::SELECT|BufferView::FITCUR);
 		lt->cursorDown(bv_);
-		lt->finishUndo();
+		finishUndo();
 		moveCursorUpdate(true);
 		owner_->showState();
 	}
@@ -2131,7 +2193,7 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument)
 		update(lt,
 		       BufferView::SELECT|BufferView::FITCUR);
 		lt->cursorUpParagraph(bv_);
-		lt->finishUndo();
+		finishUndo();
 		moveCursorUpdate(true);
 		owner_->showState();
 	}
@@ -2144,7 +2206,7 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument)
 		update(lt,
 		       BufferView::SELECT|BufferView::FITCUR);
 		lt->cursorDownParagraph(bv_);
-		lt->finishUndo();
+		finishUndo();
 		moveCursorUpdate(true);
 		owner_->showState();
 	}
@@ -2156,7 +2218,7 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument)
 		
 		update(lt, BufferView::SELECT|BufferView::FITCUR);
 		cursorPrevious(lt);
-		lt->finishUndo();
+		finishUndo();
 		moveCursorUpdate(true);
 		owner_->showState();
 	}
@@ -2168,7 +2230,7 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument)
 		
 		update(lt, BufferView::SELECT|BufferView::FITCUR);
 		cursorNext(lt);
-		lt->finishUndo();
+		finishUndo();
 		moveCursorUpdate(true);
 		owner_->showState();
 	}
@@ -2180,7 +2242,7 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument)
 		
 		update(lt, BufferView::SELECT|BufferView::FITCUR);
 		lt->cursorHome(bv_);
-		lt->finishUndo();
+		finishUndo();
 		moveCursorUpdate(true);
 		owner_->showState();
 	}
@@ -2192,7 +2254,7 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument)
 		
 		update(lt, BufferView::SELECT|BufferView::FITCUR);
 		lt->cursorEnd(bv_);
-		lt->finishUndo();
+		finishUndo();
 		moveCursorUpdate(true);
 		owner_->showState();
 	}
@@ -2207,7 +2269,7 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument)
 			lt->cursorLeftOneWord(bv_);
 		else
 			lt->cursorRightOneWord(bv_);
-		lt->finishUndo();
+		finishUndo();
 		moveCursorUpdate(true);
 		owner_->showState();
 	}
@@ -2222,7 +2284,7 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument)
 			lt->cursorRightOneWord(bv_);
 		else
 			lt->cursorLeftOneWord(bv_);
-		lt->finishUndo();
+		finishUndo();
 		moveCursorUpdate(true);
 		owner_->showState();
 	}
@@ -2236,7 +2298,7 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument)
 			break;
 		update(lt, BufferView::SELECT|BufferView::FITCUR);
 		lt->cursorTop(bv_);
-		lt->finishUndo();
+		finishUndo();
 		moveCursorUpdate(true);
 		owner_->showState();
 	}
@@ -2251,7 +2313,7 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument)
 		update(lt,
 		       BufferView::SELECT|BufferView::FITCUR);
 		lt->cursorBottom(bv_);
-		lt->finishUndo();
+		finishUndo();
 		moveCursorUpdate(true);
 		owner_->showState();
 	}
@@ -2276,9 +2338,7 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument)
 	{
 		LyXText * lt = bv_->getLyXText();
 
-		LyXLayout const & style = textclasslist
-			.Style(buffer_->params.textclass,
-			       lt->cursor.par()->getLayout());
+		LyXLayout const & style = textclasslist[buffer_->params.textclass][lt->cursor.par()->layout()];
 
 		if (style.free_spacing) {
 			lt->insertChar(bv_, ' ');
@@ -2330,7 +2390,7 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument)
 			// just comment out the line below...
 			showCursor();
 		} else {
-			bv_->cut();
+			bv_->cut(false);
 		}
 		moveCursorUpdate(false);
 		owner_->showState();
@@ -2361,6 +2421,7 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument)
 						 cursor.par()->params().pagebreakBottom(),
 						 VSpace(VSpace::NONE), 
 						 cursor.par()->params().spaceBottom(),
+						 cursor.par()->params().spacing(), 
 						 cursor.par()->params().align(), 
 						 cursor.par()->params().labelWidthString(), 0);
 					lt->cursorLeft(bv_);
@@ -2386,7 +2447,7 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument)
 				       | BufferView::CHANGE);
 			}
 		} else {
-			bv_->cut();
+			bv_->cut(false);
 		}
 	}
 	break;
@@ -2473,7 +2534,7 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument)
 				showCursor();
 			}
 		} else {
-			bv_->cut();
+			bv_->cut(false);
 		}
 		owner_->showState();
 		setState();
@@ -2498,6 +2559,7 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument)
 					 cursor.par()->params().pagebreakTop(), 
 					 cursor.par()->params().pagebreakBottom(),
 					 VSpace(VSpace::NONE), cursor.par()->params().spaceBottom(),
+					 cursor.par()->params().spacing(), 
 					 cursor.par()->params().align(), 
 					 cursor.par()->params().labelWidthString(), 0);
 				update(lt,
@@ -2513,7 +2575,7 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument)
 				       | BufferView::CHANGE);
 			}
 		} else
-			bv_->cut();
+			bv_->cut(false);
 	}
 	break;
 
@@ -2563,12 +2625,13 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument)
 			if (cursor.par()->params().spaceTop() == VSpace(VSpace::NONE)) {
 				lt->setParagraph
 					(bv_,
-					 cursor.par()->params().lineTop(),      
+					 cursor.par()->params().lineTop(),
 					 cursor.par()->params().lineBottom(),
-					 cursor.par()->params().pagebreakTop(), 
+					 cursor.par()->params().pagebreakTop(),
 					 cursor.par()->params().pagebreakBottom(),
 					 VSpace(VSpace::DEFSKIP), cursor.par()->params().spaceBottom(),
-					 cursor.par()->params().align(), 
+					 cursor.par()->params().spacing(),
+					 cursor.par()->params().align(),
 					 cursor.par()->params().labelWidthString(), 1);
 				//update(BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
 			} 
@@ -2599,7 +2662,7 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument)
 			cur_value = par->params().spacing().getValue();
 		}
 		
-		istringstream istr(argument);
+		istringstream istr(argument.c_str());
 
 		string tmp;
 		istr >> tmp;
@@ -2638,8 +2701,20 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument)
 	}
 	break;
 	
+	case LFUN_INSET_TOGGLE:
+	{
+		LyXText * lt = bv_->getLyXText();
+		hideCursor();
+		beforeChange(lt);
+		update(lt, BufferView::SELECT|BufferView::FITCUR);
+		lt->toggleInset(bv_);
+		update(lt, BufferView::SELECT|BufferView::FITCUR);
+		setState();
+	}	
+		break;
+
 	case LFUN_QUOTE:
-		bv_->insertCorrectQuote();
+		smartQuote();
 		break;
 
 	case LFUN_HTMLURL:
@@ -2650,99 +2725,60 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument)
 			p.setCmdName("htmlurl");
 		else
 			p.setCmdName("url");
-		owner_->getDialogs()->createUrl( p.getAsString() );
+		owner_->getDialogs()->createUrl(p.getAsString());
 	}
 	break;
 	
 	case LFUN_INSERT_URL:
 	{
 		InsetCommandParams p;
-		p.setFromString( argument );
+		p.setFromString(argument);
 
-		InsetUrl * inset = new InsetUrl( p );
+		InsetUrl * inset = new InsetUrl(p);
 		if (!insertInset(inset))
 			delete inset;
 		else
-			updateInset( inset, true );
+			updateInset(inset, true);
 	}
 	break;
 	
 	case LFUN_INSET_TEXT:
-	{
-		InsetText * new_inset = new InsetText;
-		if (insertInset(new_inset))
-			new_inset->edit(bv_, 0, 0, 0);
-		else
-			delete new_inset;
-	}
-	break;
+		insertAndEditInset(new InsetText);
+		break;
 	
 	case LFUN_INSET_ERT:
-	{
-		InsetERT * new_inset = new InsetERT;
-		if (insertInset(new_inset))
-			new_inset->edit(bv_, 0, 0, 0);
-		else
-			delete new_inset;
-	}
-	break;
+		insertAndEditInset(new InsetERT);
+		break;
 	
 	case LFUN_INSET_EXTERNAL:
-	{
-		InsetExternal * new_inset = new InsetExternal;
-		if (insertInset(new_inset))
-			new_inset->edit(bv_, 0, 0, 0);
-		else
-			delete new_inset;
-	}
-	break;
+		insertAndEditInset(new InsetExternal);
+		break;
 	
 	case LFUN_INSET_FOOTNOTE:
-	{
-		InsetFoot * new_inset = new InsetFoot;
-		if (insertInset(new_inset))
-			new_inset->edit(bv_, 0, 0, 0);
-		else
-			delete new_inset;
-	}
-	break;
+		insertAndEditInset(new InsetFoot);
+		break;
 
 	case LFUN_INSET_MARGINAL:
-	{
-		InsetMarginal * new_inset = new InsetMarginal;
-		if (insertInset(new_inset))
-			new_inset->edit(bv_, 0, 0, 0);
-		else
-			delete new_inset;
-	}
-	break;
+		insertAndEditInset(new InsetMarginal);
+		break;
 
 	case LFUN_INSET_MINIPAGE:
-	{
-		InsetMinipage * new_inset = new InsetMinipage;
-		if (insertInset(new_inset))
-			new_inset->edit(bv_, 0, 0, 0);
-		else
-			delete new_inset;
-	}
-	break;
+		insertAndEditInset(new InsetMinipage);
+		break;
+
+	case LFUN_INSERT_NOTE:
+		insertAndEditInset(new InsetNote);
+		break;
 
 	case LFUN_INSET_FLOAT:
-	{
 		// check if the float type exist
 		if (floatList.typeExist(argument)) {
-			InsetFloat * new_inset = new InsetFloat(argument);
-			if (insertInset(new_inset))
-				new_inset->edit(bv_, 0, 0, 0);
-			else
-				delete new_inset;
+			insertAndEditInset(new InsetFloat(argument));
 		} else {
-			lyxerr << "Non-existant float type: "
+			lyxerr << "Non-existent float type: "
 			       << argument << endl;
 		}
-		
-	}
-	break;
+		break;
 
 	case LFUN_INSET_WIDE_FLOAT:
 	{
@@ -2751,37 +2787,27 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument)
 			InsetFloat * new_inset = new InsetFloat(argument);
 			new_inset->wide(true);
 			if (insertInset(new_inset))
-				new_inset->edit(bv_, 0, 0, 0);
+				new_inset->edit(bv_);
 			else
 				delete new_inset;
 		} else {
-			lyxerr << "Non-existant float type: "
+			lyxerr << "Non-existent float type: "
 			       << argument << endl;
 		}
 		
 	}
 	break;
 
+#if 0
 	case LFUN_INSET_LIST:
-	{
-		InsetList * new_inset = new InsetList;
-		if (insertInset(new_inset))
-			new_inset->edit(bv_, 0, 0, 0);
-		else
-			delete new_inset;
-	}
-	break;
+		insertAndEditInset(new InsetList);
+		break;
 
 	case LFUN_INSET_THEOREM:
-	{
-		InsetTheorem * new_inset = new InsetTheorem;
-		if (insertInset(new_inset))
-			new_inset->edit(bv_, 0, 0, 0);
-		else
-			delete new_inset;
-	}
-	break;
-
+		insertAndEditInset(new InsetTheorem);
+		break;
+#endif
+		
 	case LFUN_INSET_CAPTION:
 	{
 		// Do we have a locking inset...
@@ -2794,7 +2820,7 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument)
 			new_inset->setDrawFrame(0, InsetText::LOCKED);
 			new_inset->setFrameColor(0, LColor::captionframe);
 			if (insertInset(new_inset))
-				new_inset->edit(bv_, 0, 0, 0);
+				new_inset->edit(bv_);
 			else
 				delete new_inset;
 		}
@@ -2820,7 +2846,7 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument)
 
 	case LFUN_CHARATCURSOR:
 	{
-		Paragraph::size_type pos = bv_->getLyXText()->cursor.pos();
+		pos_type pos = bv_->getLyXText()->cursor.pos();
 		if (pos < bv_->getLyXText()->cursor.par()->size())
 			owner_->getLyXFunc()->setMessage(
 				tostr(bv_->getLyXText()->cursor.par()->getChar(pos)));
@@ -2848,7 +2874,7 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument)
 	break;
 	
 	case LFUN_GETLAYOUT:
-		owner_->getLyXFunc()->setMessage(tostr(bv_->getLyXText()->cursor.par()->layout));
+		owner_->getLyXFunc()->setMessage(tostr(bv_->getLyXText()->cursor.par()->layout()));
 		break;
 			
 	case LFUN_GETFONT:
@@ -2864,18 +2890,6 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument)
 	}
 	break;
 
-	case LFUN_GETLATEX:
-	{
-#ifndef NO_LATEX
-		LyXFont & font = bv_->getLyXText()->current_font;
-                if (font.latex() == LyXFont::ON)
-			owner_->getLyXFunc()->setMessage("L");
-                else
-#endif
-			owner_->getLyXFunc()->setMessage("0");
-	}
-	break;
-
 	// --- accented characters ---------------------------
 		
 	case LFUN_UMLAUT:
@@ -2909,71 +2923,48 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument)
 		}
 		break;
 	
-	// --- insert characters ----------------------------------------
-	
+	case LFUN_MATH_MACRO:
+		mathDispatchMathMacro(bv_, argument);
+		break;
+
 	case LFUN_MATH_DELIM:     
+		mathDispatchMathDelim(bv_, argument);
+		break;
+
 	case LFUN_INSERT_MATRIX:
-	{ 	   
-		if (available()) { 
-			if (open_new_inset(new InsetFormula, false)) {
-				bv_->theLockingInset()
-					->localDispatch(bv_, action, argument);
-			}
-		}
-	}	   
-	break;
-	       
+		mathDispatchInsertMatrix(bv_, argument);
+		break;
+
 	case LFUN_INSERT_MATH:
-	{
-		if (!available())
-			break;
- 
-		InsetFormula * f = new InsetFormula(LM_OT_EQUATION);
-		open_new_inset(f);
-		f->localDispatch(bv_, LFUN_INSERT_MATH, argument);
-	}
-	break;
-	
-	case LFUN_MATH_DISPLAY:
-	{	
-		if (available())
-			open_new_inset(new InsetFormula(LM_OT_EQUATION), false);
+		mathDispatchInsertMath(bv_, argument);
 		break;
-	}
-		    
-	case LFUN_MATH_MACRO:
-	{
-		if (available()) {
-			string s(argument);
-		        if (s.empty())
-				owner_->getLyXFunc()->setErrorMessage(N_("Missing argument"));
-		        else {
-				string const s1 = token(s, ' ', 1);
-				int const na = s1.empty() ? 0 : lyx::atoi(s1);
-				open_new_inset(new InsetFormulaMacro(token(s, ' ', 0), na), false);
-			}
-		}
-	}
-	break;
 
-	case LFUN_MATH_MODE:   // Open or create a math inset
-	{		
-		if (available())
-			open_new_inset(new InsetFormula, false);
-		owner_->getLyXFunc()->setMessage(N_("Math editor mode"));
-	}
-	break;
-	  
+	case LFUN_MATH_IMPORT_SELECTION: // Imports LaTeX from the X selection
+		mathDispatchMathImportSelection(bv_, argument);
+		break;
+
+	case LFUN_MATH_DISPLAY:          // Open or create a displayed math inset
+		mathDispatchMathDisplay(bv_, argument);
+		break;
+
+	case LFUN_MATH_MODE:             // Open or create an inlined math inset 
+		mathDispatchMathMode(bv_, argument);
+		break;
+		
+	case LFUN_GREEK:                 // Insert a single greek letter
+		mathDispatchGreek(bv_, argument);
+		break;
+		
 	case LFUN_CITATION_INSERT:
 	{
 		InsetCommandParams p;
-		p.setFromString( argument );
+		p.setFromString(argument);
 
-		InsetCitation * inset = new InsetCitation( p );
+		InsetCitation * inset = new InsetCitation(p);
 		if (!insertInset(inset))
 			delete inset;
 		else
-			updateInset( inset, true );
+			updateInset(inset, true);
 	}
 	break;
 		    
@@ -2983,16 +2974,14 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument)
 		// The argument can be up to two tokens separated 
 		// by a space. The first one is the bibstyle.
 		string const db       = token(argument, ' ', 0);
-		string bibstyle = token(argument, ' ', 1);
-		if (bibstyle.empty())
-			bibstyle = "plain";
+		string const bibstyle = token(argument, ' ', 1);
 
-		InsetCommandParams p( "BibTeX", db, bibstyle );
+		InsetCommandParams p("BibTeX", db, bibstyle);
 		InsetBibtex * inset = new InsetBibtex(p);
 		
 		if (insertInset(inset)) {
 			if (argument.empty())
-				inset->edit(bv_, 0, 0, 0);
+				inset->edit(bv_);
 		} else
 			delete inset;
 	}
@@ -3031,24 +3020,15 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument)
 		
 	case LFUN_INDEX_CREATE:
 	{
-		InsetCommandParams p( "index" );
-		
+		InsetCommandParams p("index");
 		if (argument.empty()) {
-			// Get the word immediately preceding the cursor
-			Paragraph::size_type curpos = 
-				bv_->getLyXText()->cursor.pos() - 1;
-
-			string curstring;
-			if (curpos >= 0 )
-				curstring = bv_->getLyXText()
-					->cursor.par()->getWord(curpos);
-
-			p.setContents( curstring );
+			string const idxstring(bv_->getLyXText()->getStringToIndex(bv_));
+			p.setContents(idxstring);
 		} else {
-			p.setContents( argument );
+			p.setContents(argument);
 		}
 
-		owner_->getDialogs()->createIndex( p.getAsString() );
+		owner_->getDialogs()->createIndex(p.getAsString());
 	}
 	break;
 		    
@@ -3067,22 +3047,18 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument)
 		    
 	case LFUN_INDEX_INSERT_LAST:
 	{
-		// Get word immediately preceding the cursor
-		Paragraph::size_type curpos = 
-			bv_->getLyXText()->cursor.pos() - 1;
-	  	// Can't do that at the beginning of a paragraph
-	  	if (curpos < 0) break;
-
-		string const curstring(bv_->getLyXText()
-				       ->cursor.par()->getWord(curpos));
-
-		InsetCommandParams p("index", curstring);
-		InsetIndex * inset = new InsetIndex(p);
-
-		if (!insertInset(inset))
-			delete inset;
-		else
-			updateInset(inset, true);
+		string const idxstring(bv_->getLyXText()->getStringToIndex(bv_));
+		if (!idxstring.empty()) {
+			owner_->message(_("Word `")
+					+ idxstring + _(("' indexed.")));
+			InsetCommandParams p("index", idxstring);
+			InsetIndex * inset = new InsetIndex(p);
+			
+			if (!insertInset(inset))
+				delete inset;
+			else
+				updateInset(inset, true);
+		}
 	}
 	break;
 
@@ -3098,7 +3074,7 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument)
 	case LFUN_PARENTINSERT:
 	{
 		lyxerr << "arg " << argument << endl;
-		InsetCommandParams p( "lyxparent", argument );
+		InsetCommandParams p("lyxparent", argument);
 		Inset * inset = new InsetParent(p, *buffer_);
 		if (!insertInset(inset, "Standard"))
 			delete inset;
@@ -3131,10 +3107,27 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument)
 	}
 	break;
 	
-	case LFUN_INSERT_NOTE:
-		insertNote();
-		break;
+	case LFUN_THESAURUS_ENTRY:
+	{
+		string arg = argument;
+
+		if (arg.empty()) {
+			arg = bv_->getLyXText()->selectionAsString(buffer_,
+								   false);
+ 
+			// FIXME
+			if (arg.size() > 100 || arg.empty()) {
+				// Get word or selection
+				bv_->getLyXText()->selectWordWhenUnderCursor(bv_, LyXText::WHOLE_WORD);
+				arg = bv_->getLyXText()->selectionAsString(buffer_, false);
+				// FIXME: where is getLyXText()->unselect(bv_) ?
+			}
+		}
 
+		bv_->owner()->getDialogs()->showThesaurus(arg);
+	}
+		break;
+ 
 	case LFUN_SELFINSERT:
 	{
 		if (argument.empty()) break;
@@ -3149,7 +3142,7 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument)
 		
 		if (lyxrc.auto_region_delete) {
 			if (lt->selection.set()) {
-				lt->cutSelection(bv_, false);
+				lt->cutSelection(bv_, false, false);
 				bv_->update(lt,
 					    BufferView::SELECT
 					    | BufferView::FITCUR
@@ -3157,17 +3150,13 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument)
 			}
 		}
 		
-		bv_->beforeChange(lt);
+		beforeChange(lt);
 		LyXFont const old_font(lt->real_current_font);
 		
 		string::const_iterator cit = argument.begin();
 		string::const_iterator end = argument.end();
 		for (; cit != end; ++cit) {
-			if (greek_kb_flag) {
-				if (!math_insert_greek(bv_, *cit))
-					owner_->getIntl()->getTrans().TranslateAndInsert(*cit, lt);
-			} else
-				owner_->getIntl()->getTrans().TranslateAndInsert(*cit, lt);
+			owner_->getIntl()->getTrans().TranslateAndInsert(*cit, lt);
 		}
 		
 		bv_->update(lt,
@@ -3268,6 +3257,12 @@ void BufferView::Pimpl::protectedBlank(LyXText * lt)
 		update(lt, BufferView::SELECT|BufferView::FITCUR);
 		InsetSpecialChar * new_inset =
 			new InsetSpecialChar(InsetSpecialChar::PROTECTED_SEPARATOR);
+#ifdef WITH_WARNINGS
+#warning Why is this code different from specialChar() below? (JMarc)
+// the code in specialChar is a generic version of what used to exist
+// for other special chars. I did not merge this case because of the
+// call to updateInset(), but what does it do?
+#endif
 		if (!insertInset(new_inset))
 			delete new_inset;
 		else
@@ -3276,7 +3271,7 @@ void BufferView::Pimpl::protectedBlank(LyXText * lt)
 }
 
 
-void BufferView::Pimpl::menuSeparator()
+void BufferView::Pimpl::specialChar(InsetSpecialChar::Kind kind)
 {
 	if (available()) {
 		LyXText * lt = bv_->getLyXText();
@@ -3284,72 +3279,60 @@ void BufferView::Pimpl::menuSeparator()
 		hideCursor();
 		update(lt, BufferView::SELECT|BufferView::FITCUR);
 		InsetSpecialChar * new_inset = 
-			new InsetSpecialChar(InsetSpecialChar::MENU_SEPARATOR);
-		insertInset(new_inset);
+			new InsetSpecialChar(kind);
+		if (!insertInset(new_inset))
+			delete new_inset;
 	}
 }
 
 
-void BufferView::Pimpl::endOfSentenceDot()
+void BufferView::Pimpl::smartQuote()
 {
-	if (available()) {
-		hideCursor();
-		update(bv_->getLyXText(), BufferView::SELECT|BufferView::FITCUR);
-		InsetSpecialChar * new_inset = 
-			new InsetSpecialChar(InsetSpecialChar::END_OF_SENTENCE);
-		insertInset(new_inset);
-	}
-}
-
+	LyXText const * lt = bv_->getLyXText();
+	Paragraph const * par = lt->cursor.par();
+	pos_type pos = lt->cursor.pos();
+	char c;
 
-void BufferView::Pimpl::ldots()
-{
-	if (available())  {
-		hideCursor();
-		update(bv_->getLyXText(), BufferView::SELECT|BufferView::FITCUR);
-		InsetSpecialChar * new_inset = 
-			new InsetSpecialChar(InsetSpecialChar::LDOTS);
-		insertInset(new_inset);
-	}
-}
+	if (!pos
+	    || (par->isInset(pos - 1)
+		&& par->getInset(pos - 1)->isSpace()))
+		c = ' ';
+	else
+		c = par->getChar(pos - 1);
+		
 
+	hideCursor();
 
-void BufferView::Pimpl::hyphenationPoint()
-{
-	if (available()) {
-		hideCursor();
-		update(bv_->getLyXText(), BufferView::SELECT|BufferView::FITCUR);
-		InsetSpecialChar * new_inset = 
-			new InsetSpecialChar(InsetSpecialChar::HYPHENATION);
-		insertInset(new_inset);
-	}
+	LyXLayout const & style =
+		textclasslist[bv_->buffer()->params.textclass][par->layout()];
+	
+	if (style.pass_thru ||
+		(!insertInset(new InsetQuotes(c, bv_->buffer()->params))))
+		bv_->owner()->getLyXFunc()->dispatch(LFUN_SELFINSERT, "\"");
 }
 
 
-void BufferView::Pimpl::insertNote()
+void BufferView::Pimpl::insertAndEditInset(Inset * inset)
 {
-	InsetInfo * new_inset = new InsetInfo();
-	insertInset(new_inset);
-	new_inset->edit(bv_, 0, 0, 0);
+	if (insertInset(inset))
+		inset->edit(bv_);
+	else
+		delete inset;
 }
 
-
+ 
 // Open and lock an updatable inset
 bool BufferView::Pimpl::open_new_inset(UpdatableInset * new_inset, bool behind)
 {
 	LyXText * lt = bv_->getLyXText();
 	
 	beforeChange(lt);
-	lt->finishUndo();
+	finishUndo();
 	if (!insertInset(new_inset)) {
 		delete new_inset;
 		return false;
 	}
-	if (behind) {
-		LyXFont & font = lt->real_current_font;
-		new_inset->edit(bv_, new_inset->width(bv_, font), 0, 0);
-	} else
-		new_inset->edit(bv_, 0, 0, 0);
+	new_inset->edit(bv_, !behind);
 	return true;
 }
 
@@ -3359,14 +3342,14 @@ bool BufferView::Pimpl::insertInset(Inset * inset, string const & lout)
 	// if we are in a locking inset we should try to insert the
 	// inset there otherwise this is a illegal function now
 	if (bv_->theLockingInset()) {
-		if (bv_->theLockingInset()->insertInsetAllowed(inset))
+		if (bv_->theLockingInset()->insetAllowed(inset))
 		    return bv_->theLockingInset()->insertInset(bv_, inset);
 		return false;
 	}
 
 	// not quite sure if we want this...
-	bv_->text->setCursorParUndo(buffer_);
-	bv_->text->freezeUndo();
+	setCursorParUndo(bv_);
+	freezeUndo();
 	
 	beforeChange(bv_->text);
 	if (!lout.empty()) {
@@ -3381,36 +3364,36 @@ bool BufferView::Pimpl::insertInset(Inset * inset, string const & lout)
 			update(bv_->text, BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
 		}
 
-		pair<bool, LyXTextClass::size_type> lres =
-			textclasslist.NumberOfLayout(buffer_->params
-						     .textclass, lout);
-		LyXTextClass::size_type lay;
-		if (lres.first != false) {
+		string lres = lout;
+		LyXTextClass const & tclass =
+			textclasslist[buffer_->params.textclass];
+		bool hasLayout = tclass.hasLayout(lres);
+		string lay = tclass.defaultLayoutName();
+
+		if (hasLayout != false) {
 			// layout found
-			lay = lres.second;
+			lay = lres;
 		} else {
-			// layout not fount using default "Standard" (0)
-			lay = 0;
+			// layout not fount using default
+			lay = tclass.defaultLayoutName();
 		}
-		 
+
 		bv_->text->setLayout(bv_, lay);
 		
 		bv_->text->setParagraph(bv_, 0, 0,
 				   0, 0,
 				   VSpace(VSpace::NONE), VSpace(VSpace::NONE),
+				   Spacing(),
 				   LYX_ALIGN_LAYOUT, 
 				   string(),
 				   0);
 		update(bv_->text, BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
-#ifndef NO_LATEX
-		bv_->text->current_font.setLatex(LyXFont::OFF);
-#endif
 	}
 	
 	bv_->text->insertInset(bv_, inset);
 	update(bv_->text, BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
 
-	bv_->text->unFreezeUndo();
+	unFreezeUndo();
 	return true;
 }
 
@@ -3432,10 +3415,9 @@ void BufferView::Pimpl::updateInset(Inset * inset, bool mark_dirty)
 				return;
 			}
 		} else if (bv_->theLockingInset()->updateInsetInInset(bv_, inset)) {
-			if (bv_->text->updateInset(bv_,
-						   bv_->theLockingInset())) {
+			if (bv_->text->updateInset(bv_,  bv_->theLockingInset())) {
 				update();
-				if (mark_dirty){
+				if (mark_dirty) {
 					buffer_->markDirty();
 				}
 				updateScrollbar();
@@ -3472,21 +3454,24 @@ void BufferView::Pimpl::gotoInset(vector<Inset::Code> const & codes,
 	beforeChange(bv_->text);
 	update(bv_->text, BufferView::SELECT|BufferView::FITCUR);
 	
+	LyXCursor const & cursor = bv_->text->cursor;
+ 
 	string contents;
 	if (same_content &&
-	    bv_->text->cursor.par()->getChar(bv_->text->cursor.pos()) == Paragraph::META_INSET) {
-		Inset const * inset = bv_->text->cursor.par()->getInset(bv_->text->cursor.pos());
+	    cursor.par()->isInset(cursor.pos())) {
+		Inset const * inset = cursor.par()->getInset(cursor.pos());
 		if (find(codes.begin(), codes.end(), inset->lyxCode())
 		    != codes.end())
 			contents =
 				static_cast<InsetCommand const *>(inset)->getContents();
 	}
 	
+ 
 	if (!bv_->text->gotoNextInset(bv_, codes, contents)) {
 		if (bv_->text->cursor.pos() 
-		    || bv_->text->cursor.par() != bv_->text->firstParagraph()) {
+		    || bv_->text->cursor.par() != bv_->text->ownerParagraph()) {
 			LyXCursor tmp = bv_->text->cursor;
-			bv_->text->cursor.par(bv_->text->firstParagraph());
+			bv_->text->cursor.par(bv_->text->ownerParagraph());
 			bv_->text->cursor.pos(0);
 			if (!bv_->text->gotoNextInset(bv_, codes, contents)) {
 				bv_->text->cursor = tmp;