X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Finsets%2FInsetLayout.cpp;h=f2b701dfb8057f81bb21b03d0242a519b9cc0ec4;hb=996505c2ae981187d34580633fca410972c2493d;hp=900881764999652e943c0921b78d7da58145bfc8;hpb=94e0c24753f4902a18bce858e1332cb181f0ab1c;p=lyx.git diff --git a/src/insets/InsetLayout.cpp b/src/insets/InsetLayout.cpp index 9008817649..f2b701dfb8 100644 --- a/src/insets/InsetLayout.cpp +++ b/src/insets/InsetLayout.cpp @@ -14,9 +14,11 @@ #include "InsetLayout.h" -#include "Color.h" -#include "Font.h" +#include "ColorSet.h" #include "Lexer.h" +#include "TextClass.h" + +#include "support/debug.h" #include "support/lstrings.h" #include @@ -28,63 +30,105 @@ using std::vector; namespace lyx { InsetLayout::InsetLayout() : - name_(from_ascii("undefined")), labelstring_(from_ascii("UNDEFINED")), - decoration_(InsetLayout::Default), - 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), + htmlforcecss_ (false), htmlisblock_(true), + multipar_(true), custompars_(true), forceplain_(false), + passthru_(false), needprotect_(false), freespacing_(false), + keepempty_(false), forceltr_(false), intoc_(false) { - labelfont_.setColor(Color_error); + labelfont_.setColor(Color_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 -}; +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; +} -namespace { - InsetLayout::InsetDecoration translateDecoration(std::string const & str) - { - if (str == "classic") - return InsetLayout::Classic; - if (str == "minimalistic") - return InsetLayout::Minimalistic; - if (str == "conglomerate") - 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; } +} // namespace anon -bool InsetLayout::read(Lexer & lexrc) + +bool InsetLayout::read(Lexer & lex, TextClass const & tclass) { - name_ = support::subst(lexrc.getDocString(), '_', ' '); + enum { + IL_BGCOLOR, + IL_COPYSTYLE, + IL_COUNTER, + IL_CUSTOMPARS, + IL_DECORATION, + IL_FONT, + IL_FORCELTR, + IL_FORCEPLAIN, + IL_FREESPACING, + IL_HTMLTAG, + IL_HTMLATTR, + IL_HTMLFORCECSS, + IL_HTMLINNERTAG, + IL_HTMLINNERATTR, + IL_HTMLISBLOCK, + IL_HTMLLABEL, + IL_HTMLSTYLE, + IL_HTMLPREAMBLE, + IL_INTOC, + 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 }, + { "counter", IL_COUNTER}, + { "custompars", IL_CUSTOMPARS }, { "decoration", IL_DECORATION }, { "end", IL_END }, { "font", IL_FONT }, { "forceltr", IL_FORCELTR }, + { "forceplain", IL_FORCEPLAIN }, { "freespacing", IL_FREESPACING }, + { "htmlattr", IL_HTMLATTR }, + { "htmlforcecss", IL_HTMLFORCECSS }, + { "htmlinnerattr", IL_HTMLINNERATTR}, + { "htmlinnertag", IL_HTMLINNERTAG}, + { "htmlisblock", IL_HTMLISBLOCK}, + { "htmllabel", IL_HTMLLABEL }, + { "htmlpreamble", IL_HTMLPREAMBLE }, + { "htmlstyle", IL_HTMLSTYLE }, + { "htmltag", IL_HTMLTAG }, + { "intoc", IL_INTOC }, { "keepempty", IL_KEEPEMPTY }, { "labelfont", IL_LABELFONT }, { "labelstring", IL_LABELSTRING }, @@ -99,93 +143,175 @@ 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(le)) { - case IL_LYXTYPE: - lexrc.next(); - lyxtype_ = lexrc.getString(); + switch (le) { + // FIXME + // Perhaps a more 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_ = translateDecoration(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(), """, "\""); + lex >> tmp; + latexparam_ = support::subst(tmp, """, "\""); 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_INTOC: + lex >> intoc_; 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_COUNTER: + lex >> counter_; + 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_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_FONT: { - font_ = lyxRead(lexrc, inherit_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: { - lexrc.next(); - string const token = lexrc.getString(); - bgcolor_ = lcolor.getFromLyXName(token); + case IL_BGCOLOR: + lex >> tmp; + bgcolor_ = lcolor.getFromLyXName(tmp); break; - } case IL_PREAMBLE: - preamble_ = lexrc.getLongString("EndPreamble"); + preamble_ = from_utf8(lex.getLongString("EndPreamble")); + break; + case IL_HTMLTAG: + lex >> htmltag_; + break; + case IL_HTMLATTR: + lex >> htmlattr_; + break; + case IL_HTMLFORCECSS: + lex >> htmlforcecss_; + break; + case IL_HTMLINNERTAG: + lex >> htmlinnertag_; + break; + case IL_HTMLINNERATTR: + lex >> htmlinnerattr_; + break; + case IL_HTMLLABEL: + lex >> htmllabel_; + break; + case IL_HTMLISBLOCK: + lex >> htmlisblock_; + break; + case IL_HTMLSTYLE: + htmlstyle_ = from_utf8(lex.getLongString("EndHTMLStyle")); + break; + case IL_HTMLPREAMBLE: + htmlpreamble_ = from_utf8(lex.getLongString("EndPreamble")); break; case IL_REQUIRES: { - lexrc.eatLine(); + lex.eatLine(); vector const req - = support::getVectorFromString(lexrc.getString()); + = support::getVectorFromString(lex.getString()); requires_.insert(req.begin(), req.end()); break; } @@ -203,8 +329,97 @@ 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; +} + + +string const & InsetLayout::htmltag() const +{ + if (htmltag_.empty()) + htmltag_ = multipar_ ? "div" : "span"; + return htmltag_; +} + + +string const & InsetLayout::htmlattr() const +{ + if (htmlattr_.empty()) + htmlattr_ = "class=\"" + defaultCSSClass() + "\""; + return htmlattr_; +} + + +string const & InsetLayout::htmlinnerattr() const +{ + if (htmlinnerattr_.empty()) + htmlinnerattr_ = "class=\"" + defaultCSSClass() + "_inner\""; + return htmlinnerattr_; +} + + +string InsetLayout::defaultCSSClass() const +{ + if (!defaultcssclass_.empty()) + return defaultcssclass_; + string d; + string n = to_utf8(name()); + string::const_iterator it = n.begin(); + string::const_iterator en = n.end(); + for (; it != en; ++it) { + if (!isalpha(*it)) + d += "_"; + else if (islower(*it)) + d += *it; + else + d += support::lowercase(*it); + } + // are there other characters we need to remove? + defaultcssclass_ = d; + return defaultcssclass_; +} + + +void InsetLayout::makeDefaultCSS() const +{ + if (!htmldefaultstyle_.empty()) + return; + docstring const mainfontCSS = font_.asCSS(); + if (!mainfontCSS.empty()) + htmldefaultstyle_ = + from_ascii(htmltag() + "." + defaultCSSClass() + " {\n") + + mainfontCSS + from_ascii("\n}\n"); +} + + +docstring InsetLayout::htmlstyle() const +{ + if (!htmlstyle_.empty() && !htmlforcecss_) + return htmlstyle_; + if (htmldefaultstyle_.empty()) + makeDefaultCSS(); + docstring retval = htmldefaultstyle_; + if (!htmlstyle_.empty()) + retval += '\n' + htmlstyle_ + '\n'; + return retval; +} + + } //namespace lyx