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

diff --git a/src/TextClass.cpp b/src/TextClass.cpp
index e2e63d5697..a594375cda 100644
--- a/src/TextClass.cpp
+++ b/src/TextClass.cpp
@@ -15,130 +15,145 @@
 #include <config.h>
 
 #include "TextClass.h"
-#include "debug.h"
-#include "Layout.h"
-#include "Lexer.h"
+
+#include "LayoutFile.h"
+#include "Color.h"
 #include "Counters.h"
-#include "gettext.h"
 #include "Floating.h"
 #include "FloatList.h"
+#include "Layout.h"
+#include "Lexer.h"
+#include "Font.h"
 
 #include "frontends/alert.h"
 
-#include "support/lstrings.h"
-#include "support/lyxlib.h"
+#include "support/lassert.h"
+#include "support/debug.h"
+#include "support/ExceptionMessage.h"
+#include "support/FileName.h"
 #include "support/filetools.h"
+#include "support/gettext.h"
+#include "support/lstrings.h"
 #include "support/os.h"
 
+#include <algorithm>
+#include <fstream>
 #include <sstream>
 
-namespace lyx {
-
-using support::FileName;
-using support::libFileSearch;
-using support::makeDisplayPath;
-using support::quoteName;
-using support::rtrim;
-using support::subst;
-using support::addName;
-
-using std::endl;
-using std::find_if;
-using std::remove_if;
-using std::string;
-using std::ostream;
+using namespace std;
+using namespace lyx::support;
 
+namespace lyx {
 
 namespace {
 
-class LayoutNamesEqual : public std::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 = 5;
+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;
 	}
 
-	std::ostringstream command;
-	command << support::os::python() << ' ' << quoteName(script.toFilesystemEncoding())
+	ostringstream command;
+	command << os::python() << ' ' << quoteName(script.toFilesystemEncoding())
 		<< ' ' << quoteName(filename.toFilesystemEncoding())
 		<< ' ' << quoteName(tempfile.toFilesystemEncoding());
 	string const command_str = command.str();
 
-	LYXERR(Debug::TCLASS) << "Running `" << command_str << '\'' << endl;
+	LYXERR(Debug::TCLASS, "Running `" << command_str << '\'');
 
-	support::cmd_ret const ret =
-		support::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;
 }
 
+
+std::string translateRT(TextClass::ReadType rt) 
+{
+	switch (rt) {
+	case TextClass::BASECLASS:
+		return "textclass";
+	case TextClass::MERGE:
+		return "input file";
+	case TextClass::MODULE:
+		return "module file";
+	case TextClass::VALIDATION:
+		return "validation";
+	}
+	// shutup warning
+	return string();
+}
+
 } // 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;
 	secnumdepth_ = 3;
 	tocdepth_ = 3;
 	pagestyle_ = "default";
-	defaultfont_ = Font(Font::ALL_SANE);
+	defaultfont_ = sane_font;
 	opt_fontsize_ = "10|11|12";
 	opt_pagestyle_ = "empty|plain|headings|fancy";
 	titletype_ = TITLE_COMMAND_AFTER;
 	titlename_ = "maketitle";
 	loaded_ = false;
+	_("Plain Layout"); // a hack to make this translatable
 }
 
 
-bool TextClass::isTeXClassAvailable() const
-{
-	return texClassAvail_;
-}
-
-
-bool TextClass::do_readStyle(Lexer & lexrc, Layout & lay)
+bool TextClass::readStyle(Lexer & lexrc, Layout & lay) const
 {
-	LYXERR(Debug::TCLASS) << "Reading style " << to_utf8(lay.name()) << endl;
+	LYXERR(Debug::TCLASS, "Reading style " << to_utf8(lay.name()));
 	if (!lay.read(lexrc, *this)) {
-		// Resolve fonts
-		lay.resfont = lay.font;
-		lay.resfont.realize(defaultfont());
-		lay.reslabelfont = lay.labelfont;
-		lay.reslabelfont.realize(defaultfont());
-		return false; // no errors
+		LYXERR0("Error parsing style `" << to_utf8(lay.name()) << '\'');
+		return false;
 	}
-	lyxerr << "Error parsing style `" << to_utf8(lay.name()) << '\'' << endl;
-	return true;
+	// Resolve fonts
+	lay.resfont = lay.font;
+	lay.resfont.realize(defaultfont_);
+	lay.reslabelfont = lay.labelfont;
+	lay.reslabelfont.realize(defaultfont_);
+	return true; // no errors
 }
 
 
