X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2FTextClass.cpp;h=a594375cda5930118f51d3513ea237c56dc77d64;hb=fb12b282f1300123c7f4c7f10525c29cb598e1fe;hp=6342c1f6914be680ffc8c03874dc599fd1fce9fa;hpb=ac1977018b67c3ec684e999cf6e4dc71a64138c4;p=lyx.git diff --git a/src/TextClass.cpp b/src/TextClass.cpp index 6342c1f691..a594375cda 100644 --- a/src/TextClass.cpp +++ b/src/TextClass.cpp @@ -16,7 +16,7 @@ #include "TextClass.h" -#include "BaseClassList.h" +#include "LayoutFile.h" #include "Color.h" #include "Counters.h" #include "Floating.h" @@ -27,6 +27,7 @@ #include "frontends/alert.h" +#include "support/lassert.h" #include "support/debug.h" #include "support/ExceptionMessage.h" #include "support/FileName.h" @@ -35,6 +36,8 @@ #include "support/lstrings.h" #include "support/os.h" +#include +#include #include using namespace std; @@ -44,29 +47,29 @@ namespace lyx { namespace { -class LayoutNamesEqual : public 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 = 6; +int const FORMAT = 8; 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; } @@ -78,11 +81,9 @@ bool layout2layout(FileName const & filename, FileName const & tempfile) LYXERR(Debug::TCLASS, "Running `" << command_str << '\''); - cmd_ret const ret = - 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; @@ -98,6 +99,8 @@ std::string translateRT(TextClass::ReadType rt) return "input file"; case TextClass::MODULE: return "module file"; + case TextClass::VALIDATION: + return "validation"; } // shutup warning return string(); @@ -106,16 +109,22 @@ std::string translateRT(TextClass::ReadType rt) } // namespace anon -docstring const TextClass::emptylayout_ = from_ascii("PlainLayout"); +// This string should not be translated here, +// because it is a layout identifier. +docstring const TextClass::plain_layout_ = from_ascii("Plain Layout"); -InsetLayout DocumentClass::empty_insetlayout_; +InsetLayout DocumentClass::plain_insetlayout_; +///////////////////////////////////////////////////////////////////////// +// +// TextClass +// +///////////////////////////////////////////////////////////////////////// + TextClass::TextClass() { - floatlist_ = boost::shared_ptr(new FloatList); - counters_ = boost::shared_ptr(new Counters); outputType_ = LATEX; columns_ = 1; sides_ = OneSide; @@ -128,17 +137,15 @@ TextClass::TextClass() titletype_ = TITLE_COMMAND_AFTER; titlename_ = "maketitle"; loaded_ = false; - // a hack to make this available for translation - // i'm sure there must be a better way (rgh) - _("PlainLayout"); + _("Plain Layout"); // a hack to make this translatable } -bool TextClass::readStyle(Lexer & lexrc, Layout & lay) +bool TextClass::readStyle(Lexer & lexrc, Layout & lay) const { LYXERR(Debug::TCLASS, "Reading style " << to_utf8(lay.name())); if (!lay.read(lexrc, *this)) { - lyxerr << "Error parsing style `" << to_utf8(lay.name()) << '\'' << endl; + LYXERR0("Error parsing style `" << to_utf8(lay.name()) << '\''); return false; } // Resolve fonts @@ -156,7 +163,6 @@ enum TextClassTags { TC_STYLE, TC_DEFAULTSTYLE, TC_INSETLAYOUT, - TC_ENVIRONMENT, TC_NOSTYLE, TC_COLUMNS, TC_SIDES, @@ -175,26 +181,21 @@ enum TextClassTags { TC_NOFLOAT, TC_TITLELATEXNAME, TC_TITLELATEXTYPE, - TC_FORMAT + TC_FORMAT, + TC_ADDTOPREAMBLE, + TC_USEMODULE }; -// Reads a textclass structure from file. -bool TextClass::read(FileName const & filename, ReadType rt) -{ - if (!filename.isReadableFile()) { - lyxerr << "Cannot read layout file `" << filename << "'." - << endl; - return false; - } +namespace { - keyword_item textClassTags[] = { + LexerKeyword textClassTags[] = { + { "addtopreamble", TC_ADDTOPREAMBLE }, { "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 }, @@ -213,40 +214,102 @@ bool TextClass::read(FileName const & filename, ReadType rt) { "style", TC_STYLE }, { "titlelatexname", TC_TITLELATEXNAME }, { "titlelatextype", TC_TITLELATEXTYPE }, - { "tocdepth", TC_TOCDEPTH } + { "tocdepth", TC_TOCDEPTH }, + { "usemodule", TC_USEMODULE } }; + +} //namespace anon + + +bool TextClass::convertLayoutFormat(support::FileName const & filename, ReadType rt) +{ + LYXERR(Debug::TCLASS, "Converting layout file to " << FORMAT); + FileName const tempfile = FileName::tempName("convert_layout"); + bool success = layout2layout(filename, tempfile); + if (success) + success = read(tempfile, rt); + tempfile.removeFile(); + return success; +} + +bool TextClass::read(FileName const & filename, ReadType rt) +{ + if (!filename.isReadableFile()) { + lyxerr << "Cannot read layout file `" << filename << "'." + << endl; + return false; + } LYXERR(Debug::TCLASS, "Reading " + translateRT(rt) + ": " + to_utf8(makeDisplayPath(filename.absFilename()))); - // Define the `empty' layout used in table cells, ert, etc. Note that + // 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) { - 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, sizeof(textClassTags) / sizeof(textClassTags[0])); - lex.setStream(ss); - Layout lay; - lay.setName(emptylayout_); - if (!readStyle(lex, lay)) { - // The only way this happens is because the hardcoded layout above - // is wrong. - BOOST_ASSERT(false); - } - layoutlist_.push_back(boost::shared_ptr(new Layout(lay))); + 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 " + translateRT(rt) + ": " + + to_utf8(makeDisplayPath(filename.absFilename()))); + + if (retval != FORMAT_MISMATCH) + return retval == OK; + + bool const worx = convertLayoutFormat(filename, rt); + if (!worx) { + lyxerr << "Unable to convert " << filename << + " to format " << FORMAT << std::endl; + return false; } + return true; +} - Lexer lexrc(textClassTags, - sizeof(textClassTags) / sizeof(textClassTags[0])); - lexrc.setFile(filename); +bool TextClass::validate(std::string const & str) +{ + TextClass tc; + return tc.read(str, VALIDATION); +} + + +bool 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; + + // 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; + } + 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 " + << FORMAT); + } + tempfile.removeFile(); + return worx; +} + + +// Reads a textclass structure from file. +TextClass::ReturnValues TextClass::read(Lexer & lexrc, ReadType rt) +{ bool error = !lexrc.isOK(); // Format of files before the 'Format' tag was introduced @@ -305,7 +368,6 @@ 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(), @@ -315,21 +377,18 @@ bool TextClass::read(FileName const & filename, ReadType rt) + lexrc.getString() + " is probably not valid UTF-8!"; lexrc.printError(s.c_str()); Layout lay; - //FIXME If we're just dropping this layout, do we really - //care whether there's an error?? Or should we just set - //error to true, since we couldn't even read the name? + // 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).get(); - error = !readStyle(lexrc, *lay); - } else { - Layout lay; - lay.setName(name); - if (le == TC_ENVIRONMENT) - lay.is_environment = true; + Layout & lay = operator[](name); error = !readStyle(lexrc, lay); + } else { + Layout layout; + layout.setName(name); + error = !readStyle(lexrc, layout); if (!error) - layoutlist_.push_back(boost::shared_ptr(new Layout(lay))); + layoutlist_.push_back(layout); if (defaultlayout_.empty()) { // We do not have a default layout yet, so we choose @@ -340,8 +399,8 @@ bool TextClass::read(FileName const & filename, ReadType rt) } else { //FIXME Should we also eat the style here? viz: - //Layout lay; - //readStyle(lexrc, lay); + //Layout layout; + //readStyle(lexrc, layout); //as above... lexrc.printError("No name given for style: `$$Token'."); error = true; @@ -411,6 +470,10 @@ bool TextClass::read(FileName const & filename, ReadType rt) preamble_ = from_utf8(lexrc.getLongString("EndPreamble")); break; + case TC_ADDTOPREAMBLE: + preamble_ += from_utf8(lexrc.getLongString("EndPreamble")); + break; + case TC_PROVIDES: { lexrc.next(); string const feature = lexrc.getString(); @@ -430,6 +493,13 @@ bool TextClass::read(FileName const & filename, ReadType rt) break; } + case TC_USEMODULE: { + lexrc.next(); + string const module = lexrc.getString(); + usemod_.insert(module); + break; + } + case TC_LEFTMARGIN: // left margin type if (lexrc.next()) leftmargin_ = lexrc.getDocString(); @@ -443,9 +513,8 @@ bool TextClass::read(FileName const & filename, ReadType rt) case TC_INSETLAYOUT: if (lexrc.next()) { InsetLayout il; - if (il.read(lexrc)) { + if (il.read(lexrc, *this)) insetlayoutlist_[il.name()] = il; - } // else there was an error, so forget it } break; @@ -470,7 +539,7 @@ bool TextClass::read(FileName const & filename, ReadType rt) case TC_NOFLOAT: if (lexrc.next()) { string const nofloat = lexrc.getString(); - floatlist_->erase(nofloat); + floatlist_.erase(nofloat); } break; } @@ -481,39 +550,28 @@ bool TextClass::read(FileName const & filename, ReadType rt) break; } - if (format != FORMAT) { - LYXERR(Debug::TCLASS, "Converting layout file from format " - << format << " to " << FORMAT); - FileName const tempfile = FileName::tempName(); - bool success = layout2layout(filename, tempfile); - if (success) - read(tempfile, rt); - tempfile.removeFile(); - return success; - } - - LYXERR(Debug::TCLASS, "Finished reading " + translateRT(rt) + ": " + - to_utf8(makeDisplayPath(filename.absFilename()))); + if (format != FORMAT) + return FORMAT_MISMATCH; if (rt != BASECLASS) - return !error; + return (error ? ERROR : OK); if (defaultlayout_.empty()) { - lyxerr << "Error: Textclass '" << name_ - << "' is missing a defaultstyle." << endl; + LYXERR0("Error: Textclass '" << name_ + << "' is missing a defaultstyle."); error = true; } - //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. + // 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"); @@ -531,8 +589,10 @@ bool TextClass::read(FileName const & filename, ReadType rt) min_toclevel_ = Layout::NOT_IN_TOC; max_toclevel_ = Layout::NOT_IN_TOC; - for (size_t i = 0; i != layoutCount(); ++i) { - int const toclevel = layout(i)->toclevel; + 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; @@ -544,32 +604,30 @@ bool TextClass::read(FileName const & filename, ReadType rt) LYXERR(Debug::TCLASS, "Minimum TocLevel is " << min_toclevel_ << ", maximum is " << max_toclevel_); - return !error; + return (error ? ERROR : OK); } void TextClass::readTitleType(Lexer & lexrc) { - keyword_item titleTypeTags[] = { + LexerKeyword titleTypeTags[] = { { "commandafter", TITLE_COMMAND_AFTER }, - { "environment", TITLE_ENVIRONMENT } + { "environment", TITLE_ENVIRONMENT } }; - PushPopHelper pph(lexrc, titleTypeTags, TITLE_ENVIRONMENT); + PushPopHelper pph(lexrc, titleTypeTags); int le = lexrc.lex(); switch (le) { case Lexer::LEX_UNDEF: lexrc.printError("Unknown output type `$$Token'"); - return; + break; case TITLE_COMMAND_AFTER: case TITLE_ENVIRONMENT: titletype_ = static_cast(le); break; default: - lyxerr << "Unhandled value " << le - << " in TextClass::readTitleType." << endl; - + LYXERR0("Unhandled value " << le << " in TextClass::readTitleType."); break; } } @@ -577,13 +635,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) { @@ -596,34 +654,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(); @@ -633,7 +688,7 @@ void TextClass::readClassOptions(Lexer & lexrc) continue; default: break; } - switch (static_cast(le)) { + switch (le) { case CO_FONTSIZE: lexrc.next(); opt_fontsize_ = rtrim(lexrc.getString()); @@ -659,22 +714,21 @@ void TextClass::readClassOptions(Lexer & lexrc) } -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) { - keyword_item floatTags[] = { + enum { + FT_TYPE = 1, + FT_NAME, + FT_PLACEMENT, + FT_EXT, + FT_WITHIN, + FT_STYLE, + FT_LISTNAME, + FT_BUILTIN, + FT_END + }; + + LexerKeyword floatTags[] = { { "end", FT_END }, { "extension", FT_EXT }, { "guiname", FT_NAME }, @@ -686,7 +740,7 @@ void TextClass::readFloat(Lexer & lexrc) { "type", FT_TYPE } }; - lexrc.pushTable(floatTags, FT_END); + lexrc.pushTable(floatTags); string type; string placement; @@ -706,12 +760,12 @@ void TextClass::readFloat(Lexer & lexrc) continue; 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(); @@ -761,13 +815,13 @@ void TextClass::readFloat(Lexer & lexrc) if (getout) { Floating fl(type, placement, ext, within, style, name, listName, builtin); - floatlist_->newFloat(fl); + floatlist_.newFloat(fl); // each float has its own counter - counters_->newCounter(from_ascii(type), from_ascii(within), + 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), + counters_.newCounter(subtype, from_ascii(type), "\\alph{" + subtype + "}", docstring()); } @@ -775,18 +829,17 @@ void TextClass::readFloat(Lexer & lexrc) } -enum CounterTags { - CT_NAME = 1, - CT_WITHIN, - CT_LABELSTRING, - CT_LABELSTRING_APPENDIX, - CT_END -}; - - void TextClass::readCounter(Lexer & lexrc) { - keyword_item counterTags[] = { + enum { + CT_NAME = 1, + CT_WITHIN, + CT_LABELSTRING, + CT_LABELSTRING_APPENDIX, + CT_END + }; + + LexerKeyword counterTags[] = { { "end", CT_END }, { "labelstring", CT_LABELSTRING }, { "labelstringappendix", CT_LABELSTRING_APPENDIX }, @@ -794,7 +847,7 @@ void TextClass::readCounter(Lexer & lexrc) { "within", CT_WITHIN } }; - lexrc.pushTable(counterTags, CT_END); + lexrc.pushTable(counterTags); docstring name; docstring within; @@ -810,11 +863,11 @@ void TextClass::readCounter(Lexer & lexrc) continue; default: break; } - switch (static_cast(le)) { + switch (le) { case CT_NAME: lexrc.next(); name = lexrc.getDocString(); - if (counters_->hasCounter(name)) + if (counters_.hasCounter(name)) LYXERR(Debug::TCLASS, "Reading existing counter " << to_utf8(name)); else LYXERR(Debug::TCLASS, "Reading new counter " << to_utf8(name)); @@ -842,7 +895,7 @@ void TextClass::readCounter(Lexer & lexrc) // Here if have a full counter if getout == true if (getout) - counters_->newCounter(name, within, + counters_.newCounter(name, within, labelstring, labelstring_appendix); lexrc.popTable(); @@ -859,35 +912,51 @@ bool TextClass::hasLayout(docstring const & n) const } - -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() || name == emptyLayoutName()) + if (name == defaultLayoutName() || name == plainLayoutName()) return false; LayoutList::iterator it = @@ -908,8 +977,9 @@ 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"); @@ -927,18 +997,29 @@ bool TextClass::load(string const & path) const } +void DocumentClass::addLayoutIfNeeded(docstring const & n) const +{ + if (!hasLayout(n)) + layoutlist_.push_back(createBasicLayout(n, true)); +} + + 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]; + 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); } - return empty_insetlayout_; + return plain_insetlayout_; } @@ -949,17 +1030,73 @@ docstring const & TextClass::defaultLayoutName() const } -LayoutPtr const & TextClass::defaultLayout() const +Layout const & TextClass::defaultLayout() const { return operator[](defaultLayoutName()); } +bool TextClass::isDefaultLayout(Layout const & layout) const +{ + return layout.name() == defaultLayoutName(); +} + + +bool TextClass::isPlainLayout(Layout const & layout) const +{ + return layout.name() == plainLayoutName(); +} + + +Layout TextClass::createBasicLayout(docstring const & name, bool unknown) const +{ + static Layout * defaultLayout = NULL; + + if (defaultLayout) { + defaultLayout->setUnknown(unknown); + defaultLayout->setName(name); + return *defaultLayout; + } + + 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; +} + +///////////////////////////////////////////////////////////////////////// +// +// 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(baseClass); - tc_list_.push_back(dc); - return tc_list_.back(); + DocumentClass * dc = new DocumentClass(baseClass); + documentClasses_.push_back(dc); + return *documentClasses_.back(); } @@ -970,6 +1107,12 @@ DocumentClassBundle & DocumentClassBundle::get() } +///////////////////////////////////////////////////////////////////////// +// +// DocumentClass +// +///////////////////////////////////////////////////////////////////////// + DocumentClass::DocumentClass(LayoutFile const & tc) : TextClass(tc) {} @@ -980,7 +1123,7 @@ bool DocumentClass::hasLaTeXLayout(std::string const & lay) const LayoutList::const_iterator it = layoutlist_.begin(); LayoutList::const_iterator end = layoutlist_.end(); for (; it != end; ++it) - if (it->get()->latexname() == lay) + if (it->latexname() == lay) return true; return false; } @@ -998,6 +1141,12 @@ bool DocumentClass::hasTocLevels() const } +///////////////////////////////////////////////////////////////////////// +// +// PageSides +// +///////////////////////////////////////////////////////////////////////// + ostream & operator<<(ostream & os, PageSides p) { switch (p) {