#include <config.h>
#include "Layout.h"
-#include "FontInfo.h"
-#include "Language.h"
-#include "Lexer.h"
#include "output_xhtml.h"
#include "TextClass.h"
#include "support/debug.h"
+#include "support/docstream.h"
#include "support/lassert.h"
+#include "support/Lexer.h"
#include "support/lstrings.h"
-#include "support/Messages.h"
#include "support/textutils.h"
LT_ITEMTAG,
LT_HTMLTAG,
LT_HTMLATTR,
+ LT_HTMLCLASS,
LT_HTMLITEM,
LT_HTMLITEMATTR,
LT_HTMLLABEL,
LT_HTMLFORCECSS,
LT_DOCBOOKTAG,
LT_DOCBOOKATTR,
+ LT_DOCBOOKTAGTYPE,
+ LT_DOCBOOKINNERATTR,
+ LT_DOCBOOKINNERTAG,
+ LT_DOCBOOKINNERTAGTYPE,
LT_DOCBOOKININFO,
+ LT_DOCBOOKABSTRACT,
+ LT_DOCBOOKGENERATETITLE,
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_DOCBOOKNOFONTINSIDE,
LT_INPREAMBLE,
LT_HTMLTITLE,
LT_SPELLCHECK,
LT_REFPREFIX,
LT_RESETARGS,
LT_RESUMECOUNTER,
- LT_STEPMASTERCOUNTER,
+ LT_STEPPARENTCOUNTER,
LT_RIGHTDELIM,
LT_FORCELOCAL,
LT_TOGGLE_INDENT,
LT_ADDTOTOC,
LT_ISTOCCAPTION,
+ LT_HTMLINTOC,
LT_INTITLE // keep this last!
};
margintype = MARGIN_STATIC;
latextype = LATEX_PARAGRAPH;
resumecounter = false;
- stepmastercounter = false;
+ stepparentcounter = false;
intitle = false;
inpreamble = false;
needprotect = false;
htmllabelfirst_ = false;
htmlforcecss_ = false;
htmltitle_ = false;
+ htmlintoc_ = true;
+ 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 },
- { "docbookattr", LT_DOCBOOKATTR },
- { "docbookforceabstracttag", LT_DOCBOOKFORCEABSTRACTTAG },
- { "docbookininfo", LT_DOCBOOKININFO },
- { "docbookitemattr", LT_DOCBOOKITEMATTR },
- { "docbookiteminnerattr", LT_DOCBOOKITEMINNERATTR },
- { "docbookiteminnertag", LT_DOCBOOKITEMINNERTAG },
- { "docbookitemlabelattr", LT_DOCBOOKITEMLABELATTR },
- { "docbookitemlabeltag", LT_DOCBOOKITEMLABELTAG },
- { "docbookitemtag", LT_DOCBOOKITEMTAG },
- { "docbookitemwrapperattr", LT_DOCBOOKITEMWRAPPERATTR },
- { "docbookitemwrappertag", LT_DOCBOOKITEMWRAPPERTAG },
- { "docbooksectiontag", LT_DOCBOOKSECTIONTAG },
- { "docbooktag", LT_DOCBOOKTAG },
- { "docbookwrapperattr", LT_DOCBOOKWRAPPERATTR },
- { "docbookwrappertag", LT_DOCBOOKWRAPPERTAG },
+ { "docbookabstract", LT_DOCBOOKABSTRACT },
+ { "docbookattr", LT_DOCBOOKATTR },
+ { "docbookforceabstracttag", LT_DOCBOOKFORCEABSTRACTTAG },
+ { "docbookgeneratetitle", LT_DOCBOOKGENERATETITLE },
+ { "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 },
+ { "docbooknofontinside", LT_DOCBOOKNOFONTINSIDE, },
+ { "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 },
{ "forcelocal", LT_FORCELOCAL },
{ "freespacing", LT_FREE_SPACING },
{ "htmlattr", LT_HTMLATTR },
+ { "htmlclass", LT_HTMLCLASS },
{ "htmlforcecss", LT_HTMLFORCECSS },
+ { "htmlintoc", LT_HTMLINTOC },
{ "htmlitem", LT_HTMLITEM },
{ "htmlitemattr", LT_HTMLITEMATTR },
{ "htmllabel", LT_HTMLLABEL },
{ "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:
case LT_LATEXPARAM:
lex >> latexparam_;
- latexparam_ = subst(latexparam_, """, "\"");
+ latexparam_ = subst(latexparam_, """, "\"");
break;
case LT_LEFTDELIM:
break;
}
+ case LT_HTMLINTOC:
+ lex >> htmlintoc_;
+ break;
+
case LT_HTMLTAG:
lex >> htmltag_;
break;
lex >> htmlattr_;
break;
+ case LT_HTMLCLASS:
+ lex >> htmlclass_;
+ break;
+
case LT_HTMLITEM:
lex >> htmlitemtag_;
break;
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;
lex >> docbookininfo_;
break;
+ case LT_DOCBOOKABSTRACT:
+ lex >> docbookabstract_;
+ break;
+
case LT_DOCBOOKWRAPPERTAG:
lex >> docbookwrappertag_;
break;
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:
+ case LT_DOCBOOKITEMWRAPPERTAG:
+ lex >> docbookitemwrappertag_;
+ break;
+
+ case LT_DOCBOOKITEMWRAPPERATTR:
lex >> docbookitemwrapperattr_;
break;
+ case LT_DOCBOOKITEMWRAPPERTAGTYPE:
+ lex >> docbookitemwrappertagtype_;
+ break;
+
case LT_DOCBOOKITEMTAG:
lex >> docbookitemtag_;
break;
lex >> docbookitemattr_;
break;
+ case LT_DOCBOOKITEMTAGTYPE:
+ lex >> docbookitemtagtype_;
+ break;
+
case LT_DOCBOOKITEMLABELTAG:
lex >> docbookitemlabeltag_;
break;
lex >> docbookitemlabelattr_;
break;
+ case LT_DOCBOOKITEMLABELTAGTYPE:
+ lex >> docbookitemlabeltagtype_;
+ break;
+
case LT_DOCBOOKITEMINNERTAG:
lex >> docbookiteminnertag_;
break;
lex >> docbookiteminnerattr_;
break;
+ case LT_DOCBOOKITEMINNERTAGTYPE:
+ lex >> docbookiteminnertagtype_;
+ break;
+
+ case LT_DOCBOOKNOFONTINSIDE:
+ lex >> docbooknofontinside_;
+ break;
+
+ case LT_DOCBOOKGENERATETITLE:
+ lex >> docbookgeneratetitle_;
+ 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];
+
+ if (listpreamble)
+ // list preamble has no delimiters by default
+ arg.nodelims = true;
+
+ bool error = false;
+ bool finished = false;
while (!finished && lex.isOK() && !error) {
lex.next();
string const tok = ascii_lowercase(lex.getString());
lex.next();
arg.tooltip = lex.getDocString();
} else if (tok == "requires") {
- lex.next();
+ lex.eatLine();
arg.required = lex.getString();
} else if (tok == "decoration") {
lex.next();
} 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 if (tok == "docbookargumentaftermaintag") {
+ lex.next();
+ arg.docbookargumentaftermaintag = lex.getBool();
+ } else if (tok == "docbookargumentbeforemaintag") {
+ lex.next();
+ arg.docbookargumentbeforemaintag = lex.getBool();
} 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);
+ }
}
if (!arg.tooltip.empty())
os << "\t\tToolTip \"" << to_utf8(arg.tooltip) << "\"\n";
if (!arg.required.empty())
- os << "\t\tRequires \"" << arg.required << "\"\n";
+ os << "\t\tRequires " << arg.required << "\n";
if (!arg.decoration.empty())
os << "\t\tDecoration \"" << arg.decoration << "\"\n";
if (!arg.newlinecmd.empty())
"\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)
if (!latexname_.empty())
os << "\tLatexName \"" << latexname_ << "\"\n";
if (!latexparam_.empty())
- os << "\tLatexParam \"" << subst(latexparam_, "\"", """)
+ os << "\tLatexParam \"" << subst(latexparam_, "\"", """)
<< "\"\n";
if (!leftdelim_.empty())
os << "\tLeftDelim "
os << "\tHTMLTag " << htmltag_ << '\n';
if (!htmlattr_.empty())
os << "\tHTMLAttr " << htmlattr_ << '\n';
+ if (!htmlclass_.empty())
+ os << "\tHTMLClass " << htmlclass_ << '\n';
+ if (!htmlintoc_)
+ os << "\tHTMLInToc " << htmlintoc_ << '\n';
if (!htmlitemtag_.empty())
os << "\tHTMLItem " << htmlitemtag_ << '\n';
if (!htmlitemattr_.empty())
<< to_utf8(rtrim(htmlpreamble_, "\n"))
<< "\n\tEndPreamble\n";
os << "\tHTMLTitle " << htmltitle_ << "\n";
- if(!docbooktag_.empty())
+ if (!docbooktag_.empty())
os << "\tDocBookTag " << docbooktag_ << '\n';
- if(!docbookattr_.empty())
- os << "\tDocBookAttr " << docbookattr_ << '\n';
- if(!docbookininfo_.empty())
+ 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';
- if(!docbookwrappertag_.empty())
+ os << "\tDocBookAbstract " << docbookabstract_ << '\n';
+ if (!docbookwrappertag_.empty())
os << "\tDocBookWrapperTag " << docbookwrappertag_ << '\n';
- if(!docbookwrapperattr_.empty())
+ if (!docbookwrapperattr_.empty())
os << "\tDocBookWrapperAttr " << docbookwrapperattr_ << '\n';
- if(!docbooksectiontag_.empty())
+ if (!docbookwrappertagtype_.empty())
+ os << "\tDocBookWrapperTagType " << docbookwrappertagtype_ << '\n';
+ os << "\tDocBookSection " << docbooksection_ << '\n';
+ if (!docbooksectiontag_.empty())
os << "\tDocBookSectionTag " << docbooksectiontag_ << '\n';
- if(!docbookitemtag_.empty())
+ if (!docbookitemtag_.empty())
os << "\tDocBookItemTag " << docbookitemtag_ << '\n';
- if(!docbookitemattr_.empty())
+ if (!docbookitemattr_.empty())
os << "\tDocBookItemAttr " << docbookitemattr_ << '\n';
- if(!docbookitemwrappertag_.empty())
+ if (!docbookitemtagtype_.empty())
+ os << "\tDocBookItemTagType " << docbookitemtagtype_ << '\n';
+ if (!docbookitemwrappertag_.empty())
os << "\tDocBookItemWrapperTag " << docbookitemwrappertag_ << '\n';
- if(!docbookitemwrapperattr_.empty())
+ if (!docbookitemwrapperattr_.empty())
os << "\tDocBookItemWrapperAttr " << docbookitemwrapperattr_ << '\n';
- if(!docbookitemlabeltag_.empty())
+ if (!docbookitemwrappertagtype_.empty())
+ os << "\tDocBookItemWrapperTagType " << docbookitemwrappertagtype_ << '\n';
+ os << "\tDocBookWrapperMergeWithPrevious " << docbookwrappermergewithprevious_ << '\n';
+ if (!docbookitemlabeltag_.empty())
os << "\tDocBookItemLabelTag " << docbookitemlabeltag_ << '\n';
- if(!docbookitemlabelattr_.empty())
+ if (!docbookitemlabelattr_.empty())
os << "\tDocBookItemLabelAttr " << docbookitemlabelattr_ << '\n';
- if(!docbookiteminnertag_.empty())
+ if (!docbookitemlabeltagtype_.empty())
+ os << "\tDocBookItemLabelTagType " << docbookitemlabeltagtype_ << '\n';
+ if (!docbookiteminnertag_.empty())
os << "\tDocBookItemInnerTag " << docbookiteminnertag_ << '\n';
- if(!docbookiteminnerattr_.empty())
+ if (!docbookiteminnerattr_.empty())
os << "\tDocBookItemInnerAttr " << docbookiteminnerattr_ << '\n';
- if(!docbookforceabstracttag_.empty())
+ if (!docbookiteminnertagtype_.empty())
+ os << "\tDocBookItemInnerTagType " << docbookiteminnertagtype_ << '\n';
+ if (!docbookforceabstracttag_.empty())
os << "\tDocBookForceAbstractTag " << docbookforceabstracttag_ << '\n';
- os << "\tSpellcheck " << spellcheck << "\n"
+ os << "\tDocBookNoFontInside " << docbooknofontinside_ << "\n"
+ "\tSpellcheck " << spellcheck << "\n"
"\tForceLocal " << forcelocal << "\n"
"End\n";
}
}
-string const & Layout::htmlattr() const
+string const & Layout::htmlclass() const
{
- if (htmlattr_.empty())
- htmlattr_ = "class=\"" + defaultCSSClass() + "\"";
- return htmlattr_;
+ // If it's an enumeration or itemize list, then we recalculate the class each
+ // time through (unless it has been given explicitly). So we do nothing here.
+ if (htmlclass_.empty() && labeltype != LABEL_ENUMERATE && labeltype != LABEL_ITEMIZE)
+ htmlclass_ = defaultCSSClass();
+ return htmlclass_;
+}
+
+
+string const & Layout::htmlGetAttrString() const {
+ if (!htmlfullattrs_.empty())
+ return htmlfullattrs_;
+ htmlfullattrs_ = htmlclass();
+ if (!htmlfullattrs_.empty())
+ htmlfullattrs_ = "class='" + htmlfullattrs_ + "'";
+ if (!htmlattr_.empty())
+ htmlfullattrs_ += " " + htmlattr_;
+ return htmlfullattrs_;
}
string const & Layout::docbooktag() const
{
- // No sensible default value, unhappily...
- if (docbooktag_.empty())
- docbooktag_ = to_utf8(name_);
+ if (docbooktag_.empty()) {
+ if (to_ascii(name_) == "Plain Layout")
+ docbooktag_ = "para";
+ else // No sensible default value, unhappily...
+ docbooktag_ = to_utf8(name_);
+ }
return docbooktag_;
}
}
+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".
}
+string const & Layout::docbookwrappertagtype() const
+{
+ if (!isValidTagType(docbookwrappertagtype_))
+ docbookwrappertagtype_ = "block";
+ return docbookwrappertagtype_;
+}
+
+
string const & Layout::docbooksectiontag() const
{
if (docbooksectiontag_.empty())
}
+string const & Layout::docbookitemwrappertagtype() const
+{
+ if (!isValidTagType(docbookitemwrappertagtype_))
+ docbookitemwrappertagtype_ = "block";
+ return docbookitemwrappertagtype_;
+}
+
+
string const & Layout::docbookitemtag() const
{
- return docbookitemtag_;
+ if (docbookitemtag_.empty())
+ docbookitemtag_ = "NONE";
+ return docbookitemtag_;
}
}
+string const & Layout::docbookitemtagtype() const
+{
+ if (!isValidTagType(docbookitemtagtype_))
+ docbookitemtagtype_ = "block";
+ return docbookitemtagtype_;
+}
+
+
string const & Layout::docbookitemlabeltag() const
{
if (docbookitemlabeltag_.empty())
}
+string const & Layout::docbookitemlabeltagtype() const
+{
+ if (!isValidTagType(docbookitemlabeltagtype_))
+ docbookitemlabeltagtype_ = "block";
+ return docbookitemlabeltagtype_;
+}
+
+
string const & Layout::docbookiteminnertag() const
{
if (docbookiteminnertag_.empty())
}
+string const & Layout::docbookiteminnertagtype() const
+{
+ if (!isValidTagType(docbookiteminnertagtype_))
+ docbookiteminnertagtype_ = "block";
+ return docbookiteminnertagtype_;
+}
+
+
std::string const & Layout::docbookforceabstracttag() const
{
if (docbookforceabstracttag_.empty())
projects / lyx.git / blobdiff