@@ -148,7 +163,6 @@ enum TextClassTags {
 	TC_STYLE,
 	TC_DEFAULTSTYLE,
 	TC_INSETLAYOUT,
-	TC_ENVIRONMENT,
 	TC_NOSTYLE,
 	TC_COLUMNS,
 	TC_SIDES,
@@ -159,6 +173,7 @@ enum TextClassTags {
 	TC_CLASSOPTIONS,
 	TC_PREAMBLE,
 	TC_PROVIDES,
+	TC_REQUIRES,
 	TC_LEFTMARGIN,
 	TC_RIGHTMARGIN,
 	TC_FLOAT,
@@ -166,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.isFileReadable()) {
-		lyxerr << "Cannot read layout file `" << filename << "'."
-		       << endl;
-		return true;
-	}
+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 },
@@ -197,35 +207,109 @@ bool TextClass::read(FileName const & filename, ReadType rt)
 		{ "pagestyle",       TC_PAGESTYLE },
 		{ "preamble",        TC_PREAMBLE },
 		{ "provides",        TC_PROVIDES },
+		{ "requires",        TC_REQUIRES },
 		{ "rightmargin",     TC_RIGHTMARGIN },
 		{ "secnumdepth",     TC_SECNUMDEPTH },
 		{ "sides",           TC_SIDES },
 		{ "style",           TC_STYLE },
 		{ "titlelatexname",  TC_TITLELATEXNAME },
 		{ "titlelatextype",  TC_TITLELATEXTYPE },
-		{ "tocdepth",        TC_TOCDEPTH }
+		{ "tocdepth",        TC_TOCDEPTH },
+		{ "usemodule",       TC_USEMODULE }
 	};
+	
+} //namespace anon
 
-	switch (rt) {
-	case BASECLASS:
-		LYXERR(Debug::TCLASS) << "Reading textclass ";
-		break;
-	case MERGE:
-		LYXERR(Debug::TCLASS) << "Reading input file ";
-	  break;
-	case MODULE:
-		LYXERR(Debug::TCLASS) << "Reading module file ";
-		break;
-	default:
-		BOOST_ASSERT(false);
+
+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) << to_utf8(makeDisplayPath(filename.absFilename()))
-		<< endl;
 
-	Lexer lexrc(textClassTags,
-		sizeof(textClassTags) / sizeof(textClassTags[0]));
+	LYXERR(Debug::TCLASS, "Reading " + translateRT(rt) + ": " +
+		to_utf8(makeDisplayPath(filename.absFilename())));
+
+	// 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(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;
+}
+
+
+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
@@ -266,10 +350,9 @@ bool TextClass::read(FileName const & filename, ReadType rt)
 							    "layout");
 
 				if (tmp.empty()) {
-					lexrc.printError("Could not find input"
-							 "file: " + inc);
+					lexrc.printError("Could not find input file: " + inc);
 					error = true;
-				} else if (read(tmp, MERGE)) {
+				} else if (!read(tmp, MERGE)) {
 					lexrc.printError("Error reading input"
 							 "file: " + tmp.absFilename());
 					error = true;
@@ -285,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(),
@@ -295,31 +377,31 @@ bool TextClass::read(FileName const & filename, ReadType rt)
 						+ lexrc.getString() + " is probably not valid UTF-8!";
 					lexrc.printError(s.c_str());
 					Layout lay;
-					error = do_readStyle(lexrc, 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).get();
-					error = do_readStyle(lexrc, *lay);
+					Layout & lay = operator[](name);
+					error = !readStyle(lexrc, lay);
 				} else {
-					Layout lay;
-					lay.setName(name);
-					if (le == TC_ENVIRONMENT)
-						lay.is_environment = true;
-					error = do_readStyle(lexrc, lay);
+					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
-						// the first layout we
-						// encounter.
+						// 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 layout;
+				//readStyle(lexrc, layout);
+				//as above...
 				lexrc.printError("No name given for style: `$$Token'.");
 				error = true;
 			}
