X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Fbuffer.C;h=3e6a4e3a2b11cf6e0d61de0627490985655117af;hb=27652900a60fd078f161ce866ddaed21dba21eff;hp=ac4a50196ad8d47796a400ab1617842418568eb0;hpb=b1b9e976a475915a2105cb744c7a428b5be1269c;p=lyx.git

diff --git a/src/buffer.C b/src/buffer.C
index ac4a50196a..3e6a4e3a2b 100644
--- a/src/buffer.C
+++ b/src/buffer.C
@@ -14,24 +14,6 @@
 
 #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
@@ -48,8 +30,26 @@
 #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"
@@ -81,31 +81,38 @@
 #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 "frontends/Dialogs.h"
-#include "frontends/Alert.h"
-#include "encoding.h"
-#include "exporter.h"
-#include "Lsstream.h"
-#include "converter.h"
-#include "BufferView.h"
-#include "ParagraphParameters.h"
-#include "iterators.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;
@@ -123,6 +130,10 @@ using std::set;
 using std::stack;
 using std::list;
 
+using lyx::pos_type;
+using lyx::layout_type;
+using lyx::textclass_type;
+
 // all these externs should eventually be removed.
 extern BufferList bufferlist;
 
@@ -138,21 +149,26 @@ extern int tex_code_break_column;
 
 
 Buffer::Buffer(string const & file, bool ronly)
+	: paragraph(0), 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();
+	}
 }
 
 
@@ -184,7 +200,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
@@ -241,7 +257,8 @@ void Buffer::setReadonly(bool flag)
 // Should work on a list
 void Buffer::updateTitles() const
 {
-	if (users) users->owner()->updateWindowTitle();
+	if (users)
+		users->owner()->updateWindowTitle();
 }
 
 
@@ -249,15 +266,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();
 }
 
@@ -275,6 +293,7 @@ struct ErtComp
 	string contents;
 	bool active;
 	bool in_tabular;
+	LyXFont font;
 };
 
 std::stack<ErtComp> ert_stack;
@@ -319,7 +338,7 @@ bool Buffer::readLyXformat2(LyXLex & lex, Paragraph * par)
 	} 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
@@ -383,14 +402,13 @@ bool Buffer::readLyXformat2(LyXLex & lex, Paragraph * par)
 
 
 #ifndef NO_COMPABILITY
-void Buffer::insertErtContents(Paragraph * par, int & pos,
-			       LyXFont const & font, bool set_inactive) 
+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;
+		lyxerr[Debug::INSETS] << "ERT contents:\n'"
+				      << ert_comp.contents << "'" << endl;
 		Inset * inset = new InsetERT(ert_comp.contents, true);
-		par->insertInset(pos++, inset, font);
+		par->insertInset(pos++, inset, ert_comp.font);
 		ert_comp.contents.erase();
 	}
 	if (set_inactive) {
@@ -443,17 +461,22 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, Paragraph *& par,
 #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 const layoutname = lex.getString();
+		//lyxerr << "Looking for layout '"
+		// << layoutname << "'!" << endl;
+		
+		pair<bool, layout_type> pp
+		  = textclasslist.NumberOfLayout(params.textclass, layoutname);
 
+		//lyxerr << "Result: " << pp.first << "/" << pp.second << endl;
+		
 #ifndef NO_COMPABILITY
 		if (compare_no_case(layoutname, "latex") == 0) {
 			ert_comp.active = true;
+			ert_comp.font = font;
 		}
 #endif
 #ifdef USE_CAPTION
@@ -524,15 +547,18 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, Paragraph *& par,
 			} else {
 				// layout not found
 				// use default layout "Standard" (0)
+				//lyxerr << "Layout '" << layoutname
+				//       << "' was not found!" << endl;
+				
 				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->setFont(0, LyXFont(LyXFont::ALL_INHERIT,
-							params.language));
+				par->insertInset(0, new_inset, 
+						 LyXFont(LyXFont::ALL_INHERIT,
+							 params.language));
 			}
 			// Test whether the layout is obsolete.
 			LyXLayout const & layout =
@@ -554,8 +580,8 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, Paragraph *& par,
 
 #ifndef NO_COMPABILITY
 	} else if (token == "\\begin_float") {
-		insertErtContents(par, pos, font);
-		//insertErtContents(par, pos, font, false);
+		insertErtContents(par, pos);
+		//insertErtContents(par, pos, false);
 		//ert_stack.push(ert_comp);
 		//ert_comp = ErtComp();
 		
@@ -645,7 +671,7 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, Paragraph *& par,
 		inset->read(this, nylex);
 		par->insertInset(pos, inset, font);
 		++pos;
-		insertErtContents(par, pos, font);
+		insertErtContents(par, pos);
 #endif
 	} else if (token == "\\begin_deeper") {
 		++depth;
@@ -660,7 +686,7 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, Paragraph *& par,
 		params.readPreamble(lex);
 	} else if (token == "\\textclass") {
 		lex.eatLine();
-		pair<bool, LyXTextClassList::size_type> pp = 
+		pair<bool, textclass_type> pp = 
 			textclasslist.NumberOfClass(lex.getString());
 		if (pp.first) {
 			params.textclass = pp.second;
@@ -716,21 +742,25 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, Paragraph *& par,
 		par->params().startOfAppendix(true);
 	} else if (token == "\\paragraph_separation") {
 		int tmpret = lex.findToken(string_paragraph_separation);
-		if (tmpret == -1) ++tmpret;
+		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());
+#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;
+		if (tmpret == -1)
+			++tmpret;
 		if (tmpret != LYX_LAYOUT_DEFAULT) {
 			InsetQuotes::quote_language tmpl = 
 				InsetQuotes::EnglishQ;
@@ -793,7 +823,8 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, Paragraph *& par,
 		params.use_numerical_citations = lex.getInteger();
 	} else if (token == "\\paperorientation") {
 		int tmpret = lex.findToken(string_orientation);
-		if (tmpret == -1) ++tmpret;
+		if (tmpret == -1)
+			++tmpret;
 		if (tmpret != LYX_LAYOUT_DEFAULT) 
 			params.orientation = static_cast<BufferParams::PAPER_ORIENTATION>(tmpret);
 	} else if (token == "\\paperwidth") {
@@ -865,6 +896,7 @@ 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();
 		lex.next();
@@ -881,6 +913,7 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, Paragraph *& par,
 			lex.next();
 			temp_str = lex.getString();
 		}
+
 		params.user_defined_bullets[index].setText(sum_str);
 		params.temp_bullets[index].setText(sum_str);
 	} else if (token == "\\secnumdepth") {
@@ -951,12 +984,13 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, Paragraph *& par,
 		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'");
@@ -1047,7 +1081,7 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, Paragraph *& par,
 		// the inset isn't it? Lgb.
 	} else if (token == "\\begin_inset") {
 #ifndef NO_COMPABILITY
-		insertErtContents(par, pos, font, false);
+		insertErtContents(par, pos, false);
 		ert_stack.push(ert_comp);
 		ert_comp = ErtComp();
 #endif
@@ -1055,7 +1089,7 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, Paragraph *& par,
 #ifndef NO_COMPABILITY
 		ert_comp = ert_stack.top();
 		ert_stack.pop();
-		insertErtContents(par, pos, font);
+		insertErtContents(par, pos);
 #endif
 	} else if (token == "\\SpecialChar") {
 		LyXLayout const & layout =
@@ -1063,7 +1097,7 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, Paragraph *& par,
 					    par->getLayout());
 
 		// Insets don't make sense in a free-spacing context! ---Kayvan
-		if (layout.free_spacing) {
+		if (layout.free_spacing || par->isFreeSpacing()) {
 			if (lex.isOK()) {
 				lex.next();
 				string next_token = lex.getString();
@@ -1093,7 +1127,7 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, Paragraph *& par,
 			// 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;
@@ -1121,7 +1155,7 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, Paragraph *& par,
 			textclasslist.Style(params.textclass, 
 					    par->getLayout());
 
-		if (layout.free_spacing) {
+		if (layout.free_spacing || par->isFreeSpacing()) {
 			par->insertChar(pos, ' ', font);
 		} else {
 			Inset * inset = new InsetSpecialChar(InsetSpecialChar::PROTECTED_SEPARATOR);
@@ -1149,7 +1183,7 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, Paragraph *& par,
 #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
@@ -1170,9 +1204,8 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, Paragraph *& par,
 			+ " " + lex.text()  + "\n";
 
 		InsetError * new_inset = new InsetError(s);
-		par->insertInset(pos, new_inset);
-		par->setFont(pos, LyXFont(LyXFont::ALL_INHERIT,
-					  params.language));
+		par->insertInset(pos, new_inset, LyXFont(LyXFont::ALL_INHERIT,
+							 params.language));
 
 #ifndef NO_COMPABILITY
 		}
@@ -1183,7 +1216,8 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, Paragraph *& par,
 #ifndef NO_PEXTRA_REALLY
 	// I wonder if we could use this blanket fix for all the
 	// checkminipage cases...
-	if (par && par->size()) {
+	// 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.
@@ -1197,6 +1231,7 @@ 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
@@ -1243,12 +1278,21 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, Paragraph *& par,
 			}
 			InsetMinipage * mini = new InsetMinipage;
 			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())+"%"));
 			}
+			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()) {
@@ -1285,6 +1329,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))
@@ -1313,10 +1359,10 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, Paragraph *& par,
 
 		InsetMinipage * mini = new InsetMinipage;
 		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())+"%"));
 		}
 		mini->inset.paragraph(minipar);
 			
@@ -1338,7 +1384,7 @@ Buffer::parseSingleLyXformat2Token(LyXLex & lex, Paragraph *& par,
 }
 
 // needed to insert the selection
-void Buffer::insertStringAsLines(Paragraph *& par, Paragraph::pos_type & pos,
+void Buffer::insertStringAsLines(Paragraph *& par, pos_type & pos,
                                  LyXFont const & fn,string const & str) const
 {
 	LyXLayout const & layout = textclasslist.Style(params.textclass, 
@@ -1362,19 +1408,19 @@ void Buffer::insertStringAsLines(Paragraph *& par, Paragraph::pos_type & pos,
 			}
 			// do not insert consecutive spaces if !free_spacing
 		} else if ((*cit == ' ' || *cit == '\t') &&
-		           space_inserted && !layout.free_spacing)
+		           space_inserted && !layout.free_spacing &&
+				   !par->isFreeSpacing())
 		{
 			continue;
 		} else if (*cit == '\t') {
-			if (!layout.free_spacing) {
+			if (!layout.free_spacing && !par->isFreeSpacing()) {
 				// tabs are like spaces here
 				par->insertChar(pos, ' ', font);
 				++pos;
 				space_inserted = true;
 			} else {
-				const Paragraph::pos_type nb = 8 - pos % 8;
-				for (Paragraph::pos_type a = 0; 
-				     a < nb ; ++a) {
+				const pos_type nb = 8 - pos % 8;
+				for (pos_type a = 0; a < nb ; ++a) {
 					par->insertChar(pos, ' ', font);
 					++pos;
 				}
@@ -1467,8 +1513,8 @@ void Buffer::readInset(LyXLex & lex, Paragraph *& par,
 		} else if (tmptok == "Formula") {
 			inset = new InsetFormula;
 		} else if (tmptok == "Figure") { // Backward compatibility
-			inset = new InsetFig(100, 100, *this);
-			//inset = new InsetGraphics;
+//			inset = new InsetFig(100, 100, *this);
+			inset = new InsetGraphics;
 		} else if (tmptok == "Graphics") {
 			inset = new InsetGraphics;
 		} else if (tmptok == "Info") {// backwards compatibility
@@ -1656,7 +1702,7 @@ 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)
@@ -1744,178 +1790,219 @@ bool Buffer::writeFile(string const & fname, bool flag) const
 
 
 string const Buffer::asciiParagraph(Paragraph const * par,
-				    unsigned int linelen) const
+                                    unsigned int linelen,
+                                    bool noparbreak) const
 {
 	ostringstream buffer;
+	ostringstream word;
 	Paragraph::depth_type depth = 0;
 	int ltype = 0;
 	Paragraph::depth_type ltype_depth = 0;
 	string::size_type 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;
+			while (par->params().depth() < depth) {
+				--depth;
+			}
 		}
+	}
+#else
+	depth = par->params().depth();
+#endif
 		
-		/* maybe some vertical spaces */ 
+	// 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;
+	}
 		
-		/* the labelwidthstring used in lists */ 
+	/* maybe some vertical spaces */ 
 		
-		/* some lines? */ 
+	/* the labelwidthstring used in lists */ 
 		
-		/* some pagebreaks? */ 
+	/* some lines? */ 
 		
-		/* noindent ? */ 
+	/* some pagebreaks? */ 
 		
-		/* what about the alignment */ 
-	} else {
-		lyxerr << "Should this ever happen?" << endl;
-	}
-
-	for (Paragraph::pos_type i = 0; i < par->size(); ++i) {
-		if (!i && !noparbreak) {
+	/* noindent ? */ 
+		
+	/* what about the alignment */ 
+//	} else {
+//		lyxerr << "Should this ever happen?" << endl;
+//	}
+
+	// linelen <= 0 is special and means we don't have pargraph breaks
+	if (!noparbreak) {
+		if (linelen > 0)
+			buffer << "\n\n";
+		for (Paragraph::depth_type j = 0; j < depth; ++j)
+			buffer << "  ";
+		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 << "\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
+				buffer << _("Abstract") << "\n\n";
+			else
+				buffer << _("Abstract: ");
+			break;
+		case 7: // Bibliography
+			if (!ref_printed) {
 				if (linelen > 0)
-					buffer << "Abstract\n\n";
+					buffer << _("References") << "\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;
+					buffer << _("References: ");
+				ref_printed = true;
 			}
-			if (ltype_depth > depth) {
-				for (Paragraph::depth_type j = ltype_depth - 1; 
-				     j > depth; --j)
-					buffer << "  ";
-				currlinelen += (ltype_depth-depth)*2;
+			break;
+		default:
+			buffer << par->params().labelString() << " ";
+			break;
+		}
+	}
+	string s = buffer.str();
+	if (s.rfind('\n') != string::npos) {
+		string dummy;
+		s = rsplit(buffer.str().c_str(), dummy, '\n');
+	}
+	currlinelen = s.length();
+	if (!currlinelen) {
+		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;
 		}
-		
+	}
+	// 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)
+	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)) {
+				if (linelen > 0) {
+					buffer << word.str();
+					word.str("");
+				}
+				if (inset->ascii(this, buffer, linelen)) {
+					// to be sure it breaks paragraph
+					currlinelen += linelen;
+				}
+#if 0
+				else {
 					string dummy;
 					string const s =
 						rsplit(buffer.str().c_str(),
 						       dummy, '\n');
-					currlinelen += s.length();
-				} else {
-					// to be sure it breaks paragraph
-					currlinelen += linelen;
+					currlinelen = s.length();
 				}
+#endif
 			}
 		}
 		break;
 		
 		case Paragraph::META_NEWLINE:
 			if (linelen > 0) {
-				buffer << "\n";
+				buffer << word.str() << "\n";
+				word.str("");
 				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;
+				currlinelen = depth * 2;
+				if (ltype_depth > depth) {
+					for (Paragraph::depth_type j = ltype_depth;
+						 j > depth; --j)
+						buffer << "  ";
+					currlinelen += (ltype_depth - depth) * 2;
+				}
 			}
 			break;
 			
-		case Paragraph::META_HFILL: 
-			buffer << "\t";
+		case Paragraph::META_HFILL:
+			buffer << word.str() << "\t";
+			currlinelen += word.str().length() + 1;
+			word.str("");
 			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)
+			if (c == ' ') {
+				buffer << word.str() << ' ';
+				currlinelen += word.str().length() + 1;
+				word.str("");
+			} else {
+				if (c != '\0') {
+					word << c;
+				} else {
+					lyxerr[Debug::INFO] <<
+						"writeAsciiFile: NULL char in structure." << endl;
+				}
+				if ((linelen > 0) &&
+					(currlinelen+word.str().length()) > linelen)
+				{
+					buffer << "\n";
+					for (Paragraph::depth_type j = 0; j < depth; ++j)
 						buffer << "  ";
-					currlinelen += (ltype_depth-depth)*2;
+					currlinelen = depth * 2;
+					if (ltype_depth > depth) {
+						for (Paragraph::depth_type j = ltype_depth;
+							 j > depth; --j)
+						{
+							buffer << "  ";
+						}
+						currlinelen += (ltype_depth-depth)*2;
+					}
 				}
-			} else if (c != '\0') {
-				buffer << c;
-				++currlinelen;
-			} else
-				lyxerr[Debug::INFO] << "writeAsciiFile: NULL char in structure." << endl;
+			}
 			break;
 		}
 	}
+	buffer << word.str();
 	return buffer.str().c_str();
 }
 
@@ -1935,14 +2022,16 @@ 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, 
 			   string const & original_path,
 			   bool nice, bool only_body)
@@ -2243,12 +2332,6 @@ void Buffer::makeLaTeXFile(string const & fname,
 			texrow.newline();
 		}
 
-		if (features.isRequired("amsstyle")
-			    && !tclass.provides(LyXTextClass::amsmath)) {
-			ofs << "\\usepackage{amsmath}\n";
-			texrow.newline();
-		}
-		
 		if (tokenPos(tclass.opt_pagestyle(),
 			     '|', params.pagestyle) >= 0) {
 			if (params.pagestyle == "fancy") {
@@ -2367,7 +2450,9 @@ 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();
 		}
 
@@ -2437,6 +2522,7 @@ void Buffer::makeLaTeXFile(string const & fname,
 	}
 	
 	lyxerr[Debug::INFO] << "Finished making latex file." << endl;
+	lyxerr[Debug::INFO] << "Row count was " << texrow.rows()-1 << "." << endl;
 }
 
 
@@ -2444,33 +2530,41 @@ void Buffer::makeLaTeXFile(string const & fname,
 // LaTeX all paragraphs from par to endpar, if endpar == 0 then to the end
 //
 void Buffer::latexParagraphs(ostream & ofs, Paragraph * par,
-			     Paragraph * endpar, TexRow & texrow) const
+                             Paragraph * endpar, TexRow & texrow) const
 {
 	bool was_title = false;
 	bool already_title = false;
 
 	// 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.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);
+			} else {
+				par = par->TeXOnePar(this, params, ofs, texrow, false);
+			}
 		} else {
 			par = par->TeXOnePar(this, params, ofs, texrow, false);
 		}
@@ -2775,7 +2869,7 @@ void Buffer::simpleLinuxDocOnePar(ostream & os,
 {
 	LyXLayout const & style = textclasslist.Style(params.textclass,
 						      par->getLayout());
-        string::size_type char_line_count = 5;     // Heuristic choice ;-) 
+	string::size_type char_line_count = 5;     // Heuristic choice ;-) 
 
 	// gets paragraph main font
 	LyXFont font_old;
@@ -2795,7 +2889,7 @@ void Buffer::simpleLinuxDocOnePar(ostream & os,
 
 	stack<PAR_TAG> tag_state;
 	// parsing main loop
-	for (Paragraph::pos_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;
@@ -2887,7 +2981,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) << ">";
@@ -2926,7 +3020,8 @@ void Buffer::simpleLinuxDocOnePar(ostream & os,
 		} else {
 			string sgml_string;
 			if (par->sgmlConvertChar(c, sgml_string)
-			    && !style.free_spacing) { 
+			    && !style.free_spacing && !par->isFreeSpacing())
+			{ 
 				// in freespacing mode, spaces are
 				// non-breaking characters
 				if (desc_on) {// if char is ' ' then...
@@ -2967,8 +3062,8 @@ void Buffer::sgmlError(Paragraph * par, int pos,
 {
 	// insert an error marker in text
 	InsetError * new_inset = new InsetError(message);
-	par->insertInset(pos, new_inset);
-	par->setFont(pos, LyXFont(LyXFont::ALL_INHERIT, params.language));
+	par->insertInset(pos, new_inset, LyXFont(LyXFont::ALL_INHERIT, 
+						 params.language));
 }
 
 
@@ -3122,6 +3217,8 @@ void Buffer::makeDocBookFile(string const & fname, bool nice, bool only_body)
 
 			// treat label as a special case for
 			// more WYSIWYM handling.
+			// 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();
@@ -3288,8 +3385,7 @@ void Buffer::simpleDocBookOnePar(ostream & os,
 	//	os << string(depth,' ');
 
 	// parsing main loop
-	for (Paragraph::pos_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
@@ -3303,18 +3399,20 @@ void Buffer::simpleDocBookOnePar(ostream & os,
 			}
 		}
       
-		char c = par->getChar(i);
 
-		if (c == Paragraph::META_INSET) {
+		if ( par->isInset(i) ) {
 			Inset * inset = par->getInset(i);
-			inset->docbook(this, os);
+			// don't print the inset in position 0 if desc_on == 3 (label)
+			if ( i || desc_on != 3)
+				inset->docbook(this, os);
 		} else {
+			char c = par->getChar(i);
 			string sgml_string;
 			par->sgmlConvertChar(c, sgml_string);
 
 			if (style.pass_thru) {
 				os << c;
-			} else if(style.free_spacing || c != ' ') {
+			} else if(style.free_spacing || par->isFreeSpacing() || c != ' ') {
 					os << sgml_string;
 			} else if (desc_on ==1) {
 				++char_line_count;
@@ -3351,7 +3449,7 @@ 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)) {
@@ -3368,7 +3466,7 @@ 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) {
@@ -3399,7 +3497,7 @@ void Buffer::validate(LaTeXFeatures & features) const
     
         // AMS Style is at document level
         if (params.use_amsmath || tclass.provides(LyXTextClass::amsmath))
-		features.require("amsstyle");
+		features.require("amsmath");
     
 	while (par) {
 		// We don't use "lyxerr.debug" because of speed. (Asger)
@@ -3492,16 +3590,16 @@ Buffer::Lists const Buffer::getLists() const
 	Paragraph * par = paragraph;
 
 #if 1
-	std::pair<bool, LyXTextClassList::size_type> const tmp =
+	std::pair<bool, textclass_type> const tmp =
 		textclasslist.NumberOfLayout(params.textclass, "Caption");
 	bool const found = tmp.first;
-	LyXTextClassList::size_type const cap = tmp.second;
+	textclass_type const cap = tmp.second;
 	
 #else
 	// This is the prefered way to to this, but boost::tie can break
 	// some compilers
 	bool found;
-	LyXTextClassList::size_type cap;
+	textclass_type cap;
 	boost::tie(found, cap) = textclasslist
 		.NumberOfLayout(params.textclass, "Caption");
 #endif
@@ -3698,8 +3796,7 @@ bool Buffer::isMultiLingual()
 }
 
 
-Buffer::inset_iterator::inset_iterator(Paragraph * paragraph,
-				       Paragraph::pos_type pos)
+Buffer::inset_iterator::inset_iterator(Paragraph * paragraph, pos_type pos)
 	: par(paragraph)
 {
 	it = par->InsetIterator(pos);