X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Finsets%2FInsetIndex.cpp;h=05da188678e31f0008f13186c8c9f0aad9a9e45b;hb=2777b51c587cb061b3214c670a3cc4b357528e6c;hp=2827488221e5070efa723654f529bca3a4712ebe;hpb=de22184d972f501233b66f815f64350c39bc5dd5;p=lyx.git diff --git a/src/insets/InsetIndex.cpp b/src/insets/InsetIndex.cpp index 2827488221..05da188678 100644 --- a/src/insets/InsetIndex.cpp +++ b/src/insets/InsetIndex.cpp @@ -16,15 +16,20 @@ #include "BufferParams.h" #include "BufferView.h" #include "ColorSet.h" +#include "Cursor.h" #include "DispatchResult.h" #include "Encoding.h" #include "FuncRequest.h" #include "FuncStatus.h" #include "IndicesList.h" +#include "Language.h" #include "LaTeXFeatures.h" #include "Lexer.h" -#include "MetricsInfo.h" +#include "output_latex.h" +#include "output_xhtml.h" #include "sgml.h" +#include "texstream.h" +#include "TextClass.h" #include "TocBackend.h" #include "support/debug.h" @@ -34,6 +39,7 @@ #include "frontends/alert.h" +#include #include using namespace std; @@ -48,28 +54,32 @@ namespace lyx { /////////////////////////////////////////////////////////////////////// -InsetIndex::InsetIndex(Buffer const & buf, InsetIndexParams const & params) - : InsetCollapsable(buf), params_(params) +InsetIndex::InsetIndex(Buffer * buf, InsetIndexParams const & params) + : InsetCollapsible(buf), params_(params) {} -int InsetIndex::latex(odocstream & os, - OutputParams const & runparams) const +void InsetIndex::latex(otexstream & os, OutputParams const & runparams_in) const { + OutputParams runparams(runparams_in); + runparams.inIndexEntry = true; + if (buffer().masterBuffer()->params().use_indices && !params_.index.empty() && params_.index != "idx") { os << "\\sindex["; - os << params_.index; + os << escape(params_.index); os << "]{"; } else { os << "\\index"; os << '{'; } - int i = 0; // get contents of InsetText as LaTeX and plaintext odocstringstream ourlatex; - InsetText::latex(ourlatex, runparams); + // FIXME: do Tex/Row correspondence (I don't currently understand what is + // being generated from latexstr below) + otexstream ots(ourlatex); + InsetText::latex(ots, runparams); odocstringstream ourplain; InsetText::plaintext(ourplain, runparams); docstring latexstr = ourlatex.str(); @@ -120,22 +130,18 @@ int InsetIndex::latex(odocstream & os, // Don't do that if the user entered '@' himself, though. if (contains(*it, '\\') && !contains(*it, '@')) { // Plaintext might return nothing (e.g. for ERTs) - docstring const spart = + docstring const spart = (it2 < levels_plain.end() && !(*it2).empty()) ? *it2 : *it; // Now we need to validate that all characters in // the sorting part are representable in the current // encoding. If not try the LaTeX macro which might // or might not be a good choice, and issue a warning. - docstring spart2; - for (size_t n = 0; n < spart.size(); ++n) { - try { - spart2 += runparams.encoding->latexChar(spart[n]); - } catch (EncodingException & /* e */) { + pair spart_latexed = + runparams.encoding->latexString(spart, runparams.dryrun); + if (!spart_latexed.second.empty()) LYXERR0("Uncodable character in index entry. Sorting might be wrong!"); - } - } - if (spart != spart2 && !runparams.dryrun) { + if (spart != spart_latexed.first && !runparams.dryrun) { // FIXME: warning should be passed to the error dialog frontend::Alert::warning(_("Index sorting failed"), bformat(_("LyX's automatic index sorting algorithm faced\n" @@ -145,7 +151,7 @@ int InsetIndex::latex(odocstream & os, } // remove remaining \'s for the sorting part docstring const ppart = - subst(spart2, from_ascii("\\"), docstring()); + subst(spart_latexed.first, from_ascii("\\"), docstring()); os << ppart; os << '@'; } @@ -155,10 +161,10 @@ int InsetIndex::latex(odocstream & os, ++it2; } // write the bit that followed "|" - if (!cmd.empty()) + if (!cmd.empty()) { os << "|" << cmd; + } os << '}'; - return i; } @@ -171,6 +177,17 @@ int InsetIndex::docbook(odocstream & os, OutputParams const & runparams) const } +docstring InsetIndex::xhtml(XHTMLStream & xs, OutputParams const &) const +{ + // we just print an anchor, taking the paragraph ID from + // our own interior paragraph, which doesn't get printed + std::string const magic = paragraphs().front().magicLabel(); + std::string const attr = "id='" + magic + "'"; + xs << html::CompTag("a", attr); + return docstring(); +} + + bool InsetIndex::showInsetDialog(BufferView * bv) const { bv->showDialog("index", params2string(params_), @@ -181,18 +198,21 @@ bool InsetIndex::showInsetDialog(BufferView * bv) const void InsetIndex::doDispatch(Cursor & cur, FuncRequest & cmd) { - switch (cmd.action) { + switch (cmd.action()) { case LFUN_INSET_MODIFY: { if (cmd.getArg(0) == "changetype") { + cur.recordUndoInset(this); params_.index = from_utf8(cmd.getArg(1)); - setLayout(cur.buffer()->params()); break; } InsetIndexParams params; InsetIndex::string2params(to_utf8(cmd.argument()), params); + cur.recordUndoInset(this); params_.index = params.index; - setLayout(cur.buffer()->params()); + // what we really want here is a TOC update, but that means + // a full buffer update + cur.forceBufferUpdate(); break; } @@ -201,7 +221,7 @@ void InsetIndex::doDispatch(Cursor & cur, FuncRequest & cmd) break; default: - InsetCollapsable::doDispatch(cur, cmd); + InsetCollapsible::doDispatch(cur, cmd); break; } } @@ -210,7 +230,7 @@ void InsetIndex::doDispatch(Cursor & cur, FuncRequest & cmd) bool InsetIndex::getStatus(Cursor & cur, FuncRequest const & cmd, FuncStatus & flag) const { - switch (cmd.action) { + switch (cmd.action()) { case LFUN_INSET_MODIFY: if (cmd.getArg(0) == "changetype") { @@ -223,29 +243,29 @@ bool InsetIndex::getStatus(Cursor & cur, FuncRequest const & cmd, from_utf8(cmd.getArg(1)) == params_.index); return true; } - flag.setEnabled(true); - return true; + return InsetCollapsible::getStatus(cur, cmd, flag); - case LFUN_INSET_DIALOG_UPDATE: - case LFUN_INSET_SETTINGS: { + case LFUN_INSET_DIALOG_UPDATE: { Buffer const & realbuffer = *buffer().masterBuffer(); flag.setEnabled(realbuffer.params().use_indices); return true; } default: - return InsetCollapsable::getStatus(cur, cmd, flag); + return InsetCollapsible::getStatus(cur, cmd, flag); } } -docstring const InsetIndex::buttonLabel(BufferView const & bv) const +ColorCode InsetIndex::labelColor() const { - docstring s = _("Idx"); - if (decoration() == InsetLayout::CLASSIC) - return isOpen(bv) ? s : getNewLabel(s); - else - return getNewLabel(s); + if (params_.index.empty() || params_.index == from_ascii("idx")) + return InsetCollapsible::labelColor(); + // FIXME UNICODE + ColorCode c = lcolor.getFromLyXName(to_utf8(params_.index)); + if (c == Color_none) + c = InsetCollapsible::labelColor(); + return c; } @@ -264,29 +284,45 @@ docstring InsetIndex::toolTip(BufferView const &, int, int) const tip += ")"; } tip += ": "; - OutputParams rp(&buffer().params().encoding()); - odocstringstream ods; - InsetText::plaintext(ods, rp); - tip += ods.str(); - // shorten it if necessary - if (tip.size() > 200) - tip = tip.substr(0, 200) + "..."; - return tip; + return toolTipText(tip); +} + + +docstring const InsetIndex::buttonLabel(BufferView const & bv) const +{ + InsetLayout const & il = getLayout(); + docstring label = translateIfPossible(il.labelstring()); + + if (buffer().params().use_indices && !params_.index.empty()) { + Buffer const & realbuffer = *buffer().masterBuffer(); + IndicesList const & indiceslist = realbuffer.params().indiceslist(); + label += " ("; + Index const * index = indiceslist.findShortcut(params_.index); + if (!index) + label += _("unknown type!"); + else + label += index->index(); + label += ")"; + } + + if (!il.contentaslabel() || geometry(bv) != ButtonOnly) + return label; + return getNewLabel(label); } void InsetIndex::write(ostream & os) const { - os << to_utf8(name()); + os << to_utf8(layoutName()); params_.write(os); - InsetCollapsable::write(os); + InsetCollapsible::write(os); } void InsetIndex::read(Lexer & lex) { params_.read(lex); - InsetCollapsable::read(lex); + InsetCollapsible::read(lex); } @@ -314,14 +350,22 @@ void InsetIndex::string2params(string const & in, InsetIndexParams & params) } -void InsetIndex::addToToc(DocIterator const & cpit) +void InsetIndex::addToToc(DocIterator const & cpit, bool output_active, + UpdateType utype, TocBackend & backend) const { DocIterator pit = cpit; - pit.push_back(CursorSlice(*this)); - docstring const item = text().asString(0, 1, AS_STR_LABEL | AS_STR_INSETS); - buffer().tocBackend().toc("index").push_back(TocItem(pit, 0, item)); + pit.push_back(CursorSlice(const_cast(*this))); + docstring str; + string type = "index"; + if (buffer().masterBuffer()->params().use_indices) + type += ":" + to_utf8(params_.index); + // this is unlikely to be terribly long + text().forOutliner(str, INT_MAX); + TocBuilder & b = backend.builder(type); + b.pushItem(pit, str, output_active); // Proceed with the rest of the inset. - InsetCollapsable::addToToc(cpit); + InsetCollapsible::addToToc(cpit, output_active, utype, backend); + b.pop(); } @@ -331,15 +375,31 @@ void InsetIndex::validate(LaTeXFeatures & features) const && !params_.index.empty() && params_.index != "idx") features.require("splitidx"); + InsetCollapsible::validate(features); +} + + +string InsetIndex::contextMenuName() const +{ + return "context-index"; } -docstring InsetIndex::contextMenu(BufferView const &, int, int) const +bool InsetIndex::hasSettings() const { - return from_ascii("context-index"); + return buffer().masterBuffer()->params().use_indices; } + + +///////////////////////////////////////////////////////////////////// +// +// InsetIndexParams +// +/////////////////////////////////////////////////////////////////////// + + void InsetIndexParams::write(ostream & os) const { os << ' '; @@ -366,8 +426,8 @@ void InsetIndexParams::read(Lexer & lex) // /////////////////////////////////////////////////////////////////////// -InsetPrintIndex::InsetPrintIndex(InsetCommandParams const & p) - : InsetCommand(p, "index_print") +InsetPrintIndex::InsetPrintIndex(Buffer * buf, InsetCommandParams const & p) + : InsetCommand(buf, p) {} @@ -375,8 +435,11 @@ ParamInfo const & InsetPrintIndex::findInfo(string const & /* cmdName */) { static ParamInfo param_info_; if (param_info_.empty()) { - param_info_.add("type", ParamInfo::LATEX_OPTIONAL); - param_info_.add("name", ParamInfo::LATEX_REQUIRED); + param_info_.add("type", ParamInfo::LATEX_OPTIONAL, + ParamInfo::HANDLING_ESCAPE); + param_info_.add("name", ParamInfo::LATEX_OPTIONAL, + ParamInfo::HANDLING_LATEXIFY); + param_info_.add("literal", ParamInfo::LYX_INTERNAL); } return param_info_; } @@ -384,37 +447,114 @@ ParamInfo const & InsetPrintIndex::findInfo(string const & /* cmdName */) docstring InsetPrintIndex::screenLabel() const { - if ((!buffer().masterBuffer()->params().use_indices + bool const printall = suffixIs(getCmdName(), '*'); + bool const multind = buffer().masterBuffer()->params().use_indices; + if ((!multind && getParam("type") == from_ascii("idx")) - || getParam("type").empty()) + || (getParam("type").empty() && !printall)) return _("Index"); Buffer const & realbuffer = *buffer().masterBuffer(); IndicesList const & indiceslist = realbuffer.params().indiceslist(); Index const * index = indiceslist.findShortcut(getParam("type")); - if (!index) + if (!index && !printall) return _("Unknown index type!"); - docstring res = index->index(); - if (!buffer().masterBuffer()->params().use_indices) + docstring res = printall ? _("All indexes") : index->index(); + if (!multind) res += " (" + _("non-active") + ")"; + else if (contains(getCmdName(), "printsubindex")) + res += " (" + _("subindex") + ")"; return res; } +bool InsetPrintIndex::isCompatibleCommand(string const & s) +{ + return s == "printindex" || s == "printsubindex" + || s == "printindex*" || s == "printsubindex*"; +} + + +void InsetPrintIndex::doDispatch(Cursor & cur, FuncRequest & cmd) +{ + switch (cmd.action()) { + + case LFUN_INSET_MODIFY: { + if (cmd.argument() == from_ascii("toggle-subindex")) { + string scmd = getCmdName(); + if (contains(scmd, "printindex")) + scmd = subst(scmd, "printindex", "printsubindex"); + else + scmd = subst(scmd, "printsubindex", "printindex"); + cur.recordUndo(); + setCmdName(scmd); + break; + } else if (cmd.argument() == from_ascii("check-printindex*")) { + string scmd = getCmdName(); + if (suffixIs(scmd, '*')) + break; + scmd += '*'; + cur.recordUndo(); + setParam("type", docstring()); + setCmdName(scmd); + break; + } + InsetCommandParams p(INDEX_PRINT_CODE); + // FIXME UNICODE + InsetCommand::string2params(to_utf8(cmd.argument()), p); + if (p.getCmdName().empty()) { + cur.noScreenUpdate(); + break; + } + cur.recordUndo(); + setParams(p); + break; + } + + default: + InsetCommand::doDispatch(cur, cmd); + break; + } +} + + bool InsetPrintIndex::getStatus(Cursor & cur, FuncRequest const & cmd, FuncStatus & status) const { - switch (cmd.action) { + switch (cmd.action()) { case LFUN_INSET_MODIFY: { - InsetCommandParams p(INDEX_PRINT_CODE); - InsetCommand::string2params("index_print", to_utf8(cmd.argument()), p); - Buffer const & realbuffer = *buffer().masterBuffer(); - IndicesList const & indiceslist = realbuffer.params().indiceslist(); - Index const * index = indiceslist.findShortcut(p["type"]); - status.setEnabled(index != 0); - status.setOnOff(p["type"] == getParam("type")); + if (cmd.argument() == from_ascii("toggle-subindex")) { + status.setEnabled(buffer().masterBuffer()->params().use_indices); + status.setOnOff(contains(getCmdName(), "printsubindex")); + return true; + } else if (cmd.argument() == from_ascii("check-printindex*")) { + status.setEnabled(buffer().masterBuffer()->params().use_indices); + status.setOnOff(suffixIs(getCmdName(), '*')); + return true; + } if (cmd.getArg(0) == "index_print" + && cmd.getArg(1) == "CommandInset") { + InsetCommandParams p(INDEX_PRINT_CODE); + InsetCommand::string2params(to_utf8(cmd.argument()), p); + if (suffixIs(p.getCmdName(), '*')) { + status.setEnabled(true); + status.setOnOff(false); + return true; + } + Buffer const & realbuffer = *buffer().masterBuffer(); + IndicesList const & indiceslist = + realbuffer.params().indiceslist(); + Index const * index = indiceslist.findShortcut(p["type"]); + status.setEnabled(index != 0); + status.setOnOff(p["type"] == getParam("type")); + return true; + } else + return InsetCommand::getStatus(cur, cmd, status); + } + + case LFUN_INSET_DIALOG_UPDATE: { + status.setEnabled(buffer().masterBuffer()->params().use_indices); return true; - } + } default: return InsetCommand::getStatus(cur, cmd, status); @@ -422,15 +562,24 @@ bool InsetPrintIndex::getStatus(Cursor & cur, FuncRequest const & cmd, } -int InsetPrintIndex::latex(odocstream & os, OutputParams const &) const +void InsetPrintIndex::updateBuffer(ParIterator const &, UpdateType) +{ + Index const * index = + buffer().masterParams().indiceslist().findShortcut(getParam("type")); + if (index) + setParam("name", index->index()); +} + + +void InsetPrintIndex::latex(otexstream & os, OutputParams const & runparams_in) const { if (!buffer().masterBuffer()->params().use_indices) { if (getParam("type") == from_ascii("idx")) - os << "\\printindex{}"; - return 0; + os << "\\printindex" << termcmd; + return; } - os << getCommand(); - return 0; + OutputParams runparams = runparams_in; + os << getCommand(runparams); } @@ -439,13 +588,303 @@ void InsetPrintIndex::validate(LaTeXFeatures & features) const features.require("makeidx"); if (buffer().masterBuffer()->params().use_indices) features.require("splitidx"); + InsetCommand::validate(features); } -docstring InsetPrintIndex::contextMenu(BufferView const &, int, int) const +string InsetPrintIndex::contextMenuName() const { return buffer().masterBuffer()->params().use_indices ? - from_ascii("context-indexprint") : docstring(); + "context-indexprint" : string(); +} + + +bool InsetPrintIndex::hasSettings() const +{ + return buffer().masterBuffer()->params().use_indices; +} + + +namespace { + +void parseItem(docstring & s, bool for_output) +{ + // this does not yet check for escaped things + size_type loc = s.find(from_ascii("@")); + if (loc != string::npos) { + if (for_output) + s.erase(0, loc + 1); + else + s.erase(loc); + } + loc = s.find(from_ascii("|")); + if (loc != string::npos) + s.erase(loc); +} + + +void extractSubentries(docstring const & entry, docstring & main, + docstring & sub1, docstring & sub2) +{ + if (entry.empty()) + return; + size_type const loc = entry.find(from_ascii(" ! ")); + if (loc == string::npos) + main = entry; + else { + main = trim(entry.substr(0, loc)); + size_t const locend = loc + 3; + size_type const loc2 = entry.find(from_ascii(" ! "), locend); + if (loc2 == string::npos) { + sub1 = trim(entry.substr(locend)); + } else { + sub1 = trim(entry.substr(locend, loc2 - locend)); + sub2 = trim(entry.substr(loc2 + 3)); + } + } +} + + +struct IndexEntry +{ + IndexEntry() + {} + + IndexEntry(docstring const & s, DocIterator const & d) + : dit(d) + { + extractSubentries(s, main, sub, subsub); + parseItem(main, false); + parseItem(sub, false); + parseItem(subsub, false); + } + + bool equal(IndexEntry const & rhs) const + { + return main == rhs.main && sub == rhs.sub && subsub == rhs.subsub; + } + + bool same_sub(IndexEntry const & rhs) const + { + return main == rhs.main && sub == rhs.sub; + } + + bool same_main(IndexEntry const & rhs) const + { + return main == rhs.main; + } + + docstring main; + docstring sub; + docstring subsub; + DocIterator dit; +}; + +bool operator<(IndexEntry const & lhs, IndexEntry const & rhs) +{ + int comp = compare_no_case(lhs.main, rhs.main); + if (comp == 0) + comp = compare_no_case(lhs.sub, rhs.sub); + if (comp == 0) + comp = compare_no_case(lhs.subsub, rhs.subsub); + return (comp < 0); +} + +} // namespace + + +docstring InsetPrintIndex::xhtml(XHTMLStream &, OutputParams const & op) const +{ + BufferParams const & bp = buffer().masterBuffer()->params(); + + // we do not presently support multiple indices, so we refuse to print + // anything but the main index, so as not to generate multiple indices. + // NOTE Multiple index support would require some work. The reason + // is that the TOC does not know about multiple indices. Either it would + // need to be told about them (not a bad idea), or else the index entries + // would need to be collected differently, say, during validation. + if (bp.use_indices && getParam("type") != from_ascii("idx")) + return docstring(); + + shared_ptr toc = buffer().tocBackend().toc("index"); + if (toc->empty()) + return docstring(); + + // Collect the index entries in a form we can use them. + Toc::const_iterator it = toc->begin(); + Toc::const_iterator const en = toc->end(); + vector entries; + for (; it != en; ++it) + if (it->isOutput()) + entries.push_back(IndexEntry(it->str(), it->dit())); + + if (entries.empty()) + // not very likely that all the index entries are in notes or + // whatever, but.... + return docstring(); + + stable_sort(entries.begin(), entries.end()); + + Layout const & lay = bp.documentClass().htmlTOCLayout(); + string const & tocclass = lay.defaultCSSClass(); + string const tocattr = "class='index " + tocclass + "'"; + + // we'll use our own stream, because we are going to defer everything. + // that's how we deal with the fact that we're probably inside a standard + // paragraph, and we don't want to be. + odocstringstream ods; + XHTMLStream xs(ods); + + xs << html::StartTag("div", tocattr); + xs << html::StartTag(lay.htmltag(), lay.htmlattr()) + << translateIfPossible(from_ascii("Index"), + op.local_font->language()->lang()) + << html::EndTag(lay.htmltag()); + xs << html::StartTag("ul", "class='main'"); + Font const dummy; + + vector::const_iterator eit = entries.begin(); + vector::const_iterator const een = entries.end(); + // tracks whether we are already inside a main entry (1), + // a sub-entry (2), or a sub-sub-entry (3). see below for the + // details. + int level = 1; + // the last one we saw + IndexEntry last; + int entry_number = -1; + for (; eit != een; ++eit) { + Paragraph const & par = eit->dit.innerParagraph(); + if (entry_number == -1 || !eit->equal(last)) { + if (entry_number != -1) { + // not the first time through the loop, so + // close last entry or entries, depending. + if (level == 3) { + // close this sub-sub-entry + xs << html::EndTag("li") << html::CR(); + // is this another sub-sub-entry within the same sub-entry? + if (!eit->same_sub(last)) { + // close this level + xs << html::EndTag("ul") << html::CR(); + level = 2; + } + } + // the point of the second test here is that we might get + // here two ways: (i) by falling through from above; (ii) because, + // though the sub-entry hasn't changed, the sub-sub-entry has, + // which means that it is the first sub-sub-entry within this + // sub-entry. In that case, we do not want to close anything. + if (level == 2 && !eit->same_sub(last)) { + // close sub-entry + xs << html::EndTag("li") << html::CR(); + // is this another sub-entry with the same main entry? + if (!eit->same_main(last)) { + // close this level + xs << html::EndTag("ul") << html::CR(); + level = 1; + } + } + // again, we can get here two ways: from above, or because we have + // found the first sub-entry. in the latter case, we do not want to + // close the entry. + if (level == 1 && !eit->same_main(last)) { + // close entry + xs << html::EndTag("li") << html::CR(); + } + } + + // we'll be starting new entries + entry_number = 0; + + // We need to use our own stream, since we will have to + // modify what we get back. + odocstringstream ent; + XHTMLStream entstream(ent); + OutputParams ours = op; + ours.for_toc = true; + par.simpleLyXHTMLOnePar(buffer(), entstream, ours, dummy); + + // these will contain XHTML versions of the main entry, etc + // remember that everything will already have been escaped, + // so we'll need to use NextRaw() during output. + docstring main; + docstring sub; + docstring subsub; + extractSubentries(ent.str(), main, sub, subsub); + parseItem(main, true); + parseItem(sub, true); + parseItem(subsub, true); + + if (level == 3) { + // another subsubentry + xs << html::StartTag("li", "class='subsubentry'") + << XHTMLStream::ESCAPE_NONE << subsub; + } else if (level == 2) { + // there are two ways we can be here: + // (i) we can actually be inside a sub-entry already and be about + // to output the first sub-sub-entry. in this case, our sub + // and the last sub will be the same. + // (ii) we can just have closed a sub-entry, possibly after also + // closing a list of sub-sub-entries. here our sub and the last + // sub are different. + // only in the latter case do we need to output the new sub-entry. + // note that in this case, too, though, the sub-entry might already + // have a sub-sub-entry. + if (eit->sub != last.sub) + xs << html::StartTag("li", "class='subentry'") + << XHTMLStream::ESCAPE_NONE << sub; + if (!subsub.empty()) { + // it's actually a subsubentry, so we need to start that list + xs << html::CR() + << html::StartTag("ul", "class='subsubentry'") + << html::StartTag("li", "class='subsubentry'") + << XHTMLStream::ESCAPE_NONE << subsub; + level = 3; + } + } else { + // there are also two ways we can be here: + // (i) we can actually be inside an entry already and be about + // to output the first sub-entry. in this case, our main + // and the last main will be the same. + // (ii) we can just have closed an entry, possibly after also + // closing a list of sub-entries. here our main and the last + // main are different. + // only in the latter case do we need to output the new main entry. + // note that in this case, too, though, the main entry might already + // have a sub-entry, or even a sub-sub-entry. + if (eit->main != last.main) + xs << html::StartTag("li", "class='main'") << main; + if (!sub.empty()) { + // there's a sub-entry, too + xs << html::CR() + << html::StartTag("ul", "class='subentry'") + << html::StartTag("li", "class='subentry'") + << XHTMLStream::ESCAPE_NONE << sub; + level = 2; + if (!subsub.empty()) { + // and a sub-sub-entry + xs << html::CR() + << html::StartTag("ul", "class='subsubentry'") + << html::StartTag("li", "class='subsubentry'") + << XHTMLStream::ESCAPE_NONE << subsub; + level = 3; + } + } + } + } + // finally, then, we can output the index link itself + string const parattr = "href='#" + par.magicLabel() + "'"; + xs << (entry_number == 0 ? ":" : ","); + xs << " " << html::StartTag("a", parattr) + << ++entry_number << html::EndTag("a"); + last = *eit; + } + // now we have to close all the open levels + while (level > 0) { + xs << html::EndTag("li") << html::EndTag("ul") << html::CR(); + --level; + } + xs << html::EndTag("div") << html::CR(); + return ods.str(); } } // namespace lyx