@@ -329,11 +411,9 @@ bool TextClass::read(FileName const & filename, ReadType rt)
 			if (lexrc.next()) {
 				docstring const style = from_utf8(subst(lexrc.getString(),
 						     '_', ' '));
-				if (!delete_layout(style))
+				if (!deleteLayout(style))
 					lyxerr << "Cannot delete style `"
 					       << to_utf8(style) << '\'' << endl;
-//					lexrc.printError("Cannot delete style"
-//							 " `$$Token'");
 			}
 			break;
 
@@ -363,11 +443,11 @@ bool TextClass::read(FileName const & filename, ReadType rt)
 			break;
 
 		case TC_DEFAULTFONT:
-			defaultfont_.lyxRead(lexrc);
+			defaultfont_ = lyxRead(lexrc);
 			if (!defaultfont_.resolved()) {
 				lexrc.printError("Warning: defaultfont should "
 						 "be fully instantiated!");
-				defaultfont_.realize(Font(Font::ALL_SANE));
+				defaultfont_.realize(sane_font);
 			}
 			break;
 
@@ -381,7 +461,7 @@ bool TextClass::read(FileName const & filename, ReadType rt)
 			tocdepth_ = lexrc.getInteger();
 			break;
 
-			// First step to support options
+		// First step to support options
 		case TC_CLASSOPTIONS:
 			readClassOptions(lexrc);
 			break;
@@ -390,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();
@@ -401,6 +485,21 @@ bool TextClass::read(FileName const & filename, ReadType rt)
 			break;
 		}
 
+		case TC_REQUIRES: {
+			lexrc.eatLine();
+			vector<string> const req 
+				= getVectorFromString(lexrc.getString());
+			requires_.insert(req.begin(), req.end());
+			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();
@@ -410,113 +509,125 @@ bool TextClass::read(FileName const & filename, ReadType rt)
 			if (lexrc.next())
 				rightmargin_ = lexrc.getDocString();
 			break;
+
 		case TC_INSETLAYOUT:
 			if (lexrc.next()) {
-				docstring const name = subst(lexrc.getDocString(), '_', ' ');
-				readInsetLayout(lexrc, name);
+				InsetLayout il;
+				if (il.read(lexrc, *this))
+					insetlayoutlist_[il.name()] = il;
+				// else there was an error, so forget it
 			}
 			break;
+
 		case TC_FLOAT:
 			readFloat(lexrc);
 			break;
+
 		case TC_COUNTER:
 			readCounter(lexrc);
 			break;
+
 		case TC_TITLELATEXTYPE:
 			readTitleType(lexrc);
 			break;
+
 		case TC_TITLELATEXNAME:
 			if (lexrc.next())
 				titlename_ = lexrc.getString();
 			break;
+
 		case TC_NOFLOAT:
 			if (lexrc.next()) {
 				string const nofloat = lexrc.getString();
-				floatlist_->erase(nofloat);
+				floatlist_.erase(nofloat);
 			}
 			break;
 		}
+
+		//Note that this is triggered the first time through the loop unless
+		//we hit a format tag.
 		if (format != FORMAT)
 			break;
 	}
 
-	if (format != FORMAT) {
-		LYXERR(Debug::TCLASS) << "Converting layout file from format "
-				      << format << " to " << FORMAT << endl;
-		FileName const tempfile(support::tempName());
-		error = !layout2layout(filename, tempfile);
-		if (!error)
-			error = read(tempfile, rt);
-		support::unlink(tempfile);
-		return error;
-	}
+	if (format != FORMAT)
+		return FORMAT_MISMATCH;
 
