X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FBufferView_pimpl.C;h=a7afbd8b2a8367f9cbcb2774801c5b370416cb52;hb=dbd7a961fc46bb10c85bdd8c7fb6626477ae63d8;hp=34814ff384dbf94b9dcd0fa18af36980ef492ddc;hpb=9d0ba3ddf295225939fcb04ffc11d6de509abdc8;p=lyx.git

diff --git a/src/BufferView_pimpl.C b/src/BufferView_pimpl.C
index 34814ff384..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,6 +9,7 @@
 #include "lyxscreen.h"
 #include "lyxtext.h"
 #include "lyxrow.h"
+#include "paragraph.h"
 #include "LyXView.h"
 #include "commandtags.h"
 #include "lyxfunc.h"
@@ -22,21 +18,23 @@
 #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 "support/lstrings.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"
@@ -61,12 +59,21 @@
 #include "insets/insetcaption.h"
 #include "insets/insetfloatlist.h"
 #include "insets/insetspecialchar.h"
-#include "gettext.h"
-#include "ParagraphParameters.h"
-#include "undo_funcs.h"
+
 #include "mathed/formulabase.h"
 
-extern LyXTextClass::size_type current_layout;
+#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;
@@ -77,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;
@@ -84,7 +94,6 @@ bool selection_possible = false;
 extern BufferList bufferlist;
 extern char ascii_type;
 
-extern void sigchldchecker(pid_t pid, int * status);
 extern int bibitemMaxWidth(BufferView *, LyXFont const &);
 
 
@@ -103,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;
@@ -143,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));
@@ -293,9 +306,9 @@ 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;
 
@@ -356,7 +369,9 @@ int BufferView::Pimpl::resizeCurrentBuffer()
 		bv_->theLockingInset(the_locking_inset);
 	}
 	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();
@@ -389,17 +404,26 @@ void BufferView::Pimpl::updateScrollbar()
 	}
 
 	long const text_height = bv_->text->height;
+	long const work_height = workarea_.height();
 
+	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;
+	}
+	
 	double const lineh = bv_->text->defaultHeight();
 	double const slider_size =
 		(text_height == 0) ? 1.0 : 1.0 / double(text_height);
-
-	static long old_text_height = 0;
-	static double old_lineh = 0;
-	static double old_slider_size = 0;
+	
+	static long old_text_height;
+	static double old_lineh;
+	static double old_slider_size;
 
 	if (text_height != old_text_height) {
-		workarea_.setScrollbarBounds(0, text_height - workarea_.height());
+		workarea_.setScrollbarBounds(0.0,
+					     text_height - work_height);
 		old_text_height = text_height;
 	}
 	if (lineh != old_lineh) {
@@ -421,6 +445,7 @@ void BufferView::Pimpl::scrollCB(double value)
 	if (!buffer_) return;
 
 	current_scrollbar_value = long(value);
+
 	if (current_scrollbar_value < 0)
 		current_scrollbar_value = 0;
    
@@ -554,11 +579,7 @@ void BufferView::Pimpl::workAreaMotionNotify(int x, int y, unsigned int state)
 	bv_->text->setSelection(bv_);
 	screen_->toggleToggle(bv_->text, bv_);
 	fitCursor();
-#if 0
-	screen_->showCursor(bv_->text, bv_);
-#else
 	showCursor();
-#endif
 }
 
 
@@ -568,7 +589,7 @@ void BufferView::Pimpl::workAreaButtonPress(int xpos, int ypos,
 {
 	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) {
@@ -614,11 +635,7 @@ void BufferView::Pimpl::workAreaButtonPress(int xpos, int ypos,
 	screen_->toggleSelection(bv_->text, bv_);
 	bv_->text->clearSelection();
 	bv_->text->fullRebreak(bv_);
-#if 0
-	screen_->update(bv_->text, bv_);
-#else
 	update();
-#endif
 	updateScrollbar();
 	
 	// Single left click in math inset?
@@ -628,8 +645,10 @@ void BufferView::Pimpl::workAreaButtonPress(int xpos, int ypos,
 		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;
 	} 
 	
@@ -669,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_, 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);
+		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);
 	}
 }
 
@@ -704,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);
@@ -718,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()) {
@@ -744,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.
@@ -762,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
@@ -802,33 +867,9 @@ void BufferView::Pimpl::workAreaButtonRelease(int x, int y,
 		return;
 	}
 
-#ifdef WITH_WARNINGS
-#warning variable c is set but never used. What is it good for?? (JMarc)
-#endif
-	// 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);
 	}
 
@@ -836,76 +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()
-	    && isMetaInset(cursor.par(), cursor.pos())
-	    && isEditableInset(cursor.par()->getInset(cursor.pos()))) {
+ 
+	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) &&
-	    isMetaInset(cursor.par(), cursor.pos() - 1) &&
-	    isEditableInset(cursor.par()->getInset(cursor.pos() - 1))) {
-		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;
 }
 
 
@@ -966,7 +1027,7 @@ void BufferView::Pimpl::update()
 		LyXText::text_status st = bv_->text->status();
 		screen_->update(bv_->text, bv_);
 		bool fitc = false;
