X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Fbuffer.C;h=62750128c60941c70bda4896eb53bf3539415296;hb=dacb5be6462e278d769686b7380984b584dd86ac;hp=2dd798f084f4e1e325c01579bef443a2e93c5116;hpb=08c732ecfad8cb933399b31f5591373fe8195f3a;p=lyx.git

diff --git a/src/buffer.C b/src/buffer.C
index 2dd798f084..62750128c6 100644
--- a/src/buffer.C
+++ b/src/buffer.C
@@ -24,6 +24,10 @@
 
 #include <algorithm>
 
+#ifdef HAVE_LOCALE
+#include <locale>
+#endif
+
 #ifdef __GNUG__
 #pragma implementation "buffer.h"
 #endif
@@ -56,9 +60,6 @@
 #include "insets/insetindex.h" 
 #include "insets/insetinclude.h"
 #include "insets/insettoc.h"
-#include "insets/insetlof.h"
-#include "insets/insetlot.h"
-#include "insets/insetloa.h"
 #include "insets/insetparent.h"
 #include "insets/insetspecialchar.h"
 #include "insets/figinset.h"
@@ -72,10 +73,10 @@
 #include "insets/insetlist.h"
 #include "insets/insettabular.h"
 #include "insets/insettheorem.h"
+#include "insets/insetcaption.h"
 #include "support/filetools.h"
 #include "support/path.h"
 #include "LaTeX.h"
-#include "Literate.h"
 #include "Chktex.h"
 #include "LyXView.h"
 #include "debug.h"
@@ -83,12 +84,15 @@
 #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"
 
 using std::ostream;
 using std::ofstream;
@@ -105,11 +109,10 @@ using std::set;
 // all these externs should eventually be removed.
 extern BufferList bufferlist;
 
-extern void MenuExport(Buffer *, string const &);
 extern LyXAction lyxaction;
 
 
-static const float LYX_FORMAT = 2.16;
+static const float LYX_FORMAT = 2.17;
 
 extern int tex_code_break_column;
 
@@ -124,6 +127,7 @@ Buffer::Buffer(string const & file, bool ronly)
 	bak_clean = true;
 	dep_clean = 0;
 	read_only = ronly;
+	unnamed = false;
 	users = 0;
 	lyxvc.buffer(this);
 	if (read_only || (lyxrc.use_tempdir)) {
@@ -158,7 +162,7 @@ Buffer::~Buffer()
 }
 
 