-	if (rt == MODULE) 
-		LYXERR(Debug::TCLASS) << "Finished reading module file "
-				<< to_utf8(makeDisplayPath(filename.absFilename()))
-				<< endl;
-	else if (rt == MERGE)
-		LYXERR(Debug::TCLASS) << "Finished reading input file "
-				<< to_utf8(makeDisplayPath(filename.absFilename()))
-				<< endl;
-	else { // we are at top level here.
-		LYXERR(Debug::TCLASS) << "Finished reading textclass "
-				      << to_utf8(makeDisplayPath(filename.absFilename()))
-				      << endl;
-		if (defaultlayout_.empty()) {
-			lyxerr << "Error: Textclass '" << name_
-			       << "' is missing a defaultstyle." << endl;
+	if (rt != BASECLASS) 
+		return (error ? ERROR : OK);
+
+	if (defaultlayout_.empty()) {
+		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.
+	int erased = provides_.erase("stdinsets");
+	if (!erased) {
+		FileName tmp = libFileSearch("layouts", "stdinsets.inc");
+
+		if (tmp.empty()) {
+			throw ExceptionMessage(WarningException, _("Missing File"),
+				_("Could not find stdinsets.inc! This may lead to data loss!"));
+			error = true;
+		} else if (!read(tmp, MERGE)) {
+			throw ExceptionMessage(WarningException, _("Corrupt File"),
+				_("Could not read stdinsets.inc! This may lead to data loss!"));
 			error = true;
 		}
+	}
 
-		min_toclevel_ = Layout::NOT_IN_TOC;
-		max_toclevel_ = Layout::NOT_IN_TOC;
-		const_iterator cit = begin();
-		const_iterator the_end = end();
-		for ( ; cit != the_end ; ++cit) {
-			int const toclevel = (*cit)->toclevel;
-			if (toclevel != Layout::NOT_IN_TOC) {
-				if (min_toclevel_ == Layout::NOT_IN_TOC)
-					min_toclevel_ = toclevel;
-				else
-					min_toclevel_ = std::min(min_toclevel_,
-							 toclevel);
-				max_toclevel_ = std::max(max_toclevel_,
-							 toclevel);
-			}
+	min_toclevel_ = Layout::NOT_IN_TOC;
+	max_toclevel_ = Layout::NOT_IN_TOC;
+	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;
+			else
+				min_toclevel_ = min(min_toclevel_, toclevel);
+			max_toclevel_ = max(max_toclevel_, toclevel);
 		}
-		LYXERR(Debug::TCLASS)
-			<< "Minimum TocLevel is " << min_toclevel_
-			<< ", maximum is " << max_toclevel_ <<endl;
-
 	}
+	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;
 	}
 }
@@ -524,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) {
@@ -543,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();
@@ -580,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());
@@ -606,188 +714,21 @@ void TextClass::readClassOptions(Lexer & lexrc)
 }
 
 