-		while(bv_->text->status() == LyXText::CHANGED_IN_DRAW) {
+		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(),
@@ -1052,27 +1113,20 @@ 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)
-		sigchldchecker(pid, &status);
-
-	updatelist.update(bv_);
-	
 	if (!screen_.get()) {
 		cursor_timeout.restart();
 		return;
 	}
 
+	/* FIXME */
+	extern void reapSpellchecker(void);
+	reapSpellchecker();
+	 
 	if (!bv_->theLockingInset()) {
 		screen_->cursorToggle(bv_);
 	} else {
@@ -1104,7 +1158,7 @@ void BufferView::Pimpl::cursorPrevious(LyXText * text)
 			      text->cursor.y()
 			      - text->cursor.row()->baseline()
 			      + text->cursor.row()->height()
-			      - workarea_.height() + 1 );
+			      - workarea_.height() + 1);
 	updateScrollbar();
 }
 
@@ -1176,7 +1230,7 @@ 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 = buffer_->getParFromID(saved_positions[i].par_id);
@@ -1339,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);
 }
@@ -1400,7 +1454,7 @@ 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))
 				initpath = trypath;
@@ -1409,9 +1463,9 @@ void BufferView::Pimpl::MenuInsertLyXFile(string const & filen)
 		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 =
@@ -1485,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)
@@ -1513,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;
@@ -1593,10 +1647,8 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument)
 		break;
 
 	case LFUN_FILE_INSERT:
-	{
 		MenuInsertLyXFile(argument);
-	}
-	break;
+		break;
 	
 	case LFUN_FILE_INSERT_ASCII_PARA:
 		InsertAsciiFile(bv_, argument, true);
@@ -1613,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
@@ -1814,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."));
 		}
@@ -1833,7 +1883,7 @@ 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()
-		    && isMetaInset(lt->cursor.par(), lt->cursor.pos())
+		    && 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());
@@ -1865,7 +1915,7 @@ 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() &&
-		    isMetaInset(lt->cursor.par(), lt->cursor.pos()) &&
+		    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());
@@ -2288,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_, ' ');
@@ -2577,13 +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().spacing(), 
-					 cursor.par()->params().align(), 
+					 cursor.par()->params().spacing(),
+					 cursor.par()->params().align(),
 					 cursor.par()->params().labelWidthString(), 1);
 				//update(BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
 			} 
@@ -2798,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)));
@@ -2826,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:
@@ -2910,13 +2958,13 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument)
 	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;
 		    
@@ -2928,7 +2976,7 @@ bool BufferView::Pimpl::Dispatch(kb_action action, string const & argument)
 		string const db       = token(argument, ' ', 0);
 		string const bibstyle = token(argument, ' ', 1);
 
-		InsetCommandParams p( "BibTeX", db, bibstyle );
+		InsetCommandParams p("BibTeX", db, bibstyle);
 		InsetBibtex * inset = new InsetBibtex(p);
 		
 		if (insertInset(inset)) {
@@ -3026,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;
@@ -3232,32 +3280,35 @@ void BufferView::Pimpl::specialChar(InsetSpecialChar::Kind kind)
 		update(lt, BufferView::SELECT|BufferView::FITCUR);
 		InsetSpecialChar * new_inset = 
 			new InsetSpecialChar(kind);
-		insertInset(new_inset);
-		// Ok, what happens here if we are unable to insert
-		// the inset? Leak it?
+		if (!insertInset(new_inset))
+			delete new_inset;
 	}
 }
 
 
 void BufferView::Pimpl::smartQuote()
 {
+	LyXText const * lt = bv_->getLyXText();
+	Paragraph const * par = lt->cursor.par();
+	pos_type pos = lt->cursor.pos();
 	char c;
-	LyXText * lt = bv_->getLyXText();
 
-	if (lt->cursor.pos())
-		c = lt->cursor.par()->getChar(lt->cursor.pos() - 1);
-	else 
+	if (!pos
+	    || (par->isInset(pos - 1)
+		&& par->getInset(pos - 1)->isSpace()))
 		c = ' ';
+	else
+		c = par->getChar(pos - 1);
+		
 
 	hideCursor();
 
-	LyXLayout const & style = textclasslist.Style(
-		bv_->buffer()->params.textclass,
-		lt->cursor.par()->getLayout());
+	LyXLayout const & style =
+		textclasslist[bv_->buffer()->params.textclass][par->layout()];
 	
 	if (style.pass_thru ||
 		(!insertInset(new InsetQuotes(c, bv_->buffer()->params))))
-		Dispatch(LFUN_SELFINSERT, "\"");
+		bv_->owner()->getLyXFunc()->dispatch(LFUN_SELFINSERT, "\"");
 }
 
 
@@ -3313,18 +3364,20 @@ 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,
@@ -3362,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();
@@ -3406,7 +3458,7 @@ void BufferView::Pimpl::gotoInset(vector<Inset::Code> const & codes,
  
 	string contents;
 	if (same_content &&
-	    isMetaInset(cursor.par(), 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())
@@ -3417,9 +3469,9 @@ void BufferView::Pimpl::gotoInset(vector<Inset::Code> const & codes,
  
 	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;