X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Fbuffer.C;h=77a16b31c7d10a547cfc26089c1483527fa818cb;hb=8283e978f8d621041c432b9b88a476bfd567385c;hp=78eed77550129a5fd807cb042b3ac25ab6149a5f;hpb=50b65ca806e62f76738a364af6b948d92863aefa;p=lyx.git

diff --git a/src/buffer.C b/src/buffer.C
index 78eed77550..77a16b31c7 100644
--- a/src/buffer.C
+++ b/src/buffer.C
@@ -1,6 +1,6 @@
 /* This file is part of
- * ====================================================== 
- * 
+ * ======================================================
+ *
  *           LyX, The Document Processor
  *
  *	     Copyright 1995 Matthias Ettrich
@@ -9,29 +9,11 @@
  *           This file is Copyright 1996-2001
  *           Lars Gullik Bjønnes
  *
- * ====================================================== 
+ * ======================================================
  */
 
 #include <config.h>
 
-#include <fstream>
-#include <iomanip>
-#include <map>
-#include <stack>
-#include <list>
-
-#include <cstdlib>
-#include <cmath>
-#include <unistd.h>
-#include <sys/types.h>
-#include <utime.h>
-
-#include <algorithm>
-
-#ifdef HAVE_LOCALE
-#include <locale>
-#endif
-
 #ifdef __GNUG__
 #pragma implementation
 #endif
@@ -39,7 +21,6 @@
 #include "buffer.h"
 #include "bufferlist.h"
 #include "lyx_main.h"
-#include "lyx_gui_misc.h"
 #include "LyXAction.h"
 #include "lyxrc.h"
 #include "lyxlex.h"
@@ -48,25 +29,42 @@
 #include "bufferview_funcs.h"
 #include "lyxfont.h"
 #include "version.h"
+#include "LaTeX.h"
+#include "Chktex.h"
+#include "LyXView.h"
+#include "debug.h"
+#include "LaTeXFeatures.h"
+#include "lyxtext.h"
+#include "gettext.h"
+#include "language.h"
+#include "encoding.h"
+#include "exporter.h"
+#include "Lsstream.h"
+#include "converter.h"
+#include "BufferView.h"
+#include "ParagraphParameters.h"
+#include "iterators.h"
+#include "lyxtextclasslist.h"
+
 #include "mathed/formulamacro.h"
 #include "mathed/formula.h"
+
 #include "insets/inset.h"
 #include "insets/inseterror.h"
 #include "insets/insetlabel.h"
 #include "insets/insetref.h"
 #include "insets/inseturl.h"
-#include "insets/insetinfo.h"
+#include "insets/insetnote.h"
 #include "insets/insetquotes.h"
 #include "insets/insetlatexaccent.h"
-#include "insets/insetbib.h" 
-#include "insets/insetcite.h" 
+#include "insets/insetbib.h"
+#include "insets/insetcite.h"
 #include "insets/insetexternal.h"
-#include "insets/insetindex.h" 
+#include "insets/insetindex.h"
 #include "insets/insetinclude.h"
 #include "insets/insettoc.h"
 #include "insets/insetparent.h"
 #include "insets/insetspecialchar.h"
-#include "insets/figinset.h"
 #include "insets/insettext.h"
 #include "insets/insetert.h"
 #include "insets/insetgraphics.h"
@@ -74,34 +72,44 @@
 #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 "frontends/Dialogs.h"
+#include "frontends/Alert.h"
+
+#include "support/textutils.h"
 #include "support/filetools.h"
 #include "support/path.h"
 #include "support/os.h"
-#include "LaTeX.h"
-#include "Chktex.h"
-#include "LyXView.h"
-#include "debug.h"
-#include "LaTeXFeatures.h"
-#include "support/syscall.h"
 #include "support/lyxlib.h"
 #include "support/FileInfo.h"
 #include "support/lyxmanip.h"
-#include "lyxtext.h"
-#include "gettext.h"
-#include "language.h"
-#include "lyx_gui_misc.h"	// WarnReadonly()
-#include "frontends/Dialogs.h"
-#include "encoding.h"
-#include "exporter.h"
-#include "Lsstream.h"
-#include "converter.h"
-#include "BufferView.h"
-#include "ParagraphParameters.h"
+#include "support/lyxalgo.h" // for lyx::count
+
+#include <fstream>
+#include <iomanip>
+#include <map>
+#include <stack>
+#include <list>
+#include <algorithm>
+
+#include <cstdlib>
+#include <cmath>
+#include <unistd.h>
+#include <sys/types.h>
+#include <utime.h>
+
+
+#ifdef HAVE_LOCALE
+#include <locale>
+#endif
+
 
 using std::ostream;
 using std::ofstream;
@@ -119,6 +127,9 @@ using std::set;
 using std::stack;
 using std::list;
 
+using lyx::pos_type;
+using lyx::textclass_type;
+
 // all these externs should eventually be removed.
 extern BufferList bufferlist;
 
@@ -134,21 +145,26 @@ extern int tex_code_break_column;
 
 
 Buffer::Buffer(string const & file, bool ronly)
+	: paragraph(0), niceFile(true), lyx_clean(true), bak_clean(true),
+	  unnamed(false), dep_clean(0), read_only(ronly),
+	  filename_(file), users(0)
 {
 	lyxerr[Debug::INFO] << "Buffer::Buffer()" << endl;
-	filename = file;
-	filepath = OnlyPath(file);
-	paragraph = 0;
-	lyx_clean = true;
-	bak_clean = true;
-	dep_clean = 0;
-	read_only = ronly;
-	unnamed = false;
-	users = 0;
+//	filename = file;
+	filepath_ = OnlyPath(file);
+//	paragraph = 0;
+//	lyx_clean = true;
+//	bak_clean = true;
+//	dep_clean = 0;
+//	read_only = ronly;
+//	unnamed = false;
+//	users = 0;
 	lyxvc.buffer(this);
-	if (read_only || (lyxrc.use_tempdir)) {
+	if (read_only || lyxrc.use_tempdir) {
 		tmppath = CreateBufferTmpDir();
-	} else tmppath.erase();
+	} else {
+		tmppath.erase();
+	}
 }
 
 
@@ -162,11 +178,11 @@ Buffer::~Buffer()
 	// forgets it.
 	if (users)
 		users->buffer(0);
-	
+
 	if (!tmppath.empty()) {
 		DestroyBufferTmpDir(tmppath);
 	}
-	
+
 	Paragraph * par = paragraph;
 	Paragraph * tmppar;
 	while (par) {
@@ -180,7 +196,7 @@ Buffer::~Buffer()
 
 string const Buffer::getLatexName(bool no_path) const
 {
-	string name = ChangeExtension(MakeLatexName(filename), ".tex");
+	string const name = ChangeExtension(MakeLatexName(fileName()), ".tex");
 	if (no_path)
 		return OnlyFilename(name);
 	else
@@ -197,7 +213,7 @@ pair<Buffer::LogType, string> const Buffer::getLogName(void) const
 
 	string path = OnlyPath(filename);
 
-	if (lyxrc.use_tempdir || (IsDirWriteable(path) < 1))
+	if (lyxrc.use_tempdir || !IsDirWriteable(path))
 		path = tmppath;
 
 	string const fname = AddName(path,
@@ -206,7 +222,7 @@ pair<Buffer::LogType, string> const Buffer::getLogName(void) const
 	string const bname =
 		AddName(path, OnlyFilename(
 			ChangeExtension(filename,
-					formats.Extension("literate") + ".out")));
+					formats.extension("literate") + ".out")));
 
 	// If no Latex log or Build log is newer, show Build log
 
@@ -226,29 +242,10 @@ pair<Buffer::LogType, string> const Buffer::getLogName(void) const
 void Buffer::setReadonly(bool flag)
 {
 	if (read_only != flag) {
-		read_only = flag; 
+		read_only = flag;
 		updateTitles();
 		users->owner()->getDialogs()->updateBufferDependent(false);
 	}
-	if (read_only) {
-		WarnReadonly(filename);
-	}
-}
-
-
-bool Buffer::saveParamsAsDefaults() // const
-{
-	string const fname = AddName(AddPath(user_lyxdir, "templates/"),
-			       "defaults.lyx");
-	Buffer defaults = Buffer(fname);
-	
-	// Use the current buffer's parameters as default
-	defaults.params = params;
-	
-	// add an empty paragraph. Is this enough?
-	defaults.paragraph = new Paragraph;
-
-	return defaults.writeFile(defaults.filename, false);
 }
 
 
@@ -256,7 +253,8 @@ bool Buffer::saveParamsAsDefaults() // const
 // Should work on a list
 void Buffer::updateTitles() const
 {
-	if (users) users->owner()->updateWindowTitle();
+	if (users)
+		users->owner()->updateWindowTitle();
 }
 
 
@@ -264,15 +262,16 @@ void Buffer::updateTitles() const
 // Should work on a list
 void Buffer::resetAutosaveTimers() const
 {
-	if (users) users->owner()->resetAutosaveTimer();
+	if (users)
+		users->owner()->resetAutosaveTimer();
 }
 
 
 void Buffer::setFileName(string const & newfile)
 {
-	filename = MakeAbsPath(newfile);
-	filepath = OnlyPath(filename);
-	setReadonly(IsFileWriteable(filename) == 0);
+	filename_ = MakeAbsPath(newfile);
+	filepath_ = OnlyPath(filename_);
+	setReadonly(IsFileWriteable(filename_) == 0);
 	updateTitles();
 }
 
@@ -282,24 +281,30 @@ namespace {
 
 string last_inset_read;
 
-struct ErtComp 
+#ifndef NO_COMPABILITY
+struct ErtComp
 {
 	ErtComp() : active(false), in_tabular(false) {
 	}
 	string contents;
 	bool active;
 	bool in_tabular;
+	LyXFont font;
 };
 
 std::stack<ErtComp> ert_stack;
 ErtComp ert_comp;
+#endif
 
+#ifdef WITH_WARNINGS
+#warning And _why_ is this here? (Lgb)
+#endif
+int unknown_layouts;
+int unknown_tokens;
 
 } // anon
 
 
-int unknown_layouts;
-
 // candidate for move to BufferView
 // (at least some parts in the beginning of the func)
 //
@@ -311,14 +316,14 @@ int unknown_layouts;
 bool Buffer::readLyXformat2(LyXLex & lex, Paragraph * par)
 {
 	unknown_layouts = 0;
-#ifdef NO_LATEX
+	unknown_tokens = 0;
+#ifndef NO_COMPABILITY
 	ert_comp.contents.erase();
 	ert_comp.active = false;
 	ert_comp.in_tabular = false;
 #endif
-	
 	int pos = 0;
-	Paragraph::depth_type depth = 0; 
+	Paragraph::depth_type depth = 0;
 	bool the_end_read = false;
 
 	Paragraph * first_par = 0;
@@ -328,17 +333,18 @@ bool Buffer::readLyXformat2(LyXLex & lex, Paragraph * par)
 
 	if (!par) {
 		par = new Paragraph;
+		par->layout(textclasslist[params.textclass].defaultLayoutName());
 	} else {
 		// We are inserting into an existing document
 		users->text->breakParagraph(users);
-		first_par = users->text->firstParagraph();
+		first_par = users->text->ownerParagraph();
 		pos = 0;
 		markDirty();
 		// We don't want to adopt the parameters from the
 		// document we insert, so we skip until the text begins:
-		while (lex.IsOK()) {
+		while (lex.isOK()) {
 			lex.nextToken();
-			string const pretoken = lex.GetString();
+			string const pretoken = lex.getString();
 			if (pretoken == "\\layout") {
 				lex.pushToken(pretoken);
 				break;
@@ -346,21 +352,21 @@ bool Buffer::readLyXformat2(LyXLex & lex, Paragraph * par)
 		}
 	}
 
-	while (lex.IsOK()) {
+	while (lex.isOK()) {
 		lex.nextToken();
-		string const token = lex.GetString();
+		string const token = lex.getString();
 
 		if (token.empty()) continue;
 
 		lyxerr[Debug::PARSER] << "Handling token: `"
 				      << token << "'" << endl;
-		
+
 		the_end_read =
 			parseSingleLyXformat2Token(lex, par, first_par,
 						   token, pos, depth,
 						   font);
 	}
-   
+
 	if (!first_par)
 		first_par = par;
 
@@ -374,51 +380,66 @@ bool Buffer::readLyXformat2(LyXLex & lex, Paragraph * par)
 			s += tostr(unknown_layouts);
 			s += _(" paragraphs");
 		}
-		WriteAlert(_("Textclass Loading Error!"), s,
+		Alert::alert(_("Textclass Loading Error!"), s,
 			   _("When reading " + fileName()));
-	}	
+	}
+
+	if (unknown_tokens > 0) {
+		string s = _("Encountered ");
+		if (unknown_tokens == 1) {
+			s += _("one unknown token");
+		} else {
+			s += tostr(unknown_tokens);
+			s += _(" unknown tokens");
+		}
+		Alert::alert(_("Textclass Loading Error!"), s,
+			   _("When reading " + fileName()));
+	}
 
 	return the_end_read;
 }
 
 
-void Buffer::insertErtContents(Paragraph * par, int & pos,
-			       LyXFont const & font, bool set_inactive) 
+#ifndef NO_COMPABILITY
+void Buffer::insertErtContents(Paragraph * par, int & pos, bool set_inactive)
 {
 	if (!ert_comp.contents.empty()) {
-		lyxerr[Debug::INSETS] << "ERT contents:\n"
-		       << ert_comp.contents << endl;
-		Inset * inset = new InsetERT(ert_comp.contents);
-		par->insertInset(pos++, inset, font);
+		lyxerr[Debug::INSETS] << "ERT contents:\n'"
+				      << ert_comp.contents << "'" << endl;
+		Inset * inset = new InsetERT(params, params.language,
+					     ert_comp.contents, true);
+		par->insertInset(pos++, inset, ert_comp.font);
 		ert_comp.contents.erase();
 	}
 	if (set_inactive) {
 		ert_comp.active = false;
 	}
 }
+#endif
 
 
 bool
 Buffer::parseSingleLyXformat2Token(LyXLex & lex, Paragraph *& par,
 				   Paragraph *& first_par,
 				   string const & token, int & pos,
-				   Paragraph::depth_type & depth, 
+				   Paragraph::depth_type & depth,
 				   LyXFont & font
 	)
 {
 	bool the_end_read = false;
+#ifndef NO_COMPABILITY
 #ifndef NO_PEXTRA_REALLY
 	// This is super temporary but is needed to get the compability
 	// mode for minipages work correctly together with new tabulars.
 	static int call_depth;
 	++call_depth;
 	bool checkminipage = false;
-	static Paragraph * minipar;
+	static Paragraph * minipar = 0;
 	static Paragraph * parBeforeMinipage;
 #endif
-	
+#endif
 	if (token[0] != '\\') {
-#ifdef NO_LATEX
+#ifndef NO_COMPABILITY
 		if (ert_comp.active) {
 			ert_comp.contents += token;
 		} else {
@@ -428,8 +449,7 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, Paragraph *& par,
 			par->insertChar(pos, (*cit), font);
 			++pos;
 		}
-		checkminipage = true;
-#ifdef NO_LATEX
+#ifndef NO_COMPABILITY
 		}
 #endif
 	} else if (token == "\\i") {
@@ -438,20 +458,34 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, Paragraph *& par,
 		par->insertInset(pos, inset, font);
 		++pos;
 	} else if (token == "\\layout") {
-#ifdef NO_LATEX
+#ifndef NO_COMPABILITY
 		ert_comp.in_tabular = false;
 		// Do the insetert.
-		insertErtContents(par, pos, font);
+		insertErtContents(par, pos);
 #endif
-                lex.EatLine();
-                string const layoutname = lex.GetString();
-                pair<bool, LyXTextClass::LayoutList::size_type> pp
-                        = textclasslist.NumberOfLayout(params.textclass,
-                                                       layoutname);
+		lex.eatLine();
+		string layoutname = lex.getString();
+
+		LyXTextClass const & tclass = textclasslist[params.textclass];
+
+		if (layoutname.empty()) {
+			layoutname = tclass.defaultLayoutName();
+		}
+
+		bool hasLayout = tclass.hasLayout(layoutname);
+		if (!hasLayout) {
+			lyxerr << "Layout '" << layoutname << "' does not"
+			       << " exist in textclass '" << tclass.name()
+			       << "'." << endl;
+			lyxerr << "Trying to use default layout instead."
+			       << endl;
+			layoutname = tclass.defaultLayoutName();
+		}
 
-#ifdef NO_LATEX
+#ifndef NO_COMPABILITY
 		if (compare_no_case(layoutname, "latex") == 0) {
 			ert_comp.active = true;
+			ert_comp.font = font;
 		}
 #endif
 #ifdef USE_CAPTION
@@ -462,7 +496,7 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, Paragraph *& par,
 			// really inside a InsetText inside a InsetFloat.
 			// We also know that captions can only be
 			// one paragraph. (Lgb)
-			
+
 			// We should now read until the next "\layout"
 			// is reached.
 			// This is probably not good enough, what if the
@@ -487,14 +521,14 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, Paragraph *& par,
 						break;
 					}
 				}