-enum InsetLayoutTags {
-	IL_FONT = 1,
-	IL_BGCOLOR,
-	IL_DECORATION,
-	IL_FREESPACING,
-	IL_LABELFONT,
-	IL_LABELSTRING,
-	IL_LATEXNAME,
-	IL_LATEXPARAM,
-	IL_LATEXTYPE,
-	IL_LYXTYPE,
-	IL_KEEPEMPTY,
-	IL_MULTIPAR,
-	IL_NEEDPROTECT,
-	IL_PASSTHRU,
-	IL_PREAMBLE,
-	IL_END
-};
-
-
-void TextClass::readInsetLayout(Lexer & lexrc, docstring const & name)
+void TextClass::readFloat(Lexer & lexrc)
 {
-	keyword_item elementTags[] = {
-		{ "bgcolor", IL_BGCOLOR },
-		{ "decoration", IL_DECORATION },
-		{ "end", IL_END },
-		{ "font", IL_FONT },
-		{ "freespacing", IL_FREESPACING },
-		{ "keepempty", IL_KEEPEMPTY },
-		{ "labelfont", IL_LABELFONT },
-		{ "labelstring", IL_LABELSTRING },
-		{ "latexname", IL_LATEXNAME },
-		{ "latexparam", IL_LATEXPARAM },
-		{ "latextype", IL_LATEXTYPE },
-		{ "lyxtype", IL_LYXTYPE },
-		{ "multipar", IL_MULTIPAR },
-		{ "needprotect", IL_NEEDPROTECT },
-		{ "passthru", IL_PASSTHRU },
-		{ "preamble", IL_PREAMBLE }
+	enum {
+		FT_TYPE = 1,
+		FT_NAME,
+		FT_PLACEMENT,
+		FT_EXT,
+		FT_WITHIN,
+		FT_STYLE,
+		FT_LISTNAME,
+		FT_BUILTIN,
+		FT_END
 	};
 
-	lexrc.pushTable(elementTags, IL_END);
-
-	string lyxtype;
-	docstring labelstring;
-	string latextype;
-	string decoration;
-	string latexname;
-	string latexparam;
-	Font font(defaultfont());
-	Font labelfont(defaultfont());
-	Color::color bgcolor(Color::background);
-	string preamble;
-	bool multipar(false);
-	bool passthru(false);
-	bool needprotect(false);
-	bool keepempty(false);
-	bool freespacing(false);
-
-	bool getout = false;
-	while (!getout && lexrc.isOK()) {
-		int le = lexrc.lex();
-		switch (le) {
-		case Lexer::LEX_UNDEF:
-			lexrc.printError("Unknown ClassOption tag `$$Token'");
-			continue;
-		default: break;
-		}
-		switch (static_cast<InsetLayoutTags>(le)) {
-		case IL_LYXTYPE:
-			lexrc.next();
-			lyxtype = lexrc.getString();
-			break;
-		case IL_LATEXTYPE:
-			lexrc.next();
-			latextype = lexrc.getString();
-			break;
-		case IL_LABELSTRING:
-			lexrc.next();
-			labelstring = lexrc.getDocString();
-			break;
-		case IL_DECORATION:
-			lexrc.next();
-			decoration = lexrc.getString();
-			break;
-		case IL_LATEXNAME:
-			lexrc.next();
-			latexname = lexrc.getString();
-			break;
-		case IL_LATEXPARAM:
-			lexrc.next();
-			latexparam = subst(lexrc.getString(), "&quot;", "\"");
-			break;
-		case IL_LABELFONT:
-			labelfont.lyxRead(lexrc);
-			labelfont.realize(defaultfont());
-			break;
-		case IL_MULTIPAR:
-			lexrc.next();
-			multipar = lexrc.getBool();
-			break;
-		case IL_PASSTHRU:
-			lexrc.next();
-			passthru = lexrc.getBool();
-			break;
-		case IL_KEEPEMPTY:
-			lexrc.next();
-			keepempty = lexrc.getBool();
-			break;
-		case IL_FREESPACING:
-			lexrc.next();
-			freespacing = lexrc.getBool();
-			break;
-		case IL_NEEDPROTECT:
-			lexrc.next();
-			needprotect = lexrc.getBool();
-			break;
-		case IL_FONT:
-			font.lyxRead(lexrc);
-			font.realize(defaultfont());
-			// So: define font before labelfont
-			labelfont = font;
-			break;
-		case IL_BGCOLOR: {
-			lexrc.next();
-			string const token = lexrc.getString();
-			bgcolor = lcolor.getFromLyXName(token);
-			break;
-		}
-		case IL_PREAMBLE:
-			preamble = lexrc.getLongString("EndPreamble");
-			break;
-		case IL_END:
-			getout = true;
-			break;
-		}
-	}
-
-	//
-	// Here add element to list if getout == true
-	if (getout) {
-		InsetLayout il;
-		il.name = to_ascii(name);
-		il.lyxtype = lyxtype;
-		il.labelstring = labelstring;
-		il.decoration = decoration;
-		il.latextype = latextype;
-		il.latexname = latexname;
-		il.latexparam = latexparam;
-		il.multipar = multipar;
-		il.passthru = passthru;
-		il.needprotect = needprotect;
-		il.freespacing = freespacing;
-		il.keepempty = keepempty;
-		il.font = font;
-		il.labelfont = labelfont;
-		il.bgcolor = bgcolor;		
-		il.preamble = preamble;
-		insetlayoutlist_[name] = il;
-	}
-
-	lexrc.popTable();
-}
-
-
-
-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[] = {
+	LexerKeyword floatTags[] = {
 		{ "end", FT_END },
 		{ "extension", FT_EXT },
 		{ "guiname", FT_NAME },
@@ -799,7 +740,7 @@ void TextClass::readFloat(Lexer & lexrc)
 		{ "type", FT_TYPE }
 	};
 
-	lexrc.pushTable(floatTags, FT_END);
+	lexrc.pushTable(floatTags);
 
 	string type;
 	string placement;
@@ -815,16 +756,16 @@ void TextClass::readFloat(Lexer & lexrc)
 		int le = lexrc.lex();
 		switch (le) {
 		case Lexer::LEX_UNDEF:
-			lexrc.printError("Unknown ClassOption tag `$$Token'");
+			lexrc.printError("Unknown float tag `$$Token'");
 			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();
@@ -874,27 +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 },
@@ -902,7 +847,7 @@ void TextClass::readCounter(Lexer & lexrc)
 		{ "within", CT_WITHIN }
 	};
 
-	lexrc.pushTable(counterTags, CT_END);
+	lexrc.pushTable(counterTags);
 
 	docstring name;
 	docstring within;
@@ -914,22 +859,18 @@ void TextClass::readCounter(Lexer & lexrc)
 		int le = lexrc.lex();
 		switch (le) {
 		case Lexer::LEX_UNDEF:
-			lexrc.printError("Unknown ClassOption tag `$$Token'");
+			lexrc.printError("Unknown counter tag `$$Token'");
 			continue;
 		default: break;
 		}
-		switch (static_cast<CounterTags>(le)) {
+		switch (le) {
 		case CT_NAME:
 			lexrc.next();
 			name = lexrc.getDocString();
-			if (counters_->hasCounter(name))
-				LYXERR(Debug::TCLASS) 
-					<< "Reading existing counter " 
-					<< to_utf8(name) << endl;
+			if (counters_.hasCounter(name))
+				LYXERR(Debug::TCLASS, "Reading existing counter " << to_utf8(name));
 			else
-				LYXERR(Debug::TCLASS) 
-					<< "Reading new counter " 
-					<< to_utf8(name) << endl;
+				LYXERR(Debug::TCLASS, "Reading new counter " << to_utf8(name));
 			break;
 		case CT_WITHIN:
 			lexrc.next();
@@ -954,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();
 }
 
 
-Font 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;
@@ -989,36 +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
-		BOOST_ASSERT(false);
+		LASSERT(false, /**/);
 	}
 
-	return (*cit);
+	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
+		LASSERT(false, /**/);
+	}
+
+	return *it;
+}
+
 
-bool TextClass::delete_layout(docstring const & name)
+bool TextClass::deleteLayout(docstring const & name)
 {
-	if (name == defaultLayoutName())
+	if (name == defaultLayoutName() || name == plainLayoutName())
 		return false;
 
 	LayoutList::iterator it =
@@ -1039,12 +977,13 @@ 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");
-	loaded_ = const_cast<TextClass*>(this)->read(layout_file) == 0;
+	loaded_ = const_cast<TextClass*>(this)->read(layout_file);
 
 	if (!loaded_) {
 		lyxerr << "Error reading `"
@@ -1058,46 +997,29 @@ bool TextClass::load(string const & path) const
 }
 
 
-FloatList & TextClass::floats()
-{
-	return *floatlist_.get();
-}
-
-
-FloatList const & TextClass::floats() const
-{
-	return *floatlist_.get();
-}
-
-
-Counters & TextClass::counters() const
+void DocumentClass::addLayoutIfNeeded(docstring const & n) const
 {
-	return *counters_.get();
+	if (!hasLayout(n))
+		layoutlist_.push_back(createBasicLayout(n, true));
 }
 
 
-// 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];
-		docstring::size_type i = n.find(':');
+		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);
 	}
-	static InsetLayout empty;
-	empty.labelstring = from_utf8("UNDEFINED");
-	empty.bgcolor = Color::error;
-	return empty;
+	return plain_insetlayout_;
 }
 
 
@@ -1108,146 +1030,130 @@ docstring const & TextClass::defaultLayoutName() const
 }
 
 
-LayoutPtr const & TextClass::defaultLayout() const
+Layout const & TextClass::defaultLayout() const
 {
 	return operator[](defaultLayoutName());
 }
 
 
-string const & TextClass::name() const
+bool TextClass::isDefaultLayout(Layout const & layout) const 
 {
-	return name_;
+	return layout.name() == defaultLayoutName();
 }
 
 
-string const & TextClass::latexname() const
+bool TextClass::isPlainLayout(Layout const & layout) const 
 {
-	const_cast<TextClass*>(this)->load();
-	return latexname_;
+	return layout.name() == plainLayoutName();
 }
 
 
-string const & TextClass::description() const
+Layout TextClass::createBasicLayout(docstring const & name, bool unknown) const
 {
-	return description_;
-}
-
-
-string const & TextClass::opt_fontsize() const
-{
-	return opt_fontsize_;
-}
+	static Layout * defaultLayout = NULL;
 
+	if (defaultLayout) {
+		defaultLayout->setUnknown(unknown);
+		defaultLayout->setName(name);
+		return *defaultLayout;
+	}
 
-string const & TextClass::opt_pagestyle() const
-{
-	return opt_pagestyle_;
+	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::options() const
+DocumentClassBundle::~DocumentClassBundle()
 {
-	return options_;
+	for (size_t i = 0; i != documentClasses_.size(); ++i)
+		delete documentClasses_[i];
+	documentClasses_.clear();
 }
 
-
-string const & TextClass::class_header() const
+DocumentClass & DocumentClassBundle::newClass(LayoutFile const & baseClass)
 {
-	return class_header_;
+	DocumentClass * dc = new DocumentClass(baseClass);
+	documentClasses_.push_back(dc);
+	return *documentClasses_.back();
 }
 
 
-string const & TextClass::pagestyle() const
+DocumentClassBundle & DocumentClassBundle::get()
 {
-	return pagestyle_;
+	static DocumentClassBundle singleton; 
+	return singleton; 
 }
 
 
-docstring const & TextClass::preamble() const
-{
-	return preamble_;
-}
-
+/////////////////////////////////////////////////////////////////////////
+//
+// DocumentClass
+//
+/////////////////////////////////////////////////////////////////////////
 
-TextClass::PageSides TextClass::sides() const
-{
-	return sides_;
-}
+DocumentClass::DocumentClass(LayoutFile const & tc)
+	: TextClass(tc)
+{}
 
 
-int TextClass::secnumdepth() const
+bool DocumentClass::hasLaTeXLayout(std::string const & lay) const
 {
-	return secnumdepth_;
+	LayoutList::const_iterator it  = layoutlist_.begin();
+	LayoutList::const_iterator end = layoutlist_.end();
+	for (; it != end; ++it)
+		if (it->latexname() == lay)
+			return true;
+	return false;
 }
 
 
-int TextClass::tocdepth() const
-{
-	return tocdepth_;
-}
-
-
-OutputType TextClass::outputType() const
-{
-	return outputType_;
-}
-
-
-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;
 }
 
 
-ostream & operator<<(ostream & os, TextClass::PageSides p)
+/////////////////////////////////////////////////////////////////////////
+//
+// PageSides
+//
+/////////////////////////////////////////////////////////////////////////
+
+ostream & operator<<(ostream & os, PageSides p)
 {
 	switch (p) {
-	case TextClass::OneSide:
+	case OneSide:
 		os << '1';
 		break;
-	case TextClass::TwoSides:
+	case TwoSides:
 		os << '2';
 		break;
 	}