#include "LaTeX.h"
#include "LaTeXFeatures.h"
#include "Lexer.h"
+#include "LyX.h"
#include "output_latex.h"
#include "output_xhtml.h"
#include "xml.h"
using namespace std;
using namespace lyx::support;
+// Uncomment to enable InsetIndex-specific debugging mode: the tree for the index will be printed to std::cout.
+// #define LYX_INSET_INDEX_DEBUG
+
namespace lyx {
namespace {
getSortkey(os, runparams);
os << "@";
os << ourlatex.str();
- getSubentries(os, runparams);
+ getSubentries(os, runparams, ourlatex.str());
if (hasSeeRef()) {
os << "|";
os << insetindexpagerangetranslator_latex().find(params_.range);
getSeeRefs(os, runparams);
+ } else if (!params_.pagefmt.empty() && params_.pagefmt != "default") {
+ os << "|";
+ os << insetindexpagerangetranslator_latex().find(params_.range);
+ os << from_utf8(params_.pagefmt);
}
} else {
// We check whether we need a sort key.
odocstringstream subentries;
otexstream otsub(subentries);
- getSubentries(otsub, runparams);
+ getSubentries(otsub, runparams, ourlatex.str());
if (subentries.str().empty()) {
// Separate the entries and subentries, i.e., split on "!".
// This goes wrong on an escaped "!", but as the escape
vector<docstring>::const_iterator it2 = levels_plain.begin();
bool first = true;
for (; it != end; ++it) {
+ if ((*it).empty()) {
+ emptySubentriesWarning(ourlatex.str());
+ if (it2 < levels_plain.end())
+ ++it2;
+ continue;
+ }
// The separator needs to be put back when
// writing the levels, except for the first level
if (!first)
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("<!-- Output Error: ") + error + 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) {
}
// Handle ranges. Happily, in the raw LaTeX mode, (| and |) can only be at the end of the string!
- bool hasInsetRange = params_.range != InsetIndexParams::PageRange::None;
- bool hasStartRange = params_.range == InsetIndexParams::PageRange::Start ||
+ const bool hasInsetRange = params_.range != InsetIndexParams::PageRange::None;
+ const bool hasStartRange = params_.range == InsetIndexParams::PageRange::Start ||
latexString.find(from_ascii("|(")) != lyx::docstring::npos;
- bool hasEndRange = params_.range == InsetIndexParams::PageRange::End ||
+ const bool hasEndRange = params_.range == InsetIndexParams::PageRange::End ||
latexString.find(from_ascii("|)")) != lyx::docstring::npos;
if (hasInsetRange) {
xs << XMLStream::ESCAPE_NONE << (from_utf8("<!-- Output Error: ") + error + from_utf8(" -->\n"));
}
- // Write all of this down.
+ // Write all of this down.
if (terms.empty() && !hasEndRange) {
docstring error = from_utf8("No index term found! Complete entry: \"") + latexString + from_utf8("\"");
LYXERR0(error);
cur.bv().updateDialog("index", params2string(params_));
break;
+ case LFUN_PARAGRAPH_BREAK: {
+ // Since this inset in single-par anyway, let's use
+ // return to enter subentries
+ FuncRequest fr(LFUN_INDEXMACRO_INSERT, "subentry");
+ lyx::dispatch(fr);
+ break;
+ }
+
default:
InsetCollapsible::doDispatch(cur, cmd);
break;
return true;
}
+ case LFUN_PARAGRAPH_BREAK:
+ return macrosPossible("subentry");
+
case LFUN_INDEXMACRO_INSERT:
return macrosPossible(cmd.getArg(0));
}
-void InsetIndex::getSubentries(otexstream & os, OutputParams const & runparams) const
+void InsetIndex::emptySubentriesWarning(docstring const & mainentry) const
+{
+ // Empty subentries crash makeindex. So warn and ignore this.
+ TeXErrors terr;
+ ErrorList & errorList = buffer().errorList("Export");
+ docstring const s = bformat(_("There is an empty index subentry in the entry '%1$s'.\n"
+ "It will be ignored in the output."), mainentry);
+ Paragraph const & par = buffer().paragraphs().front();
+ errorList.push_back(ErrorItem(_("Empty index subentry!"), s,
+ {par.id(), 0}, {par.id(), -1}));
+ buffer().bufferErrors(terr, errorList);
+}
+
+
+void InsetIndex::getSubentries(otexstream & os, OutputParams const & runparams,
+ docstring const & mainentry) const
{
Paragraph const & par = paragraphs().front();
InsetList::const_iterator it = par.insetList().begin();
if (inset.lyxCode() == INDEXMACRO_CODE) {
InsetIndexMacro const & iim =
static_cast<InsetIndexMacro const &>(inset);
- if (iim.params().type == InsetIndexMacroParams::Subindex) {
+ if (iim.params().type == InsetIndexMacroParams::Subentry) {
+ if (iim.hasNoContent()) {
+ emptySubentriesWarning(mainentry);
+ continue;
+ }
++i;
if (i > 2)
return;
}
-std::vector<docstring> InsetIndex::getSubentriesAsText(OutputParams const & runparams) const
+std::vector<docstring> InsetIndex::getSubentriesAsText(OutputParams const & runparams,
+ bool const asLabel) const
{
std::vector<docstring> subentries;
if (inset.lyxCode() == INDEXMACRO_CODE) {
InsetIndexMacro const & iim =
static_cast<InsetIndexMacro const &>(inset);
- if (iim.params().type == InsetIndexMacroParams::Subindex) {
+ if (iim.params().type == InsetIndexMacroParams::Subentry) {
++i;
if (i > 2)
break;
-
- otexstringstream os;
- iim.getLatex(os, runparams);
- subentries.emplace_back(os.str());
+ if (asLabel) {
+ docstring const l;
+ docstring const sl = iim.getNewLabel(l);
+ subentries.emplace_back(sl);
+ } else {
+ otexstringstream os;
+ iim.getLatex(os, runparams);
+ subentries.emplace_back(os.str());
+ }
}
}
}
bool InsetIndex::hasSubentries() const
{
- return hasInsetWithCode(this, INDEXMACRO_CODE, {InsetIndexMacroParams::Subindex});
+ return hasInsetWithCode(this, INDEXMACRO_CODE, {InsetIndexMacroParams::Subentry});
}
bool InsetIndex::macrosPossible(string const type) const
{
if (type != "see" && type != "seealso"
- && type != "sortkey" && type != "subindex")
+ && type != "sortkey" && type != "subentry")
return false;
Paragraph const & par = paragraphs().front();
&& (iim.params().type == InsetIndexMacroParams::See
|| iim.params().type == InsetIndexMacroParams::Seealso))
return false;
- if (type == "subindex"
- && iim.params().type == InsetIndexMacroParams::Subindex) {
+ if (type == "subentry"
+ && iim.params().type == InsetIndexMacroParams::Subentry) {
++subidxs;
if (subidxs > 1)
return false;
docstring res;
if (!il.contentaslabel() || geometry(bv) != ButtonOnly)
res = label;
- else
+ else {
res = getNewLabel(label);
+ OutputParams const rp(0);
+ vector<docstring> sublbls = getSubentriesAsText(rp, true);
+ for (auto const & sublbl : sublbls) {
+ res += " " + docstring(1, char_type(0x2023));// TRIANGULAR BULLET
+ res += " " + sublbl;
+ }
+ }
if (!insetindexpagerangetranslator_latex().find(params_.range).empty())
res += " " + from_ascii(insetindexpagerangetranslator_latex().find(params_.range));
return res;
DocIterator pit = cpit;
pit.push_back(CursorSlice(const_cast<InsetIndex &>(*this)));
docstring str;
+ InsetLayout const & il = getLayout();
+ docstring label = translateIfPossible(il.labelstring());
+ if (!il.contentaslabel())
+ str = label;
+ else {
+ str = getNewLabel(label);
+ OutputParams const rp(0);
+ vector<docstring> sublbls = getSubentriesAsText(rp, true);
+ for (auto const & sublbl : sublbls) {
+ str += " " + docstring(1, char_type(0x2023));// TRIANGULAR BULLET
+ str += " " + sublbl;
+ }
+ }
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.
if (lhs.terms_.empty())
return false;
- for (int i = 0; i < min(rhs.terms_.size(), lhs.terms_.size()); ++i) {
+ for (unsigned i = 0; i < min(rhs.terms_.size(), lhs.terms_.size()); ++i) {
int comp = compare_no_case(lhs.terms_[i], rhs.terms_[i]);
if (comp != 0)
return comp < 0;
return index_root;
}
-void outputIndexPage(XMLStream & xs, const IndexNode* root_node, unsigned depth = 0)
+void outputIndexPage(XMLStream & xs, const IndexNode* root_node, unsigned depth = 0) // NOLINT(misc-no-recursion)
{
LASSERT(root_node->entries.size() + root_node->children.size() > 0, return);
// By tree assumption, all the entries at this node have the same set of terms.
if (!root_node->entries.empty()) {
- xs << XMLStream::ESCAPE_NONE << " — ";
+ xs << XMLStream::ESCAPE_NONE << " — "; // Em dash, i.e. long (---).
unsigned entry_number = 1;
- for (unsigned i = 0; i < root_node->entries.size(); ++i) {
- const IndexEntry &entry = root_node->entries[i];
-
+ auto writeLinkToEntry = [&xs](const IndexEntry &entry, unsigned entry_number) {
std::string const link_attr = "href='#" + entry.inset()->paragraphs()[0].magicLabel() + "'";
xs << xml::StartTag("a", link_attr);
xs << from_ascii(std::to_string(entry_number));
xs << xml::EndTag("a");
+ };
+
+ for (unsigned i = 0; i < root_node->entries.size(); ++i) {
+ const IndexEntry &entry = root_node->entries[i];
+
+ switch (entry.inset()->params().range) {
+ case InsetIndexParams::PageRange::None:
+ writeLinkToEntry(entry, entry_number);
+ break;
+ case InsetIndexParams::PageRange::Start: {
+ // Try to find the end of the range, if it is just after. Otherwise, the output will be slightly
+ // scrambled, but understandable. Doing better would mean implementing more of the indexing logic here
+ // and more complex indexing here (skipping the end is not just incrementing i). Worst case output:
+ // 1--, 2, --3
+ const bool nextEntryIsEnd = i + 1 < root_node->entries.size() &&
+ root_node->entries[i + 1].inset()->params().range ==
+ InsetIndexParams::PageRange::End;
+ // No need to check if both entries are for the same terms: they are in the same IndexNode.
+
+ writeLinkToEntry(entry, entry_number);
+ xs << XMLStream::ESCAPE_NONE << " – "; // En dash, i.e. semi-long (--).
+
+ if (nextEntryIsEnd) {
+ // Skip the next entry in the loop, write it right now, after the dash.
+ entry_number += 1;
+ i += 1;
+ writeLinkToEntry(root_node->entries[i], entry_number);
+ }
+ }
+ break;
+ case InsetIndexParams::PageRange::End:
+ // This range end was not caught by the range start, do it now to avoid losing content.
+ xs << XMLStream::ESCAPE_NONE << " – "; // En dash, i.e. semi-long (--).
+ writeLinkToEntry(root_node->entries[i], entry_number);
+ }
if (i < root_node->entries.size() - 1) {
xs << ", ";
xs << xml::CR();
}
-// Only useful for debugging.
+#ifdef LYX_INSET_INDEX_DEBUG
void printTree(const IndexNode* root_node, unsigned depth = 0)
{
static const std::string pattern = " ";
printTree(node, depth + 1);
}
}
+#endif // LYX_INSET_INDEX_DEBUG
}
{
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 const> toc = buffer().tocBackend().toc("index");
if (toc->empty())
return docstring();
// Collect the index entries in a form we can use them.
vector<IndexEntry> entries;
+ const docstring & indexType = params().getParamOr("type", from_ascii("idx"));
for (const TocItem& item : *toc) {
- if (item.isOutput())
- entries.emplace_back(IndexEntry{static_cast<const InsetIndex*>(&(item.dit().inset())), &op});
+ const auto* inset = static_cast<const InsetIndex*>(&(item.dit().inset()));
+ if (item.isOutput() && inset->params().index == indexType)
+ entries.emplace_back(IndexEntry{inset, &op});
}
// If all the index entries are in notes or not displayed, get out sooner.
return docstring();
const IndexNode* index_root = buildIndexTree(entries);
-#if 0
+#ifdef LYX_INSET_INDEX_DEBUG
printTree(index_root);
#endif
Layout const & lay = bp.documentClass().htmlTOCLayout();
string const & tocclass = lay.defaultCSSClass();
string const tocattr = "class='index " + tocclass + "'";
+ docstring const indexName = params().getParamOr("name", from_ascii("Index"));
// 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
xs << xml::StartTag("div", tocattr);
xs << xml::CR();
xs << xml::StartTag(lay.htmltag(), lay.htmlattr());
- xs << translateIfPossible(from_ascii("Index"), op.local_font->language()->lang());
+ xs << translateIfPossible(indexName, op.local_font->language()->lang());
xs << xml::EndTag(lay.htmltag());
xs << xml::CR();
xs << xml::StartTag("ul", "class='main'");
projects / features.git / blobdiff