X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FTextClass.cpp;h=92adfdc7507dd7173dfa7c9bfe6f764baff46fcc;hb=55a3dd7b346d29a52ba305a4558e9e380ef50f47;hp=f1b1df7eaab855ac78b1d13843d9f45479f23ac1;hpb=cdf13782003f6fca74b267c6b23d76bb9edaa65c;p=lyx.git diff --git a/src/TextClass.cpp b/src/TextClass.cpp index f1b1df7eaa..92adfdc750 100644 --- a/src/TextClass.cpp +++ b/src/TextClass.cpp @@ -3,11 +3,11 @@ * This file is part of LyX, the document processor. * Licence details can be found in the file COPYING. * - * \author Lars Gullik Bjønnes + * \author Lars Gullik Bjønnes * \author Jean-Marc Lasgouttes * \author Angus Leeming * \author John Levon - * \author André Pönitz + * \author André Pönitz * * Full author contact details are available in file CREDITS. */ @@ -16,99 +16,131 @@ #include "TextClass.h" +#include "LayoutFile.h" #include "Color.h" #include "Counters.h" -#include "debug.h" -#include "gettext.h" #include "Floating.h" #include "FloatList.h" #include "Layout.h" #include "Lexer.h" +#include "Font.h" +#include "ModuleList.h" #include "frontends/alert.h" -#include "support/lstrings.h" -#include "support/lyxlib.h" +#include "support/lassert.h" +#include "support/debug.h" +#include "support/FileName.h" #include "support/filetools.h" +#include "support/gettext.h" +#include "support/lstrings.h" #include "support/os.h" +#include +#include #include -using std::endl; -using std::find_if; -using std::remove_if; -using std::string; -using std::ostream; +#ifdef ERROR +#undef ERROR +#endif -namespace lyx { +using namespace std; +using namespace lyx::support; -using support::FileName; -using support::libFileSearch; -using support::makeDisplayPath; -using support::quoteName; -using support::rtrim; -using support::subst; -using support::addName; +namespace lyx { -extern FontInfo lyxRead(Lexer &, FontInfo const & fi = sane_font); +// 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 +// LayoutFile.cpp. Additions will never do so, but syntax changes +// could. See LayoutFileList::addEmptyClass() and, especially, the +// 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 +// all of our layout files. +// +int const LAYOUT_FORMAT = 36; namespace { -class LayoutNamesEqual : public std::unary_function { +class LayoutNamesEqual : public unary_function { public: LayoutNamesEqual(docstring const & name) : name_(name) {} - bool operator()(LayoutPtr const & c) const + bool operator()(Layout const & c) const { - return c->name() == name_; + return c.name() == name_; } private: docstring name_; }; -int const FORMAT = 5; - - bool layout2layout(FileName const & filename, FileName const & tempfile) { FileName const script = libFileSearch("scripts", "layout2layout.py"); if (script.empty()) { - lyxerr << "Could not find layout conversion " - "script layout2layout.py." << endl; + LYXERR0("Could not find layout conversion " + "script layout2layout.py."); return false; } - std::ostringstream command; - command << support::os::python() << ' ' << quoteName(script.toFilesystemEncoding()) + ostringstream command; + command << os::python() << ' ' << quoteName(script.toFilesystemEncoding()) << ' ' << quoteName(filename.toFilesystemEncoding()) << ' ' << quoteName(tempfile.toFilesystemEncoding()); string const command_str = command.str(); - LYXERR(Debug::TCLASS) << "Running `" << command_str << '\'' << endl; + LYXERR(Debug::TCLASS, "Running `" << command_str << '\''); - support::cmd_ret const ret = - support::runCommand(command_str); + cmd_ret const ret = runCommand(command_str); if (ret.first != 0) { - lyxerr << "Could not run layout conversion " - "script layout2layout.py." << endl; + LYXERR0("Could not run layout conversion script layout2layout.py."); return false; } return true; } + +string translateReadType(TextClass::ReadType rt) +{ + switch (rt) { + case TextClass::BASECLASS: + return "textclass"; + case TextClass::MERGE: + return "input file"; + case TextClass::MODULE: + return "module file"; + case TextClass::VALIDATION: + return "validation"; + } + // shutup warning + return string(); +} + } // namespace anon -TextClass::TextClass(string const & fn, string const & cln, - string const & desc, bool texClassAvail ) - : name_(fn), latexname_(cln), description_(desc), - floatlist_(new FloatList), counters_(new Counters), - texClassAvail_(texClassAvail) +// This string should not be translated here, +// because it is a layout identifier. +docstring const TextClass::plain_layout_ = from_ascii("Plain Layout"); + + +InsetLayout DocumentClass::plain_insetlayout_; + + +///////////////////////////////////////////////////////////////////////// +// +// TextClass +// +///////////////////////////////////////////////////////////////////////// + +TextClass::TextClass() { - modular_ = false; outputType_ = LATEX; + outputFormat_ = "latex"; columns_ = 1; sides_ = OneSide; secnumdepth_ = 3; @@ -120,38 +152,34 @@ TextClass::TextClass(string const & fn, string const & cln, titletype_ = TITLE_COMMAND_AFTER; titlename_ = "maketitle"; loaded_ = false; + _("Plain Layout"); // a hack to make this translatable } -bool TextClass::isTeXClassAvailable() const +bool TextClass::readStyle(Lexer & lexrc, Layout & lay) const { - return texClassAvail_; -} - - -bool TextClass::readStyle(Lexer & lexrc, Layout & lay) -{ - LYXERR(Debug::TCLASS) << "Reading style " << to_utf8(lay.name()) << endl; + LYXERR(Debug::TCLASS, "Reading style " << to_utf8(lay.name())); if (!lay.read(lexrc, *this)) { - // Resolve fonts - lay.resfont = lay.font; - lay.resfont.realize(defaultfont()); - lay.reslabelfont = lay.labelfont; - lay.reslabelfont.realize(defaultfont()); - return false; // no errors + LYXERR0("Error parsing style `" << to_utf8(lay.name()) << '\''); + return false; } - lyxerr << "Error parsing style `" << to_utf8(lay.name()) << '\'' << endl; - return true; + // Resolve fonts + lay.resfont = lay.font; + lay.resfont.realize(defaultfont_); + lay.reslabelfont = lay.labelfont; + lay.reslabelfont.realize(defaultfont_); + return true; // no errors } enum TextClassTags { TC_OUTPUTTYPE = 1, + TC_OUTPUTFORMAT, TC_INPUT, TC_STYLE, + TC_IFSTYLE, TC_DEFAULTSTYLE, TC_INSETLAYOUT, - TC_ENVIRONMENT, TC_NOSTYLE, TC_COLUMNS, TC_SIDES, @@ -161,78 +189,202 @@ enum TextClassTags { TC_TOCDEPTH, TC_CLASSOPTIONS, TC_PREAMBLE, + TC_HTMLPREAMBLE, + TC_HTMLSTYLES, TC_PROVIDES, + TC_REQUIRES, TC_LEFTMARGIN, TC_RIGHTMARGIN, TC_FLOAT, TC_COUNTER, + TC_NOCOUNTER, + TC_IFCOUNTER, TC_NOFLOAT, TC_TITLELATEXNAME, TC_TITLELATEXTYPE, - TC_FORMAT + TC_FORMAT, + TC_ADDTOPREAMBLE, + TC_ADDTOHTMLPREAMBLE, + TC_ADDTOHTMLSTYLES, + TC_DEFAULTMODULE, + TC_PROVIDESMODULE, + TC_EXCLUDESMODULE, + TC_HTMLTOCSECTION, + TC_CITEFORMAT }; -// Reads a textclass structure from file. -bool TextClass::read(FileName const & filename, ReadType rt) +namespace { + + LexerKeyword textClassTags[] = { + { "addtohtmlpreamble", TC_ADDTOHTMLPREAMBLE }, + { "addtohtmlstyles", TC_ADDTOHTMLSTYLES }, + { "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 }, + { "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 }, + { "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 } + }; + +} //namespace anon + + +bool TextClass::convertLayoutFormat(support::FileName const & filename, ReadType rt) +{ + LYXERR(Debug::TCLASS, "Converting layout file to " << LAYOUT_FORMAT); + FileName const tempfile = FileName::tempName("convert_layout"); + bool success = layout2layout(filename, tempfile); + if (success) + success = readWithoutConv(tempfile, rt) == OK; + tempfile.removeFile(); + return success; +} + + +std::string TextClass::convert(std::string const & str) { - if (!filename.isFileReadable()) { + 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()) { lyxerr << "Cannot read layout file `" << filename << "'." << endl; - return true; + return ERROR; } - keyword_item textClassTags[] = { - { "classoptions", TC_CLASSOPTIONS }, - { "columns", TC_COLUMNS }, - { "counter", TC_COUNTER }, - { "defaultfont", TC_DEFAULTFONT }, - { "defaultstyle", TC_DEFAULTSTYLE }, - { "environment", TC_ENVIRONMENT }, - { "float", TC_FLOAT }, - { "format", TC_FORMAT }, - { "input", TC_INPUT }, - { "insetlayout", TC_INSETLAYOUT }, - { "leftmargin", TC_LEFTMARGIN }, - { "nofloat", TC_NOFLOAT }, - { "nostyle", TC_NOSTYLE }, - { "outputtype", TC_OUTPUTTYPE }, - { "pagestyle", TC_PAGESTYLE }, - { "preamble", TC_PREAMBLE }, - { "provides", TC_PROVIDES }, - { "rightmargin", TC_RIGHTMARGIN }, - { "secnumdepth", TC_SECNUMDEPTH }, - { "sides", TC_SIDES }, - { "style", TC_STYLE }, - { "titlelatexname", TC_TITLELATEXNAME }, - { "titlelatextype", TC_TITLELATEXTYPE }, - { "tocdepth", TC_TOCDEPTH } - }; + LYXERR(Debug::TCLASS, "Reading " + translateReadType(rt) + ": " + + to_utf8(makeDisplayPath(filename.absFileName()))); - switch (rt) { - case BASECLASS: - LYXERR(Debug::TCLASS) << "Reading textclass "; - break; - case MERGE: - LYXERR(Debug::TCLASS) << "Reading input file "; - break; - case MODULE: - LYXERR(Debug::TCLASS) << "Reading module file "; - break; - default: - BOOST_ASSERT(false); + // 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_)); + + Lexer lexrc(textClassTags); + lexrc.setFile(filename); + ReturnValues retval = read(lexrc, rt); + + LYXERR(Debug::TCLASS, "Finished reading " + translateReadType(rt) + ": " + + to_utf8(makeDisplayPath(filename.absFileName()))); + + return retval; +} + + +bool TextClass::read(FileName const & filename, ReadType rt) +{ + ReturnValues const retval = readWithoutConv(filename, rt); + if (retval != FORMAT_MISMATCH) + return retval == OK; + + bool const worx = convertLayoutFormat(filename, rt); + if (!worx) + LYXERR0 ("Unable to convert " << filename << + " to format " << LAYOUT_FORMAT); + return worx; +} + + +TextClass::ReturnValues TextClass::validate(std::string const & str) +{ + TextClass tc; + return tc.read(str, VALIDATION); +} + + +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; + + // 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 ERROR; } - LYXERR(Debug::TCLASS) << to_utf8(makeDisplayPath(filename.absFilename())) - << endl; + os << str; + os.close(); + + // now try to convert it + bool const worx = convertLayoutFormat(tempfile, rt); + if (!worx) { + LYXERR0("Unable to convert internal layout information to format " + << LAYOUT_FORMAT); + return ERROR; + } + tempfile.removeFile(); + return OK_OLDFORMAT; +} - Lexer lexrc(textClassTags, - sizeof(textClassTags) / sizeof(textClassTags[0])); - lexrc.setFile(filename); - bool error = !lexrc.isOK(); +// Reads a textclass structure from file. +TextClass::ReturnValues TextClass::read(Lexer & lexrc, ReadType rt) +{ + if (!lexrc.isOK()) + return ERROR; // Format of files before the 'Format' tag was introduced int format = 1; + bool error = false; // parsing while (lexrc.isOK() && !error) { @@ -251,6 +403,10 @@ bool TextClass::read(FileName const & filename, ReadType rt) break; } + // used below to track whether we are in an IfStyle or IfCounter tag. + bool ifstyle = false; + bool ifcounter = false; + switch (static_cast(le)) { case TC_FORMAT: @@ -258,8 +414,24 @@ bool TextClass::read(FileName const & filename, ReadType rt) format = lexrc.getInteger(); break; - case TC_OUTPUTTYPE: // output type definition + case TC_OUTPUTFORMAT: + if (lexrc.next()) + outputFormat_ = lexrc.getString(); + break; + + case TC_OUTPUTTYPE: readOutputType(lexrc); + switch(outputType_) { + case LATEX: + outputFormat_ = "latex"; + break; + case DOCBOOK: + outputFormat_ = "docbook"; + break; + case LITERATE: + outputFormat_ = "literate"; + break; + } break; case TC_INPUT: // Include file @@ -269,12 +441,10 @@ bool TextClass::read(FileName const & filename, ReadType rt) "layout"); if (tmp.empty()) { - lexrc.printError("Could not find input" - "file: " + inc); + lexrc.printError("Could not find input file: " + inc); error = true; - } else if (read(tmp, MERGE)) { - lexrc.printError("Error reading input" - "file: " + tmp.absFilename()); + } else if (!read(tmp, MERGE)) { + lexrc.printError("Error reading input file: " + tmp.absFileName()); error = true; } } @@ -288,45 +458,52 @@ bool TextClass::read(FileName const & filename, ReadType rt) } break; - case TC_ENVIRONMENT: - case TC_STYLE: - if (lexrc.next()) { - docstring const name = from_utf8(subst(lexrc.getString(), - '_', ' ')); - if (name.empty()) { - string s = "Could not read name for style: `$$Token' " - + lexrc.getString() + " is probably not valid UTF-8!"; - lexrc.printError(s.c_str()); - Layout lay; - error = readStyle(lexrc, lay); - } else if (hasLayout(name)) { - Layout * lay = operator[](name).get(); - error = readStyle(lexrc, *lay); - } else { - Layout lay; - lay.setName(name); - if (le == TC_ENVIRONMENT) - lay.is_environment = true; - error = readStyle(lexrc, lay); - if (!error) - layoutlist_.push_back( - boost::shared_ptr(new Layout(lay)) - ); - - if (defaultlayout_.empty()) { - // We do not have a default - // layout yet, so we choose - // the first layout we - // encounter. - defaultlayout_ = name; - } + case TC_IFSTYLE: + ifstyle = true; + // fall through + case TC_STYLE: { + if (!lexrc.next()) { + lexrc.printError("No name given for style: `$$Token'."); + error = true; + break; + } + docstring const name = from_utf8(subst(lexrc.getString(), + '_', ' ')); + if (name.empty()) { + string s = "Could not read name for style: `$$Token' " + + lexrc.getString() + " is probably not valid UTF-8!"; + lexrc.printError(s); + Layout lay; + // Since we couldn't read the name, we just scan the rest + // of the style and discard it. + error = !readStyle(lexrc, lay); + } else if (hasLayout(name)) { + Layout & lay = operator[](name); + error = !readStyle(lexrc, lay); + } else if (!ifstyle) { + Layout layout; + layout.setName(name); + error = !readStyle(lexrc, layout); + if (!error) + layoutlist_.push_back(layout); + + if (defaultlayout_.empty()) { + // We do not have a default layout yet, so we choose + // the first layout we encounter. + defaultlayout_ = name; } } else { - lexrc.printError("No name given for style: `$$Token'."); - error = true; + // this was an ifstyle where we didn't have the style + // scan the rest and discard it + Layout lay; + readStyle(lexrc, lay); } + + // reset flag + ifstyle = false; break; + } case TC_NOSTYLE: if (lexrc.next()) { @@ -335,8 +512,6 @@ bool TextClass::read(FileName const & filename, ReadType rt) if (!deleteLayout(style)) lyxerr << "Cannot delete style `" << to_utf8(style) << '\'' << endl; -// lexrc.printError("Cannot delete style" -// " `$$Token'"); } break; @@ -384,7 +559,7 @@ bool TextClass::read(FileName const & filename, ReadType rt) tocdepth_ = lexrc.getInteger(); break; - // First step to support options + // First step to support options case TC_CLASSOPTIONS: readClassOptions(lexrc); break; @@ -393,6 +568,30 @@ bool TextClass::read(FileName const & filename, ReadType rt) preamble_ = from_utf8(lexrc.getLongString("EndPreamble")); break; + 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; + + case TC_ADDTOPREAMBLE: + preamble_ += from_utf8(lexrc.getLongString("EndPreamble")); + break; + + case TC_ADDTOHTMLPREAMBLE: + 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(); @@ -404,6 +603,43 @@ bool TextClass::read(FileName const & filename, ReadType rt) break; } + case TC_REQUIRES: { + lexrc.eatLine(); + vector const req + = getVectorFromString(lexrc.getString()); + requires_.insert(req.begin(), req.end()); + break; + } + + case TC_DEFAULTMODULE: { + lexrc.next(); + string const module = lexrc.getString(); + if (find(default_modules_.begin(), default_modules_.end(), module) == default_modules_.end()) + default_modules_.push_back(module); + break; + } + + case TC_PROVIDESMODULE: { + lexrc.next(); + string const module = lexrc.getString(); + if (find(provided_modules_.begin(), provided_modules_.end(), module) == provided_modules_.end()) + provided_modules_.push_back(module); + break; + } + + case TC_EXCLUDESMODULE: { + lexrc.next(); + string const module = lexrc.getString(); + // modules already have their own way to exclude other modules + if (rt == MODULE) { + LYXERR0("ExcludesModule tag cannot be used in a module!"); + break; + } + if (find(excluded_modules_.begin(), excluded_modules_.end(), module) == excluded_modules_.end()) + excluded_modules_.push_back(module); + break; + } + case TC_LEFTMARGIN: // left margin type if (lexrc.next()) leftmargin_ = lexrc.getDocString(); @@ -413,113 +649,180 @@ bool TextClass::read(FileName const & filename, ReadType rt) if (lexrc.next()) rightmargin_ = lexrc.getDocString(); break; - case TC_INSETLAYOUT: - if (lexrc.next()) { - docstring const name = subst(lexrc.getDocString(), '_', ' '); - readInsetLayout(lexrc, name); + + case TC_INSETLAYOUT: { + if (!lexrc.next()) { + lexrc.printError("No name given for InsetLayout: `$$Token'."); + error = true; + break; + } + docstring const name = subst(lexrc.getDocString(), '_', ' '); + if (name.empty()) { + string s = "Could not read name for InsetLayout: `$$Token' " + + lexrc.getString() + " is probably not valid UTF-8!"; + lexrc.printError(s); + InsetLayout il; + // Since we couldn't read the name, we just scan the rest + // of the style and discard it. + il.read(lexrc, *this); + // Let's try to continue rather than abort. + // error = true; + } else if (hasInsetLayout(name)) { + InsetLayout & il = insetlayoutlist_[name]; + error = !il.read(lexrc, *this); + } else { + InsetLayout il; + il.setName(name); + error = !il.read(lexrc, *this); + if (!error) + insetlayoutlist_[name] = il; } break; + } + case TC_FLOAT: - readFloat(lexrc); + error = !readFloat(lexrc); + break; + + case TC_CITEFORMAT: + readCiteFormat(lexrc); 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: + ifcounter = true; case TC_COUNTER: - readCounter(lexrc); + if (lexrc.next()) { + docstring const name = lexrc.getDocString(); + if (name.empty()) { + string s = "Could not read name for counter: `$$Token' " + + lexrc.getString() + " is probably not valid UTF-8!"; + lexrc.printError(s.c_str()); + Counter c; + // Since we couldn't read the name, we just scan the rest + // and discard it. + c.read(lexrc); + } else + error = !counters_.read(lexrc, name, !ifcounter); + } + else { + lexrc.printError("No name given for style: `$$Token'."); + error = true; + } + // reset flag + ifcounter = false; break; + case TC_TITLELATEXTYPE: readTitleType(lexrc); break; + case TC_TITLELATEXNAME: if (lexrc.next()) titlename_ = lexrc.getString(); break; + case TC_NOFLOAT: if (lexrc.next()) { string const nofloat = lexrc.getString(); - floatlist_->erase(nofloat); + floatlist_.erase(nofloat); } break; - } - if (format != FORMAT) - break; + } // end of switch + + // Note that this is triggered the first time through the loop unless + // we hit a format tag. + if (format != LAYOUT_FORMAT) + return FORMAT_MISMATCH; } - if (format != FORMAT) { - LYXERR(Debug::TCLASS) << "Converting layout file from format " - << format << " to " << FORMAT << endl; - FileName const tempfile(support::tempName()); - error = !layout2layout(filename, tempfile); - if (!error) - error = read(tempfile, rt); - support::unlink(tempfile); - return error; + // at present, we abort if we encounter an error, + // so there is no point continuing. + if (error) + return ERROR; + + if (rt != BASECLASS) + return (error ? ERROR : OK); + + if (defaultlayout_.empty()) { + LYXERR0("Error: Textclass '" << name_ + << "' is missing a defaultstyle."); + return ERROR; } - if (rt == MODULE) - LYXERR(Debug::TCLASS) << "Finished reading module file " - << to_utf8(makeDisplayPath(filename.absFilename())) - << endl; - else if (rt == MERGE) - LYXERR(Debug::TCLASS) << "Finished reading input file " - << to_utf8(makeDisplayPath(filename.absFilename())) - << endl; - else { // we are at top level here. - LYXERR(Debug::TCLASS) << "Finished reading textclass " - << to_utf8(makeDisplayPath(filename.absFilename())) - << endl; - if (defaultlayout_.empty()) { - lyxerr << "Error: Textclass '" << name_ - << "' is missing a defaultstyle." << endl; + // Try to erase "stdinsets" from the provides_ set. + // The + // Provides stdinsets 1 + // declaration simply tells us that the standard insets have been + // defined. (It's found in stdinsets.inc but could also be used in + // user-defined files.) There isn't really any such package. So we + // might as well go ahead and erase it. + // If we do not succeed, then it was not there, which means that + // the textclass did not provide the definitions of the standard + // insets. So we need to try to load them. + int erased = provides_.erase("stdinsets"); + if (!erased) { + FileName tmp = libFileSearch("layouts", "stdinsets.inc"); + + if (tmp.empty()) { + frontend::Alert::warning(_("Missing File"), + _("Could not find stdinsets.inc! This may lead to data loss!")); + error = true; + } else if (!read(tmp, MERGE)) { + frontend::Alert::warning(_("Corrupt File"), + _("Could not read stdinsets.inc! This may lead to data loss!")); error = true; } + } - min_toclevel_ = Layout::NOT_IN_TOC; - max_toclevel_ = Layout::NOT_IN_TOC; - const_iterator cit = begin(); - const_iterator the_end = end(); - for ( ; cit != the_end ; ++cit) { - int const toclevel = (*cit)->toclevel; - if (toclevel != Layout::NOT_IN_TOC) { - if (min_toclevel_ == Layout::NOT_IN_TOC) - min_toclevel_ = toclevel; - else - min_toclevel_ = std::min(min_toclevel_, - toclevel); - max_toclevel_ = std::max(max_toclevel_, - toclevel); - } + min_toclevel_ = Layout::NOT_IN_TOC; + max_toclevel_ = Layout::NOT_IN_TOC; + const_iterator lit = begin(); + const_iterator len = end(); + for (; lit != len; ++lit) { + int const toclevel = lit->toclevel; + if (toclevel != Layout::NOT_IN_TOC) { + if (min_toclevel_ == Layout::NOT_IN_TOC) + min_toclevel_ = toclevel; + else + min_toclevel_ = min(min_toclevel_, toclevel); + max_toclevel_ = max(max_toclevel_, toclevel); } - LYXERR(Debug::TCLASS) - << "Minimum TocLevel is " << min_toclevel_ - << ", maximum is " << max_toclevel_ <(le); break; default: - lyxerr << "Unhandled value " << le - << " in TextClass::readTitleType." << endl; - + LYXERR0("Unhandled value " << le << " in TextClass::readTitleType."); break; } } @@ -527,13 +830,13 @@ void TextClass::readTitleType(Lexer & lexrc) void TextClass::readOutputType(Lexer & lexrc) { - keyword_item outputTypeTags[] = { - { "docbook", DOCBOOK }, - { "latex", LATEX }, + LexerKeyword outputTypeTags[] = { + { "docbook", DOCBOOK }, + { "latex", LATEX }, { "literate", LITERATE } }; - PushPopHelper pph(lexrc, outputTypeTags, LITERATE); + PushPopHelper pph(lexrc, outputTypeTags); int le = lexrc.lex(); switch (le) { @@ -546,34 +849,31 @@ void TextClass::readOutputType(Lexer & lexrc) outputType_ = static_cast(le); break; default: - lyxerr << "Unhandled value " << le - << " in TextClass::readOutputType." << endl; - + LYXERR0("Unhandled value " << le); break; } } -enum ClassOptionsTags { - CO_FONTSIZE = 1, - CO_PAGESTYLE, - CO_OTHER, - CO_HEADER, - CO_END -}; - - void TextClass::readClassOptions(Lexer & lexrc) { - keyword_item classOptionsTags[] = { - {"end", CO_END }, - {"fontsize", CO_FONTSIZE }, - {"header", CO_HEADER }, - {"other", CO_OTHER }, + enum { + CO_FONTSIZE = 1, + CO_PAGESTYLE, + CO_OTHER, + CO_HEADER, + CO_END + }; + + LexerKeyword classOptionsTags[] = { + {"end", CO_END }, + {"fontsize", CO_FONTSIZE }, + {"header", CO_HEADER }, + {"other", CO_OTHER }, {"pagestyle", CO_PAGESTYLE } }; - lexrc.pushTable(classOptionsTags, CO_END); + lexrc.pushTable(classOptionsTags); bool getout = false; while (!getout && lexrc.isOK()) { int le = lexrc.lex(); @@ -581,9 +881,10 @@ void TextClass::readClassOptions(Lexer & lexrc) case Lexer::LEX_UNDEF: lexrc.printError("Unknown ClassOption tag `$$Token'"); continue; - default: break; + default: + break; } - switch (static_cast(le)) { + switch (le) { case CO_FONTSIZE: lexrc.next(); opt_fontsize_ = rtrim(lexrc.getString()); @@ -594,7 +895,10 @@ void TextClass::readClassOptions(Lexer & lexrc) break; case CO_OTHER: lexrc.next(); - options_ = lexrc.getString(); + if (options_.empty()) + options_ = lexrc.getString(); + else + options_ += ',' + lexrc.getString(); break; case CO_HEADER: lexrc.next(); @@ -609,241 +913,110 @@ void TextClass::readClassOptions(Lexer & lexrc) } -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_END -}; - - -void TextClass::readInsetLayout(Lexer & lexrc, docstring const & name) +void TextClass::readCiteFormat(Lexer & lexrc) { - keyword_item elementTags[] = { - { "bgcolor", IL_BGCOLOR }, - { "decoration", IL_DECORATION }, - { "end", IL_END }, - { "font", IL_FONT }, - { "forceltr", IL_FORCELTR }, - { "freespacing", IL_FREESPACING }, - { "keepempty", IL_KEEPEMPTY }, - { "labelfont", IL_LABELFONT }, - { "labelstring", IL_LABELSTRING }, - { "latexname", IL_LATEXNAME }, - { "latexparam", IL_LATEXPARAM }, - { "latextype", IL_LATEXTYPE }, - { "lyxtype", IL_LYXTYPE }, - { "multipar", IL_MULTIPAR }, - { "needprotect", IL_NEEDPROTECT }, - { "passthru", IL_PASSTHRU }, - { "preamble", IL_PREAMBLE } - }; - - lexrc.pushTable(elementTags, IL_END); - - string lyxtype; - docstring labelstring; - string latextype; - string decoration; - string latexname; - string latexparam; - FontInfo font = inherit_font; - FontInfo labelfont = inherit_font; - ColorCode bgcolor(Color_background); - string preamble; - bool multipar = false; - bool passthru = false; - bool needprotect = false; - bool keepempty = false; - bool freespacing = false; - bool forceltr = false; - - bool getout = false; - while (!getout && lexrc.isOK()) { - int le = lexrc.lex(); - switch (le) { - case Lexer::LEX_UNDEF: - lexrc.printError("Unknown ClassOption tag `$$Token'"); - continue; - default: break; - } - switch (static_cast(le)) { - case IL_LYXTYPE: - lexrc.next(); - lyxtype = lexrc.getString(); + string etype; + string definition; + while (lexrc.isOK()) { + lexrc.next(); + etype = lexrc.getString(); + if (!lexrc.isOK() || compare_ascii_no_case(etype, "end") == 0) break; - case IL_LATEXTYPE: - lexrc.next(); - latextype = lexrc.getString(); - break; - case IL_LABELSTRING: - lexrc.next(); - labelstring = lexrc.getDocString(); - break; - case IL_DECORATION: - lexrc.next(); - decoration = lexrc.getString(); - break; - case IL_LATEXNAME: - lexrc.next(); - latexname = lexrc.getString(); - break; - case IL_LATEXPARAM: - lexrc.next(); - latexparam = subst(lexrc.getString(), """, "\""); - break; - case IL_LABELFONT: - labelfont = lyxRead(lexrc, inherit_font); - break; - case IL_FORCELTR: - lexrc.next(); - forceltr = lexrc.getBool(); - break; - case IL_MULTIPAR: - lexrc.next(); - multipar = lexrc.getBool(); - break; - case IL_PASSTHRU: - lexrc.next(); - passthru = lexrc.getBool(); - break; - case IL_KEEPEMPTY: - lexrc.next(); - keepempty = lexrc.getBool(); - break; - case IL_FREESPACING: - lexrc.next(); - freespacing = lexrc.getBool(); - break; - case IL_NEEDPROTECT: - lexrc.next(); - needprotect = lexrc.getBool(); - break; - case IL_FONT: - font = lyxRead(lexrc, inherit_font); - // So: define font before labelfont - labelfont = font; - break; - case IL_BGCOLOR: { - lexrc.next(); - string const token = lexrc.getString(); - bgcolor = lcolor.getFromLyXName(token); - break; - } - case IL_PREAMBLE: - preamble = lexrc.getLongString("EndPreamble"); - break; - case IL_END: - getout = true; - break; - } - } - - // Here add element to list if getout == true - if (getout) { - InsetLayout il; - il.name = to_ascii(name); - il.lyxtype = lyxtype; - il.labelstring = labelstring; - il.decoration = decoration; - il.latextype = latextype; - il.latexname = latexname; - il.latexparam = latexparam; - il.multipar = multipar; - il.passthru = passthru; - il.needprotect = needprotect; - il.freespacing = freespacing; - il.forceltr = forceltr; - il.keepempty = keepempty; - il.font = font; - // The label font is generally used as-is without - // any realization against a given context. - labelfont.realize(sane_font); - il.labelfont = labelfont; - il.bgcolor = bgcolor; - il.preamble = preamble; - insetlayoutlist_[name] = il; + lexrc.eatLine(); + definition = lexrc.getString(); + char initchar = etype[0]; + if (initchar == '#') + continue; + if (initchar == '!' || initchar == '_') + cite_macros_[etype] = definition; + else + cite_formats_[etype] = definition; } - - lexrc.popTable(); } - -enum FloatTags { - FT_TYPE = 1, - FT_NAME, - FT_PLACEMENT, - FT_EXT, - FT_WITHIN, - FT_STYLE, - FT_LISTNAME, - FT_BUILTIN, - FT_END -}; - - -void TextClass::readFloat(Lexer & lexrc) +bool TextClass::readFloat(Lexer & lexrc) { - keyword_item floatTags[] = { + enum { + FT_TYPE = 1, + FT_NAME, + FT_PLACEMENT, + FT_EXT, + FT_WITHIN, + FT_STYLE, + FT_LISTNAME, + FT_USESFLOAT, + FT_PREDEFINED, + FT_HTMLSTYLE, + FT_HTMLATTR, + FT_HTMLTAG, + FT_LISTCOMMAND, + FT_REFPREFIX, + FT_END + }; + + LexerKeyword floatTags[] = { { "end", FT_END }, { "extension", FT_EXT }, { "guiname", FT_NAME }, - { "latexbuiltin", FT_BUILTIN }, + { "htmlattr", FT_HTMLATTR }, + { "htmlstyle", FT_HTMLSTYLE }, + { "htmltag", FT_HTMLTAG }, + { "ispredefined", FT_PREDEFINED }, + { "listcommand", FT_LISTCOMMAND }, { "listname", FT_LISTNAME }, { "numberwithin", FT_WITHIN }, { "placement", FT_PLACEMENT }, + { "refprefix", FT_REFPREFIX }, { "style", FT_STYLE }, - { "type", FT_TYPE } + { "type", FT_TYPE }, + { "usesfloatpkg", FT_USESFLOAT } }; - lexrc.pushTable(floatTags, FT_END); + lexrc.pushTable(floatTags); - string type; - string placement; string ext; - string within; - string style; + string htmlattr; + string htmlstyle; + string htmltag; + string listname; + string listcommand; string name; - string listName; - bool builtin = false; + string placement; + string refprefix; + string style; + string type; + string within; + bool usesfloat = true; + bool ispredefined = false; bool getout = false; while (!getout && lexrc.isOK()) { int le = lexrc.lex(); switch (le) { case Lexer::LEX_UNDEF: - lexrc.printError("Unknown ClassOption tag `$$Token'"); + lexrc.printError("Unknown float tag `$$Token'"); continue; - default: break; + default: + break; } - switch (static_cast(le)) { + switch (le) { case FT_TYPE: lexrc.next(); type = lexrc.getString(); - if (floatlist_->typeExist(type)) { - Floating const & fl = floatlist_->getType(type); + if (floatlist_.typeExist(type)) { + Floating const & fl = floatlist_.getType(type); placement = fl.placement(); ext = fl.ext(); within = fl.within(); style = fl.style(); name = fl.name(); - listName = fl.listName(); - builtin = fl.builtin(); - } + listname = fl.listName(); + usesfloat = fl.usesFloatPkg(); + ispredefined = fl.isPredefined(); + listcommand = fl.listCommand(); + refprefix = fl.refPrefix(); + } break; case FT_NAME: lexrc.next(); @@ -867,129 +1040,90 @@ void TextClass::readFloat(Lexer & lexrc) lexrc.next(); style = lexrc.getString(); break; - case FT_LISTNAME: + case FT_LISTCOMMAND: lexrc.next(); - listName = lexrc.getString(); + listcommand = lexrc.getString(); break; - case FT_BUILTIN: + case FT_REFPREFIX: lexrc.next(); - builtin = lexrc.getBool(); + refprefix = lexrc.getString(); break; - case FT_END: - getout = true; + case FT_LISTNAME: + lexrc.next(); + listname = lexrc.getString(); break; - } - } - - // Here if have a full float if getout == true - if (getout) { - Floating fl(type, placement, ext, within, - style, name, listName, builtin); - floatlist_->newFloat(fl); - // each float has its own counter - counters_->newCounter(from_ascii(type), from_ascii(within), - docstring(), docstring()); - } - - lexrc.popTable(); -} - - -enum CounterTags { - CT_NAME = 1, - CT_WITHIN, - CT_LABELSTRING, - CT_LABELSTRING_APPENDIX, - CT_END -}; - -void TextClass::readCounter(Lexer & lexrc) -{ - keyword_item counterTags[] = { - { "end", CT_END }, - { "labelstring", CT_LABELSTRING }, - { "labelstringappendix", CT_LABELSTRING_APPENDIX }, - { "name", CT_NAME }, - { "within", CT_WITHIN } - }; - - lexrc.pushTable(counterTags, CT_END); - - docstring name; - docstring within; - docstring labelstring; - docstring labelstring_appendix; - - bool getout = false; - while (!getout && lexrc.isOK()) { - int le = lexrc.lex(); - switch (le) { - case Lexer::LEX_UNDEF: - lexrc.printError("Unknown ClassOption tag `$$Token'"); - continue; - default: break; - } - switch (static_cast(le)) { - case CT_NAME: + case FT_USESFLOAT: lexrc.next(); - name = lexrc.getDocString(); - if (counters_->hasCounter(name)) - LYXERR(Debug::TCLASS) - << "Reading existing counter " - << to_utf8(name) << endl; - else - LYXERR(Debug::TCLASS) - << "Reading new counter " - << to_utf8(name) << endl; + usesfloat = lexrc.getBool(); break; - case CT_WITHIN: + case FT_PREDEFINED: lexrc.next(); - within = lexrc.getDocString(); - if (within == "none") - within.erase(); + ispredefined = lexrc.getBool(); + break; + case FT_HTMLATTR: + lexrc.next(); + htmlattr = lexrc.getString(); break; - case CT_LABELSTRING: + case FT_HTMLSTYLE: lexrc.next(); - labelstring = lexrc.getDocString(); - labelstring_appendix = labelstring; + htmlstyle = lexrc.getLongString("EndHTMLStyle"); break; - case CT_LABELSTRING_APPENDIX: + case FT_HTMLTAG: lexrc.next(); - labelstring_appendix = lexrc.getDocString(); + htmltag = lexrc.getString(); break; - case CT_END: + case FT_END: getout = true; break; } } - // Here if have a full counter if getout == true - if (getout) - counters_->newCounter(name, within, - labelstring, labelstring_appendix); - lexrc.popTable(); -} - - -FontInfo const & TextClass::defaultfont() const -{ - return defaultfont_; -} - -docstring const & TextClass::leftmargin() const -{ - return leftmargin_; + // Here we have a full float if getout == true + if (getout) { + 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), + docstring(), docstring()); + // also define sub-float counters + docstring const subtype = "sub-" + from_ascii(type); + counters_.newCounter(subtype, from_ascii(type), + "\\alph{" + subtype + "}", docstring()); + } + return getout; } -docstring const & TextClass::rightmargin() const +string const & TextClass::prerequisites() const { - return rightmargin_; + if (contains(prerequisites_, ',')) { + vector const pres = getVectorFromString(prerequisites_); + prerequisites_ = getStringFromVector(pres, "\n\t"); + } + return prerequisites_; } - bool TextClass::hasLayout(docstring const & n) const { docstring const name = n.empty() ? defaultLayoutName() : n; @@ -1000,35 +1134,64 @@ bool TextClass::hasLayout(docstring const & n) const } +bool TextClass::hasInsetLayout(docstring const & n) const +{ + 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; +} -LayoutPtr const & TextClass::operator[](docstring const & name) const + +Layout const & TextClass::operator[](docstring const & name) const { - BOOST_ASSERT(!name.empty()); + LASSERT(!name.empty(), /**/); - LayoutList::const_iterator cit = - find_if(layoutlist_.begin(), - layoutlist_.end(), - LayoutNamesEqual(name)); + const_iterator it = + find_if(begin(), end(), LayoutNamesEqual(name)); - if (cit == layoutlist_.end()) { + if (it == end()) { lyxerr << "We failed to find the layout '" << to_utf8(name) << "' in the layout list. You MUST investigate!" << endl; - for (LayoutList::const_iterator it = layoutlist_.begin(); - it != layoutlist_.end(); ++it) - lyxerr << " " << to_utf8(it->get()->name()) << endl; + for (const_iterator cit = begin(); cit != end(); ++cit) + lyxerr << " " << to_utf8(cit->name()) << endl; + + // we require the name to exist + LASSERT(false, /**/); + } + + return *it; +} + + +Layout & TextClass::operator[](docstring const & name) +{ + LASSERT(!name.empty(), /**/); + + iterator it = find_if(begin(), end(), LayoutNamesEqual(name)); + + if (it == end()) { + LYXERR0("We failed to find the layout '" << to_utf8(name) + << "' in the layout list. You MUST investigate!"); + for (const_iterator cit = begin(); cit != end(); ++cit) + LYXERR0(" " << to_utf8(cit->name())); // we require the name to exist - BOOST_ASSERT(false); + LASSERT(false, /**/); } - return *cit; + return *it; } bool TextClass::deleteLayout(docstring const & name) { - if (name == defaultLayoutName()) + if (name == defaultLayoutName() || name == plainLayoutName()) return false; LayoutList::iterator it = @@ -1049,209 +1212,267 @@ bool TextClass::load(string const & path) const return true; // Read style-file, provided path is searched before the system ones - FileName layout_file; - if (!path.empty()) + // If path is a file, it is loaded directly. + FileName layout_file(path); + if (!path.empty() && !layout_file.isReadableFile()) layout_file = FileName(addName(path, name_ + ".layout")); if (layout_file.empty() || !layout_file.exists()) layout_file = libFileSearch("layouts", name_, "layout"); - loaded_ = const_cast(this)->read(layout_file) == 0; + loaded_ = const_cast(this)->read(layout_file); if (!loaded_) { lyxerr << "Error reading `" - << to_utf8(makeDisplayPath(layout_file.absFilename())) + << to_utf8(makeDisplayPath(layout_file.absFileName())) << "'\n(Check `" << name_ << "')\nCheck your installation and " - "try Options/Reconfigure..." << endl; + "try Options/Reconfigure..." + << endl; } return loaded_; } -FloatList & TextClass::floats() -{ - return *floatlist_.get(); -} - - -FloatList const & TextClass::floats() const +bool DocumentClass::addLayoutIfNeeded(docstring const & n) const { - return *floatlist_.get(); -} - + if (hasLayout(n)) + return false; -Counters & TextClass::counters() const -{ - return *counters_.get(); + layoutlist_.push_back(createBasicLayout(n, true)); + return true; } -// Return the layout object of an inset given by name. If the name -// is not found as such, the part after the ':' is stripped off, and -// searched again. In this way, an error fallback can be provided: -// An erroneous 'CharStyle:badname' (e.g., after a documentclass switch) -// will invoke the layout object defined by name = 'CharStyle'. -// If that doesn't work either, an empty object returns (shouldn't -// happen). -- Idea JMarc, comment MV -InsetLayout const & TextClass::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. docstring n = name; + InsetLayouts::const_iterator cen = insetlayoutlist_.end(); while (!n.empty()) { - if (insetlayoutlist_.count(n) > 0) - return insetlayoutlist_[n]; - docstring::size_type i = n.find(':'); + InsetLayouts::const_iterator cit = insetlayoutlist_.lower_bound(n); + if (cit != cen && cit->first == n) + return cit->second; + size_t i = n.find(':'); if (i == string::npos) break; - n = n.substr(0,i); + n = n.substr(0, i); } - static InsetLayout empty; - empty.labelstring = from_utf8("UNDEFINED"); - empty.labelfont = sane_font; - empty.labelfont.setColor(Color_error); - empty.bgcolor = Color_error; - return empty; + return plain_insetlayout_; } docstring const & TextClass::defaultLayoutName() const { - // This really should come from the actual layout... (Lgb) return defaultlayout_; } -LayoutPtr const & TextClass::defaultLayout() const +Layout const & TextClass::defaultLayout() const { return operator[](defaultLayoutName()); } -string const & TextClass::name() const +bool TextClass::isDefaultLayout(Layout const & layout) const { - return name_; + return layout.name() == defaultLayoutName(); } -string const & TextClass::latexname() const +bool TextClass::isPlainLayout(Layout const & layout) const { - const_cast(this)->load(); - return latexname_; + return layout.name() == plainLayoutName(); } -string const & TextClass::description() const +Layout TextClass::createBasicLayout(docstring const & name, bool unknown) const { - return description_; -} - - -string const & TextClass::opt_fontsize() const -{ - return opt_fontsize_; -} + static Layout * defaultLayout = NULL; + if (defaultLayout) { + defaultLayout->setUnknown(unknown); + defaultLayout->setName(name); + return *defaultLayout; + } -string const & TextClass::opt_pagestyle() const -{ - return opt_pagestyle_; + static char const * s = "Margin Static\n" + "LatexType Paragraph\n" + "LatexName dummy\n" + "Align Block\n" + "AlignPossible Left, Right, Center\n" + "LabelType No_Label\n" + "End"; + istringstream ss(s); + Lexer lex(textClassTags); + lex.setStream(ss); + defaultLayout = new Layout; + defaultLayout->setUnknown(unknown); + defaultLayout->setName(name); + if (!readStyle(lex, *defaultLayout)) { + // The only way this happens is because the hardcoded layout above + // is wrong. + LASSERT(false, /**/); + }; + return *defaultLayout; } -string const & TextClass::options() const -{ - return options_; -} - +///////////////////////////////////////////////////////////////////////// +// +// DocumentClassBundle +// +///////////////////////////////////////////////////////////////////////// -string const & TextClass::class_header() const +DocumentClassBundle::~DocumentClassBundle() { - return class_header_; + for (size_t i = 0; i != documentClasses_.size(); ++i) + delete documentClasses_[i]; + documentClasses_.clear(); } - -string const & TextClass::pagestyle() const +DocumentClass & DocumentClassBundle::newClass(LayoutFile const & baseClass) { - return pagestyle_; + DocumentClass * dc = new DocumentClass(baseClass); + documentClasses_.push_back(dc); + return *documentClasses_.back(); } -docstring const & TextClass::preamble() const +DocumentClassBundle & DocumentClassBundle::get() { - return preamble_; + static DocumentClassBundle singleton; + return singleton; } -PageSides TextClass::sides() const +DocumentClass & DocumentClassBundle::makeDocumentClass( + LayoutFile const & baseClass, LayoutModuleList const & modlist) { - return sides_; + DocumentClass & doc_class = newClass(baseClass); + LayoutModuleList::const_iterator it = modlist.begin(); + LayoutModuleList::const_iterator en = modlist.end(); + for (; it != en; it++) { + string const modName = *it; + LyXModule * lm = theModuleList[modName]; + if (!lm) { + docstring const msg = + bformat(_("The module %1$s has been requested by\n" + "this document but has not been found in the list of\n" + "available modules. If you recently installed it, you\n" + "probably need to reconfigure LyX.\n"), from_utf8(modName)); + frontend::Alert::warning(_("Module not available"), msg); + 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 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)) { + docstring const msg = + bformat(_("Error reading module %1$s\n"), from_utf8(modName)); + frontend::Alert::warning(_("Read Error"), msg); + } + } + return doc_class; } -int TextClass::secnumdepth() const -{ - return secnumdepth_; -} - +///////////////////////////////////////////////////////////////////////// +// +// DocumentClass +// +///////////////////////////////////////////////////////////////////////// -int TextClass::tocdepth() const -{ - return tocdepth_; -} +DocumentClass::DocumentClass(LayoutFile const & tc) + : TextClass(tc) +{} -OutputType TextClass::outputType() const +bool DocumentClass::hasLaTeXLayout(std::string const & lay) const { - return outputType_; + LayoutList::const_iterator it = layoutlist_.begin(); + LayoutList::const_iterator end = layoutlist_.end(); + for (; it != end; ++it) + if (it->latexname() == lay) + return true; + return false; } -bool TextClass::provides(string const & p) const +bool DocumentClass::provides(string const & p) const { return provides_.find(p) != provides_.end(); } -unsigned int TextClass::columns() const +bool DocumentClass::hasTocLevels() const { - return columns_; -} - - -TitleLatexType TextClass::titletype() const -{ - return titletype_; + return min_toclevel_ != Layout::NOT_IN_TOC; } -string const & TextClass::titlename() const +Layout const & DocumentClass::htmlTOCLayout() const { - return titlename_; + 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(); + } + return operator[](html_toc_section_); } -int TextClass::size() const +string const & DocumentClass::getCiteFormat(string const & entry_type) const { - return layoutlist_.size(); -} + static string default_format = "{%author%[[%author%, ]][[{%editor%[[%editor%, ed., ]]}]]}\"%title%\"{%journal%[[, {!!}%journal%{!!}]][[{%publisher%[[, %publisher%]][[{%institution%[[, %institution%]]}]]}]]}{%year%[[ (%year%)]]}{%pages%[[, %pages%]]}."; - -int TextClass::min_toclevel() const -{ - return min_toclevel_; + map::const_iterator it = cite_formats_.find(entry_type); + if (it != cite_formats_.end()) + return it->second; + return default_format; } -int TextClass::max_toclevel() const +string const & DocumentClass::getCiteMacro(string const & macro) const { - return max_toclevel_; + static string empty; + map::const_iterator it = cite_macros_.find(macro); + if (it != cite_macros_.end()) + return it->second; + return empty; } -bool TextClass::hasTocLevels() const -{ - return min_toclevel_ != Layout::NOT_IN_TOC; -} - +///////////////////////////////////////////////////////////////////////// +// +// PageSides +// +///////////////////////////////////////////////////////////////////////// ostream & operator<<(ostream & os, PageSides p) {