X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FTextClass.cpp;h=79e8b0e7d1e39c955bd13a4a67831eca0acbd9f5;hb=2420f5ed1e9fe98c6273de3c9d661641aefc011b;hp=f7da2d11f2876a96e94dccb6753472e75f46f81a;hpb=c88e7a7ef66a880b5fb6166ff9151001269bc7cd;p=lyx.git

diff --git a/src/TextClass.cpp b/src/TextClass.cpp
index f7da2d11f2..79e8b0e7d1 100644
--- a/src/TextClass.cpp
+++ b/src/TextClass.cpp
@@ -3,11 +3,11 @@
  * This file is part of LyX, the document processor.
  * Licence details can be found in the file COPYING.
  *
- * \author Lars Gullik Bjønnes
+ * \author Lars Gullik Bjønnes
  * \author Jean-Marc Lasgouttes
  * \author Angus Leeming
  * \author John Levon
- * \author André Pönitz
+ * \author André Pönitz
  *
  * Full author contact details are available in file CREDITS.
  */
@@ -24,9 +24,11 @@
 #include "Layout.h"
 #include "Lexer.h"
 #include "Font.h"
+#include "ModuleList.h"
 
 #include "frontends/alert.h"
 
+#include "support/lassert.h"
 #include "support/debug.h"
 #include "support/ExceptionMessage.h"
 #include "support/FileName.h"
@@ -39,8 +41,6 @@
 #include <fstream>
 #include <sstream>
 
-#include "boost/assert.hpp"
-
 using namespace std;
 using namespace lyx::support;
 
@@ -61,16 +61,16 @@ private:
 	docstring name_;
 };
 
-
-int const FORMAT = 7;
+// Keep the changes documented in the Customization manual. 
+int const FORMAT = 14;
 
 
 bool layout2layout(FileName const & filename, FileName const & tempfile)
 {
 	FileName const script = libFileSearch("scripts", "layout2layout.py");
 	if (script.empty()) {
-		lyxerr << "Could not find layout conversion "
-			  "script layout2layout.py." << endl;
+		LYXERR0("Could not find layout conversion "
+			  "script layout2layout.py.");
 		return false;
 	}
 
@@ -82,11 +82,9 @@ bool layout2layout(FileName const & filename, FileName const & tempfile)
 
 	LYXERR(Debug::TCLASS, "Running `" << command_str << '\'');
 
-	cmd_ret const ret =
-		runCommand(command_str);
+	cmd_ret const ret = runCommand(command_str);
 	if (ret.first != 0) {
-		lyxerr << "Could not run layout conversion "
-			  "script layout2layout.py." << endl;
+		LYXERR0("Could not run layout conversion script layout2layout.py.");
 		return false;
 	}
 	return true;
@@ -112,11 +110,19 @@ std::string translateRT(TextClass::ReadType rt)
 } // namespace anon
 
 
-docstring const TextClass::emptylayout_ = from_ascii(N_("Plain Layout"));
+// This string should not be translated here, 
+// because it is a layout identifier.
+docstring const TextClass::plain_layout_ = from_ascii("Plain Layout");
+
 
+InsetLayout DocumentClass::plain_insetlayout_;
 
-InsetLayout DocumentClass::empty_insetlayout_;
 
+/////////////////////////////////////////////////////////////////////////
+//
+// TextClass
+//
+/////////////////////////////////////////////////////////////////////////
 
 TextClass::TextClass()
 {
@@ -132,14 +138,15 @@ TextClass::TextClass()
 	titletype_ = TITLE_COMMAND_AFTER;
 	titlename_ = "maketitle";
 	loaded_ = false;
+	_("Plain Layout"); // a hack to make this translatable
 }
 
 
-bool TextClass::readStyle(Lexer & lexrc, Layout & lay)
+bool TextClass::readStyle(Lexer & lexrc, Layout & lay) const
 {
 	LYXERR(Debug::TCLASS, "Reading style " << to_utf8(lay.name()));
 	if (!lay.read(lexrc, *this)) {
-		lyxerr << "Error parsing style `" << to_utf8(lay.name()) << '\'' << endl;
+		LYXERR0("Error parsing style `" << to_utf8(lay.name()) << '\'');
 		return false;
 	}
 	// Resolve fonts
@@ -157,7 +164,6 @@ enum TextClassTags {
 	TC_STYLE,
 	TC_DEFAULTSTYLE,
 	TC_INSETLAYOUT,
-	TC_ENVIRONMENT,
 	TC_NOSTYLE,
 	TC_COLUMNS,
 	TC_SIDES,
@@ -177,7 +183,10 @@ enum TextClassTags {
 	TC_TITLELATEXNAME,
 	TC_TITLELATEXTYPE,
 	TC_FORMAT,
-	TC_ADDTOPREAMBLE
+	TC_ADDTOPREAMBLE,
+	TC_DEFAULTMODULE,
+	TC_PROVIDESMODULE,
+	TC_EXCLUDESMODULE
 };
 
 
@@ -189,8 +198,9 @@ namespace {
 		{ "columns",         TC_COLUMNS },
 		{ "counter",         TC_COUNTER },
 		{ "defaultfont",     TC_DEFAULTFONT },
+		{ "defaultmodule",   TC_DEFAULTMODULE },
 		{ "defaultstyle",    TC_DEFAULTSTYLE },
-		{ "environment",     TC_ENVIRONMENT },
+		{ "excludesmodule",  TC_EXCLUDESMODULE },
 		{ "float",           TC_FLOAT },
 		{ "format",          TC_FORMAT },
 		{ "input",           TC_INPUT },
@@ -202,6 +212,7 @@ namespace {
 		{ "pagestyle",       TC_PAGESTYLE },
 		{ "preamble",        TC_PREAMBLE },
 		{ "provides",        TC_PROVIDES },
+		{ "providesmodule",  TC_PROVIDESMODULE },
 		{ "requires",        TC_REQUIRES },
 		{ "rightmargin",     TC_RIGHTMARGIN },
 		{ "secnumdepth",     TC_SECNUMDEPTH },
@@ -218,48 +229,31 @@ namespace {
 bool TextClass::convertLayoutFormat(support::FileName const & filename, ReadType rt)
 {
 	LYXERR(Debug::TCLASS, "Converting layout file to " << FORMAT);
-		FileName const tempfile = FileName::tempName();
-		bool success = layout2layout(filename, tempfile);
-		if (success)
-			success = read(tempfile, rt);
-		tempfile.removeFile();
-		return success;
+	FileName const tempfile = FileName::tempName("convert_layout");
+	bool success = layout2layout(filename, tempfile);
+	if (success)
+		success = readWithoutConv(tempfile, rt) == OK;
+	tempfile.removeFile();
+	return success;
 }
 
-bool TextClass::read(FileName const & filename, ReadType rt)
+
+TextClass::ReturnValues TextClass::readWithoutConv(FileName const & filename, ReadType rt)
 {
 	if (!filename.isReadableFile()) {
 		lyxerr << "Cannot read layout file `" << filename << "'."
 		       << endl;
-		return false;
+		return ERROR;
 	}
 
 	LYXERR(Debug::TCLASS, "Reading " + translateRT(rt) + ": " +
 		to_utf8(makeDisplayPath(filename.absFilename())));
 
-	// Define the `empty' layout used in table cells, ert, etc. Note that 
+	// Define the plain layout used in table cells, ert, etc. Note that 
 	// we do this before loading any layout file, so that classes can 
 	// override features of this layout if they should choose to do so.
-	if (rt == BASECLASS && !hasLayout(emptylayout_)) {
-		static char const * s = "Margin Static\n"
-			"LatexType Paragraph\n"
-			"LatexName dummy\n"
-			"Align Block\n"
-			"AlignPossible Left, Right, Center\n"
-			"LabelType No_Label\n"
-			"End";
-		istringstream ss(s);
-		Lexer lex(textClassTags);
-		lex.setStream(ss);
-		Layout lay;
-		lay.setName(emptylayout_);
-		if (!readStyle(lex, lay)) {
-			// The only way this happens is because the hardcoded layout above
-			// is wrong.
-			BOOST_ASSERT(false);
-		};
-		layoutlist_.push_back(lay);
-	}
+	if (rt == BASECLASS && !hasLayout(plain_layout_))
+		layoutlist_.push_back(createBasicLayout(plain_layout_));
 
 	Lexer lexrc(textClassTags);
 	lexrc.setFile(filename);
@@ -267,14 +261,21 @@ bool TextClass::read(FileName const & filename, ReadType rt)
 	
 	LYXERR(Debug::TCLASS, "Finished reading " + translateRT(rt) + ": " +
 			to_utf8(makeDisplayPath(filename.absFilename())));
-	
-	if (retval != FORMAT_MISMATCH) 
+
+	return retval;
+}
+
+
+bool TextClass::read(FileName const & filename, ReadType rt)
+{
+	ReturnValues const retval = readWithoutConv(filename, rt);
+	if (retval != FORMAT_MISMATCH)
 		return retval == OK;
-	
+
 	bool const worx = convertLayoutFormat(filename, rt);
 	if (!worx) {
-		lyxerr << "Unable to convert " << filename << 
-			" to format " << FORMAT << std::endl;
+		LYXERR0 ("Unable to convert " << filename << 
+			" to format " << FORMAT);
 		return false;
 	}
 	return true;
@@ -299,11 +300,10 @@ bool TextClass::read(std::string const & str, ReadType rt)
 		return retval == OK;
 
 	// write the layout string to a temporary file
-	FileName const tempfile = FileName::tempName();
+	FileName const tempfile = FileName::tempName("TextClass_read");
 	ofstream os(tempfile.toFilesystemEncoding().c_str());
 	if (!os) {
-		lyxerr << "Unable to create tempoary file in TextClass::read!!" 
-			<< std::endl;
+		LYXERR0("Unable to create temporary file");
 		return false;
 	}
 	os << str;
@@ -312,8 +312,8 @@ bool TextClass::read(std::string const & str, ReadType rt)
 	// now try to convert it
 	bool const worx = convertLayoutFormat(tempfile, rt);
 	if (!worx) {
-		lyxerr << "Unable to convert internal layout information to format " 
-			<< FORMAT << std::endl;
+		LYXERR0("Unable to convert internal layout information to format " 
+			<< FORMAT);
 	}
 	tempfile.removeFile();
 	return worx;
@@ -381,47 +381,40 @@ TextClass::ReturnValues TextClass::read(Lexer & lexrc, ReadType rt)
 			}
 			break;
 
-		case TC_ENVIRONMENT:
-		case TC_STYLE:
-			if (lexrc.next()) {
-				docstring const name = from_utf8(subst(lexrc.getString(),
-						    '_', ' '));
-				if (name.empty()) {
-					string s = "Could not read name for style: `$$Token' "
-						+ lexrc.getString() + " is probably not valid UTF-8!";
-					lexrc.printError(s.c_str());
-					Layout lay;
-					// Since we couldn't read the name, we just scan the rest
-					// of the style and discard it.
-					error = !readStyle(lexrc, lay);
-				} else if (hasLayout(name)) {
-					Layout & lay = operator[](name);
-					error = !readStyle(lexrc, lay);
-				} else {
-					Layout lay;
-					lay.setName(name);
-					if (le == TC_ENVIRONMENT)
-						lay.is_environment = true;
-					error = !readStyle(lexrc, lay);
-					if (!error)
-						layoutlist_.push_back(lay);
-
-					if (defaultlayout_.empty()) {
-						// We do not have a default layout yet, so we choose
-						// the first layout we encounter.
-						defaultlayout_ = name;
-					}
-				}
-			}
-			else {
-				//FIXME Should we also eat the style here? viz:
-				//Layout lay;
-				//readStyle(lexrc, lay);
-				//as above...
+		case TC_STYLE: {
+			if (!lexrc.next()) {
 				lexrc.printError("No name given for style: `$$Token'.");
 				error = true;
+				break;
+			}
+			docstring const name = from_utf8(subst(lexrc.getString(),
+							'_', ' '));
+			if (name.empty()) {
+				string s = "Could not read name for style: `$$Token' "
+					+ lexrc.getString() + " is probably not valid UTF-8!";
+				lexrc.printError(s.c_str());
+				Layout lay;
+				// Since we couldn't read the name, we just scan the rest
+				// of the style and discard it.
+				error = !readStyle(lexrc, lay);
+			} else if (hasLayout(name)) {
+				Layout & lay = operator[](name);
+				error = !readStyle(lexrc, lay);
+			} else {
+				Layout layout;
+				layout.setName(name);
+				error = !readStyle(lexrc, layout);
+				if (!error)
+					layoutlist_.push_back(layout);
+
+				if (defaultlayout_.empty()) {
+					// We do not have a default layout yet, so we choose
+					// the first layout we encounter.
+					defaultlayout_ = name;
+				}
 			}
 			break;
+		}
 
 		case TC_NOSTYLE:
 			if (lexrc.next()) {
@@ -509,6 +502,35 @@ TextClass::ReturnValues TextClass::read(Lexer & lexrc, ReadType rt)
 			break;
 		}
 
+		case TC_DEFAULTMODULE: {
+			lexrc.next();
+			string const module = lexrc.getString();
+			if (find(default_modules_.begin(), default_modules_.end(), module) == default_modules_.end())
+				default_modules_.push_back(module);
+			break;
+		}
+
+		case TC_PROVIDESMODULE: {
+			lexrc.next();
+			string const module = lexrc.getString();
+			if (find(provided_modules_.begin(), provided_modules_.end(), module) == provided_modules_.end())
+				provided_modules_.push_back(module);
+			break;
+		}
+
+		case TC_EXCLUDESMODULE: {
+			lexrc.next();
+			string const module = lexrc.getString();
+			// modules already have their own way to exclude other modules
+			if (rt == MODULE) {
+				LYXERR0("ExcludesModule tag cannot be used in a module!");
+				break;
+			}
+			if (find(excluded_modules_.begin(), excluded_modules_.end(), module) == excluded_modules_.end())
+				excluded_modules_.push_back(module);
+			break;
+		}
+
 		case TC_LEFTMARGIN:	// left margin type
 			if (lexrc.next())
 				leftmargin_ = lexrc.getDocString();
@@ -519,22 +541,57 @@ TextClass::ReturnValues TextClass::read(Lexer & lexrc, ReadType rt)
 				rightmargin_ = lexrc.getDocString();
 			break;
 
-		case TC_INSETLAYOUT:
-			if (lexrc.next()) {
+		case TC_INSETLAYOUT: {
+			if (!lexrc.next()) {
+				lexrc.printError("No name given for InsetLayout: `$$Token'.");
+				error = true;
+				break;
+			}
+			docstring const name = subst(lexrc.getDocString(), '_', ' ');
+			if (name.empty()) {
+				string s = "Could not read name for InsetLayout: `$$Token' "
+					+ lexrc.getString() + " is probably not valid UTF-8!";
+				lexrc.printError(s.c_str());
 				InsetLayout il;
-				if (il.read(lexrc)) {
-					insetlayoutlist_[il.name()] = il;
-				}
-				// else there was an error, so forget it
+				// Since we couldn't read the name, we just scan the rest
+				// of the style and discard it.
+				il.read(lexrc, *this);
+				error = true;
+			} else if (hasInsetLayout(name)) {
+				InsetLayout & il = insetlayoutlist_[name];
+				error = !il.read(lexrc, *this);
+			} else {
+				InsetLayout il;
+				il.setName(name);
+				error = !il.read(lexrc, *this);
+				if (!error)
+					insetlayoutlist_[name] = il;
 			}
 			break;
+		}
 
 		case TC_FLOAT:
 			readFloat(lexrc);
 			break;
 
 		case TC_COUNTER:
-			readCounter(lexrc);
+			if (lexrc.next()) {
+				docstring const name = lexrc.getDocString();
+				if (name.empty()) {
+					string s = "Could not read name for counter: `$$Token' "
+							+ lexrc.getString() + " is probably not valid UTF-8!";
+					lexrc.printError(s.c_str());
+					Counter c;
+					// Since we couldn't read the name, we just scan the rest
+					// and discard it.
+					c.read(lexrc);
+				} else
+					error = !counters_.read(lexrc, name);
+			}
+			else {
+				lexrc.printError("No name given for style: `$$Token'.");
+				error = true;
+			}
 			break;
 
 		case TC_TITLELATEXTYPE:
@@ -552,7 +609,7 @@ TextClass::ReturnValues TextClass::read(Lexer & lexrc, ReadType rt)
 				floatlist_.erase(nofloat);
 			}
 			break;
-		}
+		} // end of switch
 
 		//Note that this is triggered the first time through the loop unless
 		//we hit a format tag.
@@ -567,21 +624,21 @@ TextClass::ReturnValues TextClass::read(Lexer & lexrc, ReadType rt)
 		return (error ? ERROR : OK);
 
 	if (defaultlayout_.empty()) {
-		lyxerr << "Error: Textclass '" << name_
-						<< "' is missing a defaultstyle." << endl;
+		LYXERR0("Error: Textclass '" << name_
+						<< "' is missing a defaultstyle.");
 		error = true;
 	}
 		
-	//Try to erase "stdinsets" from the provides_ set. 
-	//The
-	//  Provides stdinsets 1
-	//declaration simply tells us that the standard insets have been
-	//defined. (It's found in stdinsets.inc but could also be used in
-	//user-defined files.) There isn't really any such package. So we
-	//might as well go ahead and erase it.
-	//If we do not succeed, then it was not there, which means that
-	//the textclass did not provide the definitions of the standard
-	//insets. So we need to try to load them.
+	// Try to erase "stdinsets" from the provides_ set. 
+	// The
+	//   Provides stdinsets 1
+	// declaration simply tells us that the standard insets have been
+	// defined. (It's found in stdinsets.inc but could also be used in
+	// user-defined files.) There isn't really any such package. So we
+	// might as well go ahead and erase it.
+	// If we do not succeed, then it was not there, which means that
+	// the textclass did not provide the definitions of the standard
+	// insets. So we need to try to load them.
 	int erased = provides_.erase("stdinsets");
 	if (!erased) {
 		FileName tmp = libFileSearch("layouts", "stdinsets.inc");
@@ -631,15 +688,13 @@ void TextClass::readTitleType(Lexer & lexrc)
 	switch (le) {
 	case Lexer::LEX_UNDEF:
 		lexrc.printError("Unknown output type `$$Token'");
-		return;
+		break;
 	case TITLE_COMMAND_AFTER:
 	case TITLE_ENVIRONMENT:
 		titletype_ = static_cast<TitleLatexType>(le);
 		break;
 	default:
-		lyxerr << "Unhandled value " << le
-		       << " in TextClass::readTitleType." << endl;
-
+		LYXERR0("Unhandled value " << le << " in TextClass::readTitleType.");
 		break;
 	}
 }
@@ -666,9 +721,7 @@ void TextClass::readOutputType(Lexer & lexrc)
 		outputType_ = static_cast<OutputType>(le);
 		break;
 	default:
-		lyxerr << "Unhandled value " << le
-		       << " in TextClass::readOutputType." << endl;
-
+		LYXERR0("Unhandled value " << le);
 		break;
 	}
 }
@@ -843,79 +896,6 @@ void TextClass::readFloat(Lexer & lexrc)
 }
 
 
-void TextClass::readCounter(Lexer & lexrc)
-{
-	enum {
-		CT_NAME = 1,
-		CT_WITHIN,
-		CT_LABELSTRING,
-		CT_LABELSTRING_APPENDIX,
-		CT_END
-	};
-
-	LexerKeyword counterTags[] = {
-		{ "end", CT_END },
-		{ "labelstring", CT_LABELSTRING },
-		{ "labelstringappendix", CT_LABELSTRING_APPENDIX },
-		{ "name", CT_NAME },
-		{ "within", CT_WITHIN }
-	};
-
-	lexrc.pushTable(counterTags);
-
-	docstring name;
-	docstring within;
-	docstring labelstring;
-	docstring labelstring_appendix;
-
-	bool getout = false;
-	while (!getout && lexrc.isOK()) {
-		int le = lexrc.lex();
-		switch (le) {
-		case Lexer::LEX_UNDEF:
-			lexrc.printError("Unknown counter tag `$$Token'");
-			continue;
-		default: break;
-		}
-		switch (le) {
-		case CT_NAME:
-			lexrc.next();
-			name = lexrc.getDocString();
-			if (counters_.hasCounter(name))
-				LYXERR(Debug::TCLASS, "Reading existing counter " << to_utf8(name));
-			else
-				LYXERR(Debug::TCLASS, "Reading new counter " << to_utf8(name));
-			break;
-		case CT_WITHIN:
-			lexrc.next();
-			within = lexrc.getDocString();
-			if (within == "none")
-				within.erase();
-			break;
-		case CT_LABELSTRING:
-			lexrc.next();
-			labelstring = lexrc.getDocString();
-			labelstring_appendix = labelstring;
-			break;
-		case CT_LABELSTRING_APPENDIX:
-			lexrc.next();
-			labelstring_appendix = lexrc.getDocString();
-			break;
-		case CT_END:
-			getout = true;
-			break;
-		}
-	}
-
-	// Here if have a full counter if getout == true
-	if (getout)
-		counters_.newCounter(name, within, 
-				      labelstring, labelstring_appendix);
-
-	lexrc.popTable();
-}
-
-
 bool TextClass::hasLayout(docstring const & n) const
 {
 	docstring const name = n.empty() ? defaultLayoutName() : n;
@@ -926,10 +906,22 @@ bool TextClass::hasLayout(docstring const & n) const
 }
 
 
+bool TextClass::hasInsetLayout(docstring const & n) const
+{
+	if (n.empty()) 
+		return false;
+	InsetLayouts::const_iterator it = insetlayoutlist_.begin();
+	InsetLayouts::const_iterator en = insetlayoutlist_.end();
+	for (; it != en; ++it)
+		if (n == it->first)
+			return true;
+	return false;
+}
+
 
 Layout const & TextClass::operator[](docstring const & name) const
 {
-	BOOST_ASSERT(!name.empty());
+	LASSERT(!name.empty(), /**/);
 
 	const_iterator it = 
 		find_if(begin(), end(), LayoutNamesEqual(name));
@@ -942,7 +934,7 @@ Layout const & TextClass::operator[](docstring const & name) const
 			lyxerr  << " " << to_utf8(cit->name()) << endl;
 
 		// we require the name to exist
-		BOOST_ASSERT(false);
+		LASSERT(false, /**/);
 	}
 
 	return *it;
@@ -951,19 +943,18 @@ Layout const & TextClass::operator[](docstring const & name) const
 
 Layout & TextClass::operator[](docstring const & name)
 {
-	BOOST_ASSERT(!name.empty());
+	LASSERT(!name.empty(), /**/);
 
 	iterator it = find_if(begin(), end(), LayoutNamesEqual(name));
 
 	if (it == end()) {
-		lyxerr << "We failed to find the layout '" << to_utf8(name)
-		       << "' in the layout list. You MUST investigate!"
-		       << endl;
+		LYXERR0("We failed to find the layout '" << to_utf8(name)
+		       << "' in the layout list. You MUST investigate!");
 		for (const_iterator cit = begin(); cit != end(); ++cit)
-			lyxerr  << " " << to_utf8(cit->name()) << endl;
+			LYXERR0(" " << to_utf8(cit->name()));
 
 		// we require the name to exist
-		BOOST_ASSERT(false);
+		LASSERT(false, /**/);
 	}
 
 	return *it;
@@ -972,7 +963,7 @@ Layout & TextClass::operator[](docstring const & name)
 
 bool TextClass::deleteLayout(docstring const & name)
 {
-	if (name == defaultLayoutName() || name == emptyLayoutName())
+	if (name == defaultLayoutName() || name == plainLayoutName())
 		return false;
 
 	LayoutList::iterator it =
@@ -993,8 +984,9 @@ bool TextClass::load(string const & path) const
 		return true;
 
 	// Read style-file, provided path is searched before the system ones
-	FileName layout_file;
-	if (!path.empty())
+	// If path is a file, it is loaded directly.
+	FileName layout_file(path);
+	if (!path.empty() && !layout_file.isReadableFile())
 		layout_file = FileName(addName(path, name_ + ".layout"));
 	if (layout_file.empty() || !layout_file.exists())
 		layout_file = libFileSearch("layouts", name_, "layout");
@@ -1012,8 +1004,17 @@ bool TextClass::load(string const & path) const
 }
 
 
+void DocumentClass::addLayoutIfNeeded(docstring const & n) const
+{
+	if (!hasLayout(n))
+		layoutlist_.push_back(createBasicLayout(n, true));
+}
+
+
 InsetLayout const & DocumentClass::insetLayout(docstring const & name) const 
 {
+	// FIXME The fix for the InsetLayout part of 4812 would be here:
+	// Add the InsetLayout to the document class if it is not found.
 	docstring n = name;
 	InsetLayouts::const_iterator cen = insetlayoutlist_.end();
 	while (!n.empty()) {
@@ -1023,9 +1024,9 @@ InsetLayout const & DocumentClass::insetLayout(docstring const & name) const
 		size_t i = n.find(':');
 		if (i == string::npos)
 			break;
-		n = n.substr(0,i);
+		n = n.substr(0, i);
 	}
-	return empty_insetlayout_;
+	return plain_insetlayout_;
 }
 
 
@@ -1042,23 +1043,67 @@ Layout const & TextClass::defaultLayout() const
 }
 
 
-bool TextClass::isDefaultLayout(Layout const & lay) const 
+bool TextClass::isDefaultLayout(Layout const & layout) const 
 {
-	return lay.name() == defaultLayoutName();
+	return layout.name() == defaultLayoutName();
 }
 
 
-bool TextClass::isEmptyLayout(Layout const & lay) const 
+bool TextClass::isPlainLayout(Layout const & layout) const 
 {
-	return lay.name() == emptyLayoutName();
+	return layout.name() == plainLayoutName();
 }
 
 
+Layout TextClass::createBasicLayout(docstring const & name, bool unknown) const
+{
+	static Layout * defaultLayout = NULL;
+
+	if (defaultLayout) {
+		defaultLayout->setUnknown(unknown);
+		defaultLayout->setName(name);
+		return *defaultLayout;
+	}
+
+	static char const * s = "Margin Static\n"
+			"LatexType Paragraph\n"
+			"LatexName dummy\n"
+			"Align Block\n"
+			"AlignPossible Left, Right, Center\n"
+			"LabelType No_Label\n"
+			"End";
+	istringstream ss(s);
+	Lexer lex(textClassTags);
+	lex.setStream(ss);
+	defaultLayout = new Layout;
+	defaultLayout->setUnknown(unknown);
+	defaultLayout->setName(name);
+	if (!readStyle(lex, *defaultLayout)) {
+		// The only way this happens is because the hardcoded layout above
+		// is wrong.
+		LASSERT(false, /**/);
+	};
+	return *defaultLayout;
+}
+
+/////////////////////////////////////////////////////////////////////////
+//
+// DocumentClassBundle
+//
+/////////////////////////////////////////////////////////////////////////
+
+DocumentClassBundle::~DocumentClassBundle()
+{
+	for (size_t i = 0; i != documentClasses_.size(); ++i)
+		delete documentClasses_[i];
+	documentClasses_.clear();
+}
+
 DocumentClass & DocumentClassBundle::newClass(LayoutFile const & baseClass)
 {
 	DocumentClass * dc = new DocumentClass(baseClass);
-	tc_list_.push_back(dc);
-	return *tc_list_.back();
+	documentClasses_.push_back(dc);
+	return *documentClasses_.back();
 }
 
 
@@ -1069,6 +1114,49 @@ DocumentClassBundle & DocumentClassBundle::get()
 }
 
 
+DocumentClass & DocumentClassBundle::makeDocumentClass(
+		LayoutFile const & baseClass, LayoutModuleList const & modlist)
+{
+	DocumentClass & doc_class = newClass(baseClass);
+	LayoutModuleList::const_iterator it = modlist.begin();
+	LayoutModuleList::const_iterator en = modlist.end();
+	for (; it != en; it++) {
+		string const modName = *it;
+		LyXModule * lm = moduleList[modName];
+		if (!lm) {
+			docstring const msg =
+						bformat(_("The module %1$s has been requested by\n"
+						"this document but has not been found in the list of\n"
+						"available modules. If you recently installed it, you\n"
+						"probably need to reconfigure LyX.\n"), from_utf8(modName));
+			ExceptionMessage(WarningException,_("Module not available"),
+					msg + _("Some layouts may not be available."));
+			continue;
+		}
+		if (!lm->isAvailable()) {
+			docstring const msg =
+						bformat(_("The module %1$s requires a package that is\n"
+						"not available in your LaTeX installation. LaTeX output\n"
+						"may not be possible.\n"), from_utf8(modName));
+			ExceptionMessage(WarningException, _("Package not available"), msg);
+		}
+		FileName layout_file = libFileSearch("layouts", lm->getFilename());
+		if (!doc_class.read(layout_file, TextClass::MODULE)) {
+			docstring const msg =
+						bformat(_("Error reading module %1$s\n"), from_utf8(modName));
+			throw ExceptionMessage(WarningException, _("Read Error"), msg);
+		}
+	}
+	return doc_class;
+}
+
+
+/////////////////////////////////////////////////////////////////////////
+//
+// DocumentClass
+//
+/////////////////////////////////////////////////////////////////////////
+
 DocumentClass::DocumentClass(LayoutFile const & tc)
 	: TextClass(tc)
 {}
@@ -1097,6 +1185,12 @@ bool DocumentClass::hasTocLevels() const
 }
 
 
+/////////////////////////////////////////////////////////////////////////
+//
+// PageSides
+//
+/////////////////////////////////////////////////////////////////////////
+
 ostream & operator<<(ostream & os, PageSides p)
 {
 	switch (p) {