X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FTextClass.cpp;h=b77f31b3369c68b7422fe8f5e99ec8b1657d29c1;hb=73368ed2d97728ee3ec889383b3803d8e3309e9d;hp=73ad37c409e26efbc1f93316990c1ffb02225cc8;hpb=5ee70976def8b8107e5c51af5ff7e4091f602d9c;p=lyx.git diff --git a/src/TextClass.cpp b/src/TextClass.cpp index 73ad37c409..b77f31b336 100644 --- a/src/TextClass.cpp +++ b/src/TextClass.cpp @@ -30,6 +30,7 @@ #include "support/lassert.h" #include "support/debug.h" +#include "support/ExceptionMessage.h" #include "support/FileName.h" #include "support/filetools.h" #include "support/gettext.h" @@ -49,19 +50,19 @@ using namespace lyx::support; namespace lyx { -// Keep the changes documented in the Customization manual. +// Keep the changes documented in the Customization manual. // // If you change this format, then you MUST also make sure that -// your changes do not invalidate the hardcoded layout file in +// your changes do not invalidate the hardcoded layout file in // LayoutFile.cpp. Additions will never do so, but syntax changes // could. See LayoutFileList::addEmptyClass() and, especially, the -// definition of the layoutpost string. +// definition of the layoutpost string. // You should also run (or ask someone who has bash to run) the -// development/updatelayouts.sh script, to update the format of +// development/tools/updatelayouts.sh script, to update the format of // all of our layout files. // -int const LAYOUT_FORMAT = 27; - +int const LAYOUT_FORMAT = 48; //rgh: initial values for counter + namespace { class LayoutNamesEqual : public unary_function { @@ -104,7 +105,7 @@ bool layout2layout(FileName const & filename, FileName const & tempfile) } -string translateReadType(TextClass::ReadType rt) +string translateReadType(TextClass::ReadType rt) { switch (rt) { case TextClass::BASECLASS: @@ -123,7 +124,7 @@ string translateReadType(TextClass::ReadType rt) } // namespace anon -// This string should not be translated here, +// This string should not be translated here, // because it is a layout identifier. docstring const TextClass::plain_layout_ = from_ascii("Plain Layout"); @@ -147,8 +148,10 @@ TextClass::TextClass() tocdepth_ = 3; pagestyle_ = "default"; defaultfont_ = sane_font; + opt_enginetype_ = "authoryear|numerical"; opt_fontsize_ = "10|11|12"; opt_pagestyle_ = "empty|plain|headings|fancy"; + cite_full_author_list_ = true; titletype_ = TITLE_COMMAND_AFTER; titlename_ = "maketitle"; loaded_ = false; @@ -180,6 +183,7 @@ enum TextClassTags { TC_IFSTYLE, TC_DEFAULTSTYLE, TC_INSETLAYOUT, + TC_NOINSETLAYOUT, TC_NOSTYLE, TC_COLUMNS, TC_SIDES, @@ -190,12 +194,15 @@ enum TextClassTags { TC_CLASSOPTIONS, TC_PREAMBLE, TC_HTMLPREAMBLE, + TC_HTMLSTYLES, TC_PROVIDES, TC_REQUIRES, + TC_PKGOPTS, TC_LEFTMARGIN, TC_RIGHTMARGIN, TC_FLOAT, TC_COUNTER, + TC_NOCOUNTER, TC_IFCOUNTER, TC_NOFLOAT, TC_TITLELATEXNAME, @@ -203,54 +210,68 @@ enum TextClassTags { TC_FORMAT, TC_ADDTOPREAMBLE, TC_ADDTOHTMLPREAMBLE, + TC_ADDTOHTMLSTYLES, TC_DEFAULTMODULE, TC_PROVIDESMODULE, TC_EXCLUDESMODULE, TC_HTMLTOCSECTION, - TC_CITEFORMAT + TC_CITEENGINE, + TC_CITEENGINETYPE, + TC_CITEFORMAT, + TC_DEFAULTBIBLIO, + TC_FULLAUTHORLIST, }; namespace { - LexerKeyword textClassTags[] = { - { "addtohtmlpreamble", TC_ADDTOHTMLPREAMBLE }, - { "addtopreamble", TC_ADDTOPREAMBLE }, - { "citeformat", TC_CITEFORMAT }, - { "classoptions", TC_CLASSOPTIONS }, - { "columns", TC_COLUMNS }, - { "counter", TC_COUNTER }, - { "defaultfont", TC_DEFAULTFONT }, - { "defaultmodule", TC_DEFAULTMODULE }, - { "defaultstyle", TC_DEFAULTSTYLE }, - { "excludesmodule", TC_EXCLUDESMODULE }, - { "float", TC_FLOAT }, - { "format", TC_FORMAT }, - { "htmlpreamble", TC_HTMLPREAMBLE }, - { "htmltocsection", TC_HTMLTOCSECTION }, - { "ifcounter", TC_IFCOUNTER }, - { "ifstyle", TC_IFSTYLE }, - { "input", TC_INPUT }, - { "insetlayout", TC_INSETLAYOUT }, - { "leftmargin", TC_LEFTMARGIN }, - { "nofloat", TC_NOFLOAT }, - { "nostyle", TC_NOSTYLE }, - { "outputformat", TC_OUTPUTFORMAT }, - { "outputtype", TC_OUTPUTTYPE }, - { "pagestyle", TC_PAGESTYLE }, - { "preamble", TC_PREAMBLE }, - { "provides", TC_PROVIDES }, - { "providesmodule", TC_PROVIDESMODULE }, - { "requires", TC_REQUIRES }, - { "rightmargin", TC_RIGHTMARGIN }, - { "secnumdepth", TC_SECNUMDEPTH }, - { "sides", TC_SIDES }, - { "style", TC_STYLE }, - { "titlelatexname", TC_TITLELATEXNAME }, - { "titlelatextype", TC_TITLELATEXTYPE }, - { "tocdepth", TC_TOCDEPTH } - }; - +LexerKeyword textClassTags[] = { + { "addtohtmlpreamble", TC_ADDTOHTMLPREAMBLE }, + { "addtohtmlstyles", TC_ADDTOHTMLSTYLES }, + { "addtopreamble", TC_ADDTOPREAMBLE }, + { "citeengine", TC_CITEENGINE }, + { "citeenginetype", TC_CITEENGINETYPE }, + { "citeformat", TC_CITEFORMAT }, + { "classoptions", TC_CLASSOPTIONS }, + { "columns", TC_COLUMNS }, + { "counter", TC_COUNTER }, + { "defaultbiblio", TC_DEFAULTBIBLIO }, + { "defaultfont", TC_DEFAULTFONT }, + { "defaultmodule", TC_DEFAULTMODULE }, + { "defaultstyle", TC_DEFAULTSTYLE }, + { "excludesmodule", TC_EXCLUDESMODULE }, + { "float", TC_FLOAT }, + { "format", TC_FORMAT }, + { "fullauthorlist", TC_FULLAUTHORLIST }, + { "htmlpreamble", TC_HTMLPREAMBLE }, + { "htmlstyles", TC_HTMLSTYLES }, + { "htmltocsection", TC_HTMLTOCSECTION }, + { "ifcounter", TC_IFCOUNTER }, + { "ifstyle", TC_IFSTYLE }, + { "input", TC_INPUT }, + { "insetlayout", TC_INSETLAYOUT }, + { "leftmargin", TC_LEFTMARGIN }, + { "nocounter", TC_NOCOUNTER }, + { "nofloat", TC_NOFLOAT }, + { "noinsetlayout", TC_NOINSETLAYOUT }, + { "nostyle", TC_NOSTYLE }, + { "outputformat", TC_OUTPUTFORMAT }, + { "outputtype", TC_OUTPUTTYPE }, + { "packageoptions", TC_PKGOPTS }, + { "pagestyle", TC_PAGESTYLE }, + { "preamble", TC_PREAMBLE }, + { "provides", TC_PROVIDES }, + { "providesmodule", TC_PROVIDESMODULE }, + { "requires", TC_REQUIRES }, + { "rightmargin", TC_RIGHTMARGIN }, + { "secnumdepth", TC_SECNUMDEPTH }, + { "sides", TC_SIDES }, + { "style", TC_STYLE }, + { "titlelatexname", TC_TITLELATEXNAME }, + { "titlelatextype", TC_TITLELATEXTYPE }, + { "tocdepth", TC_TOCDEPTH } +}; + } //namespace anon @@ -266,6 +287,29 @@ bool TextClass::convertLayoutFormat(support::FileName const & filename, ReadType } +std::string TextClass::convert(std::string const & str) +{ + FileName const fn = FileName::tempName("locallayout"); + ofstream os(fn.toFilesystemEncoding().c_str()); + os << str; + os.close(); + FileName const tempfile = FileName::tempName("convert_locallayout"); + bool success = layout2layout(fn, tempfile); + if (!success) + return ""; + ifstream is(tempfile.toFilesystemEncoding().c_str()); + string ret; + string tmp; + while (!is.eof()) { + getline(is, tmp); + ret += tmp + '\n'; + } + is.close(); + tempfile.removeFile(); + return ret; +} + + TextClass::ReturnValues TextClass::readWithoutConv(FileName const & filename, ReadType rt) { if (!filename.isReadableFile()) { @@ -277,8 +321,8 @@ TextClass::ReturnValues TextClass::readWithoutConv(FileName const & filename, Re LYXERR(Debug::TCLASS, "Reading " + translateReadType(rt) + ": " + to_utf8(makeDisplayPath(filename.absFileName()))); - // Define the plain layout used in table cells, ert, etc. Note that - // we do this before loading any layout file, so that classes can + // Define the plain layout used in table cells, ert, etc. Note that + // we do this before loading any layout file, so that classes can // override features of this layout if they should choose to do so. if (rt == BASECLASS && !hasLayout(plain_layout_)) layoutlist_.push_back(createBasicLayout(plain_layout_)); @@ -286,7 +330,7 @@ TextClass::ReturnValues TextClass::readWithoutConv(FileName const & filename, Re Lexer lexrc(textClassTags); lexrc.setFile(filename); ReturnValues retval = read(lexrc, rt); - + LYXERR(Debug::TCLASS, "Finished reading " + translateReadType(rt) + ": " + to_utf8(makeDisplayPath(filename.absFileName()))); @@ -301,38 +345,36 @@ bool TextClass::read(FileName const & filename, ReadType rt) return retval == OK; bool const worx = convertLayoutFormat(filename, rt); - if (!worx) { - LYXERR0 ("Unable to convert " << filename << + if (!worx) + LYXERR0 ("Unable to convert " << filename << " to format " << LAYOUT_FORMAT); - return false; - } - return true; + return worx; } -bool TextClass::validate(std::string const & str) +TextClass::ReturnValues TextClass::validate(std::string const & str) { TextClass tc; return tc.read(str, VALIDATION); } -bool TextClass::read(std::string const & str, ReadType rt) +TextClass::ReturnValues TextClass::read(std::string const & str, ReadType rt) { Lexer lexrc(textClassTags); istringstream is(str); lexrc.setStream(is); ReturnValues retval = read(lexrc, rt); - if (retval != FORMAT_MISMATCH) - return retval == OK; + if (retval != FORMAT_MISMATCH) + return retval; // write the layout string to a temporary file FileName const tempfile = FileName::tempName("TextClass_read"); ofstream os(tempfile.toFilesystemEncoding().c_str()); if (!os) { LYXERR0("Unable to create temporary file"); - return false; + return ERROR; } os << str; os.close(); @@ -340,16 +382,17 @@ bool TextClass::read(std::string const & str, ReadType rt) // now try to convert it bool const worx = convertLayoutFormat(tempfile, rt); if (!worx) { - LYXERR0("Unable to convert internal layout information to format " + LYXERR0("Unable to convert internal layout information to format " << LAYOUT_FORMAT); + return ERROR; } tempfile.removeFile(); - return worx; + return OK_OLDFORMAT; } // Reads a textclass structure from file. -TextClass::ReturnValues TextClass::read(Lexer & lexrc, ReadType rt) +TextClass::ReturnValues TextClass::read(Lexer & lexrc, ReadType rt) { if (!lexrc.isOK()) return ERROR; @@ -487,6 +530,16 @@ TextClass::ReturnValues TextClass::read(Lexer & lexrc, ReadType rt) } break; + case TC_NOINSETLAYOUT: + if (lexrc.next()) { + docstring const style = from_utf8(subst(lexrc.getString(), + '_', ' ')); + if (!deleteInsetLayout(style)) + LYXERR0("Style `" << style << "' cannot be removed\n" + "because it was not found!"); + } + break; + case TC_COLUMNS: if (lexrc.next()) columns_ = lexrc.getInteger(); @@ -543,7 +596,11 @@ TextClass::ReturnValues TextClass::read(Lexer & lexrc, ReadType rt) case TC_HTMLPREAMBLE: htmlpreamble_ = from_utf8(lexrc.getLongString("EndPreamble")); break; - + + case TC_HTMLSTYLES: + htmlstyles_ = from_utf8(lexrc.getLongString("EndStyles")); + break; + case TC_HTMLTOCSECTION: html_toc_section_ = from_utf8(trim(lexrc.getString())); break; @@ -556,6 +613,10 @@ TextClass::ReturnValues TextClass::read(Lexer & lexrc, ReadType rt) htmlpreamble_ += from_utf8(lexrc.getLongString("EndPreamble")); break; + case TC_ADDTOHTMLSTYLES: + htmlstyles_ += from_utf8(lexrc.getLongString("EndStyles")); + break; + case TC_PROVIDES: { lexrc.next(); string const feature = lexrc.getString(); @@ -569,12 +630,21 @@ TextClass::ReturnValues TextClass::read(Lexer & lexrc, ReadType rt) case TC_REQUIRES: { lexrc.eatLine(); - vector const req + vector const req = getVectorFromString(lexrc.getString()); requires_.insert(req.begin(), req.end()); break; } + case TC_PKGOPTS : { + lexrc.next(); + string const pkg = lexrc.getString(); + lexrc.next(); + string const options = lexrc.getString(); + package_options_[pkg] = options; + break; + } + case TC_DEFAULTMODULE: { lexrc.next(); string const module = lexrc.getString(); @@ -647,9 +717,36 @@ TextClass::ReturnValues TextClass::read(Lexer & lexrc, ReadType rt) case TC_FLOAT: error = !readFloat(lexrc); break; - + + case TC_CITEENGINE: + error = !readCiteEngine(lexrc); + break; + + case TC_CITEENGINETYPE: + if (lexrc.next()) + opt_enginetype_ = rtrim(lexrc.getString()); + break; + case TC_CITEFORMAT: - readCiteFormat(lexrc); + error = !readCiteFormat(lexrc); + break; + + case TC_DEFAULTBIBLIO: + if (lexrc.next()) + cite_default_biblio_style_ = rtrim(lexrc.getString()); + break; + + case TC_FULLAUTHORLIST: + if (lexrc.next()) + cite_full_author_list_ &= lexrc.getBool(); + break; + + case TC_NOCOUNTER: + if (lexrc.next()) { + docstring const cnt = lexrc.getDocString(); + if (!counters_.remove(cnt)) + LYXERR0("Unable to remove counter: " + to_utf8(cnt)); + } break; case TC_IFCOUNTER: @@ -712,8 +809,8 @@ TextClass::ReturnValues TextClass::read(Lexer & lexrc, ReadType rt) << "' is missing a defaultstyle."); return ERROR; } - - // Try to erase "stdinsets" from the provides_ set. + + // Try to erase "stdinsets" from the provides_ set. // The // Provides stdinsets 1 // declaration simply tells us that the standard insets have been @@ -869,25 +966,117 @@ void TextClass::readClassOptions(Lexer & lexrc) } -void TextClass::readCiteFormat(Lexer & lexrc) +bool TextClass::readCiteEngine(Lexer & lexrc) { + int const type = readCiteEngineType(lexrc); + if (type & ENGINE_TYPE_AUTHORYEAR) + cite_styles_[ENGINE_TYPE_AUTHORYEAR].clear(); + if (type & ENGINE_TYPE_NUMERICAL) + cite_styles_[ENGINE_TYPE_NUMERICAL].clear(); + if (type & ENGINE_TYPE_DEFAULT) + cite_styles_[ENGINE_TYPE_DEFAULT].clear(); + string def; + bool getout = false; + while (!getout && lexrc.isOK()) { + lexrc.eatLine(); + def = lexrc.getString(); + def = subst(def, " ", ""); + def = subst(def, "\t", ""); + if (compare_ascii_no_case(def, "end") == 0) { + getout = true; + continue; + } + string cmd; + CitationStyle cs; + char ichar = def[0]; + if (ichar == '#') + continue; + if (ichar == 'C') { + cs.forceUpperCase = true; + def[0] = 'c'; + } + + size_t const n = def.size(); + for (size_t i = 0; i != n; ++i) { + ichar = def[i]; + if (ichar == '*') + cs.fullAuthorList = true; + else if (ichar == '[' && cs.textAfter) + cs.textBefore = true; + else if (ichar == '[') + cs.textAfter = true; + else if (ichar != ']') + cmd += ichar; + } + + cs.cmd = cmd; + if (type & ENGINE_TYPE_AUTHORYEAR) + cite_styles_[ENGINE_TYPE_AUTHORYEAR].push_back(cs); + if (type & ENGINE_TYPE_NUMERICAL) + cite_styles_[ENGINE_TYPE_NUMERICAL].push_back(cs); + if (type & ENGINE_TYPE_DEFAULT) + cite_styles_[ENGINE_TYPE_DEFAULT].push_back(cs); + } + return getout; +} + + +int TextClass::readCiteEngineType(Lexer & lexrc) const +{ + LATTEST(ENGINE_TYPE_DEFAULT == + (ENGINE_TYPE_AUTHORYEAR | ENGINE_TYPE_NUMERICAL)); + if (!lexrc.next()) { + lexrc.printError("No cite engine type given for token: `$$Token'."); + return ENGINE_TYPE_DEFAULT; + } + string const type = rtrim(lexrc.getString()); + if (compare_ascii_no_case(type, "authoryear") == 0) + return ENGINE_TYPE_AUTHORYEAR; + else if (compare_ascii_no_case(type, "numerical") == 0) + return ENGINE_TYPE_NUMERICAL; + else if (compare_ascii_no_case(type, "default") != 0) { + string const s = "Unknown cite engine type `" + type + + "' given for token: `$$Token',"; + lexrc.printError(s); + } + return ENGINE_TYPE_DEFAULT; +} + + +bool TextClass::readCiteFormat(Lexer & lexrc) +{ + int const type = readCiteEngineType(lexrc); string etype; string definition; while (lexrc.isOK()) { lexrc.next(); etype = lexrc.getString(); - if (!lexrc.isOK() || compare_ascii_no_case(etype, "end") == 0) + if (compare_ascii_no_case(etype, "end") == 0) break; + if (!lexrc.isOK()) + return false; lexrc.eatLine(); definition = lexrc.getString(); char initchar = etype[0]; if (initchar == '#') continue; - if (initchar == '!' || initchar == '_') - cite_macros_[etype] = definition; - else - cite_formats_[etype] = definition; + if (initchar == '!' || initchar == '_') { + if (type & ENGINE_TYPE_AUTHORYEAR) + cite_macros_[ENGINE_TYPE_AUTHORYEAR][etype] = definition; + if (type & ENGINE_TYPE_NUMERICAL) + cite_macros_[ENGINE_TYPE_NUMERICAL][etype] = definition; + if (type & ENGINE_TYPE_DEFAULT) + cite_macros_[ENGINE_TYPE_DEFAULT][etype] = definition; + } else { + if (type & ENGINE_TYPE_AUTHORYEAR) + cite_formats_[ENGINE_TYPE_AUTHORYEAR][etype] = definition; + if (type & ENGINE_TYPE_NUMERICAL) + cite_formats_[ENGINE_TYPE_NUMERICAL][etype] = definition; + if (type & ENGINE_TYPE_DEFAULT) + cite_formats_[ENGINE_TYPE_DEFAULT][etype] = definition; + } } + return true; } @@ -901,7 +1090,8 @@ bool TextClass::readFloat(Lexer & lexrc) FT_WITHIN, FT_STYLE, FT_LISTNAME, - FT_NEEDSFLOAT, + FT_USESFLOAT, + FT_PREDEFINED, FT_HTMLSTYLE, FT_HTMLATTR, FT_HTMLTAG, @@ -917,14 +1107,15 @@ bool TextClass::readFloat(Lexer & lexrc) { "htmlattr", FT_HTMLATTR }, { "htmlstyle", FT_HTMLSTYLE }, { "htmltag", FT_HTMLTAG }, + { "ispredefined", FT_PREDEFINED }, { "listcommand", FT_LISTCOMMAND }, { "listname", FT_LISTNAME }, - { "needsfloatpkg", FT_NEEDSFLOAT }, { "numberwithin", FT_WITHIN }, { "placement", FT_PLACEMENT }, { "refprefix", FT_REFPREFIX }, { "style", FT_STYLE }, - { "type", FT_TYPE } + { "type", FT_TYPE }, + { "usesfloatpkg", FT_USESFLOAT } }; lexrc.pushTable(floatTags); @@ -941,7 +1132,8 @@ bool TextClass::readFloat(Lexer & lexrc) string style; string type; string within; - bool needsfloat = true; + bool usesfloat = true; + bool ispredefined = false; bool getout = false; while (!getout && lexrc.isOK()) { @@ -965,10 +1157,11 @@ bool TextClass::readFloat(Lexer & lexrc) style = fl.style(); name = fl.name(); listname = fl.listName(); - needsfloat = fl.needsFloatPkg(); + usesfloat = fl.usesFloatPkg(); + ispredefined = fl.isPredefined(); listcommand = fl.listCommand(); refprefix = fl.refPrefix(); - } + } break; case FT_NAME: lexrc.next(); @@ -1004,9 +1197,13 @@ bool TextClass::readFloat(Lexer & lexrc) lexrc.next(); listname = lexrc.getString(); break; - case FT_NEEDSFLOAT: + case FT_USESFLOAT: + lexrc.next(); + usesfloat = lexrc.getBool(); + break; + case FT_PREDEFINED: lexrc.next(); - needsfloat = lexrc.getBool(); + ispredefined = lexrc.getBool(); break; case FT_HTMLATTR: lexrc.next(); @@ -1030,13 +1227,26 @@ bool TextClass::readFloat(Lexer & lexrc) // Here we have a full float if getout == true if (getout) { - if (!needsfloat && listcommand.empty()) - LYXERR0("The layout does not provide a list command " << - "for the builtin float `" << type << "'. LyX will " << - "not be able to produce a float list."); - Floating fl(type, placement, ext, within, style, name, - listname, listcommand, refprefix, - htmltag, htmlattr, htmlstyle, needsfloat); + if (!usesfloat && listcommand.empty()) { + // if this float uses the same auxfile as an existing one, + // there is no need for it to provide a list command. + FloatList::const_iterator it = floatlist_.begin(); + FloatList::const_iterator en = floatlist_.end(); + bool found_ext = false; + for (; it != en; ++it) { + if (it->second.ext() == ext) { + found_ext = true; + break; + } + } + if (!found_ext) + LYXERR0("The layout does not provide a list command " << + "for the float `" << type << "'. LyX will " << + "not be able to produce a float list."); + } + Floating fl(type, placement, ext, within, style, name, + listname, listcommand, refprefix, + htmltag, htmlattr, htmlstyle, usesfloat, ispredefined); floatlist_.newFloat(fl); // each float has its own counter counters_.newCounter(from_ascii(type), from_ascii(within), @@ -1050,15 +1260,16 @@ bool TextClass::readFloat(Lexer & lexrc) } -string const & TextClass::prerequisites() const -{ +string const & TextClass::prerequisites(string const & sep) const +{ if (contains(prerequisites_, ',')) { vector const pres = getVectorFromString(prerequisites_); - prerequisites_ = getStringFromVector(pres, "\n\t"); + prerequisites_ = getStringFromVector(pres, sep); } - return prerequisites_; + return prerequisites_; } + bool TextClass::hasLayout(docstring const & n) const { docstring const name = n.empty() ? defaultLayoutName() : n; @@ -1071,33 +1282,29 @@ bool TextClass::hasLayout(docstring const & n) const bool TextClass::hasInsetLayout(docstring const & n) const { - if (n.empty()) + if (n.empty()) return false; - InsetLayouts::const_iterator it = insetlayoutlist_.begin(); - InsetLayouts::const_iterator en = insetlayoutlist_.end(); - for (; it != en; ++it) - if (n == it->first) - return true; - return false; + InsetLayouts::const_iterator it = insetlayoutlist_.find(n); + return it != insetlayoutlist_.end(); } Layout const & TextClass::operator[](docstring const & name) const { - LASSERT(!name.empty(), /**/); + LATTEST(!name.empty()); - const_iterator it = + const_iterator it = find_if(begin(), end(), LayoutNamesEqual(name)); if (it == end()) { - lyxerr << "We failed to find the layout '" << to_utf8(name) - << "' in the layout list. You MUST investigate!" - << endl; + LYXERR0("We failed to find the layout '" << name + << "' in the layout list. You MUST investigate!"); for (const_iterator cit = begin(); cit != end(); ++cit) lyxerr << " " << to_utf8(cit->name()) << endl; - // we require the name to exist - LASSERT(false, /**/); + // We require the name to exist + static const Layout dummy; + LASSERT(false, return dummy); } return *it; @@ -1106,7 +1313,8 @@ Layout const & TextClass::operator[](docstring const & name) const Layout & TextClass::operator[](docstring const & name) { - LASSERT(!name.empty(), /**/); + LATTEST(!name.empty()); + // Safe to continue, given what we do below. iterator it = find_if(begin(), end(), LayoutNamesEqual(name)); @@ -1117,7 +1325,10 @@ Layout & TextClass::operator[](docstring const & name) LYXERR0(" " << to_utf8(cit->name())); // we require the name to exist - LASSERT(false, /**/); + LATTEST(false); + // we are here only in release mode + layoutlist_.push_back(createBasicLayout(name, true)); + it = find_if(begin(), end(), LayoutNamesEqual(name)); } return *it; @@ -1140,6 +1351,12 @@ bool TextClass::deleteLayout(docstring const & name) } +bool TextClass::deleteInsetLayout(docstring const & name) +{ + return insetlayoutlist_.erase(name); +} + + // Load textclass info if not loaded yet bool TextClass::load(string const & path) const { @@ -1160,7 +1377,7 @@ bool TextClass::load(string const & path) const << to_utf8(makeDisplayPath(layout_file.absFileName())) << "'\n(Check `" << name_ << "')\nCheck your installation and " - "try Options/Reconfigure..." + "try Options/Reconfigure..." << endl; } @@ -1168,14 +1385,35 @@ bool TextClass::load(string const & path) const } -void DocumentClass::addLayoutIfNeeded(docstring const & n) const +bool DocumentClass::addLayoutIfNeeded(docstring const & n) const { - if (!hasLayout(n)) - layoutlist_.push_back(createBasicLayout(n, true)); + if (hasLayout(n)) + return false; + + layoutlist_.push_back(createBasicLayout(n, true)); + return true; +} + + +string DocumentClass::forcedLayouts() const +{ + ostringstream os; + bool first = true; + const_iterator const e = end(); + for (const_iterator i = begin(); i != e; ++i) { + if (i->forcelocal > 0) { + if (first) { + os << "Format " << LAYOUT_FORMAT << '\n'; + first = false; + } + i->write(os); + } + } + return os.str(); } -InsetLayout const & DocumentClass::insetLayout(docstring const & name) const +InsetLayout const & DocumentClass::insetLayout(docstring const & name) const { // FIXME The fix for the InsetLayout part of 4812 would be here: // Add the InsetLayout to the document class if it is not found. @@ -1196,7 +1434,6 @@ InsetLayout const & DocumentClass::insetLayout(docstring const & name) const docstring const & TextClass::defaultLayoutName() const { - // This really should come from the actual layout... (Lgb) return defaultlayout_; } @@ -1207,13 +1444,13 @@ Layout const & TextClass::defaultLayout() const } -bool TextClass::isDefaultLayout(Layout const & layout) const +bool TextClass::isDefaultLayout(Layout const & layout) const { return layout.name() == defaultLayoutName(); } -bool TextClass::isPlainLayout(Layout const & layout) const +bool TextClass::isPlainLayout(Layout const & layout) const { return layout.name() == plainLayoutName(); } @@ -1245,47 +1482,20 @@ Layout TextClass::createBasicLayout(docstring const & name, bool unknown) const if (!readStyle(lex, *defaultLayout)) { // The only way this happens is because the hardcoded layout above // is wrong. - LASSERT(false, /**/); + LATTEST(false); }; return *defaultLayout; } -///////////////////////////////////////////////////////////////////////// -// -// DocumentClassBundle -// -///////////////////////////////////////////////////////////////////////// - -DocumentClassBundle::~DocumentClassBundle() -{ - for (size_t i = 0; i != documentClasses_.size(); ++i) - delete documentClasses_[i]; - documentClasses_.clear(); -} - -DocumentClass & DocumentClassBundle::newClass(LayoutFile const & baseClass) -{ - DocumentClass * dc = new DocumentClass(baseClass); - documentClasses_.push_back(dc); - return *documentClasses_.back(); -} - - -DocumentClassBundle & DocumentClassBundle::get() -{ - static DocumentClassBundle singleton; - return singleton; -} - - -DocumentClass & DocumentClassBundle::makeDocumentClass( +DocumentClassPtr getDocumentClass( LayoutFile const & baseClass, LayoutModuleList const & modlist) { - DocumentClass & doc_class = newClass(baseClass); + DocumentClassPtr doc_class = + DocumentClassPtr(new DocumentClass(baseClass)); LayoutModuleList::const_iterator it = modlist.begin(); LayoutModuleList::const_iterator en = modlist.end(); - for (; it != en; it++) { + for (; it != en; ++it) { string const modName = *it; LyXModule * lm = theModuleList[modName]; if (!lm) { @@ -1298,14 +1508,19 @@ DocumentClass & DocumentClassBundle::makeDocumentClass( continue; } if (!lm->isAvailable()) { + docstring const prereqs = from_utf8(getStringFromVector(lm->prerequisites(), "\n\t")); docstring const msg = - bformat(_("The module %1$s requires a package that is\n" - "not available in your LaTeX installation. LaTeX output\n" - "may not be possible.\n"), from_utf8(modName)); - frontend::Alert::warning(_("Package not available"), msg); + bformat(_("The module %1$s requires a package that is not\n" + "available in your LaTeX installation, or a converter that\n" + "you have not installed. LaTeX output may not be possible.\n" + "Missing prerequisites:\n" + "\t%2$s\n" + "See section 3.1.2.3 (Modules) of the User's Guide for more information."), + from_utf8(modName), prereqs); + frontend::Alert::warning(_("Package not available"), msg, true); } FileName layout_file = libFileSearch("layouts", lm->getFilename()); - if (!doc_class.read(layout_file, TextClass::MODULE)) { + if (!doc_class->read(layout_file, TextClass::MODULE)) { docstring const msg = bformat(_("Error reading module %1$s\n"), from_utf8(modName)); frontend::Alert::warning(_("Read Error"), msg); @@ -1349,50 +1564,91 @@ bool DocumentClass::hasTocLevels() const } -Layout const & DocumentClass::htmlTOCLayout() const +Layout const & DocumentClass::getTOCLayout() const { - if (html_toc_section_.empty()) { - // we're going to look for the layout with the minimum toclevel - TextClass::LayoutList::const_iterator lit = begin(); - TextClass::LayoutList::const_iterator const len = end(); - int minlevel = 1000; - Layout const * lay = NULL; - for (; lit != len; ++lit) { - int const level = lit->toclevel; - // we don't want Part - if (level == Layout::NOT_IN_TOC || level < 0 || level >= minlevel) - continue; - lay = &*lit; - minlevel = level; - } - if (lay) - html_toc_section_ = lay->name(); - else - // hmm. that is very odd, so we'll do our best - html_toc_section_ = defaultLayoutName(); + // we're going to look for the layout with the minimum toclevel + TextClass::LayoutList::const_iterator lit = begin(); + TextClass::LayoutList::const_iterator const len = end(); + int minlevel = 1000; + Layout const * lay = NULL; + for (; lit != len; ++lit) { + int const level = lit->toclevel; + // we don't want Part or unnumbered sections + if (level == Layout::NOT_IN_TOC || level < 0 + || level >= minlevel || lit->counter.empty()) + continue; + lay = &*lit; + minlevel = level; } + if (lay) + return *lay; + // hmm. that is very odd, so we'll do our best. + return operator[](defaultLayoutName()); +} + + +Layout const & DocumentClass::htmlTOCLayout() const +{ + if (html_toc_section_.empty()) + html_toc_section_ = getTOCLayout().name(); return operator[](html_toc_section_); } -string const & DocumentClass::getCiteFormat(string const & entry_type) const +string const & DocumentClass::getCiteFormat(CiteEngineType const & type, + string const & entry, string const & fallback) const { - static string default_format = N_("{%author%[[%author%, ]][[{%editor%[[%editor%, ed., ]]}]]}\"%title%\"{%journal%[[, {!!}%journal%{!!}]][[{%publisher%[[, %publisher%]][[{%institution%[[, %institution%]]}]]}]]}{%year%[[ (%year%)]]}{%pages%[[, %pages%]]}."); - - map::const_iterator it = cite_formats_.find(entry_type); - if (it != cite_formats_.end()) - return it->second; - return default_format; + static string default_format = "{%author%[[%author%, ]][[{%editor%[[%editor%, ed., ]]}]]}\"%title%\"{%journal%[[, {!!}%journal%{!!}]][[{%publisher%[[, %publisher%]][[{%institution%[[, %institution%]]}]]}]]}{%year%[[ (%year%)]]}{%pages%[[, %pages%]]}."; + + map >::const_iterator itype = cite_formats_.find(type); + if (itype == cite_formats_.end()) + return default_format; + map::const_iterator it = itype->second.find(entry); + if (it == itype->second.end() && !fallback.empty()) + it = itype->second.find(fallback); + if (it == itype->second.end()) + return default_format; + return it->second; } -string const & DocumentClass::getCiteMacro(string const & macro) const +string const & DocumentClass::getCiteMacro(CiteEngineType const & type, + string const & macro) const { static string empty; - map::const_iterator it = cite_macros_.find(macro); - if (it != cite_macros_.end()) - return it->second; - return empty; + map >::const_iterator itype = cite_macros_.find(type); + if (itype == cite_macros_.end()) + return empty; + map::const_iterator it = itype->second.find(macro); + if (it == itype->second.end()) + return empty; + return it->second; +} + + +vector const DocumentClass::citeCommands( + CiteEngineType const & type) const +{ + vector const styles = citeStyles(type); + vector::const_iterator it = styles.begin(); + vector::const_iterator end = styles.end(); + vector cmds; + for (; it != end; ++it) { + CitationStyle const cite = *it; + cmds.push_back(cite.cmd); + } + return cmds; +} + + +vector const & DocumentClass::citeStyles( + CiteEngineType const & type) const +{ + static vector empty; + map >::const_iterator it = cite_styles_.find(type); + if (it == cite_styles_.end()) + return empty; + return it->second; }