-				
+
 				ss << line << '\n';
 			}
 			// Now we should have the whole layout in ss
 			// we should now be able to give this to the
 			// caption inset.
 			ss << "\\end_inset\n";
-			
+
 			// This seems like a bug in stringstream.
 			// We really should be able to use ss
 			// directly. (Lgb)
@@ -511,94 +545,92 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, Paragraph *& par,
 				first_par = par;
 			else {
 				par = new Paragraph(par);
+				par->layout(textclasslist[params.textclass].defaultLayoutName());
 			}
 			pos = 0;
-			if (pp.first) {
-				par->layout = pp.second;
-			} else {
-				// layout not found
-				// use default layout "Standard" (0)
-				par->layout = 0;
-				++unknown_layouts;
-				string const s = _("Layout had to be changed from\n")
-					+ layoutname + _(" to ")
-					+ textclasslist.NameOfLayout(params.textclass, par->layout);
-				InsetError * new_inset = new InsetError(s);
-				par->insertInset(0, new_inset);
-			}
+			par->layout(layoutname);
 			// Test whether the layout is obsolete.
 			LyXLayout const & layout =
-				textclasslist.Style(params.textclass,
-						    par->layout);
+				textclasslist[params.textclass][par->layout()];
 			if (!layout.obsoleted_by().empty())
-				par->layout = textclasslist
-					.NumberOfLayout(params.textclass,
-							layout.obsoleted_by())
-					.second;
+				par->layout(layout.obsoleted_by());
 			par->params().depth(depth);
 			font = LyXFont(LyXFont::ALL_INHERIT, params.language);
 			if (file_format < 216
 			    && params.language->lang() == "hebrew")
 				font.setLanguage(default_language);
 #if USE_CAPTION
-                }
+		}
 #endif
 
+#ifndef NO_COMPABILITY
 	} else if (token == "\\begin_float") {
+		insertErtContents(par, pos);
+		//insertErtContents(par, pos, false);
+		//ert_stack.push(ert_comp);
+		//ert_comp = ErtComp();
+
 		// This is the compability reader. It can be removed in
 		// LyX version 1.3.0. (Lgb)
 		lex.next();
-		string const tmptok = lex.GetString();
+		string const tmptok = lex.getString();
 		//lyxerr << "old float: " << tmptok << endl;
-		
+
 		Inset * inset = 0;
 		stringstream old_float;
-		
+
 		if (tmptok == "footnote") {
-			inset = new InsetFoot;
+			inset = new InsetFoot(params);
+			old_float << "collapsed true\n";
 		} else if (tmptok == "margin") {
-			inset = new InsetMarginal;
+			inset = new InsetMarginal(params);
+			old_float << "collapsed true\n";
 		} else if (tmptok == "fig") {
-			inset = new InsetFloat("figure");
+			inset = new InsetFloat(params, "figure");
 			old_float << "placement htbp\n"
-				  << "wide false\n";
+				  << "wide false\n"
+				  << "collapsed false\n";
 		} else if (tmptok == "tab") {
-			inset = new InsetFloat("table");
+			inset = new InsetFloat(params, "table");
 			old_float << "placement htbp\n"
-				  << "wide false\n";
+				  << "wide false\n"
+				  << "collapsed false\n";
 		} else if (tmptok == "alg") {
-			inset = new InsetFloat("algorithm");
+			inset = new InsetFloat(params, "algorithm");
 			old_float << "placement htbp\n"
-				  << "wide false\n";
+				  << "wide false\n"
+				  << "collapsed false\n";
 		} else if (tmptok == "wide-fig") {
-			inset = new InsetFloat("figure");
+			inset = new InsetFloat(params, "figure");
 			//InsetFloat * tmp = new InsetFloat("figure");
 			//tmp->wide(true);
 			//inset = tmp;
 			old_float << "placement htbp\n"
-				  << "wide true\n";
+				  << "wide true\n"
+				  << "collapsed false\n";
 		} else if (tmptok == "wide-tab") {
-			inset = new InsetFloat("table");
+			inset = new InsetFloat(params, "table");
 			//InsetFloat * tmp = new InsetFloat("table");
 			//tmp->wide(true);
 			//inset = tmp;
 			old_float << "placement htbp\n"
-				  << "wide true\n";
+				  << "wide true\n"
+				  << "collapsed false\n";
 		}
 
 		if (!inset) {
+#ifndef NO_PEXTRA_REALLY
 			--call_depth;
+#endif
 			return false; // no end read yet
 		}
-		
-		old_float << "collapsed true\n";
 
 		// Here we need to check for \end_deeper and handle that
 		// before we do the footnote parsing.
 		// This _is_ a hack! (Lgb)
 		while (true) {
 			lex.next();
-			string const tmp = lex.GetString();
+			string const tmp = lex.getString();
 			if (tmp == "\\end_deeper") {
 				//lyxerr << "\\end_deeper caught!" << endl;
 				if (!depth) {
@@ -606,13 +638,13 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, Paragraph *& par,
 						       "depth is already null");
 				} else
 					--depth;
-				
+
 			} else {
 				old_float << tmp << ' ';
 				break;
 			}
 		}
-		
+
 		old_float << lex.getLongString("\\end_float")
 			  << "\n\\end_inset\n";
 		//lyxerr << "Float Body:\n" << old_float.str() << endl;
@@ -624,6 +656,8 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, Paragraph *& par,
 		inset->read(this, nylex);
 		par->insertInset(pos, inset, font);
 		++pos;
+		insertErtContents(par, pos);
+#endif
 	} else if (token == "\\begin_deeper") {
 		++depth;
 	} else if (token == "\\end_deeper") {
@@ -636,45 +670,45 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, Paragraph *& par,
 	} else if (token == "\\begin_preamble") {
 		params.readPreamble(lex);
 	} else if (token == "\\textclass") {
-		lex.EatLine();
-		pair<bool, LyXTextClassList::size_type> pp = 
-			textclasslist.NumberOfClass(lex.GetString());
+		lex.eatLine();
+		pair<bool, textclass_type> pp =
+			textclasslist.NumberOfClass(lex.getString());
 		if (pp.first) {
 			params.textclass = pp.second;
 		} else {
-			WriteAlert(string(_("Textclass error")), 
-				string(_("The document uses an unknown textclass \"")) + 
-				lex.GetString() + string("\"."),
+			Alert::alert(string(_("Textclass error")),
+				string(_("The document uses an unknown textclass \"")) +
+				lex.getString() + string("\"."),
 				string(_("LyX will not be able to produce output correctly.")));
 			params.textclass = 0;
 		}
-		if (!textclasslist.Load(params.textclass)) {
-				// if the textclass wasn't loaded properly
-				// we need to either substitute another
-				// or stop loading the file.
-				// I can substitute but I don't see how I can
-				// stop loading... ideas??  ARRae980418
-			WriteAlert(_("Textclass Loading Error!"),
+		if (!textclasslist[params.textclass].load()) {
+			// if the textclass wasn't loaded properly
+			// we need to either substitute another
+			// or stop loading the file.
+			// I can substitute but I don't see how I can
+			// stop loading... ideas??  ARRae980418
+			Alert::alert(_("Textclass Loading Error!"),
 				   string(_("Can't load textclass ")) +
-				   textclasslist.NameOfClass(params.textclass),
+				   textclasslist[params.textclass].name(),
 				   _("-- substituting default"));
 			params.textclass = 0;
 		}
 	} else if (token == "\\options") {
-		lex.EatLine();
-		params.options = lex.GetString();
+		lex.eatLine();
+		params.options = lex.getString();
 	} else if (token == "\\language") {
-		params.readLanguage(lex);    
+		params.readLanguage(lex);
 	} else if (token == "\\fontencoding") {
-		lex.EatLine();
+		lex.eatLine();
 	} else if (token == "\\inputencoding") {
-		lex.EatLine();
-		params.inputenc = lex.GetString();
+		lex.eatLine();
+		params.inputenc = lex.getString();
 	} else if (token == "\\graphics") {
 		params.readGraphicsDriver(lex);
 	} else if (token == "\\fontscheme") {
-		lex.EatLine();
-		params.fonts = lex.GetString();
+		lex.eatLine();
+		params.fonts = lex.getString();
 	} else if (token == "\\noindent") {
 		par->params().noindent(true);
 	} else if (token == "\\fill_top") {
@@ -692,24 +726,28 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, Paragraph *& par,
 	} else if (token == "\\start_of_appendix") {
 		par->params().startOfAppendix(true);
 	} else if (token == "\\paragraph_separation") {
-		int tmpret = lex.FindToken(string_paragraph_separation);
-		if (tmpret == -1) ++tmpret;
-		if (tmpret != LYX_LAYOUT_DEFAULT) 
+		int tmpret = lex.findToken(string_paragraph_separation);
+		if (tmpret == -1)
+			++tmpret;
+		if (tmpret != LYX_LAYOUT_DEFAULT)
 			params.paragraph_separation =
 				static_cast<BufferParams::PARSEP>(tmpret);
 	} else if (token == "\\defskip") {
 		lex.nextToken();
-		params.defskip = VSpace(lex.GetString());
+		params.defskip = VSpace(lex.getString());
+#ifndef NO_COMPABILITY
 	} else if (token == "\\epsfig") { // obsolete
 		// Indeed it is obsolete, but we HAVE to be backwards
 		// compatible until 0.14, because otherwise all figures
 		// in existing documents are irretrivably lost. (Asger)
 		params.readGraphicsDriver(lex);
+#endif
 	} else if (token == "\\quotes_language") {
-		int tmpret = lex.FindToken(string_quotes_language);
-		if (tmpret == -1) ++tmpret;
+		int tmpret = lex.findToken(string_quotes_language);
+		if (tmpret == -1)
+			++tmpret;
 		if (tmpret != LYX_LAYOUT_DEFAULT) {
-			InsetQuotes::quote_language tmpl = 
+			InsetQuotes::quote_language tmpl =
 				InsetQuotes::EnglishQ;
 			switch (tmpret) {
 			case 0:
@@ -729,28 +767,28 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, Paragraph *& par,
 				break;
 			case 5:
 				tmpl = InsetQuotes::DanishQ;
-				break;	
+				break;
 			}
 			params.quotes_language = tmpl;
 		}
 	} else if (token == "\\quotes_times") {
 		lex.nextToken();
-		switch (lex.GetInteger()) {
-		case 1: 
-			params.quotes_times = InsetQuotes::SingleQ; 
+		switch (lex.getInteger()) {
+		case 1:
+			params.quotes_times = InsetQuotes::SingleQ;
 			break;
-		case 2: 
-			params.quotes_times = InsetQuotes::DoubleQ; 
+		case 2:
+			params.quotes_times = InsetQuotes::DoubleQ;
 			break;
 		}
 	} else if (token == "\\papersize") {
-		int tmpret = lex.FindToken(string_papersize);
+		int tmpret = lex.findToken(string_papersize);
 		if (tmpret == -1)
 			++tmpret;
 		else
 			params.papersize2 = tmpret;
 	} else if (token == "\\paperpackage") {
-		int tmpret = lex.FindToken(string_paperpackages);
+		int tmpret = lex.findToken(string_paperpackages);
 		if (tmpret == -1) {
 			++tmpret;
 			params.paperpackage = BufferParams::PACKAGE_NONE;
@@ -758,81 +796,82 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, Paragraph *& par,
 			params.paperpackage = tmpret;
 	} else if (token == "\\use_geometry") {
 		lex.nextToken();
-		params.use_geometry = lex.GetInteger();
+		params.use_geometry = lex.getInteger();
 	} else if (token == "\\use_amsmath") {
 		lex.nextToken();
-		params.use_amsmath = lex.GetInteger();
+		params.use_amsmath = lex.getInteger();
 	} else if (token == "\\use_natbib") {
 		lex.nextToken();
-		params.use_natbib = lex.GetInteger();
+		params.use_natbib = lex.getInteger();
 	} else if (token == "\\use_numerical_citations") {
 		lex.nextToken();
-		params.use_numerical_citations = lex.GetInteger();
+		params.use_numerical_citations = lex.getInteger();
 	} else if (token == "\\paperorientation") {
-		int tmpret = lex.FindToken(string_orientation);
-		if (tmpret == -1) ++tmpret;
-		if (tmpret != LYX_LAYOUT_DEFAULT) 
+		int tmpret = lex.findToken(string_orientation);
+		if (tmpret == -1)
+			++tmpret;
+		if (tmpret != LYX_LAYOUT_DEFAULT)
 			params.orientation = static_cast<BufferParams::PAPER_ORIENTATION>(tmpret);
 	} else if (token == "\\paperwidth") {
 		lex.next();
-		params.paperwidth = lex.GetString();
+		params.paperwidth = lex.getString();
 	} else if (token == "\\paperheight") {
 		lex.next();
-		params.paperheight = lex.GetString();
+		params.paperheight = lex.getString();
 	} else if (token == "\\leftmargin") {
 		lex.next();
-		params.leftmargin = lex.GetString();
+		params.leftmargin = lex.getString();
 	} else if (token == "\\topmargin") {
 		lex.next();
-		params.topmargin = lex.GetString();
+		params.topmargin = lex.getString();
 	} else if (token == "\\rightmargin") {
 		lex.next();
-		params.rightmargin = lex.GetString();
+		params.rightmargin = lex.getString();
 	} else if (token == "\\bottommargin") {
 		lex.next();
-		params.bottommargin = lex.GetString();
+		params.bottommargin = lex.getString();
 	} else if (token == "\\headheight") {
 		lex.next();
-		params.headheight = lex.GetString();
+		params.headheight = lex.getString();
 	} else if (token == "\\headsep") {
 		lex.next();
-		params.headsep = lex.GetString();
+		params.headsep = lex.getString();
 	} else if (token == "\\footskip") {
 		lex.next();
-		params.footskip = lex.GetString();
+		params.footskip = lex.getString();
 	} else if (token == "\\paperfontsize") {
 		lex.nextToken();
-		params.fontsize = strip(lex.GetString());
+		params.fontsize = strip(lex.getString());
 	} else if (token == "\\papercolumns") {
 		lex.nextToken();
-		params.columns = lex.GetInteger();
+		params.columns = lex.getInteger();
 	} else if (token == "\\papersides") {
 		lex.nextToken();
-		switch (lex.GetInteger()) {
+		switch (lex.getInteger()) {
 		default:
 		case 1: params.sides = LyXTextClass::OneSide; break;
 		case 2: params.sides = LyXTextClass::TwoSides; break;
 		}
 	} else if (token == "\\paperpagestyle") {
 		lex.nextToken();
-		params.pagestyle = strip(lex.GetString());
+		params.pagestyle = strip(lex.getString());
 	} else if (token == "\\bullet") {
 		lex.nextToken();
-		int const index = lex.GetInteger();
+		int const index = lex.getInteger();
 		lex.nextToken();
-		int temp_int = lex.GetInteger();
+		int temp_int = lex.getInteger();
 		params.user_defined_bullets[index].setFont(temp_int);
 		params.temp_bullets[index].setFont(temp_int);
 		lex.nextToken();
-		temp_int = lex.GetInteger();
+		temp_int = lex.getInteger();
 		params.user_defined_bullets[index].setCharacter(temp_int);
 		params.temp_bullets[index].setCharacter(temp_int);
 		lex.nextToken();
-		temp_int = lex.GetInteger();
+		temp_int = lex.getInteger();
 		params.user_defined_bullets[index].setSize(temp_int);
 		params.temp_bullets[index].setSize(temp_int);
 		lex.nextToken();
-		string const temp_str = lex.GetString();
+		string const temp_str = lex.getString();
 		if (temp_str != "\\end_bullet") {
 				// this element isn't really necessary for
 				// parsing but is easier for humans
@@ -842,10 +881,11 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, Paragraph *& par,
 				//how can I put it back?
 		}
 	} else if (token == "\\bulletLaTeX") {
+		// The bullet class should be able to read this.
 		lex.nextToken();
-		int const index = lex.GetInteger();
+		int const index = lex.getInteger();
 		lex.next();
-		string temp_str = lex.GetString();
+		string temp_str = lex.getString();
 		string sum_str;
 		while (temp_str != "\\end_bullet") {
 				// this loop structure is needed when user
@@ -856,19 +896,20 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, Paragraph *& par,
 				// therefore needs to be read in turn
 			sum_str += temp_str;
 			lex.next();
-			temp_str = lex.GetString();
+			temp_str = lex.getString();
 		}
+
 		params.user_defined_bullets[index].setText(sum_str);
 		params.temp_bullets[index].setText(sum_str);
 	} else if (token == "\\secnumdepth") {
 		lex.nextToken();
-		params.secnumdepth = lex.GetInteger();
+		params.secnumdepth = lex.getInteger();
 	} else if (token == "\\tocdepth") {
 		lex.nextToken();
-		params.tocdepth = lex.GetInteger();
+		params.tocdepth = lex.getInteger();
 	} else if (token == "\\spacing") {
 		lex.next();
-		string const tmp = strip(lex.GetString());
+		string const tmp = strip(lex.getString());
 		Spacing::Space tmp_space = Spacing::Default;
 		float tmp_val = 0.0;
 		if (tmp == "single") {
@@ -880,7 +921,7 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, Paragraph *& par,
 		} else if (tmp == "other") {
 			lex.next();
 			tmp_space = Spacing::Other;
-			tmp_val = lex.GetFloat();
+			tmp_val = lex.getFloat();
 		} else {
 			lex.printError("Unknown spacing token: '$$Token'");
 		}
@@ -893,7 +934,7 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, Paragraph *& par,
 		}
 	} else if (token == "\\paragraph_spacing") {
 		lex.next();
-		string const tmp = strip(lex.GetString());
+		string const tmp = strip(lex.getString());
 		if (tmp == "single") {
 			par->params().spacing(Spacing(Spacing::Single));
 		} else if (tmp == "onehalf") {
@@ -903,54 +944,38 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, Paragraph *& par,
 		} else if (tmp == "other") {
 			lex.next();
 			par->params().spacing(Spacing(Spacing::Other,
-					 lex.GetFloat()));
+					 lex.getFloat()));
 		} else {
 			lex.printError("Unknown spacing token: '$$Token'");
 		}
 	} else if (token == "\\float_placement") {
 		lex.nextToken();
-		params.float_placement = lex.GetString();
-	} else if (token == "\\family") { 
+		params.float_placement = lex.getString();
+	} else if (token == "\\family") {
 		lex.next();
-		font.setLyXFamily(lex.GetString());
+		font.setLyXFamily(lex.getString());
 	} else if (token == "\\series") {
 		lex.next();
-		font.setLyXSeries(lex.GetString());
+		font.setLyXSeries(lex.getString());
 	} else if (token == "\\shape") {
 		lex.next();
-		font.setLyXShape(lex.GetString());
+		font.setLyXShape(lex.getString());
 	} else if (token == "\\size") {
 		lex.next();
-		font.setLyXSize(lex.GetString());
-#ifndef NO_LATEX
-#ifdef WITH_WARNINGS
-#warning compatability hack needed
-#endif
-	} else if (token == "\\latex") {
-		lex.next();
-		string const tok = lex.GetString();
-		// This is dirty, but gone with LyX3. (Asger)
-		if (tok == "no_latex")
-			font.setLatex(LyXFont::OFF);
-		else if (tok == "latex")
-			font.setLatex(LyXFont::ON);
-		else if (tok == "default")
-			font.setLatex(LyXFont::INHERIT);
-		else
-			lex.printError("Unknown LaTeX font flag "
-				       "`$$Token'");
-#else
+		font.setLyXSize(lex.getString());
+#ifndef NO_COMPABILITY
 	} else if (token == "\\latex") {
 		lex.next();
-		string const tok = lex.GetString();
+		string const tok = lex.getString();
 		if (tok == "no_latex") {
 			// Do the insetert.
-			insertErtContents(par, pos, font);
+			insertErtContents(par, pos);
 		} else if (tok == "latex") {
 			ert_comp.active = true;
+			ert_comp.font = font;
 		} else if (tok == "default") {
 			// Do the insetert.
-			insertErtContents(par, pos, font);
+			insertErtContents(par, pos);
 		} else {
 			lex.printError("Unknown LaTeX font flag "
 				       "`$$Token'");
@@ -958,7 +983,7 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, Paragraph *& par,
 #endif
 	} else if (token == "\\lang") {
 		lex.next();
-		string const tok = lex.GetString();
+		string const tok = lex.getString();
 		Language const * lang = languages.getLanguage(tok);
 		if (lang) {
 			font.setLanguage(lang);
@@ -968,13 +993,13 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, Paragraph *& par,
 		}
 	} else if (token == "\\numeric") {
 		lex.next();
-		font.setNumber(font.setLyXMisc(lex.GetString()));
+		font.setNumber(font.setLyXMisc(lex.getString()));
 	} else if (token == "\\emph") {
 		lex.next();
-		font.setEmph(font.setLyXMisc(lex.GetString()));
+		font.setEmph(font.setLyXMisc(lex.getString()));
 	} else if (token == "\\bar") {
 		lex.next();
-		string const tok = lex.GetString();
+		string const tok = lex.getString();
 		// This is dirty, but gone with LyX3. (Asger)
 		if (tok == "under")
 			font.setUnderbar(LyXFont::ON);
@@ -987,12 +1012,12 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, Paragraph *& par,
 				       "`$$Token'");
 	} else if (token == "\\noun") {
 		lex.next();
-		font.setNoun(font.setLyXMisc(lex.GetString()));
+		font.setNoun(font.setLyXMisc(lex.getString()));
 	} else if (token == "\\color") {
 		lex.next();
-		font.setLyXColor(lex.GetString());
+		font.setLyXColor(lex.getString());
 	} else if (token == "\\align") {
-		int tmpret = lex.FindToken(string_align);
+		int tmpret = lex.findToken(string_align);
 		if (tmpret == -1) ++tmpret;
 		if (tmpret != LYX_LAYOUT_DEFAULT) { // tmpret != 99 ???
 			int const tmpret2 = int(pow(2.0, tmpret));
@@ -1001,33 +1026,41 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, Paragraph *& par,
 		}
 	} else if (token == "\\added_space_top") {
 		lex.nextToken();
-		par->params().spaceTop(VSpace(lex.GetString()));
+		VSpace value = VSpace(lex.getString());
+		if ((value.length().len().value() != 0) ||
+		    (value.kind() != VSpace::LENGTH))
+		    par->params().spaceTop(value);
 	} else if (token == "\\added_space_bottom") {
 		lex.nextToken();
-		par->params().spaceBottom(VSpace(lex.GetString()));
+		VSpace value = VSpace(lex.getString());
+		if ((value.length().len().value() != 0) ||
+		    (value.kind() != VSpace::LENGTH))
+		    par->params().spaceBottom(value);
+#ifndef NO_COMPABILITY
 #ifndef NO_PEXTRA_REALLY
 	} else if (token == "\\pextra_type") {
 		lex.nextToken();
-		par->params().pextraType(lex.GetInteger());
+		par->params().pextraType(lex.getInteger());
 	} else if (token == "\\pextra_width") {
 		lex.nextToken();
-		par->params().pextraWidth(lex.GetString());
+		par->params().pextraWidth(lex.getString());
 	} else if (token == "\\pextra_widthp") {
 		lex.nextToken();
-		par->params().pextraWidthp(lex.GetString());
+		par->params().pextraWidthp(lex.getString());
 	} else if (token == "\\pextra_alignment") {
 		lex.nextToken();
-		par->params().pextraAlignment(lex.GetInteger());
+		par->params().pextraAlignment(lex.getInteger());
 	} else if (token == "\\pextra_hfill") {
 		lex.nextToken();
-		par->params().pextraHfill(lex.GetInteger());
+		par->params().pextraHfill(lex.getInteger());
 	} else if (token == "\\pextra_start_minipage") {
 		lex.nextToken();
-		par->params().pextraStartMinipage(lex.GetInteger());
+		par->params().pextraStartMinipage(lex.getInteger());
+#endif
 #endif
 	} else if (token == "\\labelwidthstring") {
-		lex.EatLine();
-		par->params().labelWidthString(lex.GetString());
+		lex.eatLine();
+		par->params().labelWidthString(lex.getString());
 		// do not delete this token, it is still needed!
 	} else if (token == "\\end_inset") {
 		lyxerr << "Solitary \\end_inset. Missing \\begin_inset?.\n"
@@ -1038,26 +1071,26 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, Paragraph *& par,
 		// But insets should read it, it is a part of
 		// the inset isn't it? Lgb.
 	} else if (token == "\\begin_inset") {
-#ifdef NO_LATEX
-		insertErtContents(par, pos, font, false);
+#ifndef NO_COMPABILITY
+		insertErtContents(par, pos, false);
 		ert_stack.push(ert_comp);
 		ert_comp = ErtComp();
 #endif
 		readInset(lex, par, pos, font);
-#ifdef NO_LATEX
+#ifndef NO_COMPABILITY
 		ert_comp = ert_stack.top();
 		ert_stack.pop();
+		insertErtContents(par, pos);
 #endif
 	} else if (token == "\\SpecialChar") {
 		LyXLayout const & layout =
-			textclasslist.Style(params.textclass, 
-					    par->getLayout());
+			textclasslist[params.textclass][par->layout()];
 
 		// Insets don't make sense in a free-spacing context! ---Kayvan
-		if (layout.free_spacing) {
-			if (lex.IsOK()) {
+		if (layout.free_spacing || par->isFreeSpacing()) {
+			if (lex.isOK()) {
 				lex.next();
-				string next_token = lex.GetString();
+				string next_token = lex.getString();
 				if (next_token == "\\-") {
 					par->insertChar(pos, '-', font);
 				} else if (next_token == "\\protected_separator"
@@ -1077,15 +1110,14 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, Paragraph *& par,
 		}
 		++pos;
 	} else if (token == "\\newline") {
-#ifdef NO_LATEX
-
+#ifndef NO_COMPABILITY
 		if (!ert_comp.in_tabular && ert_comp.active) {
 			ert_comp.contents += char(Paragraph::META_NEWLINE);
 		} else {
 			// Since we cannot know it this is only a regular
 			// newline or a tabular cell delimter we have to
 			// handle the ERT here.
-			insertErtContents(par, pos, font, false);
+			insertErtContents(par, pos, false);
 
 			par->insertChar(pos, Paragraph::META_NEWLINE, font);
 			++pos;
@@ -1095,16 +1127,13 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, Paragraph *& par,
 		++pos;
 #endif
 	} else if (token == "\\LyXTable") {
-#ifdef NO_LATEX
+#ifndef NO_COMPABILITY
 		ert_comp.in_tabular = true;
 #endif
 		Inset * inset = new InsetTabular(*this);
 		inset->read(this, lex);
 		par->insertInset(pos, inset, font);
 		++pos;
-		// because of OLD_TABULAR_READ where tabulars have been
-		// one paragraph.
-		checkminipage = true;
 	} else if (token == "\\hfill") {
 		par->insertChar(pos, Paragraph::META_HFILL, font);
 		++pos;
@@ -1113,10 +1142,9 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, Paragraph *& par,
 		// Remove it later some time...introduced with fileformat
 		// 2.16. (Lgb)
 		LyXLayout const & layout =
-			textclasslist.Style(params.textclass, 
-					    par->getLayout());
+			textclasslist[params.textclass][par->layout()];
 
-		if (layout.free_spacing) {
+		if (layout.free_spacing || par->isFreeSpacing()) {
 			par->insertChar(pos, ' ', font);
 		} else {
 			Inset * inset = new InsetSpecialChar(InsetSpecialChar::PROTECTED_SEPARATOR);
@@ -1128,46 +1156,66 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, Paragraph *& par,
 			InsetCommandParams p("bibitem", "dummy");
 			par->bibkey = new InsetBibKey(p);
 		}
-		par->bibkey->read(this, lex);		        
+		par->bibkey->read(this, lex);
 	} else if (token == "\\backslash") {
-#ifdef NO_LATEX
+#ifndef NO_COMPABILITY
 		if (ert_comp.active) {
 			ert_comp.contents += "\\";
 		} else {
 #endif
 		par->insertChar(pos, '\\', font);
 		++pos;
-#ifdef NO_LATEX
+#ifndef NO_COMPABILITY
 		}
 #endif
 	} else if (token == "\\the_end") {
-#ifdef NO_LATEX
+#ifndef NO_COMPABILITY
 		// If we still have some ert active here we have to insert
 		// it so we don't loose it. (Lgb)
-		insertErtContents(par, pos, font);
+		insertErtContents(par, pos);
 #endif
 		the_end_read = true;
+#ifndef NO_COMPABILITY
+#ifndef NO_PEXTRA_REALLY
+		if (minipar == par)
+			par = 0;
 		minipar = parBeforeMinipage = 0;
+#endif
+#endif
 	} else {
-#ifdef NO_LATEX
+#ifndef NO_COMPABILITY
 		if (ert_comp.active) {
 			ert_comp.contents += token;
 		} else {
 #endif
 		// This should be insurance for the future: (Asger)
-		lex.printError("Unknown token `$$Token'. "
-			       "Inserting as text.");
-		string::const_iterator cit = token.begin();
-		string::const_iterator end = token.end();
-		for (; cit != end; ++cit) {
-			par->insertChar(pos, (*cit), font);
-			++pos;
-		}
-#ifdef NO_LATEX
+		++unknown_tokens;
+		lex.eatLine();
+		string const s = _("Unknown token: ") + token
+			+ " " + lex.text()  + "\n";
+		// we can do this here this way because we're actually reading
+		// the buffer and don't care about LyXText right now.
+		InsetError * new_inset = new InsetError(s);
+		par->insertInset(pos, new_inset, LyXFont(LyXFont::ALL_INHERIT,
+				 params.language));
+
+#ifndef NO_COMPABILITY
 		}
 #endif
 	}
+
+#ifndef NO_COMPABILITY
 #ifndef NO_PEXTRA_REALLY
+	// I wonder if we could use this blanket fix for all the
+	// checkminipage cases...
+	// don't forget about ert paragraphs and compatibility read for'em
+	if (par && (par->size() || !ert_comp.contents.empty())) {
+		// It is possible that this will check to often,
+		// but that should not be an correctness issue.
+		// Only a speed issue.
+		checkminipage = true;
+	}
+
 	// now check if we have a minipage paragraph as at this
 	// point we already read all the necessary data!
 	// this cannot be done in layout because there we did
@@ -1175,7 +1223,8 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, Paragraph *& par,
 	//
 	// BEGIN pextra_minipage compability
 	// This should be removed in 1.3.x (Lgb)
-	
+	// I don't think we should remove this so fast (Jug)
+
 	// This compability code is not perfect. In a couple
 	// of rand cases it fails. When the minipage par is
 	// the first par in the document, and when there are
@@ -1187,7 +1236,7 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, Paragraph *& par,
 	if (checkminipage && (call_depth == 1)) {
 	checkminipage = false;
 	if (minipar && (minipar != par) &&
-	    (par->params().pextraType()==Paragraph::PEXTRA_MINIPAGE))
+	    (par->params().pextraType() == Paragraph::PEXTRA_MINIPAGE))
 	{
 		lyxerr << "minipages in a row" << endl;
 		if (par->params().pextraStartMinipage()) {
@@ -1195,7 +1244,7 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, Paragraph *& par,
 			// minipages in a row
 			par->previous()->next(0);
 			par->previous(0);
-				
+
 			Paragraph * tmp = minipar;
 			while (tmp) {
 				tmp->params().pextraType(0);
@@ -1209,24 +1258,33 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, Paragraph *& par,
 			// create a new paragraph to insert the
 			// minipages in the following case
 			if (par->params().pextraStartMinipage() &&
-			    !par->params().pextraHfill())
-			{
+			    !par->params().pextraHfill()) {
 				Paragraph * p = new Paragraph;
-				p->layout = 0;
+				p->layout(textclasslist[params.textclass].defaultLayoutName());
+
 				p->previous(parBeforeMinipage);
 				parBeforeMinipage->next(p);
 				p->next(0);
 				p->params().depth(parBeforeMinipage->params().depth());
 				parBeforeMinipage = p;
 			}
-			InsetMinipage * mini = new InsetMinipage;
+			InsetMinipage * mini = new InsetMinipage(params);
 			mini->pos(static_cast<InsetMinipage::Position>(par->params().pextraAlignment()));
-			mini->width(par->params().pextraWidth());
+			mini->pageWidth(LyXLength(par->params().pextraWidth()));
 			if (!par->params().pextraWidthp().empty()) {
-			    lyxerr << "WP:" << mini->width() << endl;
-			    mini->width(tostr(par->params().pextraWidthp())+"%");
+			    lyxerr << "WP:" << mini->pageWidth().asString() << endl;
+			    mini->pageWidth(LyXLength((par->params().pextraWidthp())+"p%"));
 			}
+			Paragraph * op = mini->firstParagraph();
 			mini->inset.paragraph(par);
+			//
+			// and free the old ones!
+			//
+			while(op) {
+				Paragraph * pp = op->next();
+				delete op;
+				op = pp;
+			}
 			// Insert the minipage last in the
 			// previous paragraph.
 			if (par->params().pextraHfill()) {
@@ -1235,13 +1293,13 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, Paragraph *& par,
 			}
 			parBeforeMinipage->insertInset
 				(parBeforeMinipage->size(), mini);
-				
+
 			minipar = par;
 		} else {
 			lyxerr << "new minipage par" << endl;
 			//nothing to do just continue reading
 		}
-			
+
 	} else if (minipar && (minipar != par)) {
 		lyxerr << "last minipage par read" << endl;
 		// The last paragraph read was not part of a
@@ -1263,6 +1321,8 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, Paragraph *& par,
 			tmp = tmp->next();
 		}
 		depth = parBeforeMinipage->params().depth();
+		// and set this depth on the par as it has not been set already
+		par->params().depth(depth);
 		minipar = parBeforeMinipage = 0;
 	} else if (!minipar &&
 		   (par->params().pextraType() == Paragraph::PEXTRA_MINIPAGE))
@@ -1275,7 +1335,7 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, Paragraph *& par,
 		// a sequence of minipages
 		// in its own paragraph.
 		Paragraph * p = new Paragraph;
-		p->layout = 0;
+		p->layout(textclasslist[params.textclass].defaultLayoutName());
 		p->previous(par->previous());
 		p->next(0);
 		p->params().depth(depth);
@@ -1289,15 +1349,25 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, Paragraph *& par,
 		if (!first_par || (first_par == par))
 			first_par = p;
 
-		InsetMinipage * mini = new InsetMinipage;
+		InsetMinipage * mini = new InsetMinipage(params);
 		mini->pos(static_cast<InsetMinipage::Position>(minipar->params().pextraAlignment()));
-		mini->width(minipar->params().pextraWidth());
+		mini->pageWidth(LyXLength(minipar->params().pextraWidth()));
 		if (!par->params().pextraWidthp().empty()) {
-		    lyxerr << "WP:" << mini->width() << endl;
-		    mini->width(tostr(par->params().pextraWidthp())+"%");
+		    lyxerr << "WP:" << mini->pageWidth().asString() << endl;
+		    mini->pageWidth(LyXLength((par->params().pextraWidthp())+"p%"));
 		}
+
+		Paragraph * op = mini->firstParagraph();
 		mini->inset.paragraph(minipar);
-			
+		//
+		// and free the old ones!
+		//
+		while(op) {
+			Paragraph * pp = op->next();
+			delete op;
+			op = pp;
+		}
+
 		// Insert the minipage last in the
 		// previous paragraph.
 		if (minipar->params().pextraHfill()) {
@@ -1309,25 +1379,82 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, Paragraph *& par,
 	}
 	}
 	// End of pextra_minipage compability
-#endif
 	--call_depth;
+#endif
+#endif
 	return the_end_read;
 }
 
+// needed to insert the selection
+void Buffer::insertStringAsLines(Paragraph *& par, pos_type & pos,
+				 LyXFont const & fn,string const & str) const
+{
+	LyXLayout const & layout =
+		textclasslist[params.textclass][par->layout()];
+	LyXFont font = fn;
+
+	par->checkInsertChar(font);
+	// insert the string, don't insert doublespace
+	bool space_inserted = true;
+	for(string::const_iterator cit = str.begin();
+	    cit != str.end(); ++cit) {
+		if (*cit == '\n') {
+			if (par->size() || layout.keepempty) {
+				par->breakParagraph(params, pos,
+						    layout.isEnvironment());
+				par = par->next();
+				pos = 0;
+				space_inserted = true;
+			} else {
+				continue;
+			}
+			// do not insert consecutive spaces if !free_spacing
+		} else if ((*cit == ' ' || *cit == '\t') &&
+			   space_inserted && !layout.free_spacing &&
+				   !par->isFreeSpacing())
+		{
+			continue;
+		} else if (*cit == '\t') {
+			if (!layout.free_spacing && !par->isFreeSpacing()) {
+				// tabs are like spaces here
+				par->insertChar(pos, ' ', font);
+				++pos;
+				space_inserted = true;
+			} else {
+				const pos_type nb = 8 - pos % 8;
+				for (pos_type a = 0; a < nb ; ++a) {
+					par->insertChar(pos, ' ', font);
+					++pos;
+				}
+				space_inserted = true;
+			}
+		} else if (!IsPrintable(*cit)) {
+			// Ignore unprintables
+			continue;
+		} else {
+			// just insert the character
+			par->insertChar(pos, *cit, font);
+			++pos;
+			space_inserted = (*cit == ' ');
+		}
+
+	}
+}
+
 
 void Buffer::readInset(LyXLex & lex, Paragraph *& par,
 		       int & pos, LyXFont & font)
 {
 	// consistency check
-	if (lex.GetString() != "\\begin_inset") {
+	if (lex.getString() != "\\begin_inset") {
 		lyxerr << "Buffer::readInset: Consistency check failed."
 		       << endl;
 	}
-	
+
 	Inset * inset = 0;
 
 	lex.next();
-	string const tmptok = lex.GetString();
+	string const tmptok = lex.getString();
 	last_inset_read = tmptok;
 
 	// test the different insets
@@ -1336,7 +1463,7 @@ void Buffer::readInset(LyXLex & lex, Paragraph *& par,
 		inscmd.read(lex);
 
 		string const cmdName = inscmd.getCmdName();
-		
+
 		// This strange command allows LyX to recognize "natbib" style
 		// citations: citet, citep, Citet etc.
 		if (compare_no_case(cmdName, "cite", 4) == 0) {
@@ -1378,6 +1505,7 @@ void Buffer::readInset(LyXLex & lex, Paragraph *& par,
 			inset = new InsetParent(inscmd, *this);
 		}
 	} else {
+		bool alreadyread = false;
 		if (tmptok == "Quotes") {
 			inset = new InsetQuotes;
 		} else if (tmptok == "External") {
@@ -1386,44 +1514,52 @@ void Buffer::readInset(LyXLex & lex, Paragraph *& par,
 			inset = new InsetFormulaMacro;
 		} else if (tmptok == "Formula") {
 			inset = new InsetFormula;
-		} else if (tmptok == "Figure") {
-			inset = new InsetFig(100, 100, *this);
-		} else if (tmptok == "Info") {
-			inset = new InsetInfo;
+		} else if (tmptok == "Figure") { // Backward compatibility
+//			inset = new InsetFig(100, 100, *this);
+			inset = new InsetGraphics;
+		} else if (tmptok == "Graphics") {
+			inset = new InsetGraphics;
+		} else if (tmptok == "Info") {// backwards compatibility
+			inset = new InsetNote(this,
+					      lex.getLongString("\\end_inset"),
+					      true);
+			alreadyread = true;
+		} else if (tmptok == "Note") {
+			inset = new InsetNote(params);
 		} else if (tmptok == "Include") {
-			InsetCommandParams p( "Include" );
+			InsetCommandParams p("Include");
 			inset = new InsetInclude(p, *this);
 		} else if (tmptok == "ERT") {
-			inset = new InsetERT;
+			inset = new InsetERT(params);
 		} else if (tmptok == "Tabular") {
 			inset = new InsetTabular(*this);
 		} else if (tmptok == "Text") {
-			inset = new InsetText;
+			inset = new InsetText(params);
 		} else if (tmptok == "Foot") {
-			inset = new InsetFoot;
+			inset = new InsetFoot(params);
 		} else if (tmptok == "Marginal") {
-			inset = new InsetMarginal;
+			inset = new InsetMarginal(params);
 		} else if (tmptok == "Minipage") {
-			inset = new InsetMinipage;
+			inset = new InsetMinipage(params);
 		} else if (tmptok == "Float") {
 			lex.next();
-			string tmptok = lex.GetString();
-			inset = new InsetFloat(tmptok);
+			string tmptok = lex.getString();
+			inset = new InsetFloat(params, tmptok);
+#if 0
 		} else if (tmptok == "List") {
 			inset = new InsetList;
 		} else if (tmptok == "Theorem") {
 			inset = new InsetList;
+#endif
 		} else if (tmptok == "Caption") {
-			inset = new InsetCaption;
-		} else if (tmptok == "GRAPHICS") {
-			inset = new InsetGraphics;
+			inset = new InsetCaption(params);
 		} else if (tmptok == "FloatList") {
 			inset = new InsetFloatList;
 		}
-		
-		if (inset) inset->read(this, lex);
+
+		if (inset && !alreadyread) inset->read(this, lex);
 	}
-	
+
 	if (inset) {
 		par->insertInset(pos, inset, font);
 		++pos;
@@ -1433,12 +1569,12 @@ void Buffer::readInset(LyXLex & lex, Paragraph *& par,
 
 bool Buffer::readFile(LyXLex & lex, Paragraph * par)
 {
-	if (lex.IsOK()) {
+	if (lex.isOK()) {
 		lex.next();
-		string const token(lex.GetString());
+		string const token(lex.getString());
 		if (token == "\\lyxformat") { // the first token _must_ be...
-			lex.EatLine();
-			string tmp_format = lex.GetString();
+			lex.eatLine();
+			string tmp_format = lex.getString();
 			//lyxerr << "LyX Format: `" << tmp_format << "'" << endl;
 			// if present remove ".," from string.
 			string::size_type dot = tmp_format.find_first_of(".,");
@@ -1450,38 +1586,39 @@ bool Buffer::readFile(LyXLex & lex, Paragraph * par)
 				// current format
 			} else if (file_format > LYX_FORMAT) {
 				// future format
-				WriteAlert(_("Warning!"),
+				Alert::alert(_("Warning!"),
 					   _("LyX file format is newer that what"),
 					   _("is supported in this LyX version. Expect some problems."));
-				
+
 			} else if (file_format < LYX_FORMAT) {
 				// old formats
 				if (file_format < 200) {
-					WriteAlert(_("ERROR!"),
+					Alert::alert(_("ERROR!"),
 						   _("Old LyX file format found. "
 						     "Use LyX 0.10.x to read this!"));
 					return false;
 				}
 			}
 			bool the_end = readLyXformat2(lex, par);
-			setPaperStuff();
+			params.setPaperStuff();
 			// the_end was added in 213
 			if (file_format < 213)
 				the_end = true;
 
-			if (!the_end)
-				WriteAlert(_("Warning!"),
+			if (!the_end) {
+				Alert::alert(_("Warning!"),
 					   _("Reading of document is not complete"),
 					   _("Maybe the document is truncated"));
+			}
 			return true;
 		} else { // "\\lyxformat" not found
-			WriteAlert(_("ERROR!"), _("Not a LyX file!"));
+			Alert::alert(_("ERROR!"), _("Not a LyX file!"));
 		}
 	} else
-		WriteAlert(_("ERROR!"), _("Unable to read file!"));
+		Alert::alert(_("ERROR!"), _("Unable to read file!"));
 	return false;
 }
-	    	    
+
 
 // Should probably be moved to somewhere else: BufferView? LyXView?
 bool Buffer::save() const
@@ -1535,7 +1672,7 @@ bool Buffer::save() const
 				ifs.close();
 				ofs.close();
 				::chmod(s.c_str(), fmode);
-				
+
 				if (::utime(s.c_str(), &times)) {
 					lyxerr << "utime error." << endl;
 				}
@@ -1545,7 +1682,7 @@ bool Buffer::save() const
 			}
 		}
 	}
-	
+
 	if (writeFile(fileName(), false)) {
 		markLyxClean();
 		removeAutosaveFile(fileName());
@@ -1567,14 +1704,14 @@ bool Buffer::writeFile(string const & fname, bool flag) const
 	// warnings, only cerr.
 	// Needed for autosave in background or panic save (Matthias 120496)
 
-	if (read_only && (fname == filename)) {
+	if (read_only && (fname == fileName())) {
 		// Here we should come with a question if we should
 		// perform the write anyway.
 		if (flag)
 			lyxerr << _("Error! Document is read-only: ")
 			       << fname << endl;
 		else
-			WriteAlert(_("Error! Document is read-only: "),
+			Alert::alert(_("Error! Document is read-only: "),
 				   fname);
 		return false;
 	}
@@ -1587,7 +1724,7 @@ bool Buffer::writeFile(string const & fname, bool flag) const
 			lyxerr << _("Error! Cannot write file: ")
 			       << fname << endl;
 		else
-			WriteFSAlert(_("Error! Cannot write file: "),
+			Alert::err_alert(_("Error! Cannot write file: "),
 				     fname);
 		return false;
 	}
@@ -1598,7 +1735,7 @@ bool Buffer::writeFile(string const & fname, bool flag) const
 			lyxerr << _("Error! Cannot open file: ")
 			       << fname << endl;
 		else
-			WriteFSAlert(_("Error! Cannot open file: "),
+			Alert::err_alert(_("Error! Cannot open file: "),
 				     fname);
 		return false;
 	}
@@ -1611,7 +1748,7 @@ bool Buffer::writeFile(string const & fname, bool flag) const
 	// The top of the file should not be written by params.
 
 	// write out a comment in the top of the file
-	ofs << '#' << LYX_DOCVERSION 
+	ofs << '#' << lyx_docversion
 	    << " created this file. For more info see http://www.lyx.org/\n"
 	    << "\\lyxformat " << LYX_FORMAT << "\n";
 
@@ -1631,7 +1768,7 @@ bool Buffer::writeFile(string const & fname, bool flag) const
 
 	// how to check if close went ok?
 	// Following is an attempt... (BE 20001011)
-	
+
 	// good() returns false if any error occured, including some
 	//        formatting error.
 	// bad()  returns true if something bad happened in the buffer,
@@ -1649,261 +1786,295 @@ bool Buffer::writeFile(string const & fname, bool flag) const
 		}
 #endif
 	}
-	
+
 	return status;
 }
 
 
+namespace {
+
+pair<int, string> const addDepth(int depth, int ldepth)
+{
+	int d = depth * 2;
+	if (ldepth > depth)
+		d += (ldepth - depth) * 2;
+	return make_pair(d, string(d, ' '));
+}
+
+}
+
+
 string const Buffer::asciiParagraph(Paragraph const * par,
-				    unsigned int linelen) const
+				    unsigned int linelen,
+				    bool noparbreak) const
 {
 	ostringstream buffer;
 	Paragraph::depth_type depth = 0;
 	int ltype = 0;
 	Paragraph::depth_type ltype_depth = 0;
-	unsigned int currlinelen = 0;
 	bool ref_printed = false;
-
-	int noparbreak = 0;
-	int islatex = 0;
-	if (!par->previous()) {
-		// begins or ends a deeper area ?
-		if (depth != par->params().depth()) {
-			if (par->params().depth() > depth) {
-				while (par->params().depth() > depth) {
-					++depth;
-				}
-			} else {
-				while (par->params().depth() < depth) {
-					--depth;
-				}
+//	if (!par->previous()) {
+#if 0
+	// begins or ends a deeper area ?
+	if (depth != par->params().depth()) {
+		if (par->params().depth() > depth) {
+			while (par->params().depth() > depth) {
+				++depth;
 			}
-		}
-		
-		// First write the layout
-		string const tmp = textclasslist.NameOfLayout(params.textclass, par->layout);
-		if (tmp == "Itemize") {
-			ltype = 1;
-			ltype_depth = depth + 1;
-		} else if (tmp == "Enumerate") {
-			ltype = 2;
-			ltype_depth = depth + 1;
-		} else if (contains(tmp, "ection")) {
-			ltype = 3;
-			ltype_depth = depth + 1;
-		} else if (contains(tmp, "aragraph")) {
-			ltype = 4;
-			ltype_depth = depth + 1;
-		} else if (tmp == "Description") {
-			ltype = 5;
-			ltype_depth = depth + 1;
-		} else if (tmp == "Abstract") {
-			ltype = 6;
-			ltype_depth = 0;
-		} else if (tmp == "Bibliography") {
-			ltype = 7;
-			ltype_depth = 0;
 		} else {
-			ltype = 0;
-			ltype_depth = 0;
-		}
-		
-		/* maybe some vertical spaces */ 
-		
-		/* the labelwidthstring used in lists */ 
-		
-		/* some lines? */ 
-		
-		/* some pagebreaks? */ 
-		
-		/* noindent ? */ 
-		
-		/* what about the alignment */ 
+			while (par->params().depth() < depth) {
+				--depth;
+			}
+		}
+	}
+#else
+	depth = par->params().depth();
+#endif
+
+	// First write the layout
+	string const & tmp = par->layout();
+	if (compare_no_case(tmp, "itemize") == 0) {
+		ltype = 1;
+		ltype_depth = depth + 1;
+	} else if (compare_no_case(tmp, "enumerate") == 0) {
+		ltype = 2;
+		ltype_depth = depth + 1;
+	} else if (contains(lowercase(tmp), "ection")) {
+		ltype = 3;
+		ltype_depth = depth + 1;
+	} else if (contains(lowercase(tmp), "aragraph")) {
+		ltype = 4;
+		ltype_depth = depth + 1;
+	} else if (compare_no_case(tmp, "description") == 0) {
+		ltype = 5;
+		ltype_depth = depth + 1;
+	} else if (compare_no_case(tmp, "abstract") == 0) {
+		ltype = 6;
+		ltype_depth = 0;
+	} else if (compare_no_case(tmp, "bibliography") == 0) {
+		ltype = 7;
+		ltype_depth = 0;
 	} else {
-		lyxerr << "Should this ever happen?" << endl;
+		ltype = 0;
+		ltype_depth = 0;
 	}
 
-#ifndef NO_LATEX
-	LyXFont const font1 = LyXFont(LyXFont::ALL_INHERIT, params.language);
-#endif
-	for (Paragraph::size_type i = 0; i < par->size(); ++i) {
-		if (!i && !noparbreak) {
-			if (linelen > 0)
-				buffer << "\n\n";
-			for (Paragraph::depth_type j = 0; j < depth; ++j)
-				buffer << "  ";
-			currlinelen = depth * 2;
-			switch (ltype) {
-			case 0: // Standard
-			case 4: // (Sub)Paragraph
-			case 5: // Description
-				break;
-			case 6: // Abstract
-				if (linelen > 0)
-					buffer << "Abstract\n\n";
-				else
-					buffer << "Abstract: ";
-				break;
-			case 7: // Bibliography
-				if (!ref_printed) {
-					if (linelen > 0)
-						buffer << "References\n\n";
-					else
-						buffer << "References: ";
-					ref_printed = true;
-				}
-				break;
-			default:
-				buffer << par->params().labelString() << " ";
-				break;
+	/* maybe some vertical spaces */
+
+	/* the labelwidthstring used in lists */
+
+	/* some lines? */
+
+	/* some pagebreaks? */
+
+	/* noindent ? */
+
+	/* what about the alignment */
+//	} else {
+//		lyxerr << "Should this ever happen?" << endl;
+//	}
+
+	// linelen <= 0 is special and means we don't have pargraph breaks
+
+	string::size_type currlinelen = 0;
+
+	if (!noparbreak) {
+		if (linelen > 0)
+			buffer << "\n\n";
+
+		buffer << string(depth * 2, ' ');
+		currlinelen += depth * 2;
+
+		//--
+		// we should probably change to the paragraph language in the
+		// gettext here (if possible) so that strings are outputted in
+		// the correct language! (20012712 Jug)
+		//--
+		switch (ltype) {
+		case 0: // Standard
+		case 4: // (Sub)Paragraph
+		case 5: // Description
+			break;
+		case 6: // Abstract
+			if (linelen > 0) {
+				buffer << _("Abstract") << "\n\n";
+				currlinelen = 0;
+			} else {
+				string const abst = _("Abstract: ");
+				buffer << abst;
+				currlinelen += abst.length();
 			}
-			if (ltype_depth > depth) {
-				for (Paragraph::depth_type j = ltype_depth - 1; 
-				     j > depth; --j)
-					buffer << "  ";
-				currlinelen += (ltype_depth-depth)*2;
+			break;
+		case 7: // Bibliography
+			if (!ref_printed) {
+				if (linelen > 0) {
+					buffer << _("References") << "\n\n";
+					currlinelen = 0;
+				} else {
+					string const refs = _("References: ");
+					buffer << refs;
+					currlinelen += refs.length();
+				}
+
+				ref_printed = true;
 			}
+			break;
+		default:
+		{
+			string const parlab = par->params().labelString();
+			buffer << parlab << " ";
+			currlinelen += parlab.length() + 1;
 		}
-#ifndef NO_LATEX
-		LyXFont const font2 = par->getFontSettings(params, i);
-		if (font1.latex() != font2.latex()) {
-			if (font2.latex() == LyXFont::OFF)
-				islatex = 0;
-			else
-				islatex = 1;
-		} else {
-			islatex = 0;
+		break;
+
 		}
-#endif
-		
+	}
+
+	if (!currlinelen) {
+		pair<int, string> p = addDepth(depth, ltype_depth);
+		buffer << p.second;
+		currlinelen += p.first;
+	}
+
+	// this is to change the linebreak to do it by word a bit more
+	// intelligent hopefully! (only in the case where we have a
+	// max linelenght!) (Jug)
+
+	string word;
+
+	for (pos_type i = 0; i < par->size(); ++i) {
 		char c = par->getUChar(params, i);
-		if (islatex)
-			continue;
 		switch (c) {
 		case Paragraph::META_INSET:
 		{
 			Inset const * inset = par->getInset(i);
 			if (inset) {
-				if (!inset->ascii(this, buffer)) {
-					string dummy;
-					string const s =
-						rsplit(buffer.str().c_str(),
-						       dummy, '\n');
-					currlinelen += s.length();
-				} else {
+				if (linelen > 0) {
+					buffer << word;
+					currlinelen += word.length();
+					word.erase();
+				}
+				if (inset->ascii(this, buffer, linelen)) {
 					// to be sure it breaks paragraph
 					currlinelen += linelen;
 				}
 			}
 		}
 		break;
-		
+
 		case Paragraph::META_NEWLINE:
 			if (linelen > 0) {
-				buffer << "\n";
-				for (Paragraph::depth_type j = 0; 
-				     j < depth; ++j)
-					buffer << "  ";
-			}
-			currlinelen = depth * 2;
-			if (ltype_depth > depth) {
-				for (Paragraph::depth_type j = ltype_depth;
-				     j > depth; --j)
-					buffer << "  ";
-				currlinelen += (ltype_depth - depth) * 2;
+				buffer << word << "\n";
+				word.erase();
+
+				pair<int, string> p = addDepth(depth,
+							       ltype_depth);
+				buffer << p.second;
+				currlinelen = p.first;
 			}
 			break;
-			
-		case Paragraph::META_HFILL: 
-			buffer << "\t";
-			break;
-			
-		case '\\':
-			buffer << "\\";
+
+		case Paragraph::META_HFILL:
+			buffer << word << "\t";
+			currlinelen += word.length() + 1;
+			word.erase();
 			break;
-			
+
 		default:
-			if ((linelen > 0) && (currlinelen > (linelen - 10)) &&
-			    (c == ' ') && ((i + 2) < par->size()))
-			{
-				buffer << "\n";
-				for (Paragraph::depth_type j = 0; 
-				     j < depth; ++j)
-					buffer << "  ";
-				currlinelen = depth * 2;
-				if (ltype_depth > depth) {
-					for (Paragraph::depth_type j = ltype_depth;
-					    j > depth; --j)
-						buffer << "  ";
-					currlinelen += (ltype_depth-depth)*2;
+			if (c == ' ') {
+				if (linelen > 0 &&
+				    currlinelen + word.length() > linelen - 10) {
+					buffer << "\n";
+					pair<int, string> p =
+						addDepth(depth, ltype_depth);
+					buffer << p.second;
+					currlinelen = p.first;
+				}
+
+				buffer << word << ' ';
+				currlinelen += word.length() + 1;
+				word.erase();
+
+			} else {
+				if (c != '\0') {
+					word += c;
+				} else {
+					lyxerr[Debug::INFO] <<
+						"writeAsciiFile: NULL char in structure." << endl;
 				}
-			} else if (c != '\0')
-				buffer << c;
-			else if (c == '\0')
-				lyxerr[Debug::INFO] << "writeAsciiFile: NULL char in structure." << endl;
-			++currlinelen;
+				if ((linelen > 0) &&
+					(currlinelen + word.length()) > linelen)
+				{
+					buffer << "\n";
+
+					pair<int, string> p =
+						addDepth(depth, ltype_depth);
+					buffer << p.second;
+					currlinelen = p.first;
+				}
+			}
 			break;
 		}
 	}
+	buffer << word;
 	return buffer.str().c_str();
 }
 
 
-void Buffer::writeFileAscii(string const & fname, int linelen) 
+void Buffer::writeFileAscii(string const & fname, int linelen)
 {
 	ofstream ofs(fname.c_str());
 	if (!ofs) {
-		WriteFSAlert(_("Error: Cannot write file:"), fname);
+		Alert::err_alert(_("Error: Cannot write file:"), fname);
 		return;
 	}
 	writeFileAscii(ofs, linelen);
 }
 
 
-void Buffer::writeFileAscii(ostream & ofs, int linelen) 
+void Buffer::writeFileAscii(ostream & ofs, int linelen)
 {
 	Paragraph * par = paragraph;
 	while (par) {
-		ofs << asciiParagraph(par, linelen);
+		ofs << asciiParagraph(par, linelen, par->previous() == 0);
 		par = par->next();
 	}
 	ofs << "\n";
 }
 
+
 bool use_babel;
 
-void Buffer::makeLaTeXFile(string const & fname, 
+
+void Buffer::makeLaTeXFile(string const & fname,
 			   string const & original_path,
 			   bool nice, bool only_body)
 {
 	lyxerr[Debug::LATEX] << "makeLaTeXFile..." << endl;
-	
-	niceFile = nice; // this will be used by Insetincludes.
-
-	tex_code_break_column = lyxrc.ascii_linelen;
-
-        LyXTextClass const & tclass =
-		textclasslist.TextClass(params.textclass);
 
 	ofstream ofs(fname.c_str());
 	if (!ofs) {
-		WriteFSAlert(_("Error: Cannot open file: "), fname);
+		Alert::err_alert(_("Error: Cannot open file: "), fname);
 		return;
 	}
-	
+
+	niceFile = nice; // this will be used by Insetincludes.
+
+	tex_code_break_column = lyxrc.ascii_linelen;
+
 	// validate the buffer.
 	lyxerr[Debug::LATEX] << "  Validating buffer..." << endl;
-	LaTeXFeatures features(params, tclass.numLayouts());
+	LaTeXFeatures features(params);
 	validate(features);
 	lyxerr[Debug::LATEX] << "  Buffer validation done." << endl;
-	
+
 	texrow.reset();
-	// The starting paragraph of the coming rows is the 
+	// The starting paragraph of the coming rows is the
 	// first paragraph of the document. (Asger)
 	texrow.start(paragraph, 0);
 
 	if (!only_body && nice) {
-		ofs << "%% " LYX_DOCVERSION " created this file.  "
+		ofs << "%% " << lyx_docversion << " created this file.  "
 			"For more info, see http://www.lyx.org/.\n"
 			"%% Do not edit unless you really know what "
 			"you are doing.\n";
@@ -1912,7 +2083,7 @@ void Buffer::makeLaTeXFile(string const & fname,
 	}
 	lyxerr[Debug::INFO] << "lyx header finished" << endl;
 	// There are a few differences between nice LaTeX and usual files:
-	// usual is \batchmode and has a 
+	// usual is \batchmode and has a
 	// special input@path to allow the including of figures
 	// with either \input or \includegraphics (what figinsets do).
 	// batchmode is not set if there is a tex_code_break_column.
@@ -1921,33 +2092,37 @@ void Buffer::makeLaTeXFile(string const & fname,
 	// original_path is set. This is done for usual tex-file, but not
 	// for nice-latex-file. (Matthias 250696)
 	if (!only_body) {
-		if (!nice){
+		if (!nice) {
 			// code for usual, NOT nice-latex-file
 			ofs << "\\batchmode\n"; // changed
 			// from \nonstopmode
 			texrow.newline();
 		}
 		if (!original_path.empty()) {
+			string inputpath = os::external_path(original_path);
+			subst(inputpath, "~", "\\string~");
 			ofs << "\\makeatletter\n"
 			    << "\\def\\input@path{{"
-			    << os::external_path(original_path) << "/}}\n"
+			    << inputpath << "/}}\n"
 			    << "\\makeatother\n";
 			texrow.newline();
 			texrow.newline();
 			texrow.newline();
 		}
-		
+
 		ofs << "\\documentclass";
-		
+
+		LyXTextClass const & tclass = textclasslist[params.textclass];
+
 		ostringstream options; // the document class options.
-		
+
 		if (tokenPos(tclass.opt_fontsize(),
 			     '|', params.fontsize) >= 0) {
 			// only write if existing in list (and not default)
 			options << params.fontsize << "pt,";
 		}
-		
-		
+
+
 		if (!params.use_geometry &&
 		    (params.paperpackage == BufferParams::PACKAGE_NONE)) {
 			switch (params.papersize) {
@@ -1992,26 +2167,23 @@ void Buffer::makeLaTeXFile(string const & fname,
 				options << "onecolumn,";
 		}
 
-		if (!params.use_geometry 
+		if (!params.use_geometry
 		    && params.orientation == BufferParams::ORIENTATION_LANDSCAPE)
 			options << "landscape,";
-		
+
 		// language should be a parameter to \documentclass
 		use_babel = false;
 		ostringstream language_options;
 		if (params.language->babel() == "hebrew"
 		    && default_language->babel() != "hebrew")
 			 // This seems necessary
-			features.UsedLanguages.insert(default_language);
+			features.useLanguage(default_language);
 
 		if (lyxrc.language_use_babel ||
 		    params.language->lang() != lyxrc.default_language ||
-		    !features.UsedLanguages.empty()) {
+		    !features.hasLanguages()) {
 			use_babel = true;
-			for (LaTeXFeatures::LanguageList::const_iterator cit =
-				     features.UsedLanguages.begin();
-			     cit != features.UsedLanguages.end(); ++cit)
-				language_options << (*cit)->babel() << ',';
+			language_options << features.getLanguages();
 			language_options << params.language->babel();
 			if (lyxrc.language_global_options)
 				options << language_options.str() << ',';
@@ -2023,17 +2195,15 @@ void Buffer::makeLaTeXFile(string const & fname,
 		}
 
 		string strOptions(options.str().c_str());
-		if (!strOptions.empty()){
+		if (!strOptions.empty()) {
 			strOptions = strip(strOptions, ',');
 			ofs << '[' << strOptions << ']';
 		}
-		
-		ofs << '{'
-		    << textclasslist.LatexnameOfClass(params.textclass)
-		    << "}\n";
+
+		ofs << '{' << tclass.latexname() << "}\n";
 		texrow.newline();
 		// end of \documentclass defs
-		
+
 		// font selection must be done before loading fontenc.sty
 		// The ae package is not needed when using OT1 font encoding.
 		if (params.fonts != "default" &&
@@ -2056,14 +2226,9 @@ void Buffer::makeLaTeXFile(string const & fname,
 			string const doc_encoding =
 				params.language->encoding()->LatexName();
 
-			// Create a list with all the input encodings used 
+			// Create a list with all the input encodings used
 			// in the document
-			set<string> encodings;
-			for (LaTeXFeatures::LanguageList::const_iterator it =
-				     features.UsedLanguages.begin();
-			     it != features.UsedLanguages.end(); ++it)
-				if ((*it)->encoding()->LatexName() != doc_encoding)
-					encodings.insert((*it)->encoding()->LatexName());
+			set<string> encodings = features.getEncodingSet(doc_encoding);
 
 			ofs << "\\usepackage[";
 			std::copy(encodings.begin(), encodings.end(),
@@ -2179,11 +2344,6 @@ void Buffer::makeLaTeXFile(string const & fname,
 			ofs << "}\n";
 			texrow.newline();
 		}
-		if (features.amsstyle
-		    && !tclass.provides(LyXTextClass::amsmath)) {
-			ofs << "\\usepackage{amsmath}\n";
-			texrow.newline();
-		}
 
 		if (tokenPos(tclass.opt_pagestyle(),
 			     '|', params.pagestyle) >= 0) {
@@ -2195,19 +2355,6 @@ void Buffer::makeLaTeXFile(string const & fname,
 			texrow.newline();
 		}
 
-		// We try to load babel late, in case it interferes
-		// with other packages.
-		if (use_babel) {
-			string tmp = lyxrc.language_package;
-			if (!lyxrc.language_global_options
-			    && tmp == "\\usepackage{babel}")
-				tmp = string("\\usepackage[") +
-					language_options.str().c_str() +
-					"]{babel}";
-			ofs << tmp << "\n";
-			texrow.newline();
-		}
-
 		if (params.secnumdepth != tclass.secnumdepth()) {
 			ofs << "\\setcounter{secnumdepth}{"
 			    << params.secnumdepth
@@ -2220,10 +2367,10 @@ void Buffer::makeLaTeXFile(string const & fname,
 			    << "}\n";
 			texrow.newline();
 		}
-		
+
 		if (params.paragraph_separation) {
 			switch (params.defskip.kind()) {
-			case VSpace::SMALLSKIP: 
+			case VSpace::SMALLSKIP:
 				ofs << "\\setlength\\parskip{\\smallskipamount}\n";
 				break;
 			case VSpace::MEDSKIP:
@@ -2242,7 +2389,7 @@ void Buffer::makeLaTeXFile(string const & fname,
 				break;
 			}
 			texrow.newline();
-			
+
 			ofs << "\\setlength\\parindent{0pt}\n";
 			texrow.newline();
 		}
@@ -2264,7 +2411,7 @@ void Buffer::makeLaTeXFile(string const & fname,
 				+ tmppreamble + '\n';
 		}
 
-		// the text class specific preamble 
+		// the text class specific preamble
 		tmppreamble = features.getTClassPreamble();
 		if (!tmppreamble.empty()) {
 			preamble += "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% "
@@ -2286,7 +2433,7 @@ void Buffer::makeLaTeXFile(string const & fname,
 		// in the user-defined preamble -- ARRae
 		// Actually it has to be done much later than that
 		// since some packages like frenchb make modifications
-		// at \begin{document} time -- JMarc 
+		// at \begin{document} time -- JMarc
 		string bullets_def;
 		for (int i = 0; i < 4; ++i) {
 			if (params.user_defined_bullets[i] != ITEMIZE_DEFAULTS[i]) {
@@ -2307,8 +2454,8 @@ void Buffer::makeLaTeXFile(string const & fname,
 					bullets_def += 'v';
 					break;
 				}
-				bullets_def += "}{" + 
-				  params.user_defined_bullets[i].getText() 
+				bullets_def += "}{" +
+				  params.user_defined_bullets[i].getText()
 				  + "}\n";
 			}
 		}
@@ -2316,12 +2463,27 @@ void Buffer::makeLaTeXFile(string const & fname,
 		if (!bullets_def.empty())
 		  preamble += bullets_def + "}\n\n";
 
-		for (int j = countChar(preamble, '\n'); j-- ;) {
+		int const nlines =
+			int(lyx::count(preamble.begin(), preamble.end(), '\n'));
+		for (int j = 0; j != nlines; ++j) {
 			texrow.newline();
 		}
 
 		ofs << preamble;
 
+		// We try to load babel late, in case it interferes
+		// with other packages.
+		if (use_babel) {
+			string tmp = lyxrc.language_package;
+			if (!lyxrc.language_global_options
+			    && tmp == "\\usepackage{babel}")
+				tmp = string("\\usepackage[") +
+					language_options.str().c_str() +
+					"]{babel}";
+			ofs << tmp << "\n";
+			texrow.newline();
+		}
+
 		// make the body.
 		ofs << "\\begin{document}\n";
 		texrow.newline();
@@ -2334,7 +2496,7 @@ void Buffer::makeLaTeXFile(string const & fname,
 		    << endl;
 		texrow.newline();
 	}
-	
+
 	latexParagraphs(ofs, paragraph, 0, texrow);
 
 	// add this just in case after all the paragraphs
@@ -2351,7 +2513,7 @@ void Buffer::makeLaTeXFile(string const & fname,
 	if (!only_body) {
 		ofs << "\\end{document}\n";
 		texrow.newline();
-	
+
 		lyxerr[Debug::LATEX] << "makeLaTeXFile...done" << endl;
 	} else {
 		lyxerr[Debug::LATEX] << "LaTeXFile for inclusion made."
@@ -2371,8 +2533,12 @@ void Buffer::makeLaTeXFile(string const & fname,
 	if (ofs.fail()) {
 		lyxerr << "File was not closed properly." << endl;
 	}
-	
+
 	lyxerr[Debug::INFO] << "Finished making latex file." << endl;
+	lyxerr[Debug::INFO] << "Row count was " << texrow.rows()-1 << "." << endl;
+
+	// we want this to be true outside previews (for insetexternal)
+	niceFile = true;
 }
 
 
@@ -2387,26 +2553,34 @@ void Buffer::latexParagraphs(ostream & ofs, Paragraph * par,
 
 	// if only_body
 	while (par != endpar) {
-		LyXLayout const & layout =
-			textclasslist.Style(params.textclass,
-					    par->layout);
-	    
-	        if (layout.intitle) {
-			if (already_title) {
-				lyxerr <<"Error in latexParagraphs: You"
-					" should not mix title layouts"
-					" with normal ones." << endl;
-			} else
-				was_title = true;
-	        } else if (was_title && !already_title) {
-			ofs << "\\maketitle\n";
-			texrow.newline();
-			already_title = true;
-			was_title = false;		    
-		}
-		
-		if (layout.isEnvironment()) {
-			par = par->TeXEnvironment(this, params, ofs, texrow);
+		Inset * in = par->inInset();
+		// well we have to check if we are in an inset with unlimited
+		// lenght (all in one row) if that is true then we don't allow
+		// any special options in the paragraph and also we don't allow
+		// any environment other then "Standard" to be valid!
+		if ((in == 0) || !in->forceDefaultParagraphs(in)) {
+			LyXLayout const & layout =
+				textclasslist[params.textclass][par->layout()];
+
+			if (layout.intitle) {
+				if (already_title) {
+					lyxerr <<"Error in latexParagraphs: You"
+						" should not mix title layouts"
+						" with normal ones." << endl;
+				} else
+					was_title = true;
+			} else if (was_title && !already_title) {
+				ofs << "\\maketitle\n";
+				texrow.newline();
+				already_title = true;
+				was_title = false;
+			}
+
+			if (layout.isEnvironment()) {
+				par = par->TeXEnvironment(this, params, ofs, texrow);
+			} else {
+				par = par->TeXOnePar(this, params, ofs, texrow, false);
+			}
 		} else {
 			par = par->TeXOnePar(this, params, ofs, texrow, false);
 		}
@@ -2421,50 +2595,52 @@ void Buffer::latexParagraphs(ostream & ofs, Paragraph * par,
 
 bool Buffer::isLatex() const
 {
-	return textclasslist.TextClass(params.textclass).outputType() == LATEX;
+	return textclasslist[params.textclass].outputType() == LATEX;
 }
 
 
 bool Buffer::isLinuxDoc() const
 {
-	return textclasslist.TextClass(params.textclass).outputType() == LINUXDOC;
+	return textclasslist[params.textclass].outputType() == LINUXDOC;
 }
 
 
 bool Buffer::isLiterate() const
 {
-	return textclasslist.TextClass(params.textclass).outputType() == LITERATE;
+	return textclasslist[params.textclass].outputType() == LITERATE;
 }
 
 
 bool Buffer::isDocBook() const
 {
-	return textclasslist.TextClass(params.textclass).outputType() == DOCBOOK;
+	return textclasslist[params.textclass].outputType() == DOCBOOK;
 }
 
 
 bool Buffer::isSGML() const
 {
-	return textclasslist.TextClass(params.textclass).outputType() == LINUXDOC ||
-	       textclasslist.TextClass(params.textclass).outputType() == DOCBOOK;
+	LyXTextClass const & tclass = textclasslist[params.textclass];
+
+	return tclass.outputType() == LINUXDOC ||
+	       tclass.outputType() == DOCBOOK;
 }
 
 
-void Buffer::sgmlOpenTag(ostream & os, Paragraph::depth_type depth,
+void Buffer::sgmlOpenTag(ostream & os, Paragraph::depth_type,
 			 string const & latexname) const
 {
 	if (!latexname.empty() && latexname != "!-- --")
-		os << "<!-- " << depth << " -->" << "<" << latexname << ">";
-	//os << string(depth, ' ') << "<" << latexname << ">\n";
+		//os << "<!-- " << depth << " -->" << "<" << latexname << ">";
+		os << "<" << latexname << ">";
 }
 
 
-void Buffer::sgmlCloseTag(ostream & os, Paragraph::depth_type depth,
+void Buffer::sgmlCloseTag(ostream & os, Paragraph::depth_type,
 			  string const & latexname) const
 {
 	if (!latexname.empty() && latexname != "!-- --")
-		os << "<!-- " << depth << " -->" << "</" << latexname << ">\n";
-	//os << string(depth, ' ') << "</" << latexname << ">\n";
+		//os << "<!-- " << depth << " -->" << "</" << latexname << ">\n";
+		os << "</" << latexname << ">";
 }
 
 
@@ -2473,31 +2649,35 @@ void Buffer::makeLinuxDocFile(string const & fname, bool nice, bool body_only)
 	ofstream ofs(fname.c_str());
 
 	if (!ofs) {
-		WriteAlert(_("LYX_ERROR:"), _("Cannot write file"), fname);
+		Alert::alert(_("LYX_ERROR:"), _("Cannot write file"), fname);
 		return;
 	}
 
 	niceFile = nice; // this will be used by included files.
 
-        LyXTextClass const & tclass =
-		textclasslist.TextClass(params.textclass);
+	LaTeXFeatures features(params);
 
-	LaTeXFeatures features(params, tclass.numLayouts());
 	validate(features);
 
 	texrow.reset();
 
-	string top_element = textclasslist.LatexnameOfClass(params.textclass);
+	LyXTextClass const & tclass = textclasslist[params.textclass];
+
+	string top_element = tclass.latexname();
 
 	if (!body_only) {
-		string sgml_includedfiles=features.getIncludedFiles(fname);
+		ofs << "<!doctype linuxdoc system";
 
-		if (params.preamble.empty() && sgml_includedfiles.empty()) {
-			ofs << "<!doctype linuxdoc system>\n\n";
-		} else {
-			ofs << "<!doctype linuxdoc system [ "
-			    << params.preamble << sgml_includedfiles << " \n]>\n\n";
+		string preamble = params.preamble;
+		const string name = nice ? ChangeExtension(filename_, ".sgml")
+			 : fname;
+		preamble += features.getIncludedFiles(name);
+		preamble += features.getLyXSGMLEntities();
+
+		if (!preamble.empty()) {
+			ofs << " [ " << preamble << " ]";
 		}
+		ofs << ">\n\n";
 
 		if (params.options.empty())
 			sgmlOpenTag(ofs, 0, top_element);
@@ -2509,25 +2689,23 @@ void Buffer::makeLinuxDocFile(string const & fname, bool nice, bool body_only)
 		}
 	}
 
-	ofs << "<!-- "  << LYX_DOCVERSION 
+	ofs << "<!-- "  << lyx_docversion
 	    << " created this file. For more info see http://www.lyx.org/"
 	    << " -->\n";
 
 	Paragraph::depth_type depth = 0; // paragraph depth
 	Paragraph * par = paragraph;
-        string item_name;
+	string item_name;
 	vector<string> environment_stack(5);
 
 	while (par) {
-		LyXLayout const & style =
-			textclasslist.Style(params.textclass,
-					    par->layout);
+		LyXLayout const & style = tclass[par->layout()];
 
 		// treat <toc> as a special case for compatibility with old code
-		if (par->getChar(0) == Paragraph::META_INSET) {
-		        Inset * inset = par->getInset(0);
+		if (par->isInset(0)) {
+			Inset * inset = par->getInset(0);
 			Inset::Code lyx_code = inset->lyxCode();
-			if (lyx_code == Inset::TOC_CODE){
+			if (lyx_code == Inset::TOC_CODE) {
 				string const temp = "toc";
 				sgmlOpenTag(ofs, depth, temp);
 
@@ -2545,25 +2723,25 @@ void Buffer::makeLinuxDocFile(string const & fname, bool nice, bool body_only)
 		// write opening SGML tags
 		switch (style.latextype) {
 		case LATEX_PARAGRAPH:
-			if (depth == par->params().depth() 
+			if (depth == par->params().depth()
 			   && !environment_stack[depth].empty()) {
 				sgmlCloseTag(ofs, depth, environment_stack[depth]);
 				environment_stack[depth].erase();
-				if (depth) 
+				if (depth)
 					--depth;
 				else
-				        ofs << "</p>";
+					ofs << "</p>";
 			}
 			sgmlOpenTag(ofs, depth, style.latexname());
 			break;
 
 		case LATEX_COMMAND:
 			if (depth!= 0)
-				linuxDocError(par, 0,
-					      _("Error : Wrong depth for"
-						" LatexType Command.\n"));
+				sgmlError(par, 0,
+					  _("Error : Wrong depth for"
+					    " LatexType Command.\n"));
 
-			if (!environment_stack[depth].empty()){
+			if (!environment_stack[depth].empty()) {
 				sgmlCloseTag(ofs, depth,
 					     environment_stack[depth]);
 				ofs << "</p>";
@@ -2575,7 +2753,7 @@ void Buffer::makeLinuxDocFile(string const & fname, bool nice, bool body_only)
 
 		case LATEX_ENVIRONMENT:
 		case LATEX_ITEM_ENVIRONMENT:
-			if (depth == par->params().depth() 
+			if (depth == par->params().depth()
 			    && environment_stack[depth] != style.latexname()) {
 				sgmlCloseTag(ofs, depth,
 					     environment_stack[depth]);
@@ -2632,10 +2810,10 @@ void Buffer::makeLinuxDocFile(string const & fname, bool nice, bool body_only)
 			break;
 		}
 	}
-   
+
 	// Close open tags
 	for (int i=depth; i >= 0; --i)
-	        sgmlCloseTag(ofs, depth, environment_stack[i]);
+		sgmlCloseTag(ofs, depth, environment_stack[i]);
 
 	if (!body_only) {
 		ofs << "\n\n";
@@ -2644,30 +2822,9 @@ void Buffer::makeLinuxDocFile(string const & fname, bool nice, bool body_only)
 
 	ofs.close();
 	// How to check for successful close
-}
 
-
-void Buffer::docBookHandleCaption(ostream & os, string & inner_tag,
-				  Paragraph::depth_type depth, int desc_on,
-				  Paragraph * & par)
-{
-	Paragraph * tpar = par;
-	while (tpar
-	       && (tpar->layout != textclasslist.NumberOfLayout(params.textclass,
-								"Caption").second))
-		tpar = tpar->next();
-
-	if (tpar &&
-	    tpar->layout == textclasslist.NumberOfLayout(params.textclass,
-							 "Caption").second) {
-		sgmlOpenTag(os, depth + 1, inner_tag);
-		string extra_par;
-		simpleDocBookOnePar(os, extra_par, tpar,
-				    desc_on, depth + 2);
-		sgmlCloseTag(os, depth+1, inner_tag);
-		if (!extra_par.empty())
-			os << extra_par;
-	}
+	// we want this to be true outside previews (for insetexternal)
+	niceFile = true;
 }
 
 
@@ -2675,7 +2832,7 @@ void Buffer::docBookHandleCaption(ostream & os, string & inner_tag,
 // writes newline, if necessary.
 namespace {
 
-void linux_doc_line_break(ostream & os, string::size_type & colcount,
+void sgmlLineBreak(ostream & os, string::size_type & colcount,
 			  string::size_type newcol)
 {
 	colcount += newcol;
@@ -2713,29 +2870,27 @@ string tag_name(PAR_TAG const & pt) {
 inline
 void operator|=(PAR_TAG & p1, PAR_TAG const & p2)
 {
-        p1 = static_cast<PAR_TAG>(p1 | p2);
+	p1 = static_cast<PAR_TAG>(p1 | p2);
 }
 
 
 inline
 void reset(PAR_TAG & p1, PAR_TAG const & p2)
 {
-	p1 = static_cast<PAR_TAG>( p1 & ~p2);
+	p1 = static_cast<PAR_TAG>(p1 & ~p2);
 }
 
 } // namespace anon
 
 
-
-
 // Handle internal paragraph parsing -- layout already processed.
 void Buffer::simpleLinuxDocOnePar(ostream & os,
-				  Paragraph * par, 
+				  Paragraph * par,
 				  Paragraph::depth_type /*depth*/)
 {
-	LyXLayout const & style = textclasslist.Style(params.textclass,
-						      par->getLayout());
-        string::size_type char_line_count = 5;     // Heuristic choice ;-) 
+	LyXLayout const & style =
+		textclasslist[params.textclass][par->layout()];
+	string::size_type char_line_count = 5;     // Heuristic choice ;-)
 
 	// gets paragraph main font
 	LyXFont font_old;
@@ -2753,9 +2908,9 @@ void Buffer::simpleLinuxDocOnePar(ostream & os,
 	LyXFont::FONT_SHAPE  shape_type  = LyXFont::UP_SHAPE;
 	bool is_em = false;
 
-	stack < PAR_TAG > tag_state;
+	stack<PAR_TAG> tag_state;
 	// parsing main loop
-	for (Paragraph::size_type i = 0; i < par->size(); ++i) {
+	for (pos_type i = 0; i < par->size(); ++i) {
 
 		PAR_TAG tag_close = NONE;
 		list < PAR_TAG > tag_open;
@@ -2847,7 +3002,7 @@ void Buffer::simpleLinuxDocOnePar(ostream & os,
 		}
 
 		list < PAR_TAG > temp;
-		while(!tag_state.empty() && tag_close ) {
+		while (!tag_state.empty() && tag_close) {
 			PAR_TAG k =  tag_state.top();
 			tag_state.pop();
 			os << "</" << tag_name(k) << ">";
@@ -2878,29 +3033,26 @@ void Buffer::simpleLinuxDocOnePar(ostream & os,
 			continue;
 		}
 
-		if (
-#ifndef NO_LATEX
-			font.latex() == LyXFont::ON ||
-#endif
-		    style.latexparam() == "CDATA") {
+		if (style.latexparam() == "CDATA") {
 			// "TeX"-Mode on == > SGML-Mode on.
 			if (c != '\0')
 				os << c;
 			++char_line_count;
 		} else {
 			string sgml_string;
-			if (par->linuxDocConvertChar(c, sgml_string)
-			    && !style.free_spacing) { 
+			if (par->sgmlConvertChar(c, sgml_string)
+			    && !style.free_spacing && !par->isFreeSpacing())
+			{
 				// in freespacing mode, spaces are
 				// non-breaking characters
 				if (desc_on) {// if char is ' ' then...
 
 					++char_line_count;
-					linux_doc_line_break(os, char_line_count, 6);
+					sgmlLineBreak(os, char_line_count, 6);
 					os << "</tag>";
 					desc_on = false;
 				} else  {
-					linux_doc_line_break(os, char_line_count, 1);
+					sgmlLineBreak(os, char_line_count, 1);
 					os << c;
 				}
 			} else {
@@ -2919,19 +3071,28 @@ void Buffer::simpleLinuxDocOnePar(ostream & os,
 	// resets description flag correctly
 	if (desc_on) {
 		// <tag> not closed...
-		linux_doc_line_break(os, char_line_count, 6);
+		sgmlLineBreak(os, char_line_count, 6);
 		os << "</tag>";
 	}
 }
 
 
 // Print an error message.
-void Buffer::linuxDocError(Paragraph * par, int pos,
-			   string const & message) 
+void Buffer::sgmlError(Paragraph * par, int pos,
+		       string const & message) const
 {
+#warning This is wrong we cannot insert an inset like this!!!
+	// I guess this was Jose' so I explain you more or less why this
+	// is wrong. This way you insert something in the paragraph and
+	// don't tell it to LyXText (row rebreaking and undo handling!!!)
+	// I deactivate this code, have a look at BufferView::insertErrors
+	// how you should do this correctly! (Jug 20020315)
+#if 0
 	// insert an error marker in text
 	InsetError * new_inset = new InsetError(message);
-	par->insertInset(pos, new_inset);
+	par->insertInset(pos, new_inset, LyXFont(LyXFont::ALL_INHERIT,
+			 params.language));
+#endif
 }
 
 
@@ -2939,7 +3100,7 @@ void Buffer::makeDocBookFile(string const & fname, bool nice, bool only_body)
 {
 	ofstream ofs(fname.c_str());
 	if (!ofs) {
-		WriteAlert(_("LYX_ERROR:"), _("Cannot write file"), fname);
+		Alert::alert(_("LYX_ERROR:"), _("Cannot write file"), fname);
 		return;
 	}
 
@@ -2947,30 +3108,31 @@ void Buffer::makeDocBookFile(string const & fname, bool nice, bool only_body)
 
 	niceFile = nice; // this will be used by Insetincludes.
 
-        LyXTextClass const & tclass =
-		textclasslist.TextClass(params.textclass);
-
-	LaTeXFeatures features(params, tclass.numLayouts());
+	LaTeXFeatures features(params);
 	validate(features);
-   
+
 	texrow.reset();
 
-	string top_element = textclasslist.LatexnameOfClass(params.textclass);
+	LyXTextClass const & tclass = textclasslist[params.textclass];
+	string top_element = tclass.latexname();
 
 	if (!only_body) {
-		string sgml_includedfiles = features.getIncludedFiles(fname);
+		ofs << "<!DOCTYPE " << top_element
+		    << "  PUBLIC \"-//OASIS//DTD DocBook V4.1//EN\"";
 
-		ofs << "<!doctype " << top_element
-		    << " public \"-//OASIS//DTD DocBook V3.1//EN\"";
+		string preamble = params.preamble;
+		const string name = nice ? ChangeExtension(filename_, ".sgml")
+			 : fname;
+		preamble += features.getIncludedFiles(name);
+		preamble += features.getLyXSGMLEntities();
 
-		if (params.preamble.empty() && sgml_includedfiles.empty())
-			ofs << ">\n\n";
-		else
-			ofs << "\n [ " << params.preamble 
-			    << sgml_includedfiles << " \n]>\n\n";
+		if (!preamble.empty()) {
+			ofs << "\n [ " << preamble << " ]";
+		}
+		ofs << ">\n\n";
 	}
 
-	string top = top_element;	
+	string top = top_element;
 	top += " lang=\"";
 	top += params.language->code();
 	top += "\"";
@@ -2981,7 +3143,7 @@ void Buffer::makeDocBookFile(string const & fname, bool nice, bool only_body)
 	}
 	sgmlOpenTag(ofs, 0, top);
 
-	ofs << "<!-- DocBook file was created by " << LYX_DOCVERSION 
+	ofs << "<!-- DocBook file was created by " << lyx_docversion
 	    << "\n  See http://www.lyx.org/ for more information -->\n";
 
 	vector<string> environment_stack(10);
@@ -2994,7 +3156,7 @@ void Buffer::makeDocBookFile(string const & fname, bool nice, bool only_body)
 	Paragraph::depth_type cmd_depth = 0;
 	Paragraph::depth_type depth = 0; // paragraph depth
 
-        string item_name;
+	string item_name;
 	string command_name;
 
 	while (par) {
@@ -3003,9 +3165,7 @@ void Buffer::makeDocBookFile(string const & fname, bool nice, bool only_body)
 		string c_params;
 		int desc_on = 0; // description mode
 
-		LyXLayout const & style =
-			textclasslist.Style(params.textclass,
-					    par->layout);
+		LyXLayout const & style = tclass[par->layout()];
 
 		// environment tag closing
 		for (; depth > par->params().depth(); --depth) {
@@ -3035,13 +3195,13 @@ void Buffer::makeDocBookFile(string const & fname, bool nice, bool only_body)
 						     depth + command_depth,
 						     environment_inner[depth]);
 			}
-			
+
 			sgmlCloseTag(ofs, depth + command_depth,
 				     environment_stack[depth]);
-			
+
 			environment_stack[depth].erase();
 			environment_inner[depth].erase();
-                }
+		}
 
 		// Write opening SGML tags.
 		switch (style.latextype) {
@@ -3052,17 +3212,17 @@ void Buffer::makeDocBookFile(string const & fname, bool nice, bool only_body)
 
 		case LATEX_COMMAND:
 			if (depth != 0)
-				linuxDocError(par, 0,
-					      _("Error : Wrong depth for "
-						"LatexType Command.\n"));
-			
+				sgmlError(par, 0,
+					  _("Error : Wrong depth for "
+					    "LatexType Command.\n"));
+
 			command_name = style.latexname();
-			
+
 			sgmlparam = style.latexparam();
 			c_params = split(sgmlparam, c_depth,'|');
-			
+
 			cmd_depth = lyx::atoi(c_depth);
-			
+
 			if (command_flag) {
 				if (cmd_depth < command_base) {
 					for (Paragraph::depth_type j = command_depth; j >= command_base; --j)
@@ -3084,10 +3244,12 @@ void Buffer::makeDocBookFile(string const & fname, bool nice, bool only_body)
 
 			// treat label as a special case for
 			// more WYSIWYM handling.
-			if (par->getChar(0) == Paragraph::META_INSET) {
-			        Inset * inset = par->getInset(0);
+			// This is a hack while paragraphs can't have
+			// attributes, like id in this case.
+			if (par->isInset(0)) {
+				Inset * inset = par->getInset(0);
 				Inset::Code lyx_code = inset->lyxCode();
-				if (lyx_code == Inset::LABEL_CODE){
+				if (lyx_code == Inset::LABEL_CODE) {
 					command_name += " id=\"";
 					command_name += (static_cast<InsetCommand *>(inset))->getContents();
 					command_name += "\"";
@@ -3111,7 +3273,7 @@ void Buffer::makeDocBookFile(string const & fname, bool nice, bool only_body)
 			}
 
 			if (environment_stack[depth] != style.latexname()) {
-				if(environment_stack.size() == depth + 1) {
+				if (environment_stack.size() == depth + 1) {
 					environment_stack.push_back("!-- --");
 					environment_inner.push_back("!-- --");
 				}
@@ -3131,10 +3293,10 @@ void Buffer::makeDocBookFile(string const & fname, bool nice, bool only_body)
 							     environment_inner[depth]);
 				}
 			}
-			
+
 			if (style.latextype == LATEX_ENVIRONMENT) {
 				if (!style.latexparam().empty()) {
-					if(style.latexparam() == "CDATA")
+					if (style.latexparam() == "CDATA")
 						ofs << "<![CDATA[";
 					else
 						sgmlOpenTag(ofs, depth + command_depth,
@@ -3169,9 +3331,7 @@ void Buffer::makeDocBookFile(string const & fname, bool nice, bool only_body)
 			break;
 		}
 
-		string extra_par;
-		simpleDocBookOnePar(ofs, extra_par, par, desc_on,
-				    depth + 1 + command_depth);
+		simpleDocBookOnePar(ofs, par, desc_on, depth+1+command_depth);
 		par = par->next();
 
 		string end_tag;
@@ -3186,7 +3346,7 @@ void Buffer::makeDocBookFile(string const & fname, bool nice, bool only_body)
 			break;
 		case LATEX_ENVIRONMENT:
 			if (!style.latexparam().empty()) {
-				if(style.latexparam() == "CDATA")
+				if (style.latexparam() == "CDATA")
 					ofs << "]]>";
 				else
 					sgmlCloseTag(ofs, depth + command_depth,
@@ -3214,16 +3374,16 @@ void Buffer::makeDocBookFile(string const & fname, bool nice, bool only_body)
 				item_name = "listitem";
 				sgmlCloseTag(ofs, command_depth + depth,
 					     item_name);
-                               if (environment_inner[depth] == "varlistentry")
+			       if (environment_inner[depth] == "varlistentry")
 				       sgmlCloseTag(ofs, depth + command_depth,
 						    environment_inner[depth]);
 			}
-			
+
 			sgmlCloseTag(ofs, depth + command_depth,
 				     environment_stack[depth]);
 		}
 	}
-	
+
 	for (int j = command_depth; j >= 0 ; --j)
 		if (!command_stack[j].empty())
 			sgmlCloseTag(ofs, j, command_stack[j]);
@@ -3233,17 +3393,20 @@ void Buffer::makeDocBookFile(string const & fname, bool nice, bool only_body)
 
 	ofs.close();
 	// How to check for successful close
+
+	// we want this to be true outside previews (for insetexternal)
+	niceFile = true;
 }
 
 
-void Buffer::simpleDocBookOnePar(ostream & os, string & extra,
+void Buffer::simpleDocBookOnePar(ostream & os,
 				 Paragraph * par, int & desc_on,
 				 Paragraph::depth_type depth) const
 {
 	bool emph_flag = false;
 
-	LyXLayout const & style = textclasslist.Style(params.textclass,
-						      par->getLayout());
+	LyXLayout const & style =
+		textclasslist[params.textclass][par->layout()];
 
 	LyXFont font_old = style.labeltype == LABEL_MANUAL ? style.labelfont : style.font;
 
@@ -3252,8 +3415,7 @@ void Buffer::simpleDocBookOnePar(ostream & os, string & extra,
 	//	os << string(depth,' ');
 
 	// parsing main loop
-	for (Paragraph::size_type i = 0;
-	     i < par->size(); ++i) {
+	for (pos_type i = 0; i < par->size(); ++i) {
 		LyXFont font = par->getFont(params, i);
 
 		// handle <emphasis> tag
@@ -3261,63 +3423,38 @@ void Buffer::simpleDocBookOnePar(ostream & os, string & extra,
 			if (font.emph() == LyXFont::ON) {
 				os << "<emphasis>";
 				emph_flag = true;
-			}else if(i) {
+			} else if (i) {
 				os << "</emphasis>";
 				emph_flag = false;
 			}
 		}
-      
-		char c = par->getChar(i);
 
-		if (c == Paragraph::META_INSET) {
-			Inset * inset = par->getInset(i);
-			ostringstream ost;
-			inset->docBook(this, ost);
-			string tmp_out = ost.str().c_str();
 
-			//
-			// This code needs some explanation:
-			// Two insets are treated specially
-			//   label if it is the first element in a command paragraph
-			//         desc_on == 3
-			//   graphics inside tables or figure floats can't go on
-			//   title (the equivalente in latex for this case is caption
-			//   and title should come first
-			//         desc_on == 4
-			//
-			if (desc_on!= 3 || i!= 0) {
-				if (!tmp_out.empty() && tmp_out[0] == '@') {
-					if (desc_on == 4)
-						extra += frontStrip(tmp_out, '@');
-					else
-						os << frontStrip(tmp_out, '@');
-				}
-				else
-					os << tmp_out;
+		if (par->isInset(i)) {
+			Inset * inset = par->getInset(i);
+			// don't print the inset in position 0 if desc_on == 3 (label)
+			if ( i || desc_on != 3) {
+				if(style.latexparam() == "CDATA")
+					os << "]]>";
+				inset->docbook(this, os);
+				if(style.latexparam() == "CDATA")
+					os << "<![CDATA[";
 			}
-#ifndef NO_LATEX
-		} else if (font.latex() == LyXFont::ON) {
-			// "TeX"-Mode on ==> SGML-Mode on.
-			if (c != '\0')
-				os << c;
-			++char_line_count;
-#endif
 		} else {
+			char c = par->getChar(i);
 			string sgml_string;
-			if (par->linuxDocConvertChar(c, sgml_string)
-			    && !style.free_spacing) { // in freespacing
-				                     // mode, spaces are
-				                     // non-breaking characters
-				// char is ' '
-				if (desc_on == 1) {
-					++char_line_count;
-					os << "\n</term><listitem><para>";
-					desc_on = 2;
-				} else {
-					os << c;
-				}
+			par->sgmlConvertChar(c, sgml_string);
+
+			if (style.pass_thru) {
+				os << c;
+			} else if (style.free_spacing || par->isFreeSpacing() || c != ' ') {
+					os << sgml_string;
+			} else if (desc_on ==1) {
+				++char_line_count;
+				os << "\n</term><listitem><para>";
+				desc_on = 2;
 			} else {
-				os << sgml_string;
+				os << ' ';
 			}
 		}
 		font_old = font;
@@ -3326,13 +3463,13 @@ void Buffer::simpleDocBookOnePar(ostream & os, string & extra,
 	if (emph_flag) {
 		os << "</emphasis>";
 	}
-	
+
 	// resets description flag correctly
 	if (desc_on == 1) {
 		// <term> not closed...
-		os << "</term>";
+		os << "</term>\n<listitem><para>&nbsp;</para>";
 	}
-	if(style.free_spacing) os << '\n';
+	if (style.free_spacing) os << '\n';
 }
 
 
@@ -3347,11 +3484,11 @@ int Buffer::runChktex()
 
 	// get LaTeX-Filename
 	string const name = getLatexName();
-	string path = OnlyPath(filename);
+	string path = filePath();
 
 	string const org_path = path;
-	if (lyxrc.use_tempdir || (IsDirWriteable(path) < 1)) {
-		path = tmppath;	 
+	if (lyxrc.use_tempdir || !IsDirWriteable(path)) {
+		path = tmppath;
 	}
 
 	Path p(path); // path to LaTeX file
@@ -3364,11 +3501,11 @@ int Buffer::runChktex()
 	makeLaTeXFile(name, org_path, false);
 
 	TeXErrors terr;
-	Chktex chktex(lyxrc.chktex_command, name, filepath);
+	Chktex chktex(lyxrc.chktex_command, name, filePath());
 	int res = chktex.run(terr); // run chktex
 
 	if (res == -1) {
-		WriteAlert(_("chktex did not work!"),
+		Alert::alert(_("chktex did not work!"),
 			   _("Could not run with file:"), name);
 	} else if (res > 0) {
 		// Insert all errors as errors boxes
@@ -3377,9 +3514,9 @@ int Buffer::runChktex()
 
 	// if we removed error insets before we ran chktex or if we inserted
 	// error insets after we ran chktex, this must be run:
-	if (removedErrorInsets || res){
+	if (removedErrorInsets || res) {
 		users->redraw();
-		users->fitCursor(users->text);
+		users->fitCursor();
 	}
 	users->owner()->allowInput();
 
@@ -3390,13 +3527,12 @@ int Buffer::runChktex()
 void Buffer::validate(LaTeXFeatures & features) const
 {
 	Paragraph * par = paragraph;
-        LyXTextClass const & tclass = 
-		textclasslist.TextClass(params.textclass);
-    
-        // AMS Style is at document level
-        features.amsstyle = (params.use_amsmath ||
-			     tclass.provides(LyXTextClass::amsmath));
-    
+	LyXTextClass const & tclass = textclasslist[params.textclass];
+
+	// AMS Style is at document level
+	if (params.use_amsmath || tclass.provides(LyXTextClass::amsmath))
+		features.require("amsmath");
+
 	while (par) {
 		// We don't use "lyxerr.debug" because of speed. (Asger)
 		if (lyxerr.debugging(Debug::LATEX))
@@ -3424,49 +3560,22 @@ void Buffer::validate(LaTeXFeatures & features) const
 				   || c == 25
 				   || c == 26
 				   || c == 31) {
-					features.latexsym = true;
+					features.require("latexsym");
 				}
 			} else if (font == 1) {
-				features.amssymb = true;
+				features.require("amssymb");
 			} else if ((font >= 2 && font <= 5)) {
-				features.pifont = true;
+				features.require("pifont");
 			}
 		}
 	}
-	
+
 	if (lyxerr.debugging(Debug::LATEX)) {
 		features.showStruct();
 	}
 }
 
 
-void Buffer::setPaperStuff()
-{
-	params.papersize = BufferParams::PAPER_DEFAULT;
-	char const c1 = params.paperpackage;
-	if (c1 == BufferParams::PACKAGE_NONE) {
-		char const c2 = params.papersize2;
-		if (c2 == BufferParams::VM_PAPER_USLETTER)
-			params.papersize = BufferParams::PAPER_USLETTER;
-		else if (c2 == BufferParams::VM_PAPER_USLEGAL)
-			params.papersize = BufferParams::PAPER_LEGALPAPER;
-		else if (c2 == BufferParams::VM_PAPER_USEXECUTIVE)
-			params.papersize = BufferParams::PAPER_EXECUTIVEPAPER;
-		else if (c2 == BufferParams::VM_PAPER_A3)
-			params.papersize = BufferParams::PAPER_A3PAPER;
-		else if (c2 == BufferParams::VM_PAPER_A4)
-			params.papersize = BufferParams::PAPER_A4PAPER;
-		else if (c2 == BufferParams::VM_PAPER_A5)
-			params.papersize = BufferParams::PAPER_A5PAPER;
-		else if ((c2 == BufferParams::VM_PAPER_B3) || (c2 == BufferParams::VM_PAPER_B4) ||
-			 (c2 == BufferParams::VM_PAPER_B5))
-			params.papersize = BufferParams::PAPER_B5PAPER;
-	} else if ((c1 == BufferParams::PACKAGE_A4) || (c1 == BufferParams::PACKAGE_A4WIDE) ||
-		   (c1 == BufferParams::PACKAGE_WIDEMARGINSA4))
-		params.papersize = BufferParams::PAPER_A4PAPER;
-}
-
-
 // This function should be in Buffer because it's a buffer's property (ale)
 string const Buffer::getIncludeonlyList(char delim)
 {
@@ -3474,7 +3583,7 @@ string const Buffer::getIncludeonlyList(char delim)
 	for (inset_iterator it = inset_iterator_begin();
 	    it != inset_iterator_end(); ++it) {
 		if ((*it)->lyxCode() == Inset::INCLUDE_CODE) {
-			InsetInclude * insetinc = 
+			InsetInclude * insetinc =
 				static_cast<InsetInclude *>(*it);
 			if (insetinc->isIncludeOnly()) {
 				if (!lst.empty())
@@ -3513,47 +3622,45 @@ Buffer::Lists const Buffer::getLists() const
 {
 	Lists l;
 	Paragraph * par = paragraph;
-	bool found;
-	LyXTextClassList::size_type cap;
-	boost::tie(found, cap) = textclasslist
-		.NumberOfLayout(params.textclass, "Caption");
+
+	LyXTextClass const & textclass = textclasslist[params.textclass];
+	bool found = textclass.hasLayout("Caption");
+	string const layout("Caption");
 
 	while (par) {
-		char const labeltype =
-			textclasslist.Style(params.textclass, 
-					    par->getLayout()).labeltype;
-		
+		char const labeltype = textclass[par->layout()].labeltype;
+
 		if (labeltype >= LABEL_COUNTER_CHAPTER
 		    && labeltype <= LABEL_COUNTER_CHAPTER + params.tocdepth) {
 				// insert this into the table of contents
 			SingleList & item = l["TOC"];
 			int depth = max(0,
-					labeltype - 
-					textclasslist.TextClass(params.textclass).maxcounter());
+					labeltype -
+					textclass.maxcounter());
 			item.push_back(TocItem(par, depth, par->asString(this, true)));
 		}
 		// For each paragrph, traverse its insets and look for
 		// FLOAT_CODE
-		
+
 		if (found) {
 			Paragraph::inset_iterator it =
 				par->inset_iterator_begin();
 			Paragraph::inset_iterator end =
 				par->inset_iterator_end();
-			
+
 			for (; it != end; ++it) {
 				if ((*it)->lyxCode() == Inset::FLOAT_CODE) {
 					InsetFloat * il =
 						static_cast<InsetFloat*>(*it);
-					
+
 					string const type = il->type();
-					
+
 					// Now find the caption in the float...
 					// We now tranverse the paragraphs of
 					// the inset...
 					Paragraph * tmp = il->inset.paragraph();
 					while (tmp) {
-						if (tmp->layout == cap) {
+						if (tmp->layout() == layout) {
 							SingleList & item = l[type];
 							string const str =
 								tostr(item.size()+1) + ". " + tmp->asString(this, false);
@@ -3564,9 +3671,9 @@ Buffer::Lists const Buffer::getLists() const
 				}
 			}
 		} else {
-			lyxerr << "caption not found" << endl;
+			lyxerr << "Caption not found" << endl;
 		}
-		
+
 		par = par->next();
 	}
 	return l;
@@ -3578,7 +3685,7 @@ vector<pair<string, string> > const Buffer::getBibkeyList()
 {
 	/// if this is a child document and the parent is already loaded
 	/// Use the parent's list instead  [ale990412]
-        if (!params.parentname.empty() && bufferlist.exists(params.parentname)) {
+	if (!params.parentname.empty() && bufferlist.exists(params.parentname)) {
 		Buffer * tmp = bufferlist.getBuffer(params.parentname);
 		if (tmp)
 			return tmp->getBibkeyList();
@@ -3609,7 +3716,7 @@ vector<pair<string, string> > const Buffer::getBibkeyList()
 			}
 		}
 	}
- 
+
 	return keys;
 }
 
@@ -3662,7 +3769,7 @@ bool Buffer::dispatch(int action, string const & argument)
 {
 	bool dispatched = true;
 	switch (action) {
-		case LFUN_EXPORT: 
+		case LFUN_EXPORT:
 			Exporter::Export(this, argument, false);
 			break;
 
@@ -3685,36 +3792,32 @@ void Buffer::resizeInsets(BufferView * bv)
 
 void Buffer::redraw()
 {
-	users->redraw(); 
-	users->fitCursor(users->text); 
+	users->redraw();
+	users->fitCursor();
 }
 
 
 void Buffer::changeLanguage(Language const * from, Language const * to)
 {
 
-	Paragraph * par = paragraph;
-	while (par) {
-		par->changeLanguage(params, from, to);
-		par = par->next();
-	}
+	ParIterator end = par_iterator_end();
+	for (ParIterator it = par_iterator_begin(); it != end; ++it)
+		(*it)->changeLanguage(params, from, to);
 }
 
 
 bool Buffer::isMultiLingual()
 {
-	Paragraph * par = paragraph;
-	while (par) {
-		if (par->isMultiLingual(params))
+	ParIterator end = par_iterator_end();
+	for (ParIterator it = par_iterator_begin(); it != end; ++it)
+		if ((*it)->isMultiLingual(params))
 			return true;
-		par = par->next();
-	}
+
 	return false;
 }
 
 
-Buffer::inset_iterator::inset_iterator(Paragraph * paragraph,
-				       Paragraph::size_type pos)
+Buffer::inset_iterator::inset_iterator(Paragraph * paragraph, pos_type pos)
 	: par(paragraph)
 {
 	it = par->InsetIterator(pos);
@@ -3769,3 +3872,15 @@ Paragraph * Buffer::getParFromID(int id) const
 	}
 	return 0;
 }
+
+
+ParIterator Buffer::par_iterator_begin()
+{
+	return ParIterator(paragraph);
+}
+
+
+ParIterator Buffer::par_iterator_end()
+{
+	return ParIterator();
+}