X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Finsets%2FInsetLayout.cpp;h=c4b6e896c6effb05334175422edb1e824ad68e86;hb=d6f1915684328c6e3fe61c6eef8846b5cabec334;hp=e9219740b295e6321eba12bde853f26a7ee2fdc1;hpb=20cf42b7418a73463f313ae685d10107e6966aa3;p=lyx.git

diff --git a/src/insets/InsetLayout.cpp b/src/insets/InsetLayout.cpp
index e9219740b2..c4b6e896c6 100644
--- a/src/insets/InsetLayout.cpp
+++ b/src/insets/InsetLayout.cpp
@@ -16,6 +16,10 @@
 
 #include "Color.h"
 #include "Font.h"
+#include "Lexer.h"
+#include "TextClass.h"
+
+#include "support/debug.h"
 #include "support/lstrings.h"
 
 #include <vector>
@@ -27,47 +31,87 @@ using std::vector;
 namespace lyx {
 
 InsetLayout::InsetLayout() :
-	name_(from_ascii("undefined")), labelstring_(from_ascii("UNDEFINED")),
-	font_(sane_font), labelfont_(sane_font), bgcolor_(Color_error), 
-	multipar_(false), passthru_(false), needprotect_(false),
-	freespacing_(false), keepempty_(false), forceltr_(false)
+	name_(from_ascii("undefined")), lyxtype_(STANDARD),
+	labelstring_(from_ascii("UNDEFINED")), decoration_(DEFAULT),
+	latextype_(NOLATEXTYPE), font_(sane_font), 
+	labelfont_(sane_font), bgcolor_(Color_error), 
+	multipar_(false), custompars_(false), forceplain_(true), 
+	passthru_(false), needprotect_(false), freespacing_(false), 
+	keepempty_(false), forceltr_(false)
 { 
-	labelfont_.setColor(Color_error); 
+	labelfont_.setColor(Color_error);
+}
+
+
+namespace {
+
+InsetLayout::InsetDecoration translateDecoration(std::string const & str) 
+{
+	if (support::compare_ascii_no_case(str, "classic") == 0)
+		return InsetLayout::CLASSIC;
+	if (support::compare_ascii_no_case(str, "minimalistic") == 0)
+		return InsetLayout::MINIMALISTIC;
+	if (support::compare_ascii_no_case(str, "conglomerate") == 0)
+		return InsetLayout::CONGLOMERATE;
+	return InsetLayout::DEFAULT;
+}
+
+InsetLayout::InsetLaTeXType translateLaTeXType(std::string const & str)
+{
+	if (support::compare_ascii_no_case(str, "command") == 0)
+		return InsetLayout::COMMAND;
+	if (support::compare_ascii_no_case(str, "environment") == 0)
+		return InsetLayout::ENVIRONMENT;
+	if (support::compare_ascii_no_case(str, "none") == 0)
+		return InsetLayout::NOLATEXTYPE;
+	return InsetLayout::ILT_ERROR;
+}
+
 }
 
 
-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_REQUIRES,
-	IL_END
-};
-
-
-bool InsetLayout::read(Lexer & lexrc)
+bool InsetLayout::read(Lexer & lex, TextClass & tclass)
 {
-	name_ = support::subst(lexrc.getDocString(), '_', ' ');
+	name_ = support::subst(lex.getDocString(), '_', ' ');
+	// FIXME We need to check for name_.empty() here, and
+	// take the same sort of action as in TextClass::read()
+	// if it is empty. Or, better, we could read name_ there,
+	// take action there, etc.
+
+	enum {
+		IL_BGCOLOR,
+		IL_COPYSTYLE,
+		IL_CUSTOMPARS,
+		IL_DECORATION,
+		IL_FONT,
+		IL_FORCELTR,
+		IL_FORCEPLAIN,
+		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_REQUIRES,
+		IL_END
+	};
+
 
-	keyword_item elementTags[] = {
+	LexerKeyword elementTags[] = {
 		{ "bgcolor", IL_BGCOLOR },
+		{ "copystyle", IL_COPYSTYLE }, 
+		{ "custompars", IL_CUSTOMPARS },
 		{ "decoration", IL_DECORATION },
 		{ "end", IL_END },
 		{ "font", IL_FONT },
 		{ "forceltr", IL_FORCELTR },
+		{ "forceplain", IL_FORCEPLAIN },
 		{ "freespacing", IL_FREESPACING },
 		{ "keepempty", IL_KEEPEMPTY },
 		{ "labelfont", IL_LABELFONT },
@@ -83,92 +127,142 @@ bool InsetLayout::read(Lexer & lexrc)
 		{ "requires", IL_REQUIRES }
 	};
 
-	lexrc.pushTable(elementTags, IL_END);
+	lex.pushTable(elementTags);
 
 	FontInfo font = inherit_font;
 	labelfont_ = inherit_font;
-	bgcolor_ = Color_background;
+	bgcolor_ = Color_none;
 	bool getout = false;
-	
-	while (!getout && lexrc.isOK()) {
-		int le = lexrc.lex();
+	// whether we've read the CustomPars or ForcePlain tag
+	// for issuing a warning in case MultiPars comes later
+	bool readCustomOrPlain = false;
+
+	string tmp;	
+	while (!getout && lex.isOK()) {
+		int le = lex.lex();
 		switch (le) {
 		case Lexer::LEX_UNDEF:
-			lexrc.printError("Unknown InsetLayout tag `$$Token'");
+			lex.printError("Unknown InsetLayout tag");
 			continue;
-		default: break;
+		default:
+			break;
 		}
-		switch (static_cast<InsetLayoutTags>(le)) {
-		case IL_LYXTYPE:
-			lexrc.next();
-			lyxtype_ = lexrc.getString();
+		switch (le) {
+		// FIXME
+		// Perhaps a mroe elegant way to deal with the next two would be the
+		// way this sort of thing is handled in Layout::read(), namely, by
+		// using the Lexer.
+		case IL_LYXTYPE: {
+			string lt;
+			lex >> lt;
+			lyxtype_ = translateLyXType(lt);
+			if (lyxtype_  == NOLYXTYPE)
+				LYXERR0("Unknown LyXType `" << lt << "'.");
 			break;
-		case IL_LATEXTYPE:
-			lexrc.next();
-			latextype_ = lexrc.getString();
+		}
+		case IL_LATEXTYPE:  {
+			string lt;
+			lex >> lt;
+			latextype_ = translateLaTeXType(lt);
+			if (latextype_  == ILT_ERROR)
+				LYXERR0("Unknown LaTeXType `" << lt << "'.");
 			break;
+		}
 		case IL_LABELSTRING:
-			lexrc.next();
-			labelstring_ = lexrc.getDocString();
+			lex >> labelstring_;
 			break;
 		case IL_DECORATION:
-			lexrc.next();
-			decoration_ = lexrc.getString();
+			lex >> tmp;
+			decoration_ = translateDecoration(tmp);
 			break;
 		case IL_LATEXNAME:
-			lexrc.next();
-			latexname_ = lexrc.getString();
+			lex >> latexname_;
 			break;
 		case IL_LATEXPARAM:
-			lexrc.next();
-			latexparam_ = support::subst(lexrc.getString(), "&quot;", "\"");
+			lex >> tmp;
+			latexparam_ = support::subst(tmp, "&quot;", "\"");
 			break;
 		case IL_LABELFONT:
-			labelfont_ = lyxRead(lexrc, inherit_font);
+			labelfont_ = lyxRead(lex, inherit_font);
 			break;
 		case IL_FORCELTR:
-			lexrc.next();
-			forceltr_ = lexrc.getBool();
+			lex >> forceltr_;
 			break;
 		case IL_MULTIPAR:
-			lexrc.next();
-			multipar_ = lexrc.getBool();
+			lex >> multipar_;
+			// the defaults for these depend upon multipar_
+			if (readCustomOrPlain)
+				LYXERR0("Warning: Read MultiPar after CustomPars or ForcePlain. "
+				        "Previous value may be overwritten!");
+			readCustomOrPlain = false;
+			custompars_ = multipar_;
+			forceplain_ = !multipar_;
+			break;
+		case IL_CUSTOMPARS:
+			lex >> custompars_;
+			readCustomOrPlain = true;
+			break;
+		case IL_FORCEPLAIN:
+			lex >> forceplain_;
 			break;
 		case IL_PASSTHRU:
-			lexrc.next();
-			passthru_ = lexrc.getBool();
+			lex >> passthru_;
+			readCustomOrPlain = true;
 			break;
 		case IL_KEEPEMPTY:
-			lexrc.next();
-			keepempty_ = lexrc.getBool();
+			lex >> keepempty_;
 			break;
 		case IL_FREESPACING:
-			lexrc.next();
-			freespacing_ = lexrc.getBool();
+			lex >> freespacing_;
 			break;
 		case IL_NEEDPROTECT:
-			lexrc.next();
-			needprotect_ = lexrc.getBool();
+			lex >> needprotect_;
 			break;
-		case IL_FONT: {
-			font = lyxRead(lexrc, inherit_font);
-			// So: define font before labelfont
-			labelfont_ = font;
+		case IL_COPYSTYLE: {     // initialize with a known style
+			docstring style;
+			lex >> style;
+			style = support::subst(style, '_', ' ');
+
+			// We don't want to apply the algorithm in DocumentClass::insetLayout()
+			// here. So we do it the long way.
+			TextClass::InsetLayouts::const_iterator it = 
+					tclass.insetLayouts().find(style);
+			if (it != tclass.insetLayouts().end()) {
+				docstring const tmpname = name_;
+				this->operator=(it->second);
+				name_ = tmpname;
+			} else {
+				LYXERR0("Cannot copy unknown InsetLayout `"
+					<< style << "'\n"
+					<< "All InsetLayouts so far:");
+				TextClass::InsetLayouts::const_iterator lit = 
+						tclass.insetLayouts().begin();
+				TextClass::InsetLayouts::const_iterator len = 
+						tclass.insetLayouts().end();
+				for (; lit != len; ++lit)
+					lyxerr << lit->second.name() << "\n";
+			}
 			break;
 		}
-		case IL_BGCOLOR: {
-			lexrc.next();
-			string const token = lexrc.getString();
-			bgcolor_ = lcolor.getFromLyXName(token);
+
+		case IL_FONT: {
+			font_ = lyxRead(lex, inherit_font);
+			// If you want to define labelfont, you need to do so after
+			// font is defined.
+			labelfont_ = font_;
 			break;
 		}
+		case IL_BGCOLOR:
+			lex >> tmp;
+			bgcolor_ = lcolor.getFromLyXName(tmp);
+			break;
 		case IL_PREAMBLE:
-			preamble_ = lexrc.getLongString("EndPreamble");
+			preamble_ = lex.getLongString("EndPreamble");
 			break;
 		case IL_REQUIRES: {
-			lexrc.eatLine();
+			lex.eatLine();
 			vector<string> const req 
-				= support::getVectorFromString(lexrc.getString());
+				= support::getVectorFromString(lex.getString());
 			requires_.insert(req.begin(), req.end());
 			break;
 		}
@@ -186,8 +280,25 @@ bool InsetLayout::read(Lexer & lexrc)
 	// any realization against a given context.
 	labelfont_.realize(sane_font);
 
-	lexrc.popTable();
+	lex.popTable();
 	return true;
 }
 
+
+InsetLayout::InsetLyXType translateLyXType(std::string const & str) 
+{
+	
+	if (support::compare_ascii_no_case(str, "charstyle") == 0)
+		return InsetLayout::CHARSTYLE;
+	if (support::compare_ascii_no_case(str, "custom") == 0)
+		return InsetLayout::CUSTOM;
+	if (support::compare_ascii_no_case(str, "element") == 0)
+		return InsetLayout::ELEMENT;
+	if (support::compare_ascii_no_case(str, "end") == 0)
+		return InsetLayout::END;
+	if (support::compare_ascii_no_case(str, "standard") == 0)
+		return InsetLayout::STANDARD;
+	return InsetLayout::NOLYXTYPE;
+}
+
 } //namespace lyx