X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Finsets%2FInsetIndex.cpp;h=f3fafce60b00d8af9d62813a074fa3314236634a;hb=62af7ee772f16f154225d2d0b65d77f4376b6001;hp=5db138e1dfcdb80ef930815c42e35ffb1d77916c;hpb=5577e877bb0a25a0919db09b10effe9f54ff1333;p=lyx.git diff --git a/src/insets/InsetIndex.cpp b/src/insets/InsetIndex.cpp index 5db138e1df..f3fafce60b 100644 --- a/src/insets/InsetIndex.cpp +++ b/src/insets/InsetIndex.cpp @@ -16,16 +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 "output_latex.h" #include "output_xhtml.h" #include "sgml.h" +#include "texstream.h" +#include "TextClass.h" #include "TocBackend.h" #include "support/debug.h" @@ -35,8 +39,8 @@ #include "frontends/alert.h" -#include #include +#include using namespace std; using namespace lyx::support; @@ -51,32 +55,40 @@ namespace lyx { InsetIndex::InsetIndex(Buffer * buf, InsetIndexParams const & params) - : InsetCollapsable(buf), params_(params) + : InsetCollapsible(buf), params_(params) {} -int InsetIndex::latex(odocstream & 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") { 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); + otexstream ots(ourlatex); + InsetText::latex(ots, runparams); + if (runparams.for_search) { + // No need for special handling, if we are only searching for some patterns + os << ourlatex.str() << "}"; + return; + } + // get contents of InsetText as LaTeX and plaintext odocstringstream ourplain; InsetText::plaintext(ourplain, runparams); + // FIXME: do Tex/Row correspondence (I don't currently understand what is + // being generated from latexstr below) docstring latexstr = ourlatex.str(); docstring plainstr = ourplain.str(); @@ -125,22 +137,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" @@ -150,24 +158,27 @@ 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 << '@'; - i += count_char(ppart, '\n'); } docstring const tpart = *it; os << tpart; - i += count_char(tpart, '\n'); if (it2 < levels_plain.end()) ++it2; } // write the bit that followed "|" if (!cmd.empty()) { os << "|" << cmd; - i += count_char(cmd, '\n'); } os << '}'; - return i; + + // 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(); } @@ -182,7 +193,7 @@ 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 + // 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 + "'"; @@ -205,11 +216,13 @@ void InsetIndex::doDispatch(Cursor & cur, FuncRequest & cmd) case LFUN_INSET_MODIFY: { if (cmd.getArg(0) == "changetype") { + cur.recordUndoInset(this); params_.index = from_utf8(cmd.getArg(1)); break; } InsetIndexParams params; InsetIndex::string2params(to_utf8(cmd.argument()), params); + 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 +235,7 @@ void InsetIndex::doDispatch(Cursor & cur, FuncRequest & cmd) break; default: - InsetCollapsable::doDispatch(cur, cmd); + InsetCollapsible::doDispatch(cur, cmd); break; } } @@ -244,8 +257,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 +266,7 @@ bool InsetIndex::getStatus(Cursor & cur, FuncRequest const & cmd, } default: - return InsetCollapsable::getStatus(cur, cmd, flag); + return InsetCollapsible::getStatus(cur, cmd, flag); } } @@ -262,11 +274,11 @@ 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)); if (c == Color_none) - c = InsetCollapsable::labelColor(); + c = InsetCollapsible::labelColor(); return c; } @@ -286,11 +298,7 @@ docstring InsetIndex::toolTip(BufferView const &, int, int) const tip += ")"; } tip += ": "; - OutputParams rp(&buffer().params().encoding()); - odocstringstream ods; - InsetText::plaintext(ods, rp); - tip += ods.str(); - return wrapParas(tip); + return toolTipText(tip); } @@ -319,16 +327,16 @@ docstring const InsetIndex::buttonLabel(BufferView const & bv) const 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); } @@ -356,14 +364,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(); } @@ -373,13 +389,13 @@ void InsetIndex::validate(LaTeXFeatures & features) const && !params_.index.empty() && params_.index != "idx") features.require("splitidx"); - InsetCollapsable::validate(features); + InsetCollapsible::validate(features); } -docstring InsetIndex::contextMenu(BufferView const &, int, int) const +string InsetIndex::contextMenuName() const { - return from_ascii("context-index"); + return "context-index"; } @@ -425,7 +441,7 @@ void InsetIndexParams::read(Lexer & lex) /////////////////////////////////////////////////////////////////////// InsetPrintIndex::InsetPrintIndex(Buffer * buf, InsetCommandParams const & p) - : InsetCommand(buf, p, "index_print") + : InsetCommand(buf, p) {} @@ -433,8 +449,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_; } @@ -453,7 +472,7 @@ docstring InsetPrintIndex::screenLabel() const Index const * index = indiceslist.findShortcut(getParam("type")); if (!index && !printall) return _("Unknown index type!"); - docstring res = printall ? _("All indices") : index->index(); + docstring res = printall ? _("All indexes") : index->index(); if (!multind) res += " (" + _("non-active") + ")"; else if (contains(getCmdName(), "printsubindex")) @@ -475,30 +494,32 @@ 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"); - setCmdName(cmd); + scmd = subst(scmd, "printsubindex", "printindex"); + cur.recordUndo(); + 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); // FIXME UNICODE - InsetCommand::string2params("index_print", - to_utf8(cmd.argument()), p); + InsetCommand::string2params(to_utf8(cmd.argument()), p); if (p.getCmdName().empty()) { cur.noScreenUpdate(); break; } + cur.recordUndo(); setParams(p); break; } @@ -527,8 +548,7 @@ bool InsetPrintIndex::getStatus(Cursor & cur, FuncRequest const & cmd, } if (cmd.getArg(0) == "index_print" && cmd.getArg(1) == "CommandInset") { InsetCommandParams p(INDEX_PRINT_CODE); - InsetCommand::string2params("index_print", - to_utf8(cmd.argument()), p); + InsetCommand::string2params(to_utf8(cmd.argument()), p); if (suffixIs(p.getCmdName(), '*')) { status.setEnabled(true); status.setOnOff(false); @@ -544,7 +564,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; @@ -556,16 +576,24 @@ bool InsetPrintIndex::getStatus(Cursor & cur, FuncRequest const & cmd, } -int InsetPrintIndex::latex(odocstream & os, OutputParams const & runparams_in) 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; } OutputParams runparams = runparams_in; os << getCommand(runparams); - return 0; } @@ -574,13 +602,14 @@ 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(); } @@ -607,7 +636,7 @@ void parseItem(docstring & s, bool for_output) s.erase(loc); } - + void extractSubentries(docstring const & entry, docstring & main, docstring & sub1, docstring & sub2) { @@ -632,10 +661,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); @@ -643,22 +672,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; @@ -667,12 +696,15 @@ 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 @@ -687,22 +719,29 @@ 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 @@ -710,9 +749,10 @@ docstring InsetPrintIndex::xhtml(XHTMLStream &, OutputParams const & op) const odocstringstream ods; XHTMLStream xs(ods); - xs << html::StartTag("div", "class='index'"); - xs << html::StartTag(lay.htmltag(), lay.htmlattr()) - << _("Index") + 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; @@ -734,13 +774,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 << 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"); - xs.cr(); + xs << html::EndTag("ul") << html::CR(); level = 2; } } @@ -750,14 +788,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 << 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"); - xs.cr(); + xs << html::EndTag("ul") << html::CR(); level = 1; } } @@ -766,8 +802,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 << html::EndTag("li") << html::CR(); } } @@ -781,7 +816,7 @@ docstring InsetPrintIndex::xhtml(XHTMLStream &, OutputParams const & op) const 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. @@ -792,13 +827,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::NextRaw() << subsub; + xs << html::StartTag("li", "class='subsubentry'") + << XHTMLStream::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. @@ -809,18 +844,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::NextRaw() << 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.cr(); - xs << html::StartTag("ul", "class='subsubentry'") - << html::StartTag("li", "class='subsubentry'") - << XHTMLStream::NextRaw() << subsub; + 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: + // 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. @@ -834,20 +869,20 @@ docstring InsetPrintIndex::xhtml(XHTMLStream &, OutputParams const & op) const xs << html::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::NextRaw() << sub; + 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.cr(); - xs << html::StartTag("ul", "class='subsubentry'") - << html::StartTag("li", "class='subsubentry'") - << XHTMLStream::NextRaw() << subsub; + 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 @@ -859,12 +894,10 @@ docstring InsetPrintIndex::xhtml(XHTMLStream &, OutputParams const & op) const } // now we have to close all the open levels while (level > 0) { - xs << html::EndTag("li") << html::EndTag("ul"); - xs.cr(); + xs << html::EndTag("li") << html::EndTag("ul") << html::CR(); --level; } - xs << html::EndTag("div"); - xs.cr(); + xs << html::EndTag("div") << html::CR(); return ods.str(); }