X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FTextClass.cpp;h=13adf04675cdf0a43e6673bded0843fd5f566558;hb=b7406da7f0326fbd895c700ad5ded4cc5112094f;hp=f1b1df7eaab855ac78b1d13843d9f45479f23ac1;hpb=cdf13782003f6fca74b267c6b23d76bb9edaa65c;p=lyx.git

diff --git a/src/TextClass.cpp b/src/TextClass.cpp
index f1b1df7eaa..13adf04675 100644
--- a/src/TextClass.cpp
+++ b/src/TextClass.cpp
@@ -16,59 +16,52 @@
 
 #include "TextClass.h"
 
+#include "LayoutFile.h"
 #include "Color.h"
 #include "Counters.h"
-#include "debug.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/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 <sstream>
 
-using std::endl;
-using std::find_if;
-using std::remove_if;
-using std::string;
-using std::ostream;
-
-namespace lyx {
+#include "boost/assert.hpp"
 
-using support::FileName;
-using support::libFileSearch;
-using support::makeDisplayPath;
-using support::quoteName;
-using support::rtrim;
-using support::subst;
-using support::addName;
+using namespace std;
+using namespace lyx::support;
 
-extern FontInfo lyxRead(Lexer &, FontInfo const & fi = sane_font);
+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 = 6;
 
 
 bool layout2layout(FileName const & filename, FileName const & tempfile)
@@ -80,16 +73,16 @@ bool layout2layout(FileName const & filename, FileName const & tempfile)
 		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;
@@ -98,16 +91,32 @@ bool layout2layout(FileName const & filename, FileName const & tempfile)
 	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";
+	}
+	// 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)
+docstring const TextClass::emptylayout_ = from_ascii("PlainLayout");
+
+
+InsetLayout DocumentClass::empty_insetlayout_;
+
+
+TextClass::TextClass()
 {
-	modular_ = false;
 	outputType_ = LATEX;
 	columns_ = 1;
 	sides_ = OneSide;
@@ -120,28 +129,25 @@ TextClass::TextClass(string const & fn, string const & cln,
 	titletype_ = TITLE_COMMAND_AFTER;
 	titlename_ = "maketitle";
 	loaded_ = false;
-}
-
-
-bool TextClass::isTeXClassAvailable() const
-{
-	return texClassAvail_;
+	// a hack to make this available for translation
+	// i'm sure there must be a better way (rgh)
+	_("PlainLayout");
 }
 
 
 bool TextClass::readStyle(Lexer & lexrc, Layout & lay)
 {
-	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
+		lyxerr << "Error parsing style `" << to_utf8(lay.name()) << '\'' << endl;
+		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
 }
 
 
@@ -162,6 +168,7 @@ enum TextClassTags {
 	TC_CLASSOPTIONS,
 	TC_PREAMBLE,
 	TC_PROVIDES,
+	TC_REQUIRES,
 	TC_LEFTMARGIN,
 	TC_RIGHTMARGIN,
 	TC_FLOAT,
@@ -176,10 +183,10 @@ enum TextClassTags {
 // Reads a textclass structure from file.
 bool TextClass::read(FileName const & filename, ReadType rt)
 {
-	if (!filename.isFileReadable()) {
+	if (!filename.isReadableFile()) {
 		lyxerr << "Cannot read layout file `" << filename << "'."
 		       << endl;
-		return true;
+		return false;
 	}
 
 	keyword_item textClassTags[] = {
@@ -200,6 +207,7 @@ 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 },
@@ -209,21 +217,32 @@ bool TextClass::read(FileName const & filename, ReadType rt)
 		{ "tocdepth",        TC_TOCDEPTH }
 	};
 
-	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);
+	LYXERR(Debug::TCLASS, "Reading " + translateRT(rt) + ": " +
+		to_utf8(makeDisplayPath(filename.absFilename())));
+
+	// Define the `empty' 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(lay);
 	}
-	LYXERR(Debug::TCLASS) << to_utf8(makeDisplayPath(filename.absFilename()))
-		<< endl;
 
 	Lexer lexrc(textClassTags,
 		sizeof(textClassTags) / sizeof(textClassTags[0]));
@@ -269,10 +288,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;
@@ -298,31 +316,34 @@ bool TextClass::read(FileName const & filename, ReadType rt)
 						+ lexrc.getString() + " is probably not valid UTF-8!";
 					lexrc.printError(s.c_str());
 					Layout lay;
-					error = readStyle(lexrc, 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?
+					error = !readStyle(lexrc, lay);
 				} else if (hasLayout(name)) {
-					Layout * lay = operator[](name).get();
-					error = 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 = readStyle(lexrc, lay);
+					error = !readStyle(lexrc, lay);
 					if (!error)
-						layoutlist_.push_back(
-							boost::shared_ptr<Layout>(new Layout(lay))
-							);
+						layoutlist_.push_back(lay);
 
 					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 lay;
+				//readStyle(lexrc, lay);
+				//as above...
 				lexrc.printError("No name given for style: `$$Token'.");
 				error = true;
 			}
@@ -335,8 +356,6 @@ bool TextClass::read(FileName const & filename, ReadType rt)
 				if (!deleteLayout(style))
 					lyxerr << "Cannot delete style `"
 					       << to_utf8(style) << '\'' << endl;
-//					lexrc.printError("Cannot delete style"
-//							 " `$$Token'");
 			}
 			break;
 
@@ -384,7 +403,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;
@@ -404,6 +423,14 @@ 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_LEFTMARGIN:	// left margin type
 			if (lexrc.next())
 				leftmargin_ = lexrc.getDocString();
@@ -413,88 +440,114 @@ 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)) {
+					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;
+		LYXERR(Debug::TCLASS, "Converting layout file from format "
+				      << format << " to " << FORMAT);
+		FileName const tempfile = FileName::tempName();
+		bool success = layout2layout(filename, tempfile);
+		if (success)
+			 read(tempfile, rt);
+		tempfile.removeFile();
+		return success;
 	}
 
