X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FTextClass.cpp;h=a594375cda5930118f51d3513ea237c56dc77d64;hb=fb12b282f1300123c7f4c7f10525c29cb598e1fe;hp=4df69a680c82375f2b45e84b6d37af3b57e929c0;hpb=0fb8f3fba12ab9fb395ef40e21b5ba50a5e0b9df;p=lyx.git

diff --git a/src/TextClass.cpp b/src/TextClass.cpp
index 4df69a680c..a594375cda 100644
--- a/src/TextClass.cpp
+++ b/src/TextClass.cpp
@@ -16,6 +16,7 @@
 
 #include "TextClass.h"
 
+#include "LayoutFile.h"
 #include "Color.h"
 #include "Counters.h"
 #include "Floating.h"
@@ -26,6 +27,7 @@
 
 #include "frontends/alert.h"
 
+#include "support/lassert.h"
 #include "support/debug.h"
 #include "support/ExceptionMessage.h"
 #include "support/FileName.h"
@@ -34,6 +36,8 @@
 #include "support/lstrings.h"
 #include "support/os.h"
 
+#include <algorithm>
+#include <fstream>
 #include <sstream>
 
 using namespace std;
@@ -43,29 +47,29 @@ namespace lyx {
 
 namespace {
 
-class LayoutNamesEqual : public unary_function<LayoutPtr, bool> {
+class LayoutNamesEqual : public unary_function<Layout, bool> {
 public:
 	LayoutNamesEqual(docstring const & name)
 		: name_(name)
 	{}
-	bool operator()(LayoutPtr const & c) const
+	bool operator()(Layout const & c) const
 	{
-		return c->name() == name_;
+		return c.name() == name_;
 	}
 private:
 	docstring name_;
 };
 
 
-int const FORMAT = 6;
+int const FORMAT = 8;
 
 
 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;
 	}
 
@@ -77,11 +81,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;
@@ -97,6 +99,8 @@ std::string translateRT(TextClass::ReadType rt)
 		return "input file";
 	case TextClass::MODULE:
 		return "module file";
+	case TextClass::VALIDATION:
+		return "validation";
 	}
 	// shutup warning
 	return string();
@@ -105,13 +109,22 @@ std::string translateRT(TextClass::ReadType rt)
 } // namespace anon
 
 
-TextClass::TextClass(string const & fn, string const & cln,
-			   string const & desc, bool texClassAvail )
-	: name_(fn), latexname_(cln), description_(desc),
-	  floatlist_(new FloatList), counters_(new Counters),
-	  texClassAvail_(texClassAvail)
+// 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_;
+
+
+/////////////////////////////////////////////////////////////////////////
+//
+// TextClass
+//
+/////////////////////////////////////////////////////////////////////////
+
+TextClass::TextClass()
 {
-	modular_ = false;
 	outputType_ = LATEX;
 	columns_ = 1;
 	sides_ = OneSide;
@@ -124,36 +137,22 @@ TextClass::TextClass(string const & fn, string const & cln,
 	titletype_ = TITLE_COMMAND_AFTER;
 	titlename_ = "maketitle";
 	loaded_ = false;
-	// a hack to make this available for translation
-	// i'm sure there must be a better way (rgh)
-	_("PlainLayout");
+	_("Plain Layout"); // a hack to make this translatable
 }
 
 
-docstring const TextClass::emptylayout_ = from_ascii("PlainLayout");
-
-
-InsetLayout TextClass::empty_insetlayout_;
-
-
-bool TextClass::isTeXClassAvailable() const
-{
-	return texClassAvail_;
-}
-
-
-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
 	lay.resfont = lay.font;
-	lay.resfont.realize(defaultfont());
+	lay.resfont.realize(defaultfont_);
 	lay.reslabelfont = lay.labelfont;
-	lay.reslabelfont.realize(defaultfont());
+	lay.reslabelfont.realize(defaultfont_);
 	return true; // no errors
 }
 
@@ -164,7 +163,6 @@ enum TextClassTags {
 	TC_STYLE,
 	TC_DEFAULTSTYLE,
 	TC_INSETLAYOUT,
-	TC_ENVIRONMENT,
 	TC_NOSTYLE,
 	TC_COLUMNS,
 	TC_SIDES,
@@ -183,26 +181,21 @@ enum TextClassTags {
 	TC_NOFLOAT,
 	TC_TITLELATEXNAME,
 	TC_TITLELATEXTYPE,
-	TC_FORMAT
+	TC_FORMAT,
+	TC_ADDTOPREAMBLE,
+	TC_USEMODULE
 };
 
 
-// Reads a textclass structure from file.
-bool TextClass::read(FileName const & filename, ReadType rt)
-{
-	if (!filename.isReadableFile()) {
-		lyxerr << "Cannot read layout file `" << filename << "'."
-		       << endl;
-		return false;
-	}
+namespace {
 
-	keyword_item textClassTags[] = {
+	LexerKeyword textClassTags[] = {
+		{ "addtopreamble",   TC_ADDTOPREAMBLE },
 		{ "classoptions",    TC_CLASSOPTIONS },
 		{ "columns",         TC_COLUMNS },
 		{ "counter",         TC_COUNTER },
 		{ "defaultfont",     TC_DEFAULTFONT },
 		{ "defaultstyle",    TC_DEFAULTSTYLE },
-		{ "environment",     TC_ENVIRONMENT },
 		{ "float",           TC_FLOAT },
 		{ "format",          TC_FORMAT },
 		{ "input",           TC_INPUT },
@@ -221,40 +214,102 @@ bool TextClass::read(FileName const & filename, ReadType rt)
 		{ "style",           TC_STYLE },
 		{ "titlelatexname",  TC_TITLELATEXNAME },
 		{ "titlelatextype",  TC_TITLELATEXTYPE },
-		{ "tocdepth",        TC_TOCDEPTH }
+		{ "tocdepth",        TC_TOCDEPTH },
+		{ "usemodule",       TC_USEMODULE }
 	};
+	
+} //namespace anon
+
+
+bool TextClass::convertLayoutFormat(support::FileName const & filename, ReadType rt)
+{
+	LYXERR(Debug::TCLASS, "Converting layout file to " << FORMAT);
+		FileName const tempfile = FileName::tempName("convert_layout");
+		bool success = layout2layout(filename, tempfile);
+		if (success)
+			success = read(tempfile, rt);
+		tempfile.removeFile();
+		return success;
+}
+
+bool TextClass::read(FileName const & filename, ReadType rt)
+{
+	if (!filename.isReadableFile()) {
+		lyxerr << "Cannot read layout file `" << filename << "'."
+		       << endl;
+		return false;
+	}
 
 	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) {
-		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, sizeof(textClassTags) / sizeof(textClassTags[0]));
-		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(boost::shared_ptr<Layout>(new Layout(lay)));
+	if (rt == BASECLASS && !hasLayout(plain_layout_))
+		layoutlist_.push_back(createBasicLayout(plain_layout_));
+
+	Lexer lexrc(textClassTags);
+	lexrc.setFile(filename);
+	ReturnValues retval = read(lexrc, rt);
+	
+	LYXERR(Debug::TCLASS, "Finished reading " + translateRT(rt) + ": " +
+			to_utf8(makeDisplayPath(filename.absFilename())));
+	
+	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;
+		return false;
 	}
+	return true;
+}
 
-	Lexer lexrc(textClassTags,
-		sizeof(textClassTags) / sizeof(textClassTags[0]));
 
-	lexrc.setFile(filename);
+bool TextClass::validate(std::string const & str)
+{
+	TextClass tc;
+	return tc.read(str, VALIDATION);
+}
+
+
+bool TextClass::read(std::string const & str, ReadType rt) 
+{
+	Lexer lexrc(textClassTags);
+	istringstream is(str);
+	lexrc.setStream(is);
+	ReturnValues retval = read(lexrc, rt);
+
+	if (retval != FORMAT_MISMATCH) 
+		return retval == OK;
+
+	// write the layout string to a temporary file
+	FileName const tempfile = FileName::tempName("TextClass_read");
+	ofstream os(tempfile.toFilesystemEncoding().c_str());
+	if (!os) {
+		LYXERR0("Unable to create temporary file");
+		return false;
+	}
+	os << str;
+	os.close();
+
+	// now try to convert it
+	bool const worx = convertLayoutFormat(tempfile, rt);
+	if (!worx) {
+		LYXERR0("Unable to convert internal layout information to format " 
+			<< FORMAT);
+	}
+	tempfile.removeFile();
+	return worx;
+}
+
+
+// Reads a textclass structure from file.
+TextClass::ReturnValues TextClass::read(Lexer & lexrc, ReadType rt) 
+{
 	bool error = !lexrc.isOK();
 
 	// Format of files before the 'Format' tag was introduced
@@ -313,7 +368,6 @@ bool TextClass::read(FileName const & filename, ReadType rt)
 			}
 			break;
 
-		case TC_ENVIRONMENT:
 		case TC_STYLE:
 			if (lexrc.next()) {
 				docstring const name = from_utf8(subst(lexrc.getString(),
@@ -323,21 +377,18 @@ bool TextClass::read(FileName const & filename, ReadType rt)
 						+ lexrc.getString() + " is probably not valid UTF-8!";
 					lexrc.printError(s.c_str());
 					Layout lay;
-					//FIXME If we're just dropping this layout, do we really
-					//care whether there's an error?? Or should we just set
-					//error to true, since we couldn't even read the name?
+					// 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).get();
-					error = !readStyle(lexrc, *lay);
-				} else {
-					Layout lay;
-					lay.setName(name);
-					if (le == TC_ENVIRONMENT)
-						lay.is_environment = true;
+					Layout & lay = operator[](name);
 					error = !readStyle(lexrc, lay);
+				} else {
+					Layout layout;
+					layout.setName(name);
+					error = !readStyle(lexrc, layout);
 					if (!error)
-						layoutlist_.push_back(boost::shared_ptr<Layout>(new Layout(lay)));
+						layoutlist_.push_back(layout);
 
 					if (defaultlayout_.empty()) {
 						// We do not have a default layout yet, so we choose
@@ -348,8 +399,8 @@ bool TextClass::read(FileName const & filename, ReadType rt)
 			}
 			else {
 				//FIXME Should we also eat the style here? viz:
-				//Layout lay;
-				//readStyle(lexrc, lay);
+				//Layout layout;
+				//readStyle(lexrc, layout);
 				//as above...
 				lexrc.printError("No name given for style: `$$Token'.");
 				error = true;
@@ -419,6 +470,10 @@ bool TextClass::read(FileName const & filename, ReadType rt)
 			preamble_ = from_utf8(lexrc.getLongString("EndPreamble"));
 			break;
 
+		case TC_ADDTOPREAMBLE:
+			preamble_ += from_utf8(lexrc.getLongString("EndPreamble"));
+			break;
+
 		case TC_PROVIDES: {
 			lexrc.next();
 			string const feature = lexrc.getString();
@@ -438,6 +493,13 @@ bool TextClass::read(FileName const & filename, ReadType rt)
 			break;
 		}
 
+		case TC_USEMODULE: {
+			lexrc.next();
+			string const module = lexrc.getString();
+			usemod_.insert(module);
+			break;
+		}
+
 		case TC_LEFTMARGIN:	// left margin type
 			if (lexrc.next())
 				leftmargin_ = lexrc.getDocString();
@@ -451,9 +513,8 @@ bool TextClass::read(FileName const & filename, ReadType rt)
 		case TC_INSETLAYOUT:
 			if (lexrc.next()) {
 				InsetLayout il;
-				if (il.read(lexrc)) {
+				if (il.read(lexrc, *this))
 					insetlayoutlist_[il.name()] = il;
-				}
 				// else there was an error, so forget it
 			}
 			break;
@@ -478,7 +539,7 @@ bool TextClass::read(FileName const & filename, ReadType rt)
 		case TC_NOFLOAT:
 			if (lexrc.next()) {
 				string const nofloat = lexrc.getString();
-				floatlist_->erase(nofloat);
+				floatlist_.erase(nofloat);
 			}
 			break;
 		}
@@ -489,39 +550,28 @@ bool TextClass::read(FileName const & filename, ReadType rt)
 			break;
 	}
 
-	if (format != FORMAT) {
-		LYXERR(Debug::TCLASS, "Converting layout file from format "
-				      << format << " to " << FORMAT);
-		FileName const tempfile = FileName::tempName();
-		error = !layout2layout(filename, tempfile);
-		if (!error)
-			error = read(tempfile, rt);
-		tempfile.removeFile();
-		return !error;
-	}
-
-	LYXERR(Debug::TCLASS, "Finished reading " + translateRT(rt) + ": " +
-			to_utf8(makeDisplayPath(filename.absFilename())));
+	if (format != FORMAT)
+		return FORMAT_MISMATCH;
 
 	if (rt != BASECLASS) 
-		return !error;
+		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");
@@ -539,8 +589,10 @@ bool TextClass::read(FileName const & filename, ReadType rt)
 
 	min_toclevel_ = Layout::NOT_IN_TOC;
 	max_toclevel_ = Layout::NOT_IN_TOC;
-	for (size_t i = 0; i != layoutCount(); ++i) {
-		int const toclevel = layout(i)->toclevel;
+	const_iterator lit = begin();
+	const_iterator len = end();
+	for (; lit != len; ++lit) {
+		int const toclevel = lit->toclevel;
 		if (toclevel != Layout::NOT_IN_TOC) {
 			if (min_toclevel_ == Layout::NOT_IN_TOC)
 				min_toclevel_ = toclevel;
@@ -552,32 +604,30 @@ bool TextClass::read(FileName const & filename, ReadType rt)
 	LYXERR(Debug::TCLASS, "Minimum TocLevel is " << min_toclevel_
 		<< ", maximum is " << max_toclevel_);
 
-	return !error;
+	return (error ? ERROR : OK);
 }
 
 
 void TextClass::readTitleType(Lexer & lexrc)
 {
-	keyword_item titleTypeTags[] = {
+	LexerKeyword titleTypeTags[] = {
 		{ "commandafter", TITLE_COMMAND_AFTER },
-		{ "environment", TITLE_ENVIRONMENT }
+		{ "environment",  TITLE_ENVIRONMENT }
 	};
 
-	PushPopHelper pph(lexrc, titleTypeTags, TITLE_ENVIRONMENT);
+	PushPopHelper pph(lexrc, titleTypeTags);
 
 	int le = lexrc.lex();
 	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;
 	}
 }
@@ -585,13 +635,13 @@ void TextClass::readTitleType(Lexer & lexrc)
 
 void TextClass::readOutputType(Lexer & lexrc)
 {
-	keyword_item outputTypeTags[] = {
-		{ "docbook", DOCBOOK },
-		{ "latex", LATEX },
+	LexerKeyword outputTypeTags[] = {
+		{ "docbook",  DOCBOOK },
+		{ "latex",    LATEX },
 		{ "literate", LITERATE }
 	};
 
-	PushPopHelper pph(lexrc, outputTypeTags, LITERATE);
+	PushPopHelper pph(lexrc, outputTypeTags);
 
 	int le = lexrc.lex();
 	switch (le) {
@@ -604,34 +654,31 @@ 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;
 	}
 }
 
 
-enum ClassOptionsTags {
-	CO_FONTSIZE = 1,
-	CO_PAGESTYLE,
-	CO_OTHER,
-	CO_HEADER,
-	CO_END
-};
-
-
 void TextClass::readClassOptions(Lexer & lexrc)
 {
-	keyword_item classOptionsTags[] = {
-		{"end", CO_END },
-		{"fontsize", CO_FONTSIZE },
-		{"header", CO_HEADER },
-		{"other", CO_OTHER },
+	enum {
+		CO_FONTSIZE = 1,
+		CO_PAGESTYLE,
+		CO_OTHER,
+		CO_HEADER,
+		CO_END
+	};
+
+	LexerKeyword classOptionsTags[] = {
+		{"end",       CO_END },
+		{"fontsize",  CO_FONTSIZE },
+		{"header",    CO_HEADER },
+		{"other",     CO_OTHER },
 		{"pagestyle", CO_PAGESTYLE }
 	};
 
-	lexrc.pushTable(classOptionsTags, CO_END);
+	lexrc.pushTable(classOptionsTags);
 	bool getout = false;
 	while (!getout && lexrc.isOK()) {
 		int le = lexrc.lex();
@@ -641,7 +688,7 @@ void TextClass::readClassOptions(Lexer & lexrc)
 			continue;
 		default: break;
 		}
-		switch (static_cast<ClassOptionsTags>(le)) {
+		switch (le) {
 		case CO_FONTSIZE:
 			lexrc.next();
 			opt_fontsize_ = rtrim(lexrc.getString());
@@ -667,22 +714,21 @@ void TextClass::readClassOptions(Lexer & lexrc)
 }
 
 
-enum FloatTags {
-	FT_TYPE = 1,
-	FT_NAME,
-	FT_PLACEMENT,
-	FT_EXT,
-	FT_WITHIN,
-	FT_STYLE,
-	FT_LISTNAME,
-	FT_BUILTIN,
-	FT_END
-};
-
-
 void TextClass::readFloat(Lexer & lexrc)
 {
-	keyword_item floatTags[] = {
+	enum {
+		FT_TYPE = 1,
+		FT_NAME,
+		FT_PLACEMENT,
+		FT_EXT,
+		FT_WITHIN,
+		FT_STYLE,
+		FT_LISTNAME,
+		FT_BUILTIN,
+		FT_END
+	};
+
+	LexerKeyword floatTags[] = {
 		{ "end", FT_END },
 		{ "extension", FT_EXT },
 		{ "guiname", FT_NAME },
@@ -694,7 +740,7 @@ void TextClass::readFloat(Lexer & lexrc)
 		{ "type", FT_TYPE }
 	};
 
-	lexrc.pushTable(floatTags, FT_END);
+	lexrc.pushTable(floatTags);
 
 	string type;
 	string placement;
@@ -714,12 +760,12 @@ void TextClass::readFloat(Lexer & lexrc)
 			continue;
 		default: break;
 		}
-		switch (static_cast<FloatTags>(le)) {
+		switch (le) {
 		case FT_TYPE:
 			lexrc.next();
 			type = lexrc.getString();
-			if (floatlist_->typeExist(type)) {
-				Floating const & fl = floatlist_->getType(type);
+			if (floatlist_.typeExist(type)) {
+				Floating const & fl = floatlist_.getType(type);
 				placement = fl.placement();
 				ext = fl.ext();
 				within = fl.within();
@@ -769,28 +815,31 @@ void TextClass::readFloat(Lexer & lexrc)
 	if (getout) {
 		Floating fl(type, placement, ext, within,
 			    style, name, listName, builtin);
-		floatlist_->newFloat(fl);
+		floatlist_.newFloat(fl);
 		// each float has its own counter
-		counters_->newCounter(from_ascii(type), from_ascii(within), 
+		counters_.newCounter(from_ascii(type), from_ascii(within),
 				      docstring(), docstring());
+		// also define sub-float counters
+		docstring const subtype = "sub-" + from_ascii(type);
+		counters_.newCounter(subtype, from_ascii(type),
+				      "\\alph{" + subtype + "}", docstring());
 	}
 
 	lexrc.popTable();
 }
 
 
-enum CounterTags {
-	CT_NAME = 1,
-	CT_WITHIN,
-	CT_LABELSTRING,
-	CT_LABELSTRING_APPENDIX,
-	CT_END
-};
-
-
 void TextClass::readCounter(Lexer & lexrc)
 {
-	keyword_item counterTags[] = {
+	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 },
@@ -798,7 +847,7 @@ void TextClass::readCounter(Lexer & lexrc)
 		{ "within", CT_WITHIN }
 	};
 
-	lexrc.pushTable(counterTags, CT_END);
+	lexrc.pushTable(counterTags);
 
 	docstring name;
 	docstring within;
@@ -814,11 +863,11 @@ void TextClass::readCounter(Lexer & lexrc)
 			continue;
 		default: break;
 		}
-		switch (static_cast<CounterTags>(le)) {
+		switch (le) {
 		case CT_NAME:
 			lexrc.next();
 			name = lexrc.getDocString();
-			if (counters_->hasCounter(name))
+			if (counters_.hasCounter(name))
 				LYXERR(Debug::TCLASS, "Reading existing counter " << to_utf8(name));
 			else
 				LYXERR(Debug::TCLASS, "Reading new counter " << to_utf8(name));
@@ -846,31 +895,13 @@ void TextClass::readCounter(Lexer & lexrc)
 
 	// Here if have a full counter if getout == true
 	if (getout)
-		counters_->newCounter(name, within, 
+		counters_.newCounter(name, within, 
 				      labelstring, labelstring_appendix);
 
 	lexrc.popTable();
 }
 
 
-FontInfo const & TextClass::defaultfont() const
-{
-	return defaultfont_;
-}
-
-
-docstring const & TextClass::leftmargin() const
-{
-	return leftmargin_;
-}
-
-
-docstring const & TextClass::rightmargin() const
-{
-	return rightmargin_;
-}
-
-
 bool TextClass::hasLayout(docstring const & n) const
 {
 	docstring const name = n.empty() ? defaultLayoutName() : n;
@@ -881,35 +912,51 @@ bool TextClass::hasLayout(docstring const & n) const
 }
 
 
-
-LayoutPtr const & TextClass::operator[](docstring const & name) const
+Layout const & TextClass::operator[](docstring const & name) const
 {
-	BOOST_ASSERT(!name.empty());
+	LASSERT(!name.empty(), /**/);
 
-	LayoutList::const_iterator cit =
-		find_if(layoutlist_.begin(),
-			layoutlist_.end(),
-			LayoutNamesEqual(name));
+	const_iterator it = 
+		find_if(begin(), end(), LayoutNamesEqual(name));
 
-	if (cit == layoutlist_.end()) {
+	if (it == end()) {
 		lyxerr << "We failed to find the layout '" << to_utf8(name)
 		       << "' in the layout list. You MUST investigate!"
 		       << endl;
-		for (LayoutList::const_iterator it = layoutlist_.begin();
-			 it != layoutlist_.end(); ++it)
-			lyxerr  << " " << to_utf8(it->get()->name()) << endl;
+		for (const_iterator cit = begin(); cit != end(); ++cit)
+			lyxerr  << " " << to_utf8(cit->name()) << endl;
+
+		// we require the name to exist
+		LASSERT(false, /**/);
+	}
+
+	return *it;
+}
+
+
+Layout & TextClass::operator[](docstring const & name)
+{
+	LASSERT(!name.empty(), /**/);
+
+	iterator it = find_if(begin(), end(), LayoutNamesEqual(name));
+
+	if (it == end()) {
+		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)
+			LYXERR0(" " << to_utf8(cit->name()));
 
 		// we require the name to exist
-		BOOST_ASSERT(false);
+		LASSERT(false, /**/);
 	}
 
-	return *cit;
+	return *it;
 }
 
 
 bool TextClass::deleteLayout(docstring const & name)
 {
-	if (name == defaultLayoutName() || name == emptyLayoutName())
+	if (name == defaultLayoutName() || name == plainLayoutName())
 		return false;
 
 	LayoutList::iterator it =
@@ -930,8 +977,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");
@@ -949,43 +997,29 @@ bool TextClass::load(string const & path) const
 }
 
 
-FloatList & TextClass::floats()
-{
-	return *floatlist_.get();
-}
-
-
-FloatList const & TextClass::floats() const
+void DocumentClass::addLayoutIfNeeded(docstring const & n) const
 {
-	return *floatlist_.get();
+	if (!hasLayout(n))
+		layoutlist_.push_back(createBasicLayout(n, true));
 }
 
 
-Counters & TextClass::counters() const
-{
-	return *counters_.get();
-}
-
-
-// Return the layout object of an inset given by name. If the name
-// is not found as such, the part after the ':' is stripped off, and
-// searched again. In this way, an error fallback can be provided:
-// An erroneous 'CharStyle:badname' (e.g., after a documentclass switch)
-// will invoke the layout object defined by name = 'CharStyle'.
-// If that doesn't work either, an empty object returns (shouldn't
-// happen).  -- Idea JMarc, comment MV
-InsetLayout const & TextClass::insetLayout(docstring const & name) const 
+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()) {
-		if (insetlayoutlist_.count(n) > 0)
-			return insetlayoutlist_[n];
+		InsetLayouts::const_iterator cit = insetlayoutlist_.lower_bound(n);
+		if (cit != cen && cit->first == n)
+			return cit->second;
 		size_t i = n.find(':');
 		if (i == string::npos)
 			break;
 		n = n.substr(0,i);
 	}
-	return empty_insetlayout_;
+	return plain_insetlayout_;
 }
 
 
@@ -996,139 +1030,123 @@ docstring const & TextClass::defaultLayoutName() const
 }
 
 
-LayoutPtr const & TextClass::defaultLayout() const
+Layout const & TextClass::defaultLayout() const
 {
 	return operator[](defaultLayoutName());
 }
 
 
-string const & TextClass::name() const
-{
-	return name_;
-}
-
-
-string const & TextClass::latexname() const
-{
-	const_cast<TextClass*>(this)->load();
-	return latexname_;
-}
-
-
-string const & TextClass::description() const
-{
-	return description_;
-}
-
-
-string const & TextClass::opt_fontsize() const
+bool TextClass::isDefaultLayout(Layout const & layout) const 
 {
-	return opt_fontsize_;
+	return layout.name() == defaultLayoutName();
 }
 
 
-string const & TextClass::opt_pagestyle() const
+bool TextClass::isPlainLayout(Layout const & layout) const 
 {
-	return opt_pagestyle_;
+	return layout.name() == plainLayoutName();
 }
 
 
-string const & TextClass::options() const
+Layout TextClass::createBasicLayout(docstring const & name, bool unknown) const
 {
-	return options_;
-}
+	static Layout * defaultLayout = NULL;
 
+	if (defaultLayout) {
+		defaultLayout->setUnknown(unknown);
+		defaultLayout->setName(name);
+		return *defaultLayout;
+	}
 
-string const & TextClass::class_header() const
-{
-	return class_header_;
+	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
+//
+/////////////////////////////////////////////////////////////////////////
 
-string const & TextClass::pagestyle() const
+DocumentClassBundle::~DocumentClassBundle()
 {
-	return pagestyle_;
+	for (size_t i = 0; i != documentClasses_.size(); ++i)
+		delete documentClasses_[i];
+	documentClasses_.clear();
 }
 
-
-docstring const & TextClass::preamble() const
+DocumentClass & DocumentClassBundle::newClass(LayoutFile const & baseClass)
 {
-	return preamble_;
+	DocumentClass * dc = new DocumentClass(baseClass);
+	documentClasses_.push_back(dc);
+	return *documentClasses_.back();
 }
 
 
-PageSides TextClass::sides() const
+DocumentClassBundle & DocumentClassBundle::get()
 {
-	return sides_;
+	static DocumentClassBundle singleton; 
+	return singleton; 
 }
 
 
-int TextClass::secnumdepth() const
-{
-	return secnumdepth_;
-}
+/////////////////////////////////////////////////////////////////////////
+//
+// DocumentClass
+//
+/////////////////////////////////////////////////////////////////////////
 
-
-int TextClass::tocdepth() const
-{
-	return tocdepth_;
-}
+DocumentClass::DocumentClass(LayoutFile const & tc)
+	: TextClass(tc)
+{}
 
 
-OutputType TextClass::outputType() const
+bool DocumentClass::hasLaTeXLayout(std::string const & lay) const
 {
-	return outputType_;
+	LayoutList::const_iterator it  = layoutlist_.begin();
+	LayoutList::const_iterator end = layoutlist_.end();
+	for (; it != end; ++it)
+		if (it->latexname() == lay)
+			return true;
+	return false;
 }
 
 
-bool TextClass::provides(string const & p) const
+bool DocumentClass::provides(string const & p) const
 {
 	return provides_.find(p) != provides_.end();
 }
 
 
-unsigned int TextClass::columns() const
-{
-	return columns_;
-}
-
-
-TitleLatexType TextClass::titletype() const
-{
-	return titletype_;
-}
-
-
-string const & TextClass::titlename() const
-{
-	return titlename_;
-}
-
-
-int TextClass::size() const
-{
-	return layoutlist_.size();
-}
-
-
-int TextClass::min_toclevel() const
-{
-	return min_toclevel_;
-}
-
-
-int TextClass::max_toclevel() const
-{
-	return max_toclevel_;
-}
-
-
-bool TextClass::hasTocLevels() const
+bool DocumentClass::hasTocLevels() const
 {
 	return min_toclevel_ != Layout::NOT_IN_TOC;
 }
 
 
+/////////////////////////////////////////////////////////////////////////
+//
+// PageSides
+//
+/////////////////////////////////////////////////////////////////////////
+
 ostream & operator<<(ostream & os, PageSides p)
 {
 	switch (p) {