#include "LaTeX.h"
#include "LaTeXFeatures.h"
#include "Lexer.h"
+#include "LyX.h"
#include "output_latex.h"
#include "output_xhtml.h"
#include "xml.h"
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.
}
// 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));
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)
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 << ", ";
projects / features.git / blobdiff