LT_NEED_PROTECT,
LT_NEWLINE,
LT_NEXTNOINDENT,
+ LT_PAR_GROUP,
LT_PARINDENT,
LT_PARSEP,
LT_PARSKIP,
LT_HTMLITEM,
LT_HTMLITEMATTR,
LT_HTMLLABEL,
- LT_HTMLLABELATTR,
+ LT_HTMLLABELATTR,
LT_HTMLLABELFIRST,
LT_HTMLPREAMBLE,
LT_HTMLSTYLE,
LT_SPELLCHECK,
LT_REFPREFIX,
LT_RESETARGS,
+ LT_RESUMECOUNTER,
+ LT_STEPMASTERCOUNTER,
LT_RIGHTDELIM,
LT_FORCELOCAL,
LT_TOGGLE_INDENT,
+ LT_ADDTOTOC,
+ LT_ISTOCCAPTION,
LT_INTITLE // keep this last!
};
/////////////////////
Layout::Layout()
+ : add_to_toc_(false), is_toc_caption_(false)
{
unknown_ = false;
margintype = MARGIN_STATIC;
latextype = LATEX_PARAGRAPH;
+ resumecounter = false;
+ stepmastercounter = false;
intitle = false;
inpreamble = false;
needprotect = false;
forcelocal = 0;
itemcommand_ = "item";
toggle_indent = ITOGGLE_DOCUMENT_DEFAULT;
+ par_group_ = false;
}
{
// This table is sorted alphabetically [asierra 30March96]
LexerKeyword layoutTags[] = {
+ { "addtotoc", LT_ADDTOTOC },
{ "align", LT_ALIGN },
{ "alignpossible", LT_ALIGNPOSSIBLE },
{ "argument", LT_ARGUMENT },
{ "innertag", LT_INNERTAG },
{ "inpreamble", LT_INPREAMBLE },
{ "intitle", LT_INTITLE },
+ { "istoccaption", LT_ISTOCCAPTION },
{ "itemcommand", LT_ITEMCOMMAND },
{ "itemsep", LT_ITEMSEP },
{ "itemtag", LT_ITEMTAG },
{ "newline", LT_NEWLINE },
{ "nextnoindent", LT_NEXTNOINDENT },
{ "obsoletedby", LT_OBSOLETEDBY },
+ { "paragraphgroup", LT_PAR_GROUP },
{ "parbreakisnewline", LT_PARBREAK_IS_NEWLINE },
{ "parindent", LT_PARINDENT },
{ "parsep", LT_PARSEP },
{ "refprefix", LT_REFPREFIX },
{ "requires", LT_REQUIRES },
{ "resetargs", LT_RESETARGS },
+ { "resumecounter", LT_RESUMECOUNTER },
{ "rightdelim", LT_RIGHTDELIM },
{ "rightmargin", LT_RIGHTMARGIN },
{ "spacing", LT_SPACING },
{ "spellcheck", LT_SPELLCHECK },
+ { "stepmastercounter", LT_STEPMASTERCOUNTER },
{ "textfont", LT_TEXTFONT },
{ "toclevel", LT_TOCLEVEL },
{ "toggleindent", LT_TOGGLE_INDENT },
error = true;
continue;
- default:
+ default:
break;
}
switch (static_cast<LayoutTags>(le)) {
if (obsoleted_by().empty())
obsoleted_by_ = style;
} else {
- LYXERR0("Cannot replace with unknown style `"
+ LYXERR0("Cannot replace with unknown style `"
<< style << '\'');
//lex.printError("Cannot replace with"
}
break;
+ case LT_RESUMECOUNTER:
+ lex >> resumecounter;
+ break;
+
+ case LT_STEPMASTERCOUNTER:
+ lex >> stepmastercounter;
+ break;
+
case LT_ARGUMENT:
readArgument(lex);
break;
break;
case LT_PREAMBLE:
- preamble_ = from_utf8(lex.getLongString("EndPreamble"));
+ preamble_ = lex.getLongString(from_ascii("EndPreamble"));
break;
case LT_LANGPREAMBLE:
- langpreamble_ = from_utf8(lex.getLongString("EndLangPreamble"));
+ langpreamble_ = lex.getLongString(from_ascii("EndLangPreamble"));
break;
case LT_BABELPREAMBLE:
- babelpreamble_ = from_utf8(lex.getLongString("EndBabelPreamble"));
+ babelpreamble_ = lex.getLongString(from_ascii("EndBabelPreamble"));
break;
case LT_LABELTYPE:
case LT_ALIGN:
readAlign(lex);
break;
-
+
case LT_ALIGNPOSSIBLE:
readAlignPossible(lex);
break;
// FIXME: this means LT_LABELSTRING_APPENDIX may only
// occur after LT_LABELSTRING
lex >> labelstring_;
- labelstring_ = trim(labelstring_);
labelstring_appendix_ = labelstring_;
break;
case LT_ENDLABELSTRING:
- lex >> endlabelstring_;
- endlabelstring_ = trim(endlabelstring_);
+ lex >> endlabelstring_;
break;
case LT_LABELSTRING_APPENDIX:
- lex >> labelstring_appendix_;
- labelstring_appendix_ = trim(labelstring_appendix_);
+ lex >> labelstring_appendix_;
break;
case LT_LABELCOUNTER:
- lex >> counter;
- counter = trim(counter);
+ lex >> counter;
+ break;
+
+ case LT_PAR_GROUP:
+ lex >> par_group_;
break;
case LT_FREE_SPACING:
case LT_REQUIRES: {
lex.eatLine();
- vector<string> const req =
- getVectorFromString(lex.getString());
+ vector<string> const req =
+ getVectorFromString(lex.getString(true));
requires_.insert(req.begin(), req.end());
break;
}
-
+
case LT_REFPREFIX: {
docstring arg;
lex >> arg;
case LT_HTMLTAG:
lex >> htmltag_;
break;
-
+
case LT_HTMLATTR:
lex >> htmlattr_;
break;
case LT_HTMLITEM:
lex >> htmlitemtag_;
break;
-
+
case LT_HTMLITEMATTR:
lex >> htmlitemattr_;
break;
-
+
case LT_HTMLLABEL:
lex >> htmllabeltag_;
break;
- case LT_HTMLLABELATTR:
+ case LT_HTMLLABELATTR:
lex >> htmllabelattr_;
break;
case LT_HTMLLABELFIRST:
lex >> htmllabelfirst_;
break;
-
+
case LT_HTMLSTYLE:
- htmlstyle_ = from_utf8(lex.getLongString("EndHTMLStyle"));
+ htmlstyle_ = lex.getLongString(from_ascii("EndHTMLStyle"));
break;
case LT_HTMLFORCECSS:
break;
case LT_HTMLPREAMBLE:
- htmlpreamble_ = from_utf8(lex.getLongString("EndPreamble"));
+ htmlpreamble_ = lex.getLongString(from_ascii("EndPreamble"));
break;
-
+
case LT_HTMLTITLE:
lex >> htmltitle_;
break;
case LT_FORCELOCAL:
lex >> forcelocal;
break;
+
+ case LT_ADDTOTOC:
+ lex >> toc_type_;
+ add_to_toc_ = !toc_type_.empty();
+ break;
+
+ case LT_ISTOCCAPTION:
+ lex >> is_toc_caption_;
+ break;
+
}
}
lex.popTable();
return;
case LATEX_PARAGRAPH:
case LATEX_COMMAND:
- case LATEX_ENVIRONMENT:
case LATEX_ITEM_ENVIRONMENT:
- case LATEX_BIB_ENVIRONMENT:
case LATEX_LIST_ENVIRONMENT:
latextype = static_cast<LatexType>(le);
break;
+ case LATEX_ENVIRONMENT:
+ case LATEX_BIB_ENVIRONMENT:
+ latextype = static_cast<LatexType>(le);
+ par_group_ = true;
+ break;
default:
LYXERR0("Unhandled value " << le);
break;
// writeArgument() makes use of these default values
arg.mandatory = false;
arg.autoinsert = false;
+ arg.insertcotext = false;
bool error = false;
bool finished = false;
arg.font = inherit_font;
arg.labelfont = inherit_font;
+ arg.is_toc_caption = false;
+ arg.passthru = PT_INHERITED;
string id;
lex >> id;
bool const itemarg = prefixIs(id, "item:");
} else if (tok == "autoinsert") {
lex.next();
arg.autoinsert = lex.getBool();
+ } else if (tok == "insertcotext") {
+ lex.next();
+ arg.insertcotext = lex.getBool();
} else if (tok == "leftdelim") {
lex.next();
arg.ldelim = lex.getDocString();
} else if (tok == "passthruchars") {
lex.next();
arg.pass_thru_chars = lex.getDocString();
+ } else if (tok == "passthru") {
+ lex.next();
+ docstring value = lex.getDocString();
+ if (value == "true" || value == "1")
+ arg.passthru = PT_TRUE;
+ else if (value == "false" || value == "0")
+ arg.passthru = PT_FALSE;
+ else
+ arg.passthru = PT_INHERITED;
+ } else if (tok == "istoccaption") {
+ lex.next();
+ arg.is_toc_caption = lex.getBool();
} else {
lex.printError("Unknown tag");
error = true;
os << "\t\tMandatory " << arg.mandatory << '\n';
if (arg.autoinsert)
os << "\t\tAutoinsert " << arg.autoinsert << '\n';
+ if (arg.insertcotext)
+ os << "\t\tInsertCotext " << arg.insertcotext << '\n';
if (!arg.ldelim.empty())
os << "\t\tLeftDelim \""
<< to_utf8(subst(arg.ldelim, from_ascii("\n"), from_ascii("<br/>")))
lyxWrite(os, arg.font, "Font", 2);
if (arg.labelfont != inherit_font)
lyxWrite(os, arg.labelfont, "LabelFont", 2);
+ switch (arg.passthru) {
+ case PT_TRUE:
+ os << "\t\tPassThru true\n";
+ break;
+ case PT_FALSE:
+ os << "\t\tPassThru false\n";
+ break;
+ case PT_INHERITED:
+ os << "\t\tPassThru inherited\n";
+ break;
+ }
+ if (!arg.pass_thru_chars.empty())
+ os << "\t\tPassThruChars \"" << to_utf8(arg.pass_thru_chars) << "\"\n";
os << "\tEndArgument\n";
}
void Layout::write(ostream & os) const
{
- os << "Style " << to_utf8(name_) << '\n';
+ os << "Style \"" << to_utf8(name_) << "\"\n";
if (!category_.empty() && obsoleted_by_.empty())
os << "\tCategory \"" << to_utf8(category_) << "\"\n";
// Can't deduce Copystyle here :-(
}
os << "\tInTitle " << intitle << "\n"
"\tInPreamble " << inpreamble << "\n"
- "\tTocLevel " << toclevel << '\n';
+ "\tTocLevel " << toclevel << "\n"
+ "\tResumeCounter " << resumecounter << "\n"
+ "\tStepMasterCounter " << stepmastercounter << '\n';
// ResetArgs does not make sense here
for (LaTeXArgMap::const_iterator it = latexargs_.begin();
it != latexargs_.end(); ++it)
os << "\tEndLabelType Static\n";
break;
}
+ os << "\tParagraphGroup \"" << par_group_ << "\"\n";
if (!leftmargin.empty())
os << "\tLeftMargin \"" << to_utf8(leftmargin) << "\"\n";
if (!rightmargin.empty())
bool first = true;
os << "\tAlignPossible";
if (alignpossible & LYX_ALIGN_BLOCK) {
- if (!first)
- os << ',';
os << " Block";
first = false;
}
}
+bool Layout::hasArgs() const
+{
+ return !latexargs_.empty() || !postcommandargs_.empty() ||
+ !itemargs_.empty();
+}
+
+
Layout::LaTeXArgMap Layout::args() const
{
LaTeXArgMap args = latexargs_;
}
-string const & Layout::htmltag() const
-{
+string const & Layout::htmltag() const
+{
if (htmltag_.empty())
htmltag_ = "div";
return htmltag_;
}
-string const & Layout::htmlattr() const
-{
+string const & Layout::htmlattr() const
+{
if (htmlattr_.empty())
htmlattr_ = "class=\"" + defaultCSSClass() + "\"";
- return htmlattr_;
+ return htmlattr_;
}
-string const & Layout::htmlitemtag() const
-{
+string const & Layout::htmlitemtag() const
+{
if (htmlitemtag_.empty())
htmlitemtag_ = "div";
- return htmlitemtag_;
+ return htmlitemtag_;
}
-string const & Layout::htmlitemattr() const
-{
+string const & Layout::htmlitemattr() const
+{
if (htmlitemattr_.empty())
htmlitemattr_ = "class=\"" + defaultCSSItemClass() + "\"";
- return htmlitemattr_;
+ return htmlitemattr_;
}
-string const & Layout::htmllabeltag() const
-{
- if (htmllabeltag_.empty()) {
- if (labeltype != LABEL_ABOVE &&
- labeltype != LABEL_CENTERED)
+string const & Layout::htmllabeltag() const
+{
+ if (htmllabeltag_.empty())
htmllabeltag_ = "span";
- else
- htmllabeltag_ = "div";
- }
- return htmllabeltag_;
+ return htmllabeltag_;
}
-string const & Layout::htmllabelattr() const
-{
+string const & Layout::htmllabelattr() const
+{
if (htmllabelattr_.empty())
htmllabelattr_ = "class=\"" + defaultCSSLabelClass() + "\"";
- return htmllabelattr_;
+ return htmllabelattr_;
}
{
if (!htmlstyle_.empty() && !htmlforcecss_)
return htmlstyle_;
- if (htmldefaultstyle_.empty())
+ if (htmldefaultstyle_.empty())
makeDefaultCSS();
docstring retval = htmldefaultstyle_;
if (!htmlstyle_.empty())
string Layout::defaultCSSClass() const
-{
+{
if (!defaultcssclass_.empty())
return defaultcssclass_;
docstring d;
return os.str();
}
-}
+} // namespace
void Layout::makeDefaultCSS() const
{
// this never needs to be redone, since reloading layouts will
// wipe out what we did before.
- if (!htmldefaultstyle_.empty())
+ if (!htmldefaultstyle_.empty())
return;
-
+
// main font
htmldefaultstyle_ = font.asCSS();
-
+
// bottom margins
string tmp;
if (topsep > 0)
if (bottomsep > 0)
tmp += makeMarginValue("bottom", bottomsep);
if (!leftmargin.empty()) {
- // we can't really do what LyX does with the margin, so
+ // we can't really do what LyX does with the margin, so
// we'll just figure out how many characters it is
int const len = leftmargin.length();
tmp += makeMarginValue("left", len);
int const len = rightmargin.length();
tmp += makeMarginValue("right", len);
}
-
+
if (!tmp.empty()) {
if (!htmldefaultstyle_.empty())
htmldefaultstyle_ += from_ascii("\n");
// wrap up what we have, if anything
if (!htmldefaultstyle_.empty())
- htmldefaultstyle_ =
+ htmldefaultstyle_ =
from_ascii(htmltag() + "." + defaultCSSClass() + " {\n") +
htmldefaultstyle_ + from_ascii("\n}\n");
-
+
if (labeltype == LABEL_NO_LABEL || htmllabeltag() == "NONE")
return;
-
+
docstring labelCSS;
-
+
// label font
if (labelfont != font)
labelCSS = labelfont.asCSS() + from_ascii("\n");
if (labeltype == LABEL_CENTERED)
labelCSS += from_ascii("text-align: center;\n");
-
+
if (!labelCSS.empty())
htmldefaultstyle_ +=
from_ascii(htmllabeltag() + "." + defaultCSSLabelClass() + " {\n") +