#include "TextClass.h"
#include "support/debug.h"
+#include "support/docstream.h"
#include "support/lassert.h"
#include "support/lstrings.h"
#include "support/Messages.h"
namespace lyx {
-/// Special value of toclevel for layouts that to not belong in a TOC
+/// Special value of toclevel for layouts that do not belong to a TOC
const int Layout::NOT_IN_TOC = -1000;
// The order of the LayoutTags enum is no more important. [asierra300396]
LT_HTMLPREAMBLE,
LT_HTMLSTYLE,
LT_HTMLFORCECSS,
+ LT_DOCBOOKTAG,
+ LT_DOCBOOKATTR,
+ LT_DOCBOOKTAGTYPE,
+ LT_DOCBOOKINNERATTR,
+ LT_DOCBOOKINNERTAG,
+ LT_DOCBOOKINNERTAGTYPE,
+ LT_DOCBOOKININFO,
+ LT_DOCBOOKABSTRACT,
+ LT_DOCBOOKWRAPPERTAG,
+ LT_DOCBOOKWRAPPERATTR,
+ LT_DOCBOOKWRAPPERTAGTYPE,
+ LT_DOCBOOKWRAPPERMERGEWITHPREVIOUS,
+ LT_DOCBOOKSECTION,
+ LT_DOCBOOKSECTIONTAG,
+ LT_DOCBOOKITEMWRAPPERTAG,
+ LT_DOCBOOKITEMWRAPPERATTR,
+ LT_DOCBOOKITEMWRAPPERTAGTYPE,
+ LT_DOCBOOKITEMTAG,
+ LT_DOCBOOKITEMATTR,
+ LT_DOCBOOKITEMTAGTYPE,
+ LT_DOCBOOKITEMLABELTAG,
+ LT_DOCBOOKITEMLABELATTR,
+ LT_DOCBOOKITEMLABELTAGTYPE,
+ LT_DOCBOOKITEMINNERTAG,
+ LT_DOCBOOKITEMINNERATTR,
+ LT_DOCBOOKITEMINNERTAGTYPE,
+ LT_DOCBOOKFORCEABSTRACTTAG,
LT_INPREAMBLE,
LT_HTMLTITLE,
LT_SPELLCHECK,
LT_REFPREFIX,
LT_RESETARGS,
LT_RESUMECOUNTER,
- LT_STEPMASTERCOUNTER,
+ LT_STEPPARENTCOUNTER,
LT_RIGHTDELIM,
LT_FORCELOCAL,
LT_TOGGLE_INDENT,
margintype = MARGIN_STATIC;
latextype = LATEX_PARAGRAPH;
resumecounter = false;
- stepmastercounter = false;
+ stepparentcounter = false;
intitle = false;
inpreamble = false;
needprotect = false;
htmllabelfirst_ = false;
htmlforcecss_ = false;
htmltitle_ = false;
+ docbookabstract_ = false;
+ docbookwrappermergewithprevious_ = false;
+ docbooksection_ = false;
spellcheck = true;
forcelocal = 0;
itemcommand_ = "item";
}
-bool Layout::read(Lexer & lex, TextClass const & tclass)
+bool Layout::read(Lexer & lex, TextClass const & tclass, bool validating)
{
// If this is an empty layout, or if no force local version is set,
// we know that we will not discard the stuff to read
if (forcelocal == 0)
- return readIgnoreForcelocal(lex, tclass);
+ return readIgnoreForcelocal(lex, tclass, validating);
Layout tmp(*this);
tmp.forcelocal = 0;
- bool const ret = tmp.readIgnoreForcelocal(lex, tclass);
+ bool const ret = tmp.readIgnoreForcelocal(lex, tclass, validating);
// Keep the stuff if
// - the read version is higher
// - both versions are infinity (arbitrary decision)
}
-bool Layout::readIgnoreForcelocal(Lexer & lex, TextClass const & tclass)
+bool Layout::readIgnoreForcelocal(Lexer & lex, TextClass const & tclass,
+ bool validating)
{
// This table is sorted alphabetically [asierra 30March96]
LexerKeyword layoutTags[] = {
{ "commanddepth", LT_COMMANDDEPTH },
{ "copystyle", LT_COPYSTYLE },
{ "dependson", LT_DEPENDSON },
+ { "docbookabstract", LT_DOCBOOKABSTRACT },
+ { "docbookattr", LT_DOCBOOKATTR },
+ { "docbookforceabstracttag", LT_DOCBOOKFORCEABSTRACTTAG },
+ { "docbookininfo", LT_DOCBOOKININFO },
+ { "docbookinnerattr", LT_DOCBOOKINNERATTR },
+ { "docbookinnertag", LT_DOCBOOKINNERTAG },
+ { "docbookinnertagtype", LT_DOCBOOKINNERTAGTYPE },
+ { "docbookitemattr", LT_DOCBOOKITEMATTR },
+ { "docbookiteminnerattr", LT_DOCBOOKITEMINNERATTR },
+ { "docbookiteminnertag", LT_DOCBOOKITEMINNERTAG },
+ { "docbookiteminnertagtype", LT_DOCBOOKITEMINNERTAGTYPE },
+ { "docbookitemlabelattr", LT_DOCBOOKITEMLABELATTR },
+ { "docbookitemlabeltag", LT_DOCBOOKITEMLABELTAG },
+ { "docbookitemlabeltagtype", LT_DOCBOOKITEMLABELTAGTYPE },
+ { "docbookitemtag", LT_DOCBOOKITEMTAG },
+ { "docbookitemtagtype", LT_DOCBOOKITEMTAGTYPE },
+ { "docbookitemwrapperattr", LT_DOCBOOKITEMWRAPPERATTR },
+ { "docbookitemwrappertag", LT_DOCBOOKITEMWRAPPERTAG },
+ { "docbookitemwrappertagtype", LT_DOCBOOKITEMWRAPPERTAGTYPE },
+ { "docbooksection", LT_DOCBOOKSECTION },
+ { "docbooksectiontag", LT_DOCBOOKSECTIONTAG },
+ { "docbooktag", LT_DOCBOOKTAG },
+ { "docbooktagtype", LT_DOCBOOKTAGTYPE },
+ { "docbookwrapperattr", LT_DOCBOOKWRAPPERATTR },
+ { "docbookwrappermergewithprevious", LT_DOCBOOKWRAPPERMERGEWITHPREVIOUS },
+ { "docbookwrappertag", LT_DOCBOOKWRAPPERTAG },
+ { "docbookwrappertagtype", LT_DOCBOOKWRAPPERTAGTYPE },
{ "end", LT_END },
{ "endlabelstring", LT_ENDLABELSTRING },
{ "endlabeltype", LT_ENDLABELTYPE },
{ "rightmargin", LT_RIGHTMARGIN },
{ "spacing", LT_SPACING },
{ "spellcheck", LT_SPELLCHECK },
- { "stepmastercounter", LT_STEPMASTERCOUNTER },
+ { "stepparentcounter", LT_STEPPARENTCOUNTER },
{ "textfont", LT_TEXTFONT },
{ "toclevel", LT_TOCLEVEL },
{ "toggleindent", LT_TOGGLE_INDENT },
lex >> resumecounter;
break;
- case LT_STEPMASTERCOUNTER:
- lex >> stepmastercounter;
+ case LT_STEPPARENTCOUNTER:
+ lex >> stepparentcounter;
break;
case LT_ARGUMENT:
- readArgument(lex);
+ readArgument(lex, validating);
break;
case LT_NEED_PROTECT:
lex >> htmltitle_;
break;
+ case LT_DOCBOOKTAG:
+ lex >> docbooktag_;
+ break;
+
+ case LT_DOCBOOKATTR:
+ lex >> docbookattr_;
+ break;
+
+ case LT_DOCBOOKTAGTYPE:
+ lex >> docbooktagtype_;
+ break;
+
+ case LT_DOCBOOKINNERTAG:
+ lex >> docbookinnertag_;
+ break;
+
+ case LT_DOCBOOKINNERATTR:
+ lex >> docbookinnerattr_;
+ break;
+
+ case LT_DOCBOOKINNERTAGTYPE:
+ lex >> docbookinnertagtype_;
+ break;
+
+ case LT_DOCBOOKFORCEABSTRACTTAG:
+ lex >> docbookforceabstracttag_;
+ break;
+
+ case LT_DOCBOOKININFO:
+ lex >> docbookininfo_;
+ break;
+
+ case LT_DOCBOOKABSTRACT:
+ lex >> docbookabstract_;
+ break;
+
+ case LT_DOCBOOKWRAPPERTAG:
+ lex >> docbookwrappertag_;
+ break;
+
+ case LT_DOCBOOKWRAPPERATTR:
+ lex >> docbookwrapperattr_;
+ break;
+
+ case LT_DOCBOOKWRAPPERTAGTYPE:
+ lex >> docbookwrappertagtype_;
+ break;
+
+ case LT_DOCBOOKWRAPPERMERGEWITHPREVIOUS:
+ lex >> docbookwrappermergewithprevious_;
+ break;
+
+ case LT_DOCBOOKSECTION:
+ lex >> docbooksection_;
+ break;
+
+ case LT_DOCBOOKSECTIONTAG:
+ lex >> docbooksectiontag_;
+ break;
+
+ case LT_DOCBOOKITEMWRAPPERTAG:
+ lex >> docbookitemwrappertag_;
+ break;
+
+ case LT_DOCBOOKITEMWRAPPERATTR:
+ lex >> docbookitemwrapperattr_;
+ break;
+
+ case LT_DOCBOOKITEMWRAPPERTAGTYPE:
+ lex >> docbookitemwrappertagtype_;
+ break;
+
+ case LT_DOCBOOKITEMTAG:
+ lex >> docbookitemtag_;
+ break;
+
+ case LT_DOCBOOKITEMATTR:
+ lex >> docbookitemattr_;
+ break;
+
+ case LT_DOCBOOKITEMTAGTYPE:
+ lex >> docbookitemtagtype_;
+ break;
+
+ case LT_DOCBOOKITEMLABELTAG:
+ lex >> docbookitemlabeltag_;
+ break;
+
+ case LT_DOCBOOKITEMLABELATTR:
+ lex >> docbookitemlabelattr_;
+ break;
+
+ case LT_DOCBOOKITEMLABELTAGTYPE:
+ lex >> docbookitemlabeltagtype_;
+ break;
+
+ case LT_DOCBOOKITEMINNERTAG:
+ lex >> docbookiteminnertag_;
+ break;
+
+ case LT_DOCBOOKITEMINNERATTR:
+ lex >> docbookiteminnerattr_;
+ break;
+
+ case LT_DOCBOOKITEMINNERTAGTYPE:
+ lex >> docbookiteminnertagtype_;
+ break;
+
case LT_SPELLCHECK:
lex >> spellcheck;
break;
}
-void Layout::readArgument(Lexer & lex)
+void Layout::readArgument(Lexer & lex, bool validating)
{
- latexarg arg;
- // writeArgument() makes use of these default values
- arg.mandatory = false;
- arg.nodelims = false;
- arg.autoinsert = false;
- arg.insertcotext = false;
- arg.insertonnewline = false;
- bool error = false;
- bool finished = false;
- arg.font = inherit_font;
- arg.labelfont = inherit_font;
- arg.is_toc_caption = false;
- arg.passthru = PT_INHERITED;
- arg.free_spacing = false;
- string id;
- lex >> id;
+ if (!lex.next()) {
+ LYXERR0("Unable to read argument ID!");
+ return;
+ }
+ string const id = lex.getString();
+
bool const itemarg = prefixIs(id, "item:");
bool const postcmd = prefixIs(id, "post:");
bool const listpreamble = prefixIs(id, "listpreamble:");
+ LaTeXArgMap & lam = itemarg ? itemargs_ :
+ (postcmd ? postcommandargs_ :
+ (listpreamble ? listpreamble_ :
+ latexargs_));
+ latexarg & arg = lam[id];
+
+ bool error = false;
+ bool finished = false;
while (!finished && lex.isOK() && !error) {
lex.next();
string const tok = ascii_lowercase(lex.getString());
} else if (tok == "freespacing") {
lex.next();
arg.free_spacing = lex.getBool();
+ } else if (tok == "docbooktag") {
+ lex.next();
+ arg.docbooktag = lex.getDocString();
+ } else if (tok == "docbookattr") {
+ lex.next();
+ arg.docbookattr = lex.getDocString();
+ } else if (tok == "docbooktagtype") {
+ lex.next();
+ arg.docbooktagtype = lex.getDocString();
} else {
lex.printError("Unknown tag");
error = true;
}
}
- if (arg.labelstring.empty())
+ if (!validating && arg.labelstring.empty()) {
LYXERR0("Incomplete Argument definition!");
- else if (itemarg)
- itemargs_[id] = arg;
- else if (postcmd)
- postcommandargs_[id] = arg;
- else if (listpreamble) {
- // list preamble has no delimiters by default
- arg.nodelims = true;
- listpreamble_[id] = arg;
- } else
- latexargs_[id] = arg;
+ // remove invalid definition
+ lam.erase(id);
+ }
}
"\tInPreamble " << inpreamble << "\n"
"\tTocLevel " << toclevel << "\n"
"\tResumeCounter " << resumecounter << "\n"
- "\tStepMasterCounter " << stepmastercounter << '\n';
+ "\tStepParentCounter " << stepparentcounter << '\n';
// ResetArgs does not make sense here
for (LaTeXArgMap::const_iterator it = latexargs_.begin();
it != latexargs_.end(); ++it)
os << "\tHTMLPreamble\n"
<< to_utf8(rtrim(htmlpreamble_, "\n"))
<< "\n\tEndPreamble\n";
- os << "\tHTMLTitle " << htmltitle_ << "\n"
- "\tSpellcheck " << spellcheck << "\n"
+ os << "\tHTMLTitle " << htmltitle_ << "\n";
+ if(!docbooktag_.empty())
+ os << "\tDocBookTag " << docbooktag_ << '\n';
+ if(!docbookattr_.empty())
+ os << "\tDocBookAttr \"" << docbookattr_ << "\"\n";
+ if(!docbooktagtype_.empty())
+ os << "\tDocBookTagType " << docbooktagtype_ << '\n';
+ if(!docbookinnertag_.empty())
+ os << "\tDocBookInnerTag " << docbookinnertag_ << '\n';
+ if(!docbookinnerattr_.empty())
+ os << "\tDocBookInnerAttr \"" << docbookinnerattr_ << "\"\n";
+ if(!docbookinnertagtype_.empty())
+ os << "\tDocBookInnerTagType " << docbookinnertagtype_ << '\n';
+ if(!docbookininfo_.empty())
+ os << "\tDocBookInInfo " << docbookininfo_ << '\n';
+ os << "\tDocBookAbstract " << docbookabstract_ << '\n';
+ if(!docbookwrappertag_.empty())
+ os << "\tDocBookWrapperTag " << docbookwrappertag_ << '\n';
+ if(!docbookwrapperattr_.empty())
+ os << "\tDocBookWrapperAttr " << docbookwrapperattr_ << '\n';
+ if(!docbookwrappertagtype_.empty())
+ os << "\tDocBookWrapperTagType " << docbookwrappertagtype_ << '\n';
+ os << "\tDocBookSection " << docbooksection_ << '\n';
+ if(!docbooksectiontag_.empty())
+ os << "\tDocBookSectionTag " << docbooksectiontag_ << '\n';
+ if(!docbookitemtag_.empty())
+ os << "\tDocBookItemTag " << docbookitemtag_ << '\n';
+ if(!docbookitemattr_.empty())
+ os << "\tDocBookItemAttr " << docbookitemattr_ << '\n';
+ if(!docbookitemtagtype_.empty())
+ os << "\tDocBookItemTagType " << docbookitemtagtype_ << '\n';
+ if(!docbookitemwrappertag_.empty())
+ os << "\tDocBookItemWrapperTag " << docbookitemwrappertag_ << '\n';
+ if(!docbookitemwrapperattr_.empty())
+ os << "\tDocBookItemWrapperAttr " << docbookitemwrapperattr_ << '\n';
+ if(!docbookitemwrappertagtype_.empty())
+ os << "\tDocBookItemWrapperTagType " << docbookitemwrappertagtype_ << '\n';
+ os << "\tDocBookWrapperMergeWithPrevious " << docbookwrappermergewithprevious_ << '\n';
+ if(!docbookitemlabeltag_.empty())
+ os << "\tDocBookItemLabelTag " << docbookitemlabeltag_ << '\n';
+ if(!docbookitemlabelattr_.empty())
+ os << "\tDocBookItemLabelAttr " << docbookitemlabelattr_ << '\n';
+ if(!docbookitemlabeltagtype_.empty())
+ os << "\tDocBookItemLabelTagType " << docbookitemlabeltagtype_ << '\n';
+ if(!docbookiteminnertag_.empty())
+ os << "\tDocBookItemInnerTag " << docbookiteminnertag_ << '\n';
+ if(!docbookiteminnerattr_.empty())
+ os << "\tDocBookItemInnerAttr " << docbookiteminnerattr_ << '\n';
+ if(!docbookiteminnertagtype_.empty())
+ os << "\tDocBookItemInnerTagType " << docbookiteminnertagtype_ << '\n';
+ if(!docbookforceabstracttag_.empty())
+ os << "\tDocBookForceAbstractTag " << docbookforceabstracttag_ << '\n';
+ os << "\tSpellcheck " << spellcheck << "\n"
"\tForceLocal " << forcelocal << "\n"
"End\n";
}
}
+string const & Layout::docbooktag() const
+{
+ if (docbooktag_.empty()) {
+ if (to_ascii(name_) == "Plain Layout")
+ docbooktag_ = "para";
+ else // No sensible default value, unhappily...
+ docbooktag_ = to_utf8(name_);
+ }
+ return docbooktag_;
+}
+
+
+string const & Layout::docbookattr() const
+{
+ // Perfectly OK to return no attributes, so docbookattr_ does not need to be filled.
+ return docbookattr_;
+}
+
+
+bool isValidTagType(std::string const & type)
+{
+ return !(type.empty() || (type != "block" && type != "paragraph" && type != "inline"));
+}
+
+
+string const & Layout::docbooktagtype() const
+{
+ if (!isValidTagType(docbooktagtype_))
+ docbooktagtype_ = "block";
+ return docbooktagtype_;
+}
+
+
+string const & Layout::docbookinnertag() const
+{
+ if (docbookinnertag_.empty())
+ docbookinnertag_ = "NONE";
+ return docbookinnertag_;
+}
+
+
+string const & Layout::docbookinnerattr() const
+{
+ return docbookinnerattr_;
+}
+
+
+string const & Layout::docbookinnertagtype() const
+{
+ if (!isValidTagType(docbookinnertagtype_))
+ docbookinnertagtype_ = "block";
+ return docbookinnertagtype_;
+}
+
+
+string const & Layout::docbookininfo() const
+{
+ // Indeed, a trilean. Only titles should be "maybe": otherwise, metadata is "always", content is "never".
+ if (docbookininfo_.empty() || (docbookininfo_ != "never" && docbookininfo_ != "always" && docbookininfo_ != "maybe"))
+ docbookininfo_ = "never";
+ return docbookininfo_;
+}
+
+
+string const & Layout::docbookwrappertag() const
+{
+ if (docbookwrappertag_.empty())
+ docbookwrappertag_ = "NONE";
+ return docbookwrappertag_;
+}
+
+
+string const & Layout::docbookwrapperattr() const
+{
+ return docbookwrapperattr_;
+}
+
+
+string const & Layout::docbookwrappertagtype() const
+{
+ if (!isValidTagType(docbookwrappertagtype_))
+ docbookwrappertagtype_ = "block";
+ return docbookwrappertagtype_;
+}
+
+
+string const & Layout::docbooksectiontag() const
+{
+ if (docbooksectiontag_.empty())
+ docbooksectiontag_ = "section";
+ return docbooksectiontag_;
+}
+
+
+string const & Layout::docbookitemwrappertag() const
+{
+ if (docbookitemwrappertag_.empty())
+ docbookitemwrappertag_ = "NONE";
+ return docbookitemwrappertag_;
+}
+
+
+string const & Layout::docbookitemwrapperattr() const
+{
+ return docbookitemwrapperattr_;
+}
+
+
+string const & Layout::docbookitemwrappertagtype() const
+{
+ if (!isValidTagType(docbookitemwrappertagtype_))
+ docbookitemwrappertagtype_ = "block";
+ return docbookitemwrappertagtype_;
+}
+
+
+string const & Layout::docbookitemtag() const
+{
+ if (docbookitemtag_.empty())
+ docbookitemtag_ = "NONE";
+ return docbookitemtag_;
+}
+
+
+string const & Layout::docbookitemattr() const
+{
+ return docbookitemattr_;
+}
+
+
+string const & Layout::docbookitemtagtype() const
+{
+ if (!isValidTagType(docbookitemtagtype_))
+ docbookitemtagtype_ = "block";
+ return docbookitemtagtype_;
+}
+
+
+string const & Layout::docbookitemlabeltag() const
+{
+ if (docbookitemlabeltag_.empty())
+ docbookitemlabeltag_ = "NONE";
+ return docbookitemlabeltag_;
+}
+
+
+string const & Layout::docbookitemlabelattr() const
+{
+ return docbookitemlabelattr_;
+}
+
+
+string const & Layout::docbookitemlabeltagtype() const
+{
+ if (!isValidTagType(docbookitemlabeltagtype_))
+ docbookitemlabeltagtype_ = "block";
+ return docbookitemlabeltagtype_;
+}
+
+
+string const & Layout::docbookiteminnertag() const
+{
+ if (docbookiteminnertag_.empty())
+ docbookiteminnertag_ = "NONE";
+ return docbookiteminnertag_;
+}
+
+
+string const & Layout::docbookiteminnerattr() const
+{
+ return docbookiteminnerattr_;
+}
+
+
+string const & Layout::docbookiteminnertagtype() const
+{
+ if (!isValidTagType(docbookiteminnertagtype_))
+ docbookiteminnertagtype_ = "block";
+ return docbookiteminnertagtype_;
+}
+
+
+std::string const & Layout::docbookforceabstracttag() const
+{
+ if (docbookforceabstracttag_.empty())
+ docbookforceabstracttag_ = "NONE";
+ return docbookforceabstracttag_;
+}
+
+
+
namespace {
string makeMarginValue(char const * side, double d)
projects / lyx.git / blobdiff