-string Buffer::getLatexName(bool no_path) const
+string const Buffer::getLatexName(bool no_path) const
 {
 	if (no_path)
 		return OnlyFilename(ChangeExtension(MakeLatexName(filename), 
@@ -174,7 +178,7 @@ void Buffer::setReadonly(bool flag)
 	if (read_only != flag) {
 		read_only = flag; 
 		updateTitles();
-		users->owner()->getDialogs()->updateBufferDependent();
+		users->owner()->getDialogs()->updateBufferDependent(false);
 	}
 	if (read_only) {
 		WarnReadonly(filename);
@@ -182,9 +186,9 @@ void Buffer::setReadonly(bool flag)
 }
 
 
-bool Buffer::saveParamsAsDefaults()
+bool Buffer::saveParamsAsDefaults() // const
 {
-	string fname = AddName(AddPath(user_lyxdir, "templates/"),
+	string const fname = AddName(AddPath(user_lyxdir, "templates/"),
 			       "defaults.lyx");
 	Buffer defaults = Buffer(fname);
 	
@@ -214,7 +218,7 @@ void Buffer::resetAutosaveTimers() const
 }
 
 
-void Buffer::fileName(string const & newfile)
+void Buffer::setFileName(string const & newfile)
 {
 	filename = MakeAbsPath(newfile);
 	filepath = OnlyPath(filename);
@@ -231,27 +235,26 @@ void Buffer::fileName(string const & newfile)
 // if par = 0 normal behavior
 // else insert behavior
 // Returns false if "\the_end" is not read for formats >= 2.13. (Asger)
-#define USE_PARSE_FUNCTION 1
-//#define USE_TABULAR_INSETS 1
 bool Buffer::readLyXformat2(LyXLex & lex, LyXParagraph * par)
 {
-	string tmptok;
 	int pos = 0;
 	char depth = 0; // signed or unsigned?
+#ifndef NEW_INSETS
 	LyXParagraph::footnote_flag footnoteflag = LyXParagraph::NO_FOOTNOTE;
 	LyXParagraph::footnote_kind footnotekind = LyXParagraph::FOOTNOTE;
+#endif
 	bool the_end_read = false;
 
 	LyXParagraph * return_par = 0;
-	LyXFont font(LyXFont::ALL_INHERIT, params.language_info);
-	if (format < 2.16 && params.language == "hebrew")
+	LyXFont font(LyXFont::ALL_INHERIT, params.language);
+	if (format < 2.16 && params.language->lang() == "hebrew")
 		font.setLanguage(default_language);
 
 	// If we are inserting, we cheat and get a token in advance
 	bool has_token = false;
 	string pretoken;
 
-	if(!par) {
+	if (!par) {
 		par = new LyXParagraph;
 	} else {
 		users->text->BreakParagraph(users);
@@ -278,15 +281,17 @@ bool Buffer::readLyXformat2(LyXLex & lex, LyXParagraph * par)
 			pretoken = lex.GetString();
 		}
 
-		// Profiling show this should give a lot: (Asger)
-		string const token = pretoken;
-
-		if (token.empty())
-			continue;
-		the_end_read = parseSingleLyXformat2Token(lex, par, return_par,
-							  token, pos, depth,
-							  font, footnoteflag,
-							  footnotekind);
+		if (pretoken.empty()) continue;
+		
+		the_end_read =
+			parseSingleLyXformat2Token(lex, par, return_par,
+						   pretoken, pos, depth,
+						   font
+#ifndef NEW_INSETS
+						   , footnoteflag,
+						   footnotekind
+#endif
+				);
 	}
    
 	if (!return_par)
@@ -298,16 +303,23 @@ bool Buffer::readLyXformat2(LyXLex & lex, LyXParagraph * par)
 }
 
 
+// We'll remove this later. (Lgb)
+static string last_inset_read;
+
+
 bool
 Buffer::parseSingleLyXformat2Token(LyXLex & lex, LyXParagraph *& par,
 				   LyXParagraph *& return_par,
 				   string const & token, int & pos,
-				   char & depth, LyXFont & font,
-				   LyXParagraph::footnote_flag & footnoteflag,
-				   LyXParagraph::footnote_kind & footnotekind)
+				   char & depth, LyXFont & font
+#ifndef NEW_INSETS
+				   , LyXParagraph::footnote_flag & footnoteflag,
+				   LyXParagraph::footnote_kind & footnotekind
+#endif
+	)
 {
 	bool the_end_read = false;
-
+	
 	if (token[0] != '\\') {
 		for (string::const_iterator cit = token.begin();
 		     cit != token.end(); ++cit) {
@@ -328,7 +340,7 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, LyXParagraph *& par,
 		}
 		pos = 0;
 		lex.EatLine();
-		string layoutname = lex.GetString();
+		string const layoutname = lex.GetString();
 		pair<bool, LyXTextClass::LayoutList::size_type> pp
 			= textclasslist.NumberOfLayout(params.textclass,
 						       layoutname);
@@ -346,11 +358,13 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, LyXParagraph *& par,
 			par->layout = 
 				textclasslist.NumberOfLayout(params.textclass, 
 							     layout.obsoleted_by()).second;
+#ifndef NEW_INSETS
 		par->footnoteflag = footnoteflag;
 		par->footnotekind = footnotekind;
+#endif
 		par->depth = depth;
-		font = LyXFont(LyXFont::ALL_INHERIT, params.language_info);
-		if (format < 2.16 && params.language == "hebrew")
+		font = LyXFont(LyXFont::ALL_INHERIT, params.language);
+		if (format < 2.16 && params.language->lang() == "hebrew")
 			font.setLanguage(default_language);
 #ifndef NEW_INSETS
 	} else if (token == "\\end_float") {
@@ -365,8 +379,8 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, LyXParagraph *& par,
 		pos = 0;
 		lex.EatLine();
 		par->layout = LYX_DUMMY_LAYOUT;
-		font = LyXFont(LyXFont::ALL_INHERIT, params.language_info);
-		if (format < 2.16 && params.language == "hebrew")
+		font = LyXFont(LyXFont::ALL_INHERIT, params.language);
+		if (format < 2.16 && params.language->lang() == "hebrew")
 			font.setLanguage(default_language);
 	} else if (token == "\\begin_float") {
 		int tmpret = lex.FindToken(string_footnotekinds);
@@ -383,35 +397,68 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, LyXParagraph *& par,
 		// This is the compability reader, unfinished but tested.
 		// (Lgb)
 		lex.next();
-		string tmptok = lex.GetString();
+		string const tmptok = lex.GetString();
 		//lyxerr << "old float: " << tmptok << endl;
 		
 		Inset * inset = 0;
+		string old_float;
 		
 		if (tmptok == "footnote") {
 			inset = new InsetFoot;
 		} else if (tmptok == "margin") {
 			inset = new InsetMarginal;
 		} else if (tmptok == "fig") {
-			//inset = new InsetFigure;
+			inset = new InsetFloat("figure");
+			old_float += "placement htbp\n";
 		} else if (tmptok == "tab") {
-			//inset = new InsetTable;
+			inset = new InsetFloat("table");
+			old_float += "placement htbp\n";
 		} else if (tmptok == "alg") {
-			//inset = new InsetAlgorithm;
+			inset = new InsetFloat("algorithm");
+			old_float += "placement htbp\n";
 		} else if (tmptok == "wide-fig") {
-			//inset = new InsetFigure(true);
+			InsetFloat * tmp = new InsetFloat("figure");
+			tmp->wide(true);
+			inset = tmp;
+			old_float += "placement htbp\n";
 		} else if (tmptok == "wide-tab") {
-			//inset = new InsetTable(true);
+			InsetFloat * tmp = new InsetFloat("table");
+			tmp->wide(true);
+			inset = tmp;
+			old_float += "placement htbp\n";
 		}
 
 		if (!inset) return false; // no end read yet
 		
-		string old_float = "\ncollapsed true\n";
+		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();
+			if (tmp == "\\end_deeper") {
+				lyxerr << "\\end_deeper caught!" << endl;
+				if (!depth) {
+					lex.printError("\\end_deeper: "
+						       "depth is already null");
+				} else
+					--depth;
+				
+			} else {
+				old_float += tmp;
+				old_float += ' ';
+				break;
+			}
+		}
+		
 		old_float += lex.getLongString("\\end_float");
 		old_float += "\n\\end_inset\n";
-		lyxerr << "float body: " << old_float << endl;
+		//lyxerr << "float body: " << old_float << endl;
+
+		istringstream istr(old_float);
 		
-		istrstream istr(old_float.c_str());
 		LyXLex nylex(0, 0);
 		nylex.setStream(istr);
 		
@@ -437,7 +484,7 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, LyXParagraph *& par,
 		if (pp.first) {
 			params.textclass = pp.second;
 		} else {
-			lex.printError("Unknown textclass `$$Token'");
+		  lex.printError("Unknown textclass `$$Token'");
 			params.textclass = 0;
 		}
 		if (!textclasslist.Load(params.textclass)) {
@@ -503,7 +550,7 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, LyXParagraph *& par,
 		if (tmpret != LYX_LAYOUT_DEFAULT) {
 			InsetQuotes::quote_language tmpl = 
 				InsetQuotes::EnglishQ;
-			switch(tmpret) {
+			switch (tmpret) {
 			case 0:
 				tmpl = InsetQuotes::EnglishQ;
 				break;
@@ -527,7 +574,7 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, LyXParagraph *& par,
 		}
 	} else if (token == "\\quotes_times") {
 		lex.nextToken();
-		switch(lex.GetInteger()) {
+		switch (lex.GetInteger()) {
 		case 1: 
 			params.quotes_times = InsetQuotes::SingleQ; 
 			break;
@@ -594,7 +641,7 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, LyXParagraph *& par,
 		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;
@@ -604,7 +651,7 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, LyXParagraph *& par,
 		params.pagestyle = strip(lex.GetString());
 	} else if (token == "\\bullet") {
 		lex.nextToken();
-		int index = lex.GetInteger();
+		int const index = lex.GetInteger();
 		lex.nextToken();
 		int temp_int = lex.GetInteger();
 		params.user_defined_bullets[index].setFont(temp_int);
@@ -618,7 +665,7 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, LyXParagraph *& par,
 		params.user_defined_bullets[index].setSize(temp_int);
 		params.temp_bullets[index].setSize(temp_int);
 		lex.nextToken();
-		string 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
@@ -629,9 +676,10 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, LyXParagraph *& par,
 		}
 	} else if (token == "\\bulletLaTeX") {
 		lex.nextToken();
-		int index = lex.GetInteger();
+		int const index = lex.GetInteger();
 		lex.next();
-		string temp_str = lex.GetString(), sum_str;
+		string temp_str = lex.GetString();
+		string sum_str;
 		while (temp_str != "\\end_bullet") {
 				// this loop structure is needed when user
 				// enters an empty string since the first
@@ -653,7 +701,7 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, LyXParagraph *& par,
 		params.tocdepth = lex.GetInteger();
 	} else if (token == "\\spacing") {
 		lex.next();
-		string tmp = strip(lex.GetString());
+		string const tmp = strip(lex.GetString());
 		Spacing::Space tmp_space = Spacing::Default;
 		float tmp_val = 0.0;
 		if (tmp == "single") {
@@ -678,7 +726,7 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, LyXParagraph *& par,
 		}
 	} else if (token == "\\paragraph_spacing") {
 		lex.next();
-		string tmp = strip(lex.GetString());
+		string const tmp = strip(lex.GetString());
 		if (tmp == "single") {
 			par->spacing.set(Spacing::Single);
 		} else if (tmp == "onehalf") {
@@ -709,7 +757,7 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, LyXParagraph *& par,
 		font.setLyXSize(lex.GetString());
 	} else if (token == "\\latex") {
 		lex.next();
-		string tok = lex.GetString();
+		string const tok = lex.GetString();
 		// This is dirty, but gone with LyX3. (Asger)
 		if (tok == "no_latex")
 			font.setLatex(LyXFont::OFF);
@@ -722,20 +770,23 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, LyXParagraph *& par,
 				       "`$$Token'");
 	} else if (token == "\\lang") {
 		lex.next();
-		string tok = lex.GetString();
-		Languages::iterator lit = languages.find(tok);
-		if (lit != languages.end()) {
-			font.setLanguage(&(*lit).second);
+		string const tok = lex.GetString();
+		Language const * lang = languages.getLanguage(tok);
+		if (lang) {
+			font.setLanguage(lang);
 		} else {
-			font.setLanguage(params.language_info);
+			font.setLanguage(params.language);
 			lex.printError("Unknown language `$$Token'");
 		}
+	} else if (token == "\\numeric") {
+		lex.next();
+		font.setNumber(font.setLyXMisc(lex.GetString()));
 	} else if (token == "\\emph") {
 		lex.next();
 		font.setEmph(font.setLyXMisc(lex.GetString()));
 	} else if (token == "\\bar") {
 		lex.next();
-		string tok = lex.GetString();
+		string const tok = lex.GetString();
 		// This is dirty, but gone with LyX3. (Asger)
 		if (tok == "under")
 			font.setUnderbar(LyXFont::ON);
@@ -790,146 +841,15 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, LyXParagraph *& par,
 		par->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"
+		       << "Last inset read was: " << last_inset_read
+		       << endl;
 		// Simply ignore this. The insets do not have
 		// to read this.
 		// But insets should read it, it is a part of
 		// the inset isn't it? Lgb.
 	} else if (token == "\\begin_inset") {
-		// Should be moved out into its own function/method. (Lgb)
-		lex.next();
-		string tmptok = lex.GetString();
-		// test the different insets
-		if (tmptok == "Quotes") {
-			Inset * inset = new InsetQuotes;
-			inset->Read(this, lex);
-			par->InsertInset(pos, inset, font);
-			++pos;
-		} else if (tmptok == "External") {
-			Inset * inset = new InsetExternal;
-			inset->Read(this, lex);
-			par->InsertInset(pos, inset, font);
-			++pos;
-		} else if (tmptok == "FormulaMacro") {
-			Inset * inset = new InsetFormulaMacro;
-			inset->Read(this, lex);
-			par->InsertInset(pos, inset, font);
-			++pos;
-		} else if (tmptok == "Formula") {
-			Inset * inset = new InsetFormula;
-			inset->Read(this, lex);
-			par->InsertInset(pos, inset, font);
-			++pos;
-		} else if (tmptok == "Figure") {
-			Inset * inset = new InsetFig(100, 100, this);
-			inset->Read(this, lex);
-			par->InsertInset(pos, inset, font);
-			++pos;
-		} else if (tmptok == "Info") {
-			Inset * inset = new InsetInfo;
-			inset->Read(this, lex);
-			par->InsertInset(pos, inset, font);
-			++pos;
-		} else if (tmptok == "Include") {
-			Inset * inset = new InsetInclude(string(), this);
-			inset->Read(this, lex);
-			par->InsertInset(pos, inset, font);
-			++pos;
-		} else if (tmptok == "ERT") {
-			Inset * inset = new InsetERT;
-			inset->Read(this, lex);
-			par->InsertInset(pos, inset, font);
-			++pos;
-		} else if (tmptok == "Tabular") {
-			Inset * inset = new InsetTabular(this);
-			inset->Read(this, lex);
-			par->InsertInset(pos, inset, font);
-			++pos;
-		} else if (tmptok == "Text") {
-			Inset * inset = new InsetText;
-			inset->Read(this, lex);
-			par->InsertInset(pos, inset, font);
-			++pos;
-		} else if (tmptok == "Foot") {
-			Inset * inset = new InsetFoot;
-			inset->Read(this, lex);
-			par->InsertInset(pos, inset, font);
-			++pos;
-		} else if (tmptok == "Marginal") {
-			Inset * inset = new InsetMarginal;
-			inset->Read(this, lex);
-			par->InsertInset(pos, inset, font);
-			++pos;
-		} else if (tmptok == "Minipage") {
-			Inset * inset = new InsetMinipage;
-			inset->Read(this, lex);
-			par->InsertInset(pos, inset, font);
-			++pos;
-		} else if (tmptok == "Float") {
-			Inset * inset = new InsetFloat;
-			inset->Read(this, lex);
-			par->InsertInset(pos, inset, font);
-			++pos;
-		} else if (tmptok == "List") {
-			Inset * inset = new InsetList;
-			inset->Read(this, lex);
-			par->InsertInset(pos, inset, font);
-			++pos;
-		} else if (tmptok == "Theorem") {
-			Inset * inset = new InsetList;
-			inset->Read(this, lex);
-			par->InsertInset(pos, inset, font);
-			++pos;
-		} else if (tmptok == "GRAPHICS") {
-			Inset * inset = new InsetGraphics;
-				//inset->Read(this, lex);
-			par->InsertInset(pos, inset, font);
-		} else if (tmptok == "LatexCommand") {
-			InsetCommand inscmd;
-			inscmd.Read(this, lex);
-			Inset * inset = 0;
-			if (inscmd.getCmdName() == "cite") {
-				inset = new InsetCitation(inscmd.getContents(), inscmd.getOptions());
-			} else if (inscmd.getCmdName() == "bibitem") {
-				lex.printError("Wrong place for bibitem");
-				inset = inscmd.Clone();
-			} else if (inscmd.getCmdName() == "BibTeX") {
-				inset = new InsetBibtex(inscmd.getContents(), inscmd.getOptions(), this);
-			} else if (inscmd.getCmdName() == "index") {
-				inset = new InsetIndex(inscmd.getContents());
-			} else if (inscmd.getCmdName() == "include") {
-				inset = new InsetInclude(inscmd.getContents(), this);
-			} else if (inscmd.getCmdName() == "label") {
-				inset = new InsetLabel(inscmd.getCommand());
-			} else if (inscmd.getCmdName() == "url"
-				   || inscmd.getCmdName() == "htmlurl") {
-				inset = new InsetUrl(inscmd.getCommand());
-			} else if (inscmd.getCmdName() == "ref"
-				   || inscmd.getCmdName() == "pageref"
-				   || inscmd.getCmdName() == "vref"
-				   || inscmd.getCmdName() == "vpageref"
-				   || inscmd.getCmdName() == "prettyref") {
-				if (!inscmd.getOptions().empty() || !inscmd.getContents().empty()) {
-					inset = new InsetRef(inscmd, this);
-				}
-			} else if (inscmd.getCmdName() == "tableofcontents") {
-				inset = new InsetTOC(this);
-			} else if (inscmd.getCmdName() == "listoffigures") {
-				inset = new InsetLOF(this);
-			} else if (inscmd.getCmdName() == "listofalgorithms") {
-				inset = new InsetLOA(this);
-			} else if (inscmd.getCmdName() == "listoftables") {
-				inset = new InsetLOT(this);
-			} else if (inscmd.getCmdName() == "printindex") {
-				inset = new InsetPrintIndex(this);
-			} else if (inscmd.getCmdName() == "lyxparent") {
-				inset = new InsetParent(inscmd.getContents(), this);
-			}
-			       
-			if (inset) {
-				par->InsertInset(pos, inset, font);
-				++pos;
-			}
-		}
+		readInset(lex, par, pos, font);
 	} else if (token == "\\SpecialChar") {
 		LyXLayout const & layout =
 			textclasslist.Style(params.textclass, 
@@ -938,9 +858,8 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, LyXParagraph *& par,
 		// Insets don't make sense in a free-spacing context! ---Kayvan
 		if (layout.free_spacing) {
 			if (lex.IsOK()) {
-				string next_token;
 				lex.next();
-				next_token = lex.GetString();
+				string next_token = lex.GetString();
 				if (next_token == "\\-") {
 					par->InsertChar(pos, '-', font);
 				} else if (next_token == "\\protected_separator"
@@ -963,14 +882,10 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, LyXParagraph *& par,
 		par->InsertChar(pos, LyXParagraph::META_NEWLINE, font);
 		++pos;
 	} else if (token == "\\LyXTable") {
-#ifdef USE_TABULAR_INSETS
-		Inset * inset = new InsetTabular(this);
+		Inset * inset = new InsetTabular(*this);
 		inset->Read(this, lex);
 		par->InsertInset(pos, inset, font);
 		++pos;
-#else
-		par->table = new LyXTable(lex);
-#endif
 	} else if (token == "\\hfill") {
 		par->InsertChar(pos, LyXParagraph::META_HFILL, font);
 		++pos;
@@ -990,20 +905,23 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, LyXParagraph *& par,
 		}
 		++pos;
 	} else if (token == "\\bibitem") {  // ale970302
-		if (!par->bibkey)
-			par->bibkey = new InsetBibKey;
+		if (!par->bibkey) {
+			InsetCommandParams p( "bibitem" );
+			par->bibkey = new InsetBibKey(p);
+		}
 		par->bibkey->Read(this, lex);		        
-	}else if (token == "\\backslash") {
+	} else if (token == "\\backslash") {
 		par->InsertChar(pos, '\\', font);
 		++pos;
-	}else if (token == "\\the_end") {
+	} else if (token == "\\the_end") {
 		the_end_read = true;
 	} else {
 		// This should be insurance for the future: (Asger)
 		lex.printError("Unknown token `$$Token'. "
 			       "Inserting as text.");
-		for(string::const_iterator cit = token.begin();
-		    cit != token.end(); ++cit) {
+		string::const_iterator cit = token.begin();
+		string::const_iterator end = token.end();
+		for (; cit != end; ++cit) {
 			par->InsertChar(pos, (*cit), font);
 			++pos;
 		}
@@ -1011,24 +929,130 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, LyXParagraph *& par,
 	return the_end_read;
 }
 
-bool Buffer::readFile(LyXLex & lex, LyXParagraph * par)
+
+void Buffer::readInset(LyXLex & lex, LyXParagraph *& par,
+		       int & pos, LyXFont & font)
 {
-	string token;
+	// consistency check
+	if (lex.GetString() != "\\begin_inset") {
+		lyxerr << "Buffer::readInset: Consistency check failed."
+		       << endl;
+	}
+	
+	Inset * inset = 0;
+
+	lex.next();
+	string const tmptok = lex.GetString();
+	last_inset_read = tmptok;
+
+	// test the different insets
+	if (tmptok == "LatexCommand") {
+		InsetCommandParams inscmd;
+		inscmd.Read(lex);
+
+		if (inscmd.getCmdName() == "cite") {
+			inset = new InsetCitation(inscmd);
+		} else if (inscmd.getCmdName() == "bibitem") {
+			lex.printError("Wrong place for bibitem");
+			inset = new InsetBibKey(inscmd);
+		} else if (inscmd.getCmdName() == "BibTeX") {
+			inset = new InsetBibtex(inscmd);
+		} else if (inscmd.getCmdName() == "index") {
+			inset = new InsetIndex(inscmd);
+		} else if (inscmd.getCmdName() == "include") {
+			inset = new InsetInclude(inscmd, *this);
+		} else if (inscmd.getCmdName() == "label") {
+			inset = new InsetLabel(inscmd);
+		} else if (inscmd.getCmdName() == "url"
+			   || inscmd.getCmdName() == "htmlurl") {
+			inset = new InsetUrl(inscmd);
+		} else if (inscmd.getCmdName() == "ref"
+			   || inscmd.getCmdName() == "pageref"
+			   || inscmd.getCmdName() == "vref"
+			   || inscmd.getCmdName() == "vpageref"
+			   || inscmd.getCmdName() == "prettyref") {
+			if (!inscmd.getOptions().empty()
+			    || !inscmd.getContents().empty()) {
+				inset = new InsetRef(inscmd, *this);
+			}
+		} else if (inscmd.getCmdName() == "tableofcontents"
+			   || inscmd.getCmdName() == "listofalgorithms"
+			   || inscmd.getCmdName() == "listoffigures"
+			   || inscmd.getCmdName() == "listoftables") {
+			inset = new InsetTOC(inscmd);
+		} else if (inscmd.getCmdName() == "printindex") {
+			inset = new InsetPrintIndex(inscmd);
+		} else if (inscmd.getCmdName() == "lyxparent") {
+			inset = new InsetParent(inscmd, *this);
+		}
+	} else {
+		if (tmptok == "Quotes") {
+			inset = new InsetQuotes;
+		} else if (tmptok == "External") {
+			inset = new InsetExternal;
+		} else if (tmptok == "FormulaMacro") {
+			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 == "Include") {
+			InsetCommandParams p( "Include" );
+			inset = new InsetInclude(p, *this);
+		} else if (tmptok == "ERT") {
+			inset = new InsetERT;
+		} else if (tmptok == "Tabular") {
+			inset = new InsetTabular(*this);
+		} else if (tmptok == "Text") {
+			inset = new InsetText;
+		} else if (tmptok == "Foot") {
+			inset = new InsetFoot;
+		} else if (tmptok == "Marginal") {
+			inset = new InsetMarginal;
+		} else if (tmptok == "Minipage") {
+			inset = new InsetMinipage;
+		} else if (tmptok == "Float") {
+			lex.next();
+			string tmptok = lex.GetString();
+			inset = new InsetFloat(tmptok);
+		} else if (tmptok == "List") {
+			inset = new InsetList;
+		} else if (tmptok == "Theorem") {
+			inset = new InsetList;
+		} else if (tmptok == "Caption") {
+			inset = new InsetCaption;
+		} else if (tmptok == "GRAPHICS") {
+			inset = new InsetGraphics;
+		}
+		
+		if (inset) inset->Read(this, lex);
+	}
+	
+	if (inset) {
+		par->InsertInset(pos, inset, font);
+		++pos;
+	}
+}
 
+
+bool Buffer::readFile(LyXLex & lex, LyXParagraph * par)
+{
 	if (lex.IsOK()) {
 		lex.next();
-		token = lex.GetString();
+		string const token(lex.GetString());
 		if (token == "\\lyxformat") { // the first token _must_ be...
-			lex.next();
+			lex.EatLine();
 			format = lex.GetFloat();
-			if (format > 1) {
+			if (format > 1.0) {
 				if (LYX_FORMAT - format > 0.05) {
-					printf(_("Warning: need lyxformat %.2f but found %.2f\n"),
-					       LYX_FORMAT, format);
+					lyxerr << fmt(_("Warning: need lyxformat %.2f but found %.2f"),
+						      LYX_FORMAT, format) << endl;
 				}
 				if (format - LYX_FORMAT > 0.05) {
-					printf(_("ERROR: need lyxformat %.2f but found %.2f\n"),
-					       LYX_FORMAT, format);
+					lyxerr << fmt(_("ERROR: need lyxformat %.2f but found %.2f"),
+						      LYX_FORMAT, format) << endl;
 				}
 				bool the_end = readLyXformat2(lex, par);
 				// Formats >= 2.13 support "\the_end" marker
@@ -1044,7 +1068,7 @@ bool Buffer::readFile(LyXLex & lex, LyXParagraph * par)
 				// We simulate a safe reading anyways to allow
 				// users to take the chance... (Asger)
 				return true;
-			} // format < 1
+			} // format < 1.0
 			else {
 				WriteAlert(_("ERROR!"),
 					   _("Old LyX file format found. "
@@ -1127,23 +1151,11 @@ bool Buffer::save() const
 	
 	if (writeFile(fileName(), false)) {
 		markLyxClean();
-
-		// now delete the autosavefile
-		string a = OnlyPath(fileName());
-		a += '#';
-		a += OnlyFilename(fileName());
-		a += '#';
-		FileInfo fileinfo(a);
-		if (fileinfo.exist()) {
-			if (::remove(a.c_str()) != 0) {
-				WriteFSAlert(_("Could not delete "
-					       "auto-save file!"), a);
-			}
-		}
+		removeAutosaveFile(fileName());
 	} else {
 		// Saving failed, so backup is not backup
 		if (lyxrc.make_backup) {
-			::rename(s.c_str(), fileName().c_str());
+			lyx::rename(s, fileName());
 		}
 		return false;
 	}
@@ -1193,6 +1205,12 @@ bool Buffer::writeFile(string const & fname, bool flag) const
 				     fname);
 		return false;
 	}
+
+#ifdef HAVE_LOCALE
+	// Use the standard "C" locale for file output.
+	ofs.imbue(std::locale::classic());
+#endif
+
 	// The top of the file should not be written by params.
 
 	// write out a comment in the top of the file
@@ -1200,8 +1218,13 @@ bool Buffer::writeFile(string const & fname, bool flag) const
 	    << " created this file. For more info see http://www.lyx.org/\n";
 	ofs.setf(ios::showpoint|ios::fixed);
 	ofs.precision(2);
+#ifndef HAVE_LOCALE
+	char dummy_format[512];
+	sprintf(dummy_format, "%.2f", LYX_FORMAT);
+	ofs << "\\lyxformat " <<  dummy_format << "\n";
+#else
 	ofs << "\\lyxformat " << setw(4) <<  LYX_FORMAT << "\n";
-
+#endif
 	// now write out the buffer paramters.
 	params.writeFile(ofs);
 
@@ -1214,23 +1237,50 @@ bool Buffer::writeFile(string const & fname, bool flag) const
 
 	// Write marker that shows file is complete
 	ofs << "\n\\the_end" << endl;
+
 	ofs.close();
+
 	// how to check if close went ok?
-	return true;
+	// 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,
+	//        which should include file system full errors.
+
+	bool status = true;
+	if (!ofs.good()) {
+		status = false;
+#if 0
+		if (ofs.bad()) {
+			lyxerr << "Buffer::writeFile: BAD ERROR!" << endl;
+		} else {
+			lyxerr << "Buffer::writeFile: NOT SO BAD ERROR!"
+			       << endl;
+		}
+#endif
+	}
+	
+	return status;
 }
 
 
+#if 0
 void Buffer::writeFileAscii(string const & fname, int linelen) 
 {
-	LyXFont font1, font2;
 	Inset * inset;
-	char c, footnoteflag = 0, depth = 0;
+	char c;
+	char footnoteflag = 0;
+	char depth = 0;
 	string tmp;
 	LyXParagraph::size_type i;
-	int j, h, ltype = 0, ltype_depth = 0,
-		* clen = 0, actcell = 0, actpos = 0, cell = 0, cells = 0,
-	        currlinelen = 0;
-	long fpos = 0;
+	int j;
+	int ltype = 0;
+	int ltype_depth = 0;
+	int actcell = 0;
+	int actpos = 0;
+	int currlinelen = 0;
+	int fpos = 0;
 	bool ref_printed = false;
 
 	ofstream ofs(fname.c_str());
@@ -1239,15 +1289,22 @@ void Buffer::writeFileAscii(string const & fname, int linelen)
 		return;
 	}
 
-	string fname1 = TmpFileName();
+	string const fname1 = lyx::tempName(); //TmpFileName();
 	LyXParagraph * par = paragraph;
 	while (par) {
 		int noparbreak = 0;
 		int islatex = 0;
-		if (par->footnoteflag != LyXParagraph::NO_FOOTNOTE ||
-		    !par->previous ||
-		    par->previous->footnoteflag == LyXParagraph::NO_FOOTNOTE){
-	 
+		if (
+#ifndef NEW_INSETS
+			par->footnoteflag != LyXParagraph::NO_FOOTNOTE ||
+#endif
+		    !par->previous
+#ifndef NEW_INSETS
+		    || par->previous->footnoteflag == LyXParagraph::NO_FOOTNOTE
+#endif
+			){
+
+#ifndef NEW_INSETS
 			/* begins a footnote environment ? */ 
 			if (footnoteflag != par->footnoteflag) {
 				footnoteflag = par->footnoteflag;
@@ -1260,6 +1317,7 @@ void Buffer::writeFileAscii(string const & fname, int linelen)
 					currlinelen += j;
 				}
 			}
+#endif
 	 
 			/* begins or ends a deeper area ?*/ 
 			if (depth != par->depth) {
@@ -1283,10 +1341,10 @@ void Buffer::writeFileAscii(string const & fname, int linelen)
 			} else if (tmp == "Enumerate") {
 				ltype = 2;
 				ltype_depth = depth+1;
-			} else if (strstr(tmp.c_str(), "ection")) {
+			} else if (contains(tmp, "ection")) {
 				ltype = 3;
 				ltype_depth = depth+1;
-			} else if (strstr(tmp.c_str(), "aragraph")) {
+			} else if (contains(tmp, "aragraph")) {
 				ltype = 4;
 				ltype_depth = depth+1;
 			} else if (tmp == "Description") {
@@ -1315,65 +1373,26 @@ void Buffer::writeFileAscii(string const & fname, int linelen)
 	 
 			/* what about the alignment */ 
 		} else {
+#ifndef NEW_INSETS
 			/* dummy layout, that means a footnote ended */ 
 			footnoteflag = LyXParagraph::NO_FOOTNOTE;
 			ofs << ") ";
 			noparbreak = 1;
-		}
-      
-		//LyXLayout const & layout =
-		//	textclasslist.Style(params.textclass, 
-		//			    par->GetLayout()); // unused
-		//bool free_spc = layout.free_spacing; //unused
-
-#ifndef NEW_TABULAR
-		/* It might be a table */ 
-		if (par->table){
-			cell = 1;
-                        actcell = 0;
-			cells = par->table->columns;
-			clen = new int [cells];
-			memset(clen, 0, sizeof(int) * cells);
-
-			for (i = 0, j = 0, h = 1; i < par->size(); ++i, ++h) {
-				c = par->GetChar(i);
-				if (c == LyXParagraph::META_INSET) {
-					if ((inset = par->GetInset(i))) {
-#ifdef HAVE_SSTREAM
-						std::ostringstream ost;
-						inset->Ascii(this, ost);
-						h += ost.str().length();
 #else
-						ostrstream ost;
-						inset->Ascii(this, ost);
-						ost << '\0';
-						char * tmp = ost.str();
-						string tstr(tmp);
-						h += tstr.length();
-						delete [] tmp;
+			lyxerr << "Should this ever happen?" << endl;
 #endif
-					}
-				} else if (c == LyXParagraph::META_NEWLINE) {
-					if (clen[j] < h)
-						clen[j] = h;
-					h = 0;
-					j = (++j) % par->table->NumberOfCellsInRow(actcell);
-                                        ++actcell;
-				}
-			}
-			if (clen[j] < h)
-				clen[j] = h;
 		}
-#endif
-		font1 = LyXFont(LyXFont::ALL_INHERIT, params.language_info);
+      
+		LyXFont font1 =
+			LyXFont(LyXFont::ALL_INHERIT, params.language);
                 actcell = 0;
 		for (i = 0, actpos = 1; i < par->size(); ++i, ++actpos) {
 			if (!i && !footnoteflag && !noparbreak){
 				ofs << "\n\n";
-				for(j = 0; j < depth; ++j)
+				for (j = 0; j < depth; ++j)
 					ofs << "  ";
 				currlinelen = depth * 2;
-				switch(ltype) {
+				switch (ltype) {
 				case 0: /* Standard */
 				case 4: /* (Sub)Paragraph */
                                 case 5: /* Description */
@@ -1392,33 +1411,12 @@ void Buffer::writeFileAscii(string const & fname, int linelen)
 					break;
 				}
 				if (ltype_depth > depth) {
-					for(j = ltype_depth - 1; j > depth; --j)
+					for (j = ltype_depth - 1; j > depth; --j)
 						ofs << "  ";
 					currlinelen += (ltype_depth-depth)*2;
 				}
-#ifndef NEW_TABULAR
-				if (par->table) {
-					for(j = 0; j < cells; ++j) {
-						ofs << '+';
-						for(h = 0; h < (clen[j] + 1);
-						    ++h)
-							ofs << '-';
-					}
-					ofs << "+\n";
-					for(j = 0; j < depth; ++j)
-						ofs << "  ";
-					currlinelen = depth * 2;
-					if (ltype_depth > depth) {
-						for(j = ltype_depth;
-						    j > depth; --j)
-							ofs << "  ";
-						currlinelen += (ltype_depth-depth)*2;
-					}
-					ofs << "| ";
-				}
-#endif
 			}
-			font2 = par->GetFontSettings(params, i);
+			LyXFont font2 = par->GetFontSettings(params, i);
 			if (font1.latex() != font2.latex()) {
 				if (font2.latex() == LyXFont::OFF)
 					islatex = 0;
@@ -1440,61 +1438,16 @@ void Buffer::writeFileAscii(string const & fname, int linelen)
 				}
 				break;
 			case LyXParagraph::META_NEWLINE:
-#ifndef NEW_TABULAR
-				if (par->table) {
-					if (par->table->NumberOfCellsInRow(actcell) <= cell) {
-						for(j = actpos; j < clen[cell - 1]; ++j)
-							ofs << ' ';
-						ofs << " |\n";
-						for(j = 0; j < depth; ++j)
-							ofs << "  ";
-						currlinelen = depth*2;
-						if (ltype_depth > depth) {
-							for(j = ltype_depth; j > depth; --j)
-								ofs << "  ";
-							currlinelen += (ltype_depth-depth) * 2;
-						}
-						for(j = 0; j < cells; ++j) {
-							ofs << '+';
-							for(h = 0; h < (clen[j] + 1); ++h)
-								ofs << '-';
-						}
-						ofs << "+\n";
-						for(j = 0; j < depth; ++j)
-							ofs << "  ";
-						currlinelen = depth * 2;
-						if (ltype_depth > depth) {
-							for(j = ltype_depth;
-							    j > depth; --j)
-								ofs << "  ";
-							currlinelen += (ltype_depth-depth)*2;
-						}
-						ofs << "| ";
-						cell = 1;
-					} else {
-						for(j = actpos;
-						    j < clen[cell - 1]; ++j)
-							ofs << ' ';
-						ofs << " | ";
-						++cell;
-					}
-                                        ++actcell;
-					currlinelen = actpos = 0;
-				} else {
-#endif
-					ofs << "\n";
-					for(j = 0; j < depth; ++j)
+				ofs << "\n";
+				for (j = 0; j < depth; ++j)
+					ofs << "  ";
+				currlinelen = depth * 2;
+				if (ltype_depth > depth) {
+					for (j = ltype_depth;
+					    j > depth; --j)
 						ofs << "  ";
-					currlinelen = depth * 2;
-					if (ltype_depth > depth) {
-						for(j = ltype_depth;
-						    j > depth; --j)
-							ofs << "  ";
-						currlinelen += (ltype_depth - depth) * 2;
-					}
-#ifndef NEW_TABULAR
+					currlinelen += (ltype_depth - depth) * 2;
 				}
-#endif
 				break;
 			case LyXParagraph::META_HFILL: 
 				ofs << "\t";
@@ -1506,11 +1459,11 @@ void Buffer::writeFileAscii(string const & fname, int linelen)
 				if (currlinelen > linelen - 10
                                     && c == ' ' && i + 2 < par->size()) {
 					ofs << "\n";
-					for(j = 0; j < depth; ++j)
+					for (j = 0; j < depth; ++j)
 						ofs << "  ";
 					currlinelen = depth * 2;
 					if (ltype_depth > depth) {
-						for(j = ltype_depth;
+						for (j = ltype_depth;
 						    j > depth; --j)
 							ofs << "  ";
 						currlinelen += (ltype_depth-depth)*2;
@@ -1523,34 +1476,253 @@ void Buffer::writeFileAscii(string const & fname, int linelen)
 				break;
 			}
 		}
-#ifndef NEW_TABULAR
-		if (par->table) {
-			for(j = actpos; j < clen[cell - 1]; ++j)
-				ofs << ' ';
-			ofs << " |\n";
-			for(j = 0; j < depth; ++j)
-				ofs << "  ";
+		par = par->next;
+	}
+   
+	ofs << "\n";
+}
+//----------------------------------------------------------------------------
+#else
+//----------------------------------------------------------------------------
+string const Buffer::asciiParagraph(LyXParagraph const * par,
+				    unsigned int linelen) const
+{
+	ostringstream buffer;
+	LyXFont font1;
+	LyXFont font2;
+	Inset const * inset;
+	char c;
+	LyXParagraph::footnote_flag footnoteflag = LyXParagraph::NO_FOOTNOTE;
+	char depth = 0;
+	int ltype = 0;
+	int ltype_depth = 0;
+	unsigned int currlinelen = 0;
+	bool ref_printed = false;
+
+	int noparbreak = 0;
+	int islatex = 0;
+	if (
+#ifndef NEW_INSETS
+		par->footnoteflag != LyXParagraph::NO_FOOTNOTE ||
+#endif
+		!par->previous
+#ifndef NEW_INSETS
+		|| par->previous->footnoteflag == LyXParagraph::NO_FOOTNOTE
+#endif
+		){
+#ifndef NEW_INSETS
+		/* begins a footnote environment ? */ 
+		if (footnoteflag != par->footnoteflag) {
+			footnoteflag = par->footnoteflag;
+			if (footnoteflag) {
+				size_t const j = strlen(string_footnotekinds[par->footnotekind]) + 4;
+				if ((linelen > 0) &&
+				    ((currlinelen + j) > linelen)) {
+					buffer << "\n";
+					currlinelen = 0;
+				}
+				buffer << "(["
+				       << string_footnotekinds[par->footnotekind]
+				       << "] ";
+				currlinelen += j;
+			}
+		}
+#endif
+		/* begins or ends a deeper area ?*/ 
+		if (depth != par->depth) {
+			if (par->depth > depth) {
+				while (par->depth > depth) {
+					++depth;
+				}
+			}
+			else {
+				while (par->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 (strstr(tmp.c_str(), "ection")) {
+			ltype = 3;
+			ltype_depth = depth+1;
+		} else if (strstr(tmp.c_str(), "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 */ 
+	} else {
+#ifndef NEW_INSETS
+		/* dummy layout, that means a footnote ended */ 
+		footnoteflag = LyXParagraph::NO_FOOTNOTE;
+		buffer << ") ";
+		noparbreak = 1;
+#else
+		lyxerr << "Should this ever happen?" << endl;
+#endif
+	}
+      
+	font1 = LyXFont(LyXFont::ALL_INHERIT, params.language);
+	for (LyXParagraph::size_type i = 0; i < par->size(); ++i) {
+		if (!i && !footnoteflag && !noparbreak){
+			if (linelen > 0)
+				buffer << "\n\n";
+			for (char 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->labelstring << " ";
+				break;
+			}
+			if (ltype_depth > depth) {
+				for (char j = ltype_depth - 1; j > depth; --j)
+					buffer << "  ";
+				currlinelen += (ltype_depth-depth)*2;
+			}
+		}
+		font2 = par->GetFontSettings(params, i);
+		if (font1.latex() != font2.latex()) {
+			if (font2.latex() == LyXFont::OFF)
+				islatex = 0;
+			else
+				islatex = 1;
+		} else {
+			islatex = 0;
+		}
+		c = par->GetChar(i);
+		if (islatex)
+			continue;
+		switch (c) {
+		case LyXParagraph::META_INSET:
+			if ((inset = par->GetInset(i))) {
+				if (!inset->Ascii(this, buffer)) {
+					string dummy;
+					string s = rsplit(buffer.str().c_str(),
+							  dummy, '\n');
+					currlinelen += s.length();
+				} else {
+					// to be sure it breaks paragraph
+					currlinelen += linelen;
+				}
+			}
+			break;
+		case LyXParagraph::META_NEWLINE:
+			if (linelen > 0) {
+				buffer << "\n";
+				for (char j = 0; j < depth; ++j)
+					buffer << "  ";
+			}
 			currlinelen = depth * 2;
 			if (ltype_depth > depth) {
-				for(j = ltype_depth; j > depth; --j)
-					ofs << "  ";
+				for (char j = ltype_depth;
+				    j > depth; --j)
+					buffer << "  ";
 				currlinelen += (ltype_depth - depth) * 2;
 			}
-			for(j = 0; j < cells; ++j) {
-				ofs << '+';
-				for(h = 0; h < (clen[j] + 1); ++h)
-					ofs << '-';
-			}
-			ofs << "+\n";
-			delete [] clen;    
+			break;
+		case LyXParagraph::META_HFILL: 
+			buffer << "\t";
+			break;
+		case '\\':
+			buffer << "\\";
+			break;
+		default:
+			if ((linelen > 0) && (currlinelen > (linelen - 10)) &&
+			    (c == ' ') && ((i + 2) < par->size()))
+			{
+				buffer << "\n";
+				for (char j = 0; j < depth; ++j)
+					buffer << "  ";
+				currlinelen = depth * 2;
+				if (ltype_depth > depth) {
+					for (char j = ltype_depth;
+					    j > depth; --j)
+						buffer << "  ";
+					currlinelen += (ltype_depth-depth)*2;
+				}
+			} else if (c != '\0')
+				buffer << c;
+			else if (c == '\0')
+				lyxerr.debug() << "writeAsciiFile: NULL char in structure." << endl;
+			++currlinelen;
+			break;
 		}
-#endif
+	}
+	return buffer.str().c_str();
+}
+
+
+void Buffer::writeFileAscii(string const & fname, int linelen) 
+{
+	ofstream ofs(fname.c_str());
+	if (!ofs) {
+		WriteFSAlert(_("Error: Cannot write file:"), fname);
+		return;
+	}
+	writeFileAscii(ofs, linelen);
+}
+
+
+void Buffer::writeFileAscii(ostream & ofs, int linelen) 
+{
+	LyXParagraph * par = paragraph;
+	while (par) {
+		ofs << asciiParagraph(par, linelen);
 		par = par->next;
 	}
-   
 	ofs << "\n";
 }
-
+#endif
 
 void Buffer::makeLaTeXFile(string const & fname, 
 			   string const & original_path,
@@ -1680,17 +1852,21 @@ void Buffer::makeLaTeXFile(string const & fname,
 		
 		// language should be a parameter to \documentclass
 		bool use_babel = false;
-		if (params.language_info->lang() == "hebrew") // This seems necessary
+		if (params.language->babel() == "hebrew") // This seems necessary
 			features.UsedLanguages.insert(default_language);
-		if (params.language != "default" ||
-		    !features.UsedLanguages.empty() ) {
+#ifdef DO_USE_DEFAULT_LANGUAGE
+		if (params.language->lang() != "default" ||
+		    !features.UsedLanguages.empty()) {
+#endif
 			use_babel = true;
 			for (LaTeXFeatures::LanguageList::const_iterator cit =
 				     features.UsedLanguages.begin();
 			     cit != features.UsedLanguages.end(); ++cit)
-				options += (*cit)->lang() + ",";
-			options += params.language_info->lang() + ',';
+				options += (*cit)->babel() + ",";
+			options += params.language->babel() + ',';
+#ifdef DO_USE_DEFAULT_LANGUAGE
 		}
+#endif
 
 		// the user-defined options
 		if (!params.options.empty()) {
@@ -1721,8 +1897,8 @@ void Buffer::makeLaTeXFile(string const & fname,
 		}
 
 		if (params.inputenc == "auto") {
-			string doc_encoding =
-				params.language_info->encoding()->LatexName();
+			string const doc_encoding =
+				params.language->encoding()->LatexName();
 
 			// Create a list with all the input encodings used 
 			// in the document
@@ -1734,9 +1910,8 @@ void Buffer::makeLaTeXFile(string const & fname,
 					encodings.insert((*it)->encoding()->LatexName());
 
 			ofs << "\\usepackage[";
-			for (set<string>::const_iterator it = encodings.begin();
-			     it != encodings.end(); ++it)
-				ofs << *it << ",";
+			std::copy(encodings.begin(), encodings.end(),
+				  std::ostream_iterator<string>(ofs, ","));
 			ofs << doc_encoding << "]{inputenc}\n";
 			texrow.newline();
 		} else if (params.inputenc != "default") {
@@ -1990,9 +2165,13 @@ void Buffer::makeLaTeXFile(string const & fname,
 		texrow.newline();
 	} // only_body
 	lyxerr.debug() << "preamble finished, now the body." << endl;
-	if (!lyxrc.language_auto_begin && params.language != "default") {
+#ifdef DO_USE_DEFAULT_LANGUAGE
+	if (!lyxrc.language_auto_begin && params.language->lang() != "default") {
+#else
+	if (!lyxrc.language_auto_begin) {
+#endif
 		ofs << subst(lyxrc.language_command_begin, "$$lang",
-			     params.language)
+			     params.language->babel())
 		    << endl;
 		texrow.newline();
 	}
@@ -2003,9 +2182,13 @@ void Buffer::makeLaTeXFile(string const & fname,
 	ofs << endl;
 	texrow.newline();
 
-	if (!lyxrc.language_auto_end && params.language != "default") {
+#ifdef DO_USE_DEFAULT_LANGUAGE
+	if (!lyxrc.language_auto_end && params.language->lang() != "default") {
+#else
+		if (!lyxrc.language_auto_end) {
+#endif
 		ofs << subst(lyxrc.language_command_end, "$$lang",
-			     params.language)
+			     params.language->babel())
 		    << endl;
 		texrow.newline();
 	}
@@ -2046,27 +2229,17 @@ void Buffer::latexParagraphs(ostream & ofs, LyXParagraph * par,
 {
 	bool was_title = false;
 	bool already_title = false;
-#ifdef HAVE_SSTREAM
 	std::ostringstream ftnote;
-#else
-	char * tmpholder = 0;
-#endif
 	TexRow ft_texrow;
 	int ftcount = 0;
 
 	// if only_body
 	while (par != endpar) {
-#ifndef HAVE_SSTREAM
-		ostrstream ftnote;
-		if (tmpholder) {
-			ftnote << tmpholder;
-			delete [] tmpholder;
-			tmpholder = 0;
-		}
-#endif
+#ifndef NEW_INSETS
 		if (par->IsDummy())
 			lyxerr[Debug::LATEX] << "Error in latexParagraphs."
 					     << endl;
+#endif
 		LyXLayout const & layout =
 			textclasslist.Style(params.textclass,
 					    par->layout);
@@ -2090,11 +2263,18 @@ void Buffer::latexParagraphs(ostream & ofs, LyXParagraph * par,
 		ftcount = -1;
 		if (layout.isEnvironment()
                     || par->pextra_type != LyXParagraph::PEXTRA_NONE) {
-			par = par->TeXEnvironment(this, params, ofs, texrow,
-						  ftnote, ft_texrow, ftcount);
+			par = par->TeXEnvironment(this, params, ofs, texrow
+#ifndef NEW_INSETS
+						  ,ftnote, ft_texrow, ftcount
+#endif
+				);
 		} else {
-			par = par->TeXOnePar(this, params, ofs, texrow, false,
-					     ftnote, ft_texrow, ftcount);
+			par = par->TeXOnePar(this, params, ofs, texrow, false
+#ifndef NEW_INSETS
+					     ,
+					     ftnote, ft_texrow, ftcount
+#endif
+				);
 		}
 
 		// Write out what we've generated...
@@ -2106,26 +2286,14 @@ void Buffer::latexParagraphs(ostream & ofs, LyXParagraph * par,
 			}
 			ofs << ftnote.str();
 			texrow += ft_texrow;
-#ifdef HAVE_SSTREAM
+
 			// The extra .c_str() is needed when we use
 			// lyxstring instead of the STL string class. 
 			ftnote.str(string().c_str());
-#else
-			delete [] ftnote.str();
-#endif
 			ft_texrow.reset();
 			ftcount = 0;
 		}
-#ifndef HAVE_SSTREAM
-		else {
-			// I hate strstreams
-			tmpholder = ftnote.str();
-		}
-#endif
 	}
-#ifndef HAVE_SSTREAM
-	delete [] tmpholder;
-#endif
 	// It might be that we only have a title in this document
 	if (was_title && !already_title) {
 		ofs << "\\maketitle\n";
@@ -2204,7 +2372,7 @@ void Buffer::makeLinuxDocFile(string const & fname, bool nice, bool body_only)
 	LaTeXFeatures features(params, tclass.numLayouts());
 	validate(features);
 
-	//if(nice)
+	//if (nice)
 	tex_code_break_column = lyxrc.ascii_linelen;
 	//else
 	//tex_code_break_column = 0;
@@ -2221,7 +2389,7 @@ void Buffer::makeLinuxDocFile(string const & fname, bool nice, bool body_only)
 			    << params.preamble << sgml_includedfiles << " \n]>\n\n";
 		}
 
-		if(params.options.empty())
+		if (params.options.empty())
 			sgmlOpenTag(ofs, 0, top_element);
 		else {
 			string top = top_element;
@@ -2246,29 +2414,31 @@ void Buffer::makeLinuxDocFile(string const & fname, bool nice, bool body_only)
 		        Inset * inset = par->GetInset(0);
 			Inset::Code lyx_code = inset->LyxCode();
 			if (lyx_code == Inset::TOC_CODE){
-				string temp = "toc";
+				string const temp = "toc";
 				sgmlOpenTag(ofs, depth, temp);
 
 				par = par->next;
+#ifndef NEW_INSETS
 				linuxDocHandleFootnote(ofs, par, depth);
+#endif
 				continue;
 			}
 		}
 
 		// environment tag closing
-		for( ; depth > par->depth; --depth) {
+		for (; depth > par->depth; --depth) {
 			sgmlCloseTag(ofs, depth, environment_stack[depth]);
 			environment_stack[depth].erase();
 		}
 
 		// write opening SGML tags
-		switch(style.latextype) {
+		switch (style.latextype) {
 		case LATEX_PARAGRAPH:
-			if(depth == par->depth 
+			if (depth == par->depth 
 			   && !environment_stack[depth].empty()) {
 				sgmlCloseTag(ofs, depth, environment_stack[depth]);
 				environment_stack[depth].erase();
-				if(depth) 
+				if (depth) 
 					--depth;
 				else
 				        ofs << "</p>";
@@ -2294,7 +2464,7 @@ void Buffer::makeLinuxDocFile(string const & fname, bool nice, bool body_only)
 
 		case LATEX_ENVIRONMENT:
 		case LATEX_ITEM_ENVIRONMENT:
-			if(depth == par->depth 
+			if (depth == par->depth 
 			   && environment_stack[depth] != style.latexname()
 			   && !environment_stack[depth].empty()) {
 
@@ -2307,19 +2477,19 @@ void Buffer::makeLinuxDocFile(string const & fname, bool nice, bool body_only)
 			       environment_stack[depth].erase();
 			}
 			if (environment_stack[depth] != style.latexname()) {
-				if(depth == 0) {
-					string temp = "p";
+				if (depth == 0) {
+					string const temp = "p";
 					sgmlOpenTag(ofs, depth, temp);
 				}
 				environment_stack[depth] = style.latexname();
 				sgmlOpenTag(ofs, depth,
 					    environment_stack[depth]);
 			}
-			if(style.latextype == LATEX_ENVIRONMENT) break;
+			if (style.latextype == LATEX_ENVIRONMENT) break;
 
 			desc_on = (style.labeltype == LABEL_MANUAL);
 
-			if(desc_on)
+			if (desc_on)
 				item_name = "tag";
 			else
 				item_name = "item";
@@ -2331,17 +2501,21 @@ void Buffer::makeLinuxDocFile(string const & fname, bool nice, bool body_only)
 			break;
 		}
 
+#ifndef NEW_INSETS
 		do {
+#endif
 			SimpleLinuxDocOnePar(ofs, par, desc_on, depth);
 
 			par = par->next;
+#ifndef NEW_INSETS
 			linuxDocHandleFootnote(ofs, par, depth);
 		}
 		while(par && par->IsDummy());
+#endif
 
 		ofs << "\n";
 		// write closing SGML tags
-		switch(style.latextype) {
+		switch (style.latextype) {
 		case LATEX_COMMAND:
 		case LATEX_ENVIRONMENT:
 		case LATEX_ITEM_ENVIRONMENT:
@@ -2353,10 +2527,10 @@ void Buffer::makeLinuxDocFile(string const & fname, bool nice, bool body_only)
 	}
    
 	// Close open tags
-	for(; depth > 0; --depth)
+	for (; depth > 0; --depth)
 	        sgmlCloseTag(ofs, depth, environment_stack[depth]);
 
-	if(!environment_stack[depth].empty())
+	if (!environment_stack[depth].empty())
 	        sgmlCloseTag(ofs, depth, environment_stack[depth]);
 
 	if (!body_only) {
@@ -2369,10 +2543,11 @@ void Buffer::makeLinuxDocFile(string const & fname, bool nice, bool body_only)
 }
 
 
+#ifndef NEW_INSETS
 void Buffer::linuxDocHandleFootnote(ostream & os, LyXParagraph * & par,
-				    int const depth)
+				    int depth)
 {
-	string tag = "footnote";
+	string const tag = "footnote";
 
 	while (par && par->footnoteflag != LyXParagraph::NO_FOOTNOTE) {
 		sgmlOpenTag(os, depth + 1, tag);
@@ -2381,15 +2556,19 @@ void Buffer::linuxDocHandleFootnote(ostream & os, LyXParagraph * & par,
 		par = par->next;
 	}
 }
+#endif
 
 
 void Buffer::DocBookHandleCaption(ostream & os, string & inner_tag,
-				  int const depth, int desc_on,
+				  int depth, int desc_on,
 				  LyXParagraph * & par)
 {
 	LyXParagraph * tpar = par;
-	while (tpar && (tpar->footnoteflag != LyXParagraph::NO_FOOTNOTE) &&
-	       (tpar->layout != textclasslist.NumberOfLayout(params.textclass,
+	while (tpar
+#ifndef NEW_INSETS
+	       && (tpar->footnoteflag != LyXParagraph::NO_FOOTNOTE)
+#endif
+	       && (tpar->layout != textclasslist.NumberOfLayout(params.textclass,
 							     "Caption").second))
 		tpar = tpar->next;
 	if (tpar &&
@@ -2400,14 +2579,15 @@ void Buffer::DocBookHandleCaption(ostream & os, string & inner_tag,
 		SimpleDocBookOnePar(os, extra_par, tpar,
 				    desc_on, depth + 2);
 		sgmlCloseTag(os, depth+1, inner_tag);
-		if(!extra_par.empty())
+		if (!extra_par.empty())
 			os << extra_par;
 	}
 }
 
 
+#ifndef NEW_INSETS
 void Buffer::DocBookHandleFootnote(ostream & os, LyXParagraph * & par,
-				   int const depth)
+				   int depth)
 {
 	string tag, inner_tag;
 	string tmp_par, extra_par;
@@ -2426,9 +2606,9 @@ void Buffer::DocBookHandleFootnote(ostream & os, LyXParagraph * & par,
 	SOME_ENUM present = FOOTNOTE_LIKE;
 
 	while (par && par->footnoteflag != LyXParagraph::NO_FOOTNOTE) {
-		if(last == present) {
-			if(inner_span) {
-				if(!tmp_par.empty()) {
+		if (last == present) {
+			if (inner_span) {
+				if (!tmp_par.empty()) {
 					os << tmp_par;
 					tmp_par.erase();
 					sgmlCloseTag(os, depth + 1, inner_tag);
@@ -2439,10 +2619,10 @@ void Buffer::DocBookHandleFootnote(ostream & os, LyXParagraph * & par,
 			}
 		} else {
 			os << tmp_par;
-			if(!inner_tag.empty()) sgmlCloseTag(os, depth + 1,
+			if (!inner_tag.empty()) sgmlCloseTag(os, depth + 1,
 							    inner_tag);
-			if(!extra_par.empty()) os << extra_par;
-			if(!tag.empty()) sgmlCloseTag(os, depth, tag);
+			if (!extra_par.empty()) os << extra_par;
+			if (!tag.empty()) sgmlCloseTag(os, depth, tag);
 			extra_par.erase();
 
 			switch (par->footnotekind) {
@@ -2487,21 +2667,10 @@ void Buffer::DocBookHandleFootnote(ostream & os, LyXParagraph * & par,
 		if (par->layout != textclasslist
 		    .NumberOfLayout(params.textclass,
 				    "Caption").second) {
-#ifdef HAVE_SSTREAM
 			std::ostringstream ost;
-#else
-			ostrstream ost;
-#endif
 			SimpleDocBookOnePar(ost, extra_par, par,
 					    desc_on, depth + 2);
-#ifdef HAVE_SSTREAM
 			tmp_par += ost.str().c_str();
-#else
-			ost << '\0';
-			char * ctmp = ost.str();
-			tmp_par += ctmp;
-			delete [] ctmp;
-#endif
 		}
 		tmp_par = frontStrip(strip(tmp_par));
 
@@ -2509,22 +2678,26 @@ void Buffer::DocBookHandleFootnote(ostream & os, LyXParagraph * & par,
 		par = par->next;
 	}
 	os << tmp_par;
-	if(!inner_tag.empty()) sgmlCloseTag(os, depth + 1, inner_tag);
-	if(!extra_par.empty()) os << extra_par;
-	if(!tag.empty()) sgmlCloseTag(os, depth, tag);
+	if (!inner_tag.empty()) sgmlCloseTag(os, depth + 1, inner_tag);
+	if (!extra_par.empty()) os << extra_par;
+	if (!tag.empty()) sgmlCloseTag(os, depth, tag);
 }
+#endif
 
 
 // push a tag in a style stack
-void Buffer::push_tag(ostream & os, char const * tag,
+void Buffer::push_tag(ostream & os, string const & tag,
 		      int & pos, char stack[5][3])
 {
+#ifdef WITH_WARNINGS
+#warning Use a real stack! (Lgb)
+#endif
 	// pop all previous tags
 	for (int j = pos; j >= 0; --j)
 		os << "</" << stack[j] << ">";
 
 	// add new tag
-	sprintf(stack[++pos], "%s", tag);
+	sprintf(stack[++pos], "%s", tag.c_str());
 
 	// push all tags
 	for (int i = 0; i <= pos; ++i)
@@ -2532,18 +2705,23 @@ void Buffer::push_tag(ostream & os, char const * tag,
 }
 
 
-void Buffer::pop_tag(ostream & os, char const * tag,
+void Buffer::pop_tag(ostream & os, string const & tag,
                      int & pos, char stack[5][3])
 {
-        int j;
-
+#ifdef WITH_WARNINGS
+#warning Use a real stack! (Lgb)
+#endif
+	// Please, Lars, do not remove the global variable. I already
+	// had to reintroduce it twice! (JMarc) 
+	int j;
+	
         // pop all tags till specified one
-        for (j = pos; (j >= 0) && (strcmp(stack[j], tag)); --j)
+        for (j = pos; (j >= 0) && (strcmp(stack[j], tag.c_str())); --j)
                 os << "</" << stack[j] << ">";
 
         // closes the tag
         os << "</" << tag << ">";
-
+	
         // push all tags, but the specified one
         for (j = j + 1; j <= pos; ++j) {
                 os << "<" << stack[j] << ">";
@@ -2558,8 +2736,8 @@ void Buffer::pop_tag(ostream & os, char const * tag,
 // checks, if newcol chars should be put into this line
 // writes newline, if necessary.
 static
-void linux_doc_line_break(ostream & os, unsigned int & colcount,
-			  const unsigned int newcol)
+void linux_doc_line_break(ostream & os, string::size_type & colcount,
+			  string::size_type newcol)
 {
 	colcount += newcol;
 	if (colcount > lyxrc.ascii_linelen) {
@@ -2570,9 +2748,9 @@ void linux_doc_line_break(ostream & os, unsigned int & colcount,
 
 
 void Buffer::SimpleLinuxDocOnePar(ostream & os, LyXParagraph * par,
-				  int desc_on, int const /*depth*/)
+				  int desc_on, int /*depth*/)
 {
-	LyXFont font1, font2;
+	LyXFont font1;
 	char c;
 	Inset * inset;
 	LyXParagraph::size_type main_body;
@@ -2588,7 +2766,7 @@ void Buffer::SimpleLinuxDocOnePar(ostream & os, LyXParagraph * par,
 	int stack_num = -1;          // style stack position
 	// Can this be rewritten to use a std::stack, please. (Lgb)
 	char stack[5][3];    	     // style stack 
-        unsigned int char_line_count = 5;     // Heuristic choice ;-) 
+        string::size_type char_line_count = 5;     // Heuristic choice ;-) 
 
 	if (style.labeltype != LABEL_MANUAL)
 		main_body = 0;
@@ -2607,15 +2785,19 @@ void Buffer::SimpleLinuxDocOnePar(ostream & os, LyXParagraph * par,
 	     i < par->size(); ++i) {
 
 		// handle quote tag
-		if (i == main_body && !par->IsDummy()) {
+		if (i == main_body
+#ifndef NEW_INSETS
+		    && !par->IsDummy()
+#endif
+			) {
 			if (main_body > 0)
 				font1 = style.font;
 		}
 
-		font2 = par->getFont(params, i);
+		LyXFont const font2 = par->getFont(params, i);
 
 		if (font1.family() != font2.family()) {
-			switch(family_type) {
+			switch (family_type) {
 			case 0:
 			       	if (font2.family() == LyXFont::TYPEWRITER_FAMILY) {
 			        	push_tag(os, "tt", stack_num, stack);
@@ -2659,7 +2841,7 @@ void Buffer::SimpleLinuxDocOnePar(ostream & os, LyXParagraph * par,
 
 		// handle italic and slanted fonts
 		if (font1.shape() != font2.shape()) {
-			switch(shape_type) {
+			switch (shape_type) {
 			case 0:
 			       	if (font2.shape() == LyXFont::ITALIC_SHAPE) {
 			        	push_tag(os, "it", stack_num, stack);
@@ -2749,7 +2931,7 @@ void Buffer::SimpleLinuxDocOnePar(ostream & os, LyXParagraph * par,
 	}
 
 	// resets description flag correctly
-	switch(desc_on){
+	switch (desc_on){
 	case 1:
 		// <tag> not closed...
 		linux_doc_line_break(os, char_line_count, 6);
@@ -2764,7 +2946,7 @@ void Buffer::SimpleLinuxDocOnePar(ostream & os, LyXParagraph * par,
 
 // Print an error message.
 void Buffer::LinuxDocError(LyXParagraph * par, int pos,
-			   char const * message) 
+			   string const & message) 
 {
 	// insert an error marker in text
 	InsetError * new_inset = new InsetError(message);
@@ -2804,7 +2986,7 @@ void Buffer::makeDocBookFile(string const & fname, bool nice, bool only_body)
 	LaTeXFeatures features(params, tclass.numLayouts());
 	validate(features);
 
-	//if(nice)
+	//if (nice)
 	tex_code_break_column = lyxrc.ascii_linelen;
 	//else
 	//tex_code_break_column = 0;
@@ -2817,7 +2999,7 @@ void Buffer::makeDocBookFile(string const & fname, bool nice, bool only_body)
    
 	texrow.reset();
 
-	if(!only_body) {
+	if (!only_body) {
 		string sgml_includedfiles=features.getIncludedFiles();
 
 		ofs << "<!doctype " << top_element
@@ -2829,7 +3011,7 @@ void Buffer::makeDocBookFile(string const & fname, bool nice, bool only_body)
 			ofs << "\n [ " << params.preamble 
 			    << sgml_includedfiles << " \n]>\n\n";
 
-		if(params.options.empty())
+		if (params.options.empty())
 			sgmlOpenTag(ofs, 0, top_element);
 		else {
 			string top = top_element;
@@ -2849,12 +3031,12 @@ void Buffer::makeDocBookFile(string const & fname, bool nice, bool only_body)
 					    par->layout);
 
 		// environment tag closing
-		for( ; depth > par->depth; --depth) {
-			if(environment_inner[depth] != "!-- --") {
+		for (; depth > par->depth; --depth) {
+			if (environment_inner[depth] != "!-- --") {
 				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]);
 			}
@@ -2864,14 +3046,14 @@ void Buffer::makeDocBookFile(string const & fname, bool nice, bool only_body)
 			environment_inner[depth].erase();
 		}
 
-		if(depth == par->depth
+		if (depth == par->depth
 		   && environment_stack[depth] != style.latexname()
 		   && !environment_stack[depth].empty()) {
-			if(environment_inner[depth] != "!-- --") {
+			if (environment_inner[depth] != "!-- --") {
 				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]);
@@ -2885,9 +3067,9 @@ void Buffer::makeDocBookFile(string const & fname, bool nice, bool only_body)
                 }
 
 		// Write opening SGML tags.
-		switch(style.latextype) {
+		switch (style.latextype) {
 		case LATEX_PARAGRAPH:
-			if(style.latexname() != "dummy")
+			if (style.latexname() != "dummy")
                                sgmlOpenTag(ofs, depth+command_depth,
                                            style.latexname());
 			break;
@@ -2903,20 +3085,20 @@ void Buffer::makeDocBookFile(string const & fname, bool nice, bool only_body)
 			tmps = style.latexparam();
 			c_params = split(tmps, c_depth,'|');
 			
-			cmd_depth= atoi(c_depth.c_str());
+			cmd_depth= lyx::atoi(c_depth);
 			
-			if(command_flag) {
-				if(cmd_depth<command_base) {
-					for(int j = command_depth;
+			if (command_flag) {
+				if (cmd_depth<command_base) {
+					for (int j = command_depth;
 					    j >= command_base; --j)
-						if(!command_stack[j].empty())
+						if (!command_stack[j].empty())
 							sgmlCloseTag(ofs, j, command_stack[j]);
 					command_depth= command_base= cmd_depth;
-				} else if(cmd_depth <= command_depth) {
-					for(int j = command_depth;
+				} else if (cmd_depth <= command_depth) {
+					for (int j = command_depth;
 					    j >= cmd_depth; --j)
 
-						if(!command_stack[j].empty())
+						if (!command_stack[j].empty())
 							sgmlCloseTag(ofs, j, command_stack[j]);
 					command_depth= cmd_depth;
 				} else
@@ -2958,7 +3140,7 @@ void Buffer::makeDocBookFile(string const & fname, bool nice, bool only_body)
 				sgmlOpenTag(ofs, depth + command_depth,
 					    environment_stack[depth]);
 			} else {
-				if(environment_inner[depth] != "!-- --") {
+				if (environment_inner[depth] != "!-- --") {
 					item_name= "listitem";
 					sgmlCloseTag(ofs,
 						     command_depth + depth,
@@ -2970,8 +3152,8 @@ void Buffer::makeDocBookFile(string const & fname, bool nice, bool only_body)
 				}
 			}
 			
-			if(style.latextype == LATEX_ENVIRONMENT) {
-				if(!style.latexparam().empty())
+			if (style.latextype == LATEX_ENVIRONMENT) {
+				if (!style.latexparam().empty())
 			  		sgmlOpenTag(ofs, depth + command_depth,
 						    style.latexparam());
 				break;
@@ -2979,7 +3161,7 @@ void Buffer::makeDocBookFile(string const & fname, bool nice, bool only_body)
 
 			desc_on = (style.labeltype == LABEL_MANUAL);
 
-			if(desc_on)
+			if (desc_on)
 				environment_inner[depth]= "varlistentry";
 			else
 				environment_inner[depth]= "listitem";
@@ -2987,7 +3169,7 @@ void Buffer::makeDocBookFile(string const & fname, bool nice, bool only_body)
 			sgmlOpenTag(ofs, depth + 1 + command_depth,
 				    environment_inner[depth]);
 
-			if(desc_on) {
+			if (desc_on) {
 				item_name= "term";
 				sgmlOpenTag(ofs, depth + 1 + command_depth,
 					    item_name);
@@ -3003,35 +3185,38 @@ void Buffer::makeDocBookFile(string const & fname, bool nice, bool only_body)
 			break;
 		}
 
+#ifndef NEW_INSETS
 		do {
+#endif
 			string extra_par;
 			SimpleDocBookOnePar(ofs, extra_par, par, desc_on,
 					    depth + 1 + command_depth);
 			par = par->next;
+#ifndef NEW_INSETS
 			DocBookHandleFootnote(ofs, par,
 					      depth + 1 + command_depth);
 		}
 		while(par && par->IsDummy());
-
+#endif
 		string end_tag;
 		// write closing SGML tags
-		switch(style.latextype) {
+		switch (style.latextype) {
 		case LATEX_COMMAND:
 			end_tag = "title";
 			sgmlCloseTag(ofs, depth + command_depth, end_tag);
 			break;
 		case LATEX_ENVIRONMENT:
-			if(!style.latexparam().empty())
+			if (!style.latexparam().empty())
 				sgmlCloseTag(ofs, depth + command_depth,
 					     style.latexparam());
 			break;
 		case LATEX_ITEM_ENVIRONMENT:
-			if(desc_on == 1) break;
+			if (desc_on == 1) break;
 			end_tag= "para";
 			sgmlCloseTag(ofs, depth + 1 + command_depth, end_tag);
 			break;
 		case LATEX_PARAGRAPH:
-			if(style.latexname() != "dummy")
+			if (style.latexname() != "dummy")
 				sgmlCloseTag(ofs, depth + command_depth,
 					     style.latexname());
 			break;
@@ -3043,13 +3228,13 @@ void Buffer::makeDocBookFile(string const & fname, bool nice, bool only_body)
 	}
 
 	// Close open tags
-	for(; depth >= 0; --depth) {
-		if(!environment_stack[depth].empty()) {
-			if(environment_inner[depth] != "!-- --") {
+	for (; depth >= 0; --depth) {
+		if (!environment_stack[depth].empty()) {
+			if (environment_inner[depth] != "!-- --") {
 				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]);
 			}
@@ -3059,8 +3244,8 @@ void Buffer::makeDocBookFile(string const & fname, bool nice, bool only_body)
 		}
 	}
 	
-	for(int j = command_depth; j >= command_base; --j)
-		if(!command_stack[j].empty())
+	for (int j = command_depth; j >= command_base; --j)
+		if (!command_stack[j].empty())
 			sgmlCloseTag(ofs, j, command_stack[j]);
 
 	if (!only_body) {
@@ -3075,16 +3260,8 @@ void Buffer::makeDocBookFile(string const & fname, bool nice, bool only_body)
 
 void Buffer::SimpleDocBookOnePar(ostream & os, string & extra,
 				 LyXParagraph * par, int & desc_on,
-				 int const depth) 
+				 int depth) const
 {
-#ifndef NEW_TABULAR
-	if (par->table) {
-		par->SimpleDocBookOneTablePar(this,
-					      os, extra, desc_on, depth);
-		return;
-	}
-#endif
-
 	bool emph_flag = false;
 
 	LyXLayout const & style = textclasslist.Style(params.textclass,
@@ -3100,7 +3277,7 @@ void Buffer::SimpleDocBookOnePar(ostream & os, string & extra,
 	LyXFont font1 = main_body > 0 ? style.labelfont : style.font;
 	
 	int char_line_count = depth;
-	if(!style.free_spacing)
+	if (!style.free_spacing)
 		for (int j = 0; j < depth; ++j)
 			os << ' ';
 
@@ -3124,18 +3301,10 @@ void Buffer::SimpleDocBookOnePar(ostream & os, string & extra,
 
 		if (c == LyXParagraph::META_INSET) {
 			Inset * inset = par->GetInset(i);
-#ifdef HAVE_SSTREAM
 			std::ostringstream ost;
 			inset->DocBook(this, ost);
 			string tmp_out = ost.str().c_str();
-#else
-			ostrstream ost;
-			inset->DocBook(this, ost);
-			ost << '\0';
-			char * ctmp = ost.str();
-			string tmp_out(ctmp);
-			delete [] ctmp;
-#endif
+
 			//
 			// This code needs some explanation:
 			// Two insets are treated specially
@@ -3146,9 +3315,9 @@ void Buffer::SimpleDocBookOnePar(ostream & os, string & extra,
 			//   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)
+			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, '@');
@@ -3191,7 +3360,7 @@ void Buffer::SimpleDocBookOnePar(ostream & os, string & extra,
 	}
 	
 	// resets description flag correctly
-	switch(desc_on){
+	switch (desc_on){
 	case 1:
 		// <term> not closed...
 		os << "</term>";
@@ -3201,207 +3370,6 @@ void Buffer::SimpleDocBookOnePar(ostream & os, string & extra,
 }
 
 
-int Buffer::runLaTeX()
-{
-	if (!users->text) return 0;
-
-	ProhibitInput(users);
-
-	// get LaTeX-Filename
-	string name = getLatexName();
-
-	string path = OnlyPath(filename);
-
-	string org_path = path;
-	if (lyxrc.use_tempdir || (IsDirWriteable(path) < 1)) {
-		path = tmppath;	 
-	}
-
-	Path p(path); // path to LaTeX file
-	users->owner()->getMiniBuffer()->Set(_("Running LaTeX..."));   
-
-	// Remove all error insets
-	bool a = users->removeAutoInsets();
-
-	// Always generate the LaTeX file
-	makeLaTeXFile(name, org_path, false);
-
-	// do the LaTex run(s)
-	TeXErrors terr;
-	string latex_command = lyxrc.pdf_mode ?
-		lyxrc.pdflatex_command : lyxrc.latex_command;
-	LaTeX latex(latex_command, name, filepath);
-	int res = latex.run(terr,
-			    users->owner()->getMiniBuffer()); // running latex
-
-	// check return value from latex.run().
-	if ((res & LaTeX::NO_LOGFILE)) {
-		WriteAlert(_("LaTeX did not work!"),
-			   _("Missing log file:"), name);
-	} else if ((res & LaTeX::ERRORS)) {
-		users->owner()->getMiniBuffer()->Set(_("Done"));
-		// Insert all errors as errors boxes
-		users->insertErrors(terr);
-		
-		// Dvi should also be kept dirty if the latex run
-		// ends up with errors. However it should be possible
-		// to view a dirty dvi too.
-	} else {
-		//no errors or any other things to think about so:
-		users->owner()->getMiniBuffer()->Set(_("Done"));
-	}
-
-	// if we removed error insets before we ran LaTeX or if we inserted
-	// error insets after we ran LaTeX this must be run:
-        if (a || (res & LaTeX::ERRORS)){
-                users->redraw();
-                users->fitCursor();
-                //users->updateScrollbar();
-        }
-        AllowInput(users);
- 
-        return latex.getNumErrors();
-}
-
-
-int Buffer::runLiterate()
-{
-	if (!users->text) return 0;
-
-	ProhibitInput(users);
-
-	// get LaTeX-Filename
-	string name = getLatexName();
-        // get Literate-Filename
-        string lit_name = OnlyFilename(ChangeExtension (getLatexName(), 
-					   lyxrc.literate_extension));
-
-	string path = OnlyPath(filename);
-
-	string org_path = path;
-	if (lyxrc.use_tempdir || (IsDirWriteable(path) < 1)) {
-		path = tmppath;	 
-	}
-
-	Path p(path); // path to Literate file
-	users->owner()->getMiniBuffer()->Set(_("Running Literate..."));   
-
-	// Remove all error insets
-	bool a = users->removeAutoInsets();
-
-	// generate the Literate file if necessary
-	makeLaTeXFile(lit_name, org_path, false);
-
-	string latex_command = lyxrc.pdf_mode ?
-		lyxrc.pdflatex_command : lyxrc.latex_command;
-        Literate literate(latex_command, name, filepath, 
-			  lit_name,
-			  lyxrc.literate_command, lyxrc.literate_error_filter,
-			  lyxrc.build_command, lyxrc.build_error_filter);
-	TeXErrors terr;
-	int res = literate.weave(terr, users->owner()->getMiniBuffer());
-
-	// check return value from literate.weave().
-	if ((res & Literate::NO_LOGFILE)) {
-		WriteAlert(_("Literate command did not work!"),
-			   _("Missing log file:"), name);
-	} else if ((res & Literate::ERRORS)) {
-		users->owner()->getMiniBuffer()->Set(_("Done"));
-		// Insert all errors as errors boxes
-		users->insertErrors(terr);
-		
-		// Dvi should also be kept dirty if the latex run
-		// ends up with errors. However it should be possible
-		// to view a dirty dvi too.
-	} else {
-		//no errors or any other things to think about so:
-		users->owner()->getMiniBuffer()->Set(_("Done"));
-	}
-
-	// if we removed error insets before we ran LaTeX or if we inserted
-	// error insets after we ran LaTeX this must be run:
-        if (a || (res & Literate::ERRORS)){
-                users->redraw();
-                users->fitCursor();
-                //users->updateScrollbar();
-        }
-        AllowInput(users);
- 
-        return literate.getNumErrors();
-}
-
-
-int Buffer::buildProgram()
-{
-        if (!users->text) return 0;
- 
-        ProhibitInput(users);
- 
-        // get LaTeX-Filename
-        string name = getLatexName();
-        // get Literate-Filename
-        string lit_name = OnlyFilename(ChangeExtension(getLatexName(), 
-						       lyxrc.literate_extension));
- 
-        string path = OnlyPath(filename);
- 
-        string org_path = path;
-        if (lyxrc.use_tempdir || (IsDirWriteable(path) < 1)) {
-                path = tmppath;  
-        }
- 
-        Path p(path); // path to Literate file
-        users->owner()->getMiniBuffer()->Set(_("Building Program..."));   
- 
-        // Remove all error insets
-        bool a = users->removeAutoInsets();
- 
-        // generate the LaTeX file if necessary
-        if (!isNwClean() || a) {
-                makeLaTeXFile(lit_name, org_path, false);
-                markNwDirty();
-        }
-
-	string latex_command = lyxrc.pdf_mode ?
-		lyxrc.pdflatex_command : lyxrc.latex_command;
-        Literate literate(latex_command, name, filepath, 
-			  lit_name,
-			  lyxrc.literate_command, lyxrc.literate_error_filter,
-			  lyxrc.build_command, lyxrc.build_error_filter);
-        TeXErrors terr;
-        int res = literate.build(terr, users->owner()->getMiniBuffer());
- 
-        // check return value from literate.build().
-        if ((res & Literate::NO_LOGFILE)) {
-                WriteAlert(_("Build did not work!"),
-                           _("Missing log file:"), name);
-        } else if ((res & Literate::ERRORS)) {
-                users->owner()->getMiniBuffer()->Set(_("Done"));
-                // Insert all errors as errors boxes
-		users->insertErrors(terr);
-                
-                // Literate files should also be kept dirty if the literate 
-                // command run ends up with errors.
-        } else {
-                //no errors or any other things to think about so:
-                users->owner()->getMiniBuffer()->Set(_("Done"));
-                markNwClean();
-        }
- 
-        // if we removed error insets before we ran Literate/Build or
-	// if we inserted error insets after we ran Literate/Build this
-	// must be run:
-	if (a || (res & Literate::ERRORS)){
-		users->redraw();
-		users->fitCursor();
-		//users->updateScrollbar();
-	}
-	AllowInput(users);
-
-	return literate.getNumErrors();
-}
-
-
 // This should be enabled when the Chktex class is implemented. (Asger)
 // chktex should be run with these flags disabled: 3, 22, 25, 30, 38(?)
 // Other flags: -wall -v0 -x
@@ -3412,10 +3380,10 @@ int Buffer::runChktex()
 	ProhibitInput(users);
 
 	// get LaTeX-Filename
-	string name = getLatexName();
+	string const name = getLatexName();
 	string path = OnlyPath(filename);
 
-	string org_path = path;
+	string const org_path = path;
 	if (lyxrc.use_tempdir || (IsDirWriteable(path) < 1)) {
 		path = tmppath;	 
 	}
@@ -3424,7 +3392,7 @@ int Buffer::runChktex()
 	users->owner()->getMiniBuffer()->Set(_("Running chktex..."));
 
 	// Remove all error insets
-	bool removedErrorInsets = users->removeAutoInsets();
+	bool const removedErrorInsets = users->removeAutoInsets();
 
 	// Generate the LaTeX file if neccessary
 	makeLaTeXFile(name, org_path, false);
@@ -3445,8 +3413,7 @@ int Buffer::runChktex()
 	// error insets after we ran chktex, this must be run:
 	if (removedErrorInsets || res){
 		users->redraw();
-		users->fitCursor();
-		//users->updateScrollbar();
+		users->fitCursor(users->text);
 	}
 	AllowInput(users);
 
@@ -3482,9 +3449,9 @@ void Buffer::validate(LaTeXFeatures & features) const
 	// so they are tested here
 	for (int i = 0; i < 4; ++i) {
 		if (params.user_defined_bullets[i] != ITEMIZE_DEFAULTS[i]) {
-			int font = params.user_defined_bullets[i].getFont();
+			int const font = params.user_defined_bullets[i].getFont();
 			if (font == 0) {
-				int c = params
+				int const c = params
 					.user_defined_bullets[i]
 					.getCharacter();
 				if (c == 16
@@ -3494,11 +3461,9 @@ void Buffer::validate(LaTeXFeatures & features) const
 				   || c == 31) {
 					features.latexsym = true;
 				}
-			}
-			if (font == 1) {
+			} else if (font == 1) {
 				features.amssymb = true;
-			}
-			else if ((font >= 2 && font <= 5)) {
+			} else if ((font >= 2 && font <= 5)) {
 				features.pifont = true;
 			}
 		}
@@ -3513,9 +3478,9 @@ void Buffer::validate(LaTeXFeatures & features) const
 void Buffer::setPaperStuff()
 {
 	params.papersize = BufferParams::PAPER_DEFAULT;
-	char c1 = params.paperpackage;
+	char const c1 = params.paperpackage;
 	if (c1 == BufferParams::PACKAGE_NONE) {
-		char c2 = params.papersize2;
+		char const c2 = params.papersize2;
 		if (c2 == BufferParams::VM_PAPER_USLETTER)
 			params.papersize = BufferParams::PAPER_USLETTER;
 		else if (c2 == BufferParams::VM_PAPER_USLEGAL)
@@ -3538,7 +3503,7 @@ void Buffer::setPaperStuff()
 
 
 // This function should be in Buffer because it's a buffer's property (ale)
-string Buffer::getIncludeonlyList(char delim)
+string const Buffer::getIncludeonlyList(char delim)
 {
 	string lst;
 	for (inset_iterator it = inset_iterator_begin();
@@ -3559,7 +3524,7 @@ string Buffer::getIncludeonlyList(char delim)
 }
 
 
-vector<string> Buffer::getLabelList()
+vector<string> const Buffer::getLabelList()
 {
 	/// if this is a child document and the parent is already loaded
 	/// Use the parent's list instead  [ale990407]
@@ -3573,18 +3538,19 @@ vector<string> Buffer::getLabelList()
 	vector<string> label_list;
 	for (inset_iterator it = inset_iterator_begin();
 	     it != inset_iterator_end(); ++it) {
-		vector<string> l = (*it)->getLabelList();
+		vector<string> const l = (*it)->getLabelList();
 		label_list.insert(label_list.end(), l.begin(), l.end());
 	}
 	return label_list;
 }
 
 
-vector<vector<Buffer::TocItem> > Buffer::getTocList()
+vector<vector<Buffer::TocItem> > const Buffer::getTocList()
 {
 	vector<vector<TocItem> > l(4);
 	LyXParagraph * par = paragraph;
 	while (par) {
+#ifndef NEW_INSETS
 		if (par->footnoteflag != LyXParagraph::NO_FOOTNOTE) {
 			if (textclasslist.Style(params.textclass, 
 						par->GetLayout()).labeltype
@@ -3611,8 +3577,10 @@ vector<vector<Buffer::TocItem> > Buffer::getTocList()
 				}
 			}
 		} else if (!par->IsDummy()) {
-			char labeltype = textclasslist.Style(params.textclass, 
-							     par->GetLayout()).labeltype;
+#endif
+			char const labeltype =
+				textclasslist.Style(params.textclass, 
+						    par->GetLayout()).labeltype;
       
 			if (labeltype >= LABEL_COUNTER_CHAPTER
 			    && labeltype <= LABEL_COUNTER_CHAPTER + params.tocdepth) {
@@ -3625,14 +3593,17 @@ vector<vector<Buffer::TocItem> > Buffer::getTocList()
 				tmp.str =  par->String(this, true);
 				l[TOC_TOC].push_back(tmp);
 			}
+#ifndef NEW_INSETS
 		}
+#endif
 		par = par->next;
 	}
 	return l;
 }
 
+
 // This is also a buffer property (ale)
-vector<pair<string,string> > Buffer::getBibkeyList()
+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]
@@ -3646,7 +3617,7 @@ vector<pair<string,string> > Buffer::getBibkeyList()
 	LyXParagraph * par = paragraph;
 	while (par) {
 		if (par->bibkey)
-			keys.push_back(pair<string,string>(par->bibkey->getContents(),
+			keys.push_back(pair<string, string>(par->bibkey->getContents(),
 							   par->String(this, false)));
 		par = par->next;
 	}
@@ -3658,10 +3629,10 @@ vector<pair<string,string> > Buffer::getBibkeyList()
 			// Search for Bibtex or Include inset
 			if ((*it)->LyxCode() == Inset::BIBTEX_CODE) {
 				vector<pair<string,string> > tmp =
-					static_cast<InsetBibtex*>(*it)->getKeys();
+					static_cast<InsetBibtex*>(*it)->getKeys(this);
 				keys.insert(keys.end(), tmp.begin(), tmp.end());
 			} else if ((*it)->LyxCode() == Inset::INCLUDE_CODE) {
-				vector<pair<string,string> > tmp =
+				vector<pair<string,string> > const tmp =
 					static_cast<InsetInclude*>(*it)->getKeys();
 				keys.insert(keys.end(), tmp.begin(), tmp.end());
 			}
@@ -3690,7 +3661,7 @@ void Buffer::markDepClean(string const & name)
 		dep_clean->master = name;
 		dep_clean->next = 0;
 	} else {
-		DEPCLEAN* item = dep_clean;
+		DEPCLEAN * item = dep_clean;
 		while (item && item->master != name)
 			item = item->next;
 		if (item) {
@@ -3708,10 +3679,11 @@ void Buffer::markDepClean(string const & name)
 bool Buffer::Dispatch(string const & command)
 {
 	// Split command string into command and argument
-	string cmd, line = frontStrip(command);
-	string arg = strip(frontStrip(split(line, cmd, ' ')));
+	string cmd;
+	string line = frontStrip(command);
+	string const arg = strip(frontStrip(split(line, cmd, ' ')));
 
-	return Dispatch(lyxaction.LookupFunc(cmd.c_str()), arg.c_str());
+	return Dispatch(lyxaction.LookupFunc(cmd), arg);
 }
 
 
@@ -3720,7 +3692,7 @@ bool Buffer::Dispatch(int action, string const & argument)
 	bool dispatched = true;
 	switch (action) {
 		case LFUN_EXPORT: 
-			MenuExport(this, argument);
+			Exporter::Export(this, argument, false);
 			break;
 
 		default:
@@ -3742,7 +3714,7 @@ void Buffer::resizeInsets(BufferView * bv)
 {
 	/// then remove all LyXText in text-insets
 	LyXParagraph * par = paragraph;
-	for(;par;par = par->next) {
+	for (; par; par = par->next) {
 	    par->resizeInsetsLyXText(bv);
 	}
 }
@@ -3760,7 +3732,6 @@ void Buffer::ChangeLanguage(Language const * from, Language const * to)
 
 bool Buffer::isMultiLingual()
 {
-
 	LyXParagraph * par = paragraph;
 	while (par) {
 		if (par->isMultiLingual(params))
@@ -3773,7 +3744,8 @@ bool Buffer::isMultiLingual()
 
 Buffer::inset_iterator::inset_iterator(LyXParagraph * paragraph,
 				       LyXParagraph::size_type pos)
-	: par(paragraph) {
+	: par(paragraph)
+{
 	it = par->InsetIterator(pos);
 	if (it == par->inset_iterator_end()) {
 		par = par->next;
@@ -3782,7 +3754,8 @@ Buffer::inset_iterator::inset_iterator(LyXParagraph * paragraph,
 }
 
 
-void Buffer::inset_iterator::SetParagraph() {
+void Buffer::inset_iterator::SetParagraph()
+{
 	while (par) {
 		it = par->inset_iterator_begin();
 		if (it != par->inset_iterator_end())