X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Finsets%2FInsetIndex.cpp;h=fe0890c4ae18beab7bc1f39f22bf2af1f6d2afb4;hb=997f0621c5346bb623cf86713c4fe1be0c941104;hp=60f039c381fee2a2e682f23619aa351eb0e2bcaa;hpb=3f27f951cbc2521edfbf78792839d61306bdb978;p=lyx.git diff --git a/src/insets/InsetIndex.cpp b/src/insets/InsetIndex.cpp index 60f039c381..fe0890c4ae 100644 --- a/src/insets/InsetIndex.cpp +++ b/src/insets/InsetIndex.cpp @@ -22,23 +22,29 @@ #include "FuncRequest.h" #include "FuncStatus.h" #include "IndicesList.h" +#include "Language.h" #include "LaTeXFeatures.h" #include "Lexer.h" #include "output_latex.h" #include "output_xhtml.h" -#include "sgml.h" +#include "xml.h" +#include "texstream.h" #include "TextClass.h" #include "TocBackend.h" #include "support/debug.h" #include "support/docstream.h" +#include "support/FileName.h" #include "support/gettext.h" #include "support/lstrings.h" #include "frontends/alert.h" -#include #include +#include +#include + +#include using namespace std; using namespace lyx::support; @@ -53,48 +59,62 @@ namespace lyx { InsetIndex::InsetIndex(Buffer * buf, InsetIndexParams const & params) - : InsetCollapsable(buf), params_(params) + : InsetCollapsible(buf), params_(params) {} -void InsetIndex::latex(otexstream & os, OutputParams const & runparams_in) const +void InsetIndex::latex(otexstream & ios, OutputParams const & runparams_in) const { OutputParams runparams(runparams_in); runparams.inIndexEntry = true; + otexstringstream os; + if (buffer().masterBuffer()->params().use_indices && !params_.index.empty() - && params_.index != "idx") { + && params_.index != "idx") { os << "\\sindex["; - os << params_.index; + os << escape(params_.index); os << "]{"; } else { os << "\\index"; os << '{'; } - // get contents of InsetText as LaTeX and plaintext - TexRow texrow; + // Get the LaTeX output from InsetText. We need to deconstruct this later + // in order to check if we need to generate a sorting key odocstringstream ourlatex; - otexstream ots(ourlatex, texrow); + otexstream ots(ourlatex); InsetText::latex(ots, runparams); + if (runparams.for_searchAdv != OutputParams::NoSearch) { + // No need for special handling, if we are only searching for some patterns + os << ourlatex.str() << "}"; + return; + } + + // For the sorting key, we use the plaintext version odocstringstream ourplain; InsetText::plaintext(ourplain, runparams); + + // These are the LaTeX and plaintext representations docstring latexstr = ourlatex.str(); docstring plainstr = ourplain.str(); - // this will get what follows | if anything does + // This will get what follows | if anything does, + // the command (e.g., see, textbf) for pagination + // formatting docstring cmd; - // check for the | separator - // FIXME This would go wrong on an escaped "|", but - // how far do we want to go here? + // Check for the | separator to strip the cmd. + // This goes wrong on an escaped "|", but as the escape + // character can be changed in style files, we cannot + // prevent that. size_t pos = latexstr.find(from_ascii("|")); if (pos != docstring::npos) { - // put the bit after "|" into cmd... + // Put the bit after "|" into cmd... cmd = latexstr.substr(pos + 1); // ...and erase that stuff from latexstr latexstr = latexstr.erase(pos); - // ...and similarly from plainstr + // ...as well as from plainstr size_t ppos = plainstr.find(from_ascii("|")); if (ppos < plainstr.size()) plainstr.erase(ppos); @@ -102,89 +122,303 @@ void InsetIndex::latex(otexstream & os, OutputParams const & runparams_in) const LYXERR0("The `|' separator was not found in the plaintext version!"); } - // Separate the entires and subentries, i.e., split on "!" - // FIXME This would do the wrong thing with escaped ! characters + // Separate the entries and subentries, i.e., split on "!". + // This goes wrong on an escaped "!", but as the escape + // character can be changed in style files, we cannot + // prevent that. std::vector const levels = - getVectorFromString(latexstr, from_ascii("!"), true); + getVectorFromString(latexstr, from_ascii("!"), true); std::vector const levels_plain = - getVectorFromString(plainstr, from_ascii("!"), true); + getVectorFromString(plainstr, from_ascii("!"), true); vector::const_iterator it = levels.begin(); vector::const_iterator end = levels.end(); vector::const_iterator it2 = levels_plain.begin(); bool first = true; for (; it != end; ++it) { - // write the separator except the first time + // The separator needs to be put back when + // writing the levels, except for the first level if (!first) os << '!'; else first = false; - // correctly sort macros and formatted strings - // if we do find a command, prepend a plain text + // Now here comes the reason for this whole procedure: + // We try to correctly sort macros and formatted strings. + // If we find a command, prepend a plain text // version of the content to get sorting right, - // e.g. \index{LyX@\LyX}, \index{text@\textbf{text}} - // Don't do that if the user entered '@' himself, though. + // e.g. \index{LyX@\LyX}, \index{text@\textbf{text}}. + // We do this on all levels. + // We don't do it if the level already contains a '@', though. if (contains(*it, '\\') && !contains(*it, '@')) { - // Plaintext might return nothing (e.g. for ERTs) - docstring const spart = - (it2 < levels_plain.end() && !(*it2).empty()) - ? *it2 : *it; + // Plaintext might return nothing (e.g. for ERTs). + // In that case, we use LaTeX. + 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 */) { - LYXERR0("Uncodable character in index entry. Sorting might be wrong!"); - } - } - if (spart != spart2 && !runparams.dryrun) { + 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 != 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" - "problems with the entry '%1$s'.\n" - "Please specify the sorting of this entry manually, as\n" - "explained in the User Guide."), spart)); + bformat(_("LyX's automatic index sorting algorithm faced\n" + "problems with the entry '%1$s'.\n" + "Please specify the sorting of this entry manually, as\n" + "explained in the User Guide."), spart)); } - // remove remaining \'s for the sorting part - docstring const ppart = - subst(spart2, from_ascii("\\"), docstring()); + // Remove remaining \'s from the sort key + docstring ppart = subst(spart_latexed.first, from_ascii("\\"), docstring()); + // Plain quotes need to be escaped, however (#10649), as this + // is the default escape character + ppart = subst(ppart, from_ascii("\""), from_ascii("\\\"")); + + // Now insert the sortkey, separated by '@'. os << ppart; os << '@'; } + // Insert the actual level text docstring const tpart = *it; os << tpart; if (it2 < levels_plain.end()) ++it2; } - // write the bit that followed "|" + // At last, re-insert the command, separated by "|" if (!cmd.empty()) { os << "|" << cmd; } os << '}'; + + // In macros with moving arguments, such as \section, + // we store the index and output it after the macro (#2154) + if (runparams_in.postpone_fragile_stuff) + runparams_in.post_macro += os.str(); + else + ios << os.release(); } -int InsetIndex::docbook(odocstream & os, OutputParams const & runparams) const +void InsetIndex::docbook(XMLStream & xs, OutputParams const & runparams) const { - os << ""; - int const i = InsetText::docbook(os, runparams); - os << ""; - return i; + // Get the content of the inset as LaTeX, as some things may be encoded as ERT (like {}). + // TODO: if there is an ERT within the index term, its conversion should be tried, in case it becomes useful; + // otherwise, ERTs should become comments. For now, they are just copied as-is, which is barely satisfactory. + odocstringstream odss; + otexstream ots(odss); + InsetText::latex(ots, runparams); + docstring latexString = trim(odss.str()); + + // Check whether there are unsupported things. @ is supported, but only for sorting, without specific formatting. + if (latexString.find(from_utf8("@\\")) != lyx::docstring::npos) { + docstring error = from_utf8("Unsupported feature: an index entry contains an @\\. " + "Complete entry: \"") + latexString + from_utf8("\""); + LYXERR0(error); + xs << XMLStream::ESCAPE_NONE << (from_utf8("\n")); + } + + // Handle several indices (indicated in the inset instead of the raw latexString). + docstring indexType = from_utf8(""); + if (buffer().masterBuffer()->params().use_indices) { + indexType += " type=\"" + params_.index + "\""; + } + + // Split the string into its main constituents: terms, and command (see, see also, range). + size_t positionVerticalBar = latexString.find(from_ascii("|")); // What comes before | is (sub)(sub)entries. + docstring indexTerms = latexString.substr(0, positionVerticalBar); + docstring command; + if (positionVerticalBar != lyx::docstring::npos) { + command = latexString.substr(positionVerticalBar + 1); + } + + // Handle sorting issues, with @. + vector sortingElements = getVectorFromString(indexTerms, from_ascii("@"), false); + docstring sortAs; + if (sortingElements.size() == 2) { + sortAs = sortingElements[0]; + indexTerms = sortingElements[1]; + } + + // Handle primary, secondary, and tertiary terms (entries, subentries, and subsubentries, for LaTeX). + vector terms = getVectorFromString(indexTerms, from_ascii("!"), false); + + // Handle ranges. Happily, (| and |) can only be at the end of the string! + bool hasStartRange = latexString.find(from_ascii("|(")) != lyx::docstring::npos; + bool hasEndRange = latexString.find(from_ascii("|)")) != lyx::docstring::npos; + if (hasStartRange || hasEndRange) { + // Remove the ranges from the command if they do not appear at the beginning. + size_t index = 0; + while ((index = command.find(from_utf8("|("), index)) != std::string::npos) + command.erase(index, 1); + index = 0; + while ((index = command.find(from_utf8("|)"), index)) != std::string::npos) + command.erase(index, 1); + + // Remove the ranges when they are the only vertical bar in the complete string. + if (command[0] == '(' || command[0] == ')') + command.erase(0, 1); + } + + // Handle see and seealso. As "see" is a prefix of "seealso", the order of the comparisons is important. + // Both commands are mutually exclusive! + docstring see = from_utf8(""); + vector seeAlsoes; + if (command.substr(0, 3) == "see") { + // Unescape brackets. + size_t index = 0; + while ((index = command.find(from_utf8("\\{"), index)) != std::string::npos) + command.erase(index, 1); + index = 0; + while ((index = command.find(from_utf8("\\}"), index)) != std::string::npos) + command.erase(index, 1); + + // Retrieve the part between brackets, and remove the complete seealso. + size_t positionOpeningBracket = command.find(from_ascii("{")); + size_t positionClosingBracket = command.find(from_ascii("}")); + docstring list = command.substr(positionOpeningBracket + 1, positionClosingBracket - positionOpeningBracket - 1); + + // Parse the list of referenced entries (or a single one for see). + if (command.substr(0, 7) == "seealso") { + seeAlsoes = getVectorFromString(list, from_ascii(","), false); + } else { + see = list; + + if (see.find(from_ascii(",")) != std::string::npos) { + docstring error = from_utf8("Several index terms found as \"see\"! Only one is acceptable. " + "Complete entry: \"") + latexString + from_utf8("\""); + LYXERR0(error); + xs << XMLStream::ESCAPE_NONE << (from_utf8("\n")); + } + } + + // Remove the complete see/seealso from the commands, in case there is something else to parse. + command = command.substr(positionClosingBracket + 1); + } + + // Some parts of the strings are not parsed, as they do not have anything matching in DocBook: things like + // formatting the entry or the page number, other strings for sorting. https://wiki.lyx.org/Tips/Indexing + // If there are such things in the index entry, then this code may miserably fail. For example, for "Peter|(textbf", + // no range will be detected. + // TODO: Could handle formatting as significance="preferred"? + if (!command.empty()) { + docstring error = from_utf8("Unsupported feature: an index entry contains a | with an unsupported command, ") + + command + from_utf8(". ") + from_utf8("Complete entry: \"") + latexString + from_utf8("\""); + LYXERR0(error); + xs << XMLStream::ESCAPE_NONE << (from_utf8("\n")); + } + + // Write all of this down. + if (terms.empty() && !hasEndRange) { + docstring error = from_utf8("No index term found! Complete entry: \"") + latexString + from_utf8("\""); + LYXERR0(error); + xs << XMLStream::ESCAPE_NONE << (from_utf8("\n")); + } else { + // Generate the attributes for ranges. It is based on the terms that are indexed, but the ID must be unique + // to this indexing area (xml::cleanID does not guarantee this: for each call with the same arguments, + // the same legal ID is produced; here, as the input would be the same, the output must be, by design). + // Hence the thread-local storage, as the numbers must strictly be unique, and thus cannot be shared across + // a paragraph (making the solution used for HTML worthless). This solution is very similar to the one used in + // xml::cleanID. + // indexType can only be used for singular and startofrange types! + docstring attrs; + if (!hasStartRange && !hasEndRange) { + attrs = indexType; + } else { + // Append an ID if uniqueness is not guaranteed across the document. + static QThreadStorage> tKnownTermLists; + static QThreadStorage tID; + + set &knownTermLists = tKnownTermLists.localData(); + int &ID = tID.localData(); + + if (!tID.hasLocalData()) { + tID.localData() = 0; + } + + // Modify the index terms to add the unique ID if needed. + docstring newIndexTerms = indexTerms; + if (knownTermLists.find(indexTerms) != knownTermLists.end()) { + newIndexTerms += from_ascii(string("-") + to_string(ID)); + + // Only increment for the end of range, so that the same number is used for the start of range. + if (hasEndRange) { + ID++; + } + } + + // Term list not yet known: add it to the set AFTER the end of range. After + if (knownTermLists.find(indexTerms) == knownTermLists.end() && hasEndRange) { + knownTermLists.insert(indexTerms); + } + + // Generate the attributes. + docstring id = xml::cleanID(newIndexTerms); + if (hasStartRange) { + attrs = indexType + " class=\"startofrange\" xml:id=\"" + id + "\""; + } else { + attrs = " class=\"endofrange\" startref=\"" + id + "\""; + } + } + + // Handle the index terms (including the specific index for this entry). + if (hasEndRange) { + xs << xml::CompTag("indexterm", attrs); + } else { + xs << xml::StartTag("indexterm", attrs); + if (!terms.empty()) { // hasEndRange has no content. + docstring attr; + if (!sortAs.empty()) { + attr = from_utf8("sortas='") + sortAs + from_utf8("'"); + } + + xs << xml::StartTag("primary", attr); + xs << terms[0]; + xs << xml::EndTag("primary"); + } + if (terms.size() > 1) { + xs << xml::StartTag("secondary"); + xs << terms[1]; + xs << xml::EndTag("secondary"); + } + if (terms.size() > 2) { + xs << xml::StartTag("tertiary"); + xs << terms[2]; + xs << xml::EndTag("tertiary"); + } + + // Handle see and see also. + if (!see.empty()) { + xs << xml::StartTag("see"); + xs << see; + xs << xml::EndTag("see"); + } + + if (!seeAlsoes.empty()) { + for (auto &entry : seeAlsoes) { + xs << xml::StartTag("seealso"); + xs << entry; + xs << xml::EndTag("seealso"); + } + } + + // Close the entry. + xs << xml::EndTag("indexterm"); + } + } } -docstring InsetIndex::xhtml(XHTMLStream & xs, OutputParams const &) const +docstring InsetIndex::xhtml(XMLStream & xs, OutputParams const &) const { - // we just print an anchor, taking the paragraph ID from + // 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); + xs << xml::CompTag("a", attr); return docstring(); } @@ -203,13 +437,13 @@ void InsetIndex::doDispatch(Cursor & cur, FuncRequest & cmd) case LFUN_INSET_MODIFY: { if (cmd.getArg(0) == "changetype") { - cur.recordUndoInset(ATOMIC_UNDO, this); + cur.recordUndoInset(this); params_.index = from_utf8(cmd.getArg(1)); break; } InsetIndexParams params; InsetIndex::string2params(to_utf8(cmd.argument()), params); - cur.recordUndoInset(ATOMIC_UNDO, this); + cur.recordUndoInset(this); params_.index = params.index; // what we really want here is a TOC update, but that means // a full buffer update @@ -222,7 +456,7 @@ void InsetIndex::doDispatch(Cursor & cur, FuncRequest & cmd) break; default: - InsetCollapsable::doDispatch(cur, cmd); + InsetCollapsible::doDispatch(cur, cmd); break; } } @@ -244,8 +478,7 @@ 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: { Buffer const & realbuffer = *buffer().masterBuffer(); @@ -254,7 +487,7 @@ bool InsetIndex::getStatus(Cursor & cur, FuncRequest const & cmd, } default: - return InsetCollapsable::getStatus(cur, cmd, flag); + return InsetCollapsible::getStatus(cur, cmd, flag); } } @@ -262,11 +495,12 @@ bool InsetIndex::getStatus(Cursor & cur, FuncRequest const & cmd, ColorCode InsetIndex::labelColor() const { if (params_.index.empty() || params_.index == from_ascii("idx")) - return InsetCollapsable::labelColor(); + return InsetCollapsible::labelColor(); // FIXME UNICODE - ColorCode c = lcolor.getFromLyXName(to_utf8(params_.index)); + ColorCode c = lcolor.getFromLyXName(to_utf8(params_.index) + + "@" + buffer().fileName().absFileName()); if (c == Color_none) - c = InsetCollapsable::labelColor(); + c = InsetCollapsible::labelColor(); return c; } @@ -317,14 +551,14 @@ void InsetIndex::write(ostream & os) const { 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); } @@ -352,15 +586,22 @@ void InsetIndex::string2params(string const & in, InsetIndexParams & params) } -void InsetIndex::addToToc(DocIterator const & cpit) const +void InsetIndex::addToToc(DocIterator const & cpit, bool output_active, + UpdateType utype, TocBackend & backend) const { DocIterator pit = cpit; pit.push_back(CursorSlice(const_cast(*this))); docstring str; - text().forToc(str, TOC_ENTRY_LENGTH); - buffer().tocBackend().toc("index").push_back(TocItem(pit, 0, 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(); } @@ -370,13 +611,13 @@ void InsetIndex::validate(LaTeXFeatures & features) const && !params_.index.empty() && params_.index != "idx") features.require("splitidx"); - InsetCollapsable::validate(features); + InsetCollapsible::validate(features); } -docstring InsetIndex::contextMenuName() const +string InsetIndex::contextMenuName() const { - return from_ascii("context-index"); + return "context-index"; } @@ -430,8 +671,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_; } @@ -472,22 +716,22 @@ void InsetPrintIndex::doDispatch(Cursor & cur, FuncRequest & cmd) case LFUN_INSET_MODIFY: { if (cmd.argument() == from_ascii("toggle-subindex")) { - string cmd = getCmdName(); - if (contains(cmd, "printindex")) - cmd = subst(cmd, "printindex", "printsubindex"); + string scmd = getCmdName(); + if (contains(scmd, "printindex")) + scmd = subst(scmd, "printindex", "printsubindex"); else - cmd = subst(cmd, "printsubindex", "printindex"); + scmd = subst(scmd, "printsubindex", "printindex"); cur.recordUndo(); - setCmdName(cmd); + setCmdName(scmd); break; } else if (cmd.argument() == from_ascii("check-printindex*")) { - string cmd = getCmdName(); - if (suffixIs(cmd, '*')) + string scmd = getCmdName(); + if (suffixIs(scmd, '*')) break; - cmd += '*'; + scmd += '*'; cur.recordUndo(); setParam("type", docstring()); - setCmdName(cmd); + setCmdName(scmd); break; } InsetCommandParams p(INDEX_PRINT_CODE); @@ -497,6 +741,7 @@ void InsetPrintIndex::doDispatch(Cursor & cur, FuncRequest & cmd) cur.noScreenUpdate(); break; } + cur.recordUndo(); setParams(p); break; } @@ -541,7 +786,7 @@ bool InsetPrintIndex::getStatus(Cursor & cur, FuncRequest const & cmd, } else return InsetCommand::getStatus(cur, cmd, status); } - + case LFUN_INSET_DIALOG_UPDATE: { status.setEnabled(buffer().masterBuffer()->params().use_indices); return true; @@ -553,11 +798,20 @@ bool InsetPrintIndex::getStatus(Cursor & cur, FuncRequest const & cmd, } +void InsetPrintIndex::updateBuffer(ParIterator const &, UpdateType, bool const /*deleted*/) +{ + 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{}"; + os << "\\printindex" << termcmd; return; } OutputParams runparams = runparams_in; @@ -570,13 +824,14 @@ void InsetPrintIndex::validate(LaTeXFeatures & features) const features.require("makeidx"); if (buffer().masterBuffer()->params().use_indices) features.require("splitidx"); + InsetCommand::validate(features); } -docstring InsetPrintIndex::contextMenuName() const +string InsetPrintIndex::contextMenuName() const { return buffer().masterBuffer()->params().use_indices ? - from_ascii("context-indexprint") : docstring(); + "context-indexprint" : string(); } @@ -603,7 +858,7 @@ void parseItem(docstring & s, bool for_output) s.erase(loc); } - + void extractSubentries(docstring const & entry, docstring & main, docstring & sub1, docstring & sub2) { @@ -628,10 +883,10 @@ void extractSubentries(docstring const & entry, docstring & main, struct IndexEntry { - IndexEntry() + IndexEntry() {} - - IndexEntry(docstring const & s, DocIterator const & d) + + IndexEntry(docstring const & s, DocIterator const & d) : dit(d) { extractSubentries(s, main, sub, subsub); @@ -639,22 +894,22 @@ struct IndexEntry 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; @@ -663,15 +918,18 @@ struct IndexEntry bool operator<(IndexEntry const & lhs, IndexEntry const & rhs) { - return lhs.main < rhs.main - || (lhs.main == rhs.main && lhs.sub < rhs.sub) - || (lhs.main == rhs.main && lhs.sub == rhs.sub && lhs.subsub < rhs.subsub); + 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); } -} // anon namespace +} // namespace -docstring InsetPrintIndex::xhtml(XHTMLStream &, OutputParams const & op) const +docstring InsetPrintIndex::xhtml(XMLStream &, OutputParams const & op) const { BufferParams const & bp = buffer().masterBuffer()->params(); @@ -683,34 +941,42 @@ docstring InsetPrintIndex::xhtml(XHTMLStream &, OutputParams const & op) const // would need to be collected differently, say, during validation. if (bp.use_indices && getParam("type") != from_ascii("idx")) return docstring(); - - Toc const & toc = buffer().tocBackend().toc("index"); - if (toc.empty()) + + shared_ptr toc = buffer().tocBackend().toc("index"); + if (toc->empty()) return docstring(); - // Collection the index entries in a form we can use them. - Toc::const_iterator it = toc.begin(); - Toc::const_iterator const en = toc.end(); + // 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) - entries.push_back(IndexEntry(it->str(), it->dit())); + 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='tochead " + tocclass + "'"; + 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", "class='index'"); - xs << html::StartTag(lay.htmltag(), lay.htmlattr()) - << _("Index") - << html::EndTag(lay.htmltag()); - xs << html::StartTag("ul", "class='main'"); + XMLStream xs(ods); + + xs << xml::StartTag("div", tocattr); + xs << xml::StartTag(lay.htmltag(), lay.htmlattr()) + << translateIfPossible(from_ascii("Index"), + op.local_font->language()->lang()) + << xml::EndTag(lay.htmltag()); + xs << xml::StartTag("ul", "class='main'"); Font const dummy; vector::const_iterator eit = entries.begin(); @@ -730,13 +996,11 @@ docstring InsetPrintIndex::xhtml(XHTMLStream &, OutputParams const & op) const // close last entry or entries, depending. if (level == 3) { // close this sub-sub-entry - xs << html::EndTag("li"); - xs.cr(); + xs << xml::EndTag("li") << xml::CR(); // is this another sub-sub-entry within the same sub-entry? if (!eit->same_sub(last)) { // close this level - xs << html::EndTag("ul"); - xs.cr(); + xs << xml::EndTag("ul") << xml::CR(); level = 2; } } @@ -746,14 +1010,12 @@ docstring InsetPrintIndex::xhtml(XHTMLStream &, OutputParams const & op) const // 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"); - xs.cr(); + // close sub-entry + xs << xml::EndTag("li") << xml::CR(); // is this another sub-entry with the same main entry? if (!eit->same_main(last)) { // close this level - xs << html::EndTag("ul"); - xs.cr(); + xs << xml::EndTag("ul") << xml::CR(); level = 1; } } @@ -762,8 +1024,7 @@ docstring InsetPrintIndex::xhtml(XHTMLStream &, OutputParams const & op) const // close the entry. if (level == 1 && !eit->same_main(last)) { // close entry - xs << html::EndTag("li"); - xs.cr(); + xs << xml::EndTag("li") << xml::CR(); } } @@ -773,11 +1034,11 @@ docstring InsetPrintIndex::xhtml(XHTMLStream &, OutputParams const & op) const // We need to use our own stream, since we will have to // modify what we get back. odocstringstream ent; - XHTMLStream entstream(ent); + XMLStream 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. @@ -788,13 +1049,13 @@ docstring InsetPrintIndex::xhtml(XHTMLStream &, OutputParams const & op) const parseItem(main, true); parseItem(sub, true); parseItem(subsub, true); - + if (level == 3) { // another subsubentry - xs << html::StartTag("li", "class='subsubentry'") - << XHTMLStream::ESCAPE_NONE << subsub; + xs << xml::StartTag("li", "class='subsubentry'") + << XMLStream::ESCAPE_NONE << subsub; } else if (level == 2) { - // there are two ways we can be here: + // 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. @@ -805,18 +1066,18 @@ docstring InsetPrintIndex::xhtml(XHTMLStream &, OutputParams const & op) const // 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; + xs << xml::StartTag("li", "class='subentry'") + << XMLStream::ESCAPE_NONE << sub; if (!subsub.empty()) { // it's actually a subsubentry, so we need to start that list - xs.cr(); - xs << html::StartTag("ul", "class='subsubentry'") - << html::StartTag("li", "class='subsubentry'") - << XHTMLStream::ESCAPE_NONE << subsub; + xs << xml::CR() + << xml::StartTag("ul", "class='subsubentry'") + << xml::StartTag("li", "class='subsubentry'") + << XMLStream::ESCAPE_NONE << subsub; level = 3; - } + } } else { - // there are also two ways we can be here: + // 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. @@ -827,40 +1088,38 @@ docstring InsetPrintIndex::xhtml(XHTMLStream &, OutputParams const & op) const // 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; + xs << xml::StartTag("li", "class='main'") << main; if (!sub.empty()) { // there's a sub-entry, too - xs.cr(); - xs << html::StartTag("ul", "class='subentry'") - << html::StartTag("li", "class='subentry'") - << XHTMLStream::ESCAPE_NONE << sub; + xs << xml::CR() + << xml::StartTag("ul", "class='subentry'") + << xml::StartTag("li", "class='subentry'") + << XMLStream::ESCAPE_NONE << sub; level = 2; if (!subsub.empty()) { // and a sub-sub-entry - xs.cr(); - xs << html::StartTag("ul", "class='subsubentry'") - << html::StartTag("li", "class='subsubentry'") - << XHTMLStream::ESCAPE_NONE << subsub; + xs << xml::CR() + << xml::StartTag("ul", "class='subsubentry'") + << xml::StartTag("li", "class='subsubentry'") + << XMLStream::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"); + xs << " " << xml::StartTag("a", parattr) + << ++entry_number << xml::EndTag("a"); last = *eit; } // now we have to close all the open levels while (level > 0) { - xs << html::EndTag("li") << html::EndTag("ul"); - xs.cr(); + xs << xml::EndTag("li") << xml::EndTag("ul") << xml::CR(); --level; } - xs << html::EndTag("div"); - xs.cr(); + xs << xml::EndTag("div") << xml::CR(); return ods.str(); }