X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Finsets%2FInsetIndex.cpp;h=584fb280c78d74396d77839092167861bc14f52f;hb=4947476da8d7e42ded2c53ee984dc4c38db1d528;hp=51ba81be84ff9999b7238b6065ff0862241ac122;hpb=7287a259c5436b8f3f384c0d0bd7641a2f2601e9;p=lyx.git diff --git a/src/insets/InsetIndex.cpp b/src/insets/InsetIndex.cpp index 51ba81be84..584fb280c7 100644 --- a/src/insets/InsetIndex.cpp +++ b/src/insets/InsetIndex.cpp @@ -22,11 +22,13 @@ #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" @@ -37,8 +39,8 @@ #include "frontends/alert.h" -#include #include +#include using namespace std; using namespace lyx::support; @@ -53,7 +55,7 @@ namespace lyx { InsetIndex::InsetIndex(Buffer * buf, InsetIndexParams const & params) - : InsetCollapsable(buf), params_(params) + : InsetCollapsible(buf), params_(params) {} @@ -65,7 +67,7 @@ void InsetIndex::latex(otexstream & os, OutputParams const & runparams_in) const 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"; @@ -73,9 +75,10 @@ void InsetIndex::latex(otexstream & os, OutputParams const & runparams_in) const } // get contents of InsetText as LaTeX and plaintext - TexRow texrow; odocstringstream ourlatex; - otexstream ots(ourlatex, texrow); + // 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); @@ -127,22 +130,18 @@ void InsetIndex::latex(otexstream & os, OutputParams const & runparams_in) const // 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" @@ -152,7 +151,7 @@ void InsetIndex::latex(otexstream & os, OutputParams const & runparams_in) const } // 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 << '@'; } @@ -180,7 +179,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 + "'"; @@ -203,13 +202,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 +221,7 @@ void InsetIndex::doDispatch(Cursor & cur, FuncRequest & cmd) break; default: - InsetCollapsable::doDispatch(cur, cmd); + InsetCollapsible::doDispatch(cur, cmd); break; } } @@ -244,7 +243,7 @@ bool InsetIndex::getStatus(Cursor & cur, FuncRequest const & cmd, from_utf8(cmd.getArg(1)) == params_.index); return true; } - return InsetCollapsable::getStatus(cur, cmd, flag); + return InsetCollapsible::getStatus(cur, cmd, flag); case LFUN_INSET_DIALOG_UPDATE: { Buffer const & realbuffer = *buffer().masterBuffer(); @@ -253,7 +252,7 @@ bool InsetIndex::getStatus(Cursor & cur, FuncRequest const & cmd, } default: - return InsetCollapsable::getStatus(cur, cmd, flag); + return InsetCollapsible::getStatus(cur, cmd, flag); } } @@ -261,11 +260,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; } @@ -316,14 +315,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); } @@ -351,15 +350,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(); } @@ -369,7 +375,7 @@ void InsetIndex::validate(LaTeXFeatures & features) const && !params_.index.empty() && params_.index != "idx") features.require("splitidx"); - InsetCollapsable::validate(features); + InsetCollapsible::validate(features); } @@ -429,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_; } @@ -496,6 +505,7 @@ void InsetPrintIndex::doDispatch(Cursor & cur, FuncRequest & cmd) cur.noScreenUpdate(); break; } + cur.recordUndo(); setParams(p); break; } @@ -540,7 +550,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; @@ -552,11 +562,20 @@ bool InsetPrintIndex::getStatus(Cursor & cur, FuncRequest const & cmd, } +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{}"; + os << "\\printindex" << termcmd; return; } OutputParams runparams = runparams_in; @@ -569,6 +588,7 @@ void InsetPrintIndex::validate(LaTeXFeatures & features) const features.require("makeidx"); if (buffer().masterBuffer()->params().use_indices) features.require("splitidx"); + InsetCommand::validate(features); } @@ -602,7 +622,7 @@ void parseItem(docstring & s, bool for_output) s.erase(loc); } - + void extractSubentries(docstring const & entry, docstring & main, docstring & sub1, docstring & sub2) { @@ -627,10 +647,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); @@ -638,22 +658,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; @@ -662,12 +682,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 @@ -682,22 +705,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 @@ -705,9 +735,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; @@ -743,7 +774,7 @@ 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 + // close sub-entry xs << html::EndTag("li") << html::CR(); // is this another sub-entry with the same main entry? if (!eit->same_main(last)) { @@ -771,7 +802,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. @@ -782,13 +813,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'") + 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. @@ -799,18 +830,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'") + 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'") + << 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. @@ -825,19 +856,19 @@ docstring InsetPrintIndex::xhtml(XHTMLStream &, OutputParams const & op) const if (!sub.empty()) { // there's a sub-entry, too xs << html::CR() - << html::StartTag("ul", "class='subentry'") - << html::StartTag("li", "class='subentry'") + << 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'") + << 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