-	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;
+	LYXERR(Debug::TCLASS, "Finished reading " + translateRT(rt) + ": " +
+			to_utf8(makeDisplayPath(filename.absFilename())));
+
+	if (rt != BASECLASS) 
+		return !error;
+
+	if (defaultlayout_.empty()) {
+		lyxerr << "Error: Textclass '" << name_
+						<< "' is missing a defaultstyle." << endl;
+		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;
 }
 
 
@@ -609,180 +662,6 @@ void TextClass::readClassOptions(Lexer & lexrc)
 }
 
 
-enum InsetLayoutTags {
-	IL_FONT = 1,
-	IL_BGCOLOR,
-	IL_DECORATION,
-	IL_FREESPACING,
-	IL_FORCELTR,
-	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)
-{
-	keyword_item elementTags[] = {
-		{ "bgcolor", IL_BGCOLOR },
-		{ "decoration", IL_DECORATION },
-		{ "end", IL_END },
-		{ "font", IL_FONT },
-		{ "forceltr", IL_FORCELTR },
-		{ "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 }
-	};
-
-	lexrc.pushTable(elementTags, IL_END);
-
-	string lyxtype;
-	docstring labelstring;
-	string latextype;
-	string decoration;
-	string latexname;
-	string latexparam;
-	FontInfo font = inherit_font;
-	FontInfo labelfont = inherit_font;
-	ColorCode bgcolor(Color_background);
-	string preamble;
-	bool multipar = false;
-	bool passthru = false;
-	bool needprotect = false;
-	bool keepempty = false;
-	bool freespacing = false;
-	bool forceltr = 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, inherit_font);
-			break;
-		case IL_FORCELTR:
-			lexrc.next();
-			forceltr = lexrc.getBool();
-			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, inherit_font);
-			// 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.forceltr = forceltr;
-		il.keepempty = keepempty;
-		il.font = font;
-		// The label font is generally used as-is without
-		// any realization against a given context.
-		labelfont.realize(sane_font);
-		il.labelfont = labelfont;
-		il.bgcolor = bgcolor;		
-		il.preamble = preamble;
-		insetlayoutlist_[name] = il;
-	}
-
-	lexrc.popTable();
-}
-
-
-
 enum FloatTags {
 	FT_TYPE = 1,
 	FT_NAME,
@@ -826,7 +705,7 @@ 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;
 		}
@@ -834,8 +713,8 @@ void TextClass::readFloat(Lexer & lexrc)
 		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();
@@ -885,10 +764,14 @@ 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();
@@ -903,6 +786,7 @@ enum CounterTags {
 	CT_END
 };
 
+
 void TextClass::readCounter(Lexer & lexrc)
 {
 	keyword_item counterTags[] = {
@@ -925,7 +809,7 @@ 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;
 		}
@@ -933,14 +817,10 @@ void TextClass::readCounter(Lexer & lexrc)
 		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();
@@ -965,70 +845,70 @@ 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
+bool TextClass::hasLayout(docstring const & n) const
 {
-	return defaultfont_;
-}
-
+	docstring const name = n.empty() ? defaultLayoutName() : n;
 
-docstring const & TextClass::leftmargin() const
-{
-	return leftmargin_;
+	return find_if(layoutlist_.begin(), layoutlist_.end(),
+		       LayoutNamesEqual(name))
+		!= layoutlist_.end();
 }
 
 
-docstring const & TextClass::rightmargin() const
+
+Layout const & TextClass::operator[](docstring const & name) const
 {
-	return rightmargin_;
-}
+	BOOST_ASSERT(!name.empty());
 
+	const_iterator it = 
+		find_if(begin(), end(), LayoutNamesEqual(name));
 
-bool TextClass::hasLayout(docstring const & n) const
-{
-	docstring const name = n.empty() ? defaultLayoutName() : n;
+	if (it == end()) {
+		lyxerr << "We failed to find the layout '" << to_utf8(name)
+		       << "' in the layout list. You MUST investigate!"
+		       << endl;
+		for (const_iterator cit = begin(); cit != end(); ++cit)
+			lyxerr  << " " << to_utf8(cit->name()) << endl;
 
-	return find_if(layoutlist_.begin(), layoutlist_.end(),
-		       LayoutNamesEqual(name))
-		!= layoutlist_.end();
-}
+		// we require the name to exist
+		BOOST_ASSERT(false);
+	}
 
+	return *it;
+}
 
 
-LayoutPtr const & TextClass::operator[](docstring const & name) const
+Layout & TextClass::operator[](docstring const & name)
 {
 	BOOST_ASSERT(!name.empty());
 
-	LayoutList::const_iterator cit =
-		find_if(layoutlist_.begin(),
-			layoutlist_.end(),
-			LayoutNamesEqual(name));
+	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);
 	}
 
-	return *cit;
+	return *it;
 }
 
 
 bool TextClass::deleteLayout(docstring const & name)
 {
-	if (name == defaultLayoutName())
+	if (name == defaultLayoutName() || name == emptyLayoutName())
 		return false;
 
 	LayoutList::iterator it =
@@ -1054,7 +934,7 @@ bool TextClass::load(string const & path) const
 		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 `"
@@ -1068,48 +948,20 @@ 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
-{
-	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 
 {
 	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.labelfont = sane_font;
-	empty.labelfont.setColor(Color_error);
-	empty.bgcolor = Color_error;
-	return empty;
+	return empty_insetlayout_;
 }
 
 
@@ -1120,134 +972,62 @@ 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 & lay) const 
 {
-	return name_;
+	return lay.name() == defaultLayoutName();
 }
 
 
-string const & TextClass::latexname() const
+bool TextClass::isEmptyLayout(Layout const & lay) const 
 {
-	const_cast<TextClass*>(this)->load();
-	return latexname_;
+	return lay.name() == emptyLayoutName();
 }
 
 
-string const & TextClass::description() const
+DocumentClass & DocumentClassBundle::newClass(LayoutFile const & baseClass)
 {
-	return description_;
+	DocumentClass * dc = new DocumentClass(baseClass);
+	tc_list_.push_back(dc);
+	return *tc_list_.back();
 }
 
 
-string const & TextClass::opt_fontsize() const
+DocumentClassBundle & DocumentClassBundle::get()
 {
-	return opt_fontsize_;
+	static DocumentClassBundle singleton; 
+	return singleton; 
 }
 
 
-string const & TextClass::opt_pagestyle() const
-{
-	return opt_pagestyle_;
-}
+DocumentClass::DocumentClass(LayoutFile const & tc)
+	: TextClass(tc)
+{}
 
 
-string const & TextClass::options() const
+bool DocumentClass::hasLaTeXLayout(std::string const & lay) const
 {
-	return options_;
+	LayoutList::const_iterator it  = layoutlist_.begin();
+	LayoutList::const_iterator end = layoutlist_.end();
+	for (; it != end; ++it)
+		if (it->latexname() == lay)
+			return true;
+	return false;
 }
 
 
-string const & TextClass::class_header() const
-{
-	return class_header_;
-}
-
-
-string const & TextClass::pagestyle() const
-{
-	return pagestyle_;
-}
-
-
-docstring const & TextClass::preamble() const
-{
-	return preamble_;
-}
-
-
-PageSides TextClass::sides() const
-{
-	return sides_;
-}
-
-
-int TextClass::secnumdepth() const
-{
-	return secnumdepth_;
-}
-
-
-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;
 }