InsetIndex::InsetIndex(Buffer * buf, InsetIndexParams const & params)
- : InsetCollapsable(buf), params_(params)
+ : InsetCollapsible(buf), params_(params)
{}
// 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
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 + "'";
break;
default:
- InsetCollapsable::doDispatch(cur, cmd);
+ InsetCollapsible::doDispatch(cur, cmd);
break;
}
}
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();
}
default:
- return InsetCollapsable::getStatus(cur, cmd, flag);
+ return InsetCollapsible::getStatus(cur, cmd, flag);
}
}
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;
}
{
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);
}
void InsetIndex::addToToc(DocIterator const & cpit, bool output_active,
- UpdateType utype) const
+ UpdateType utype, TocBackend & backend) const
{
DocIterator pit = cpit;
pit.push_back(CursorSlice(const_cast<InsetIndex &>(*this)));
type += ":" + to_utf8(params_.index);
// this is unlikely to be terribly long
text().forOutliner(str, INT_MAX);
- buffer().tocBackend().toc(type)->push_back(TocItem(pit, 0, str, output_active));
+ TocBuilder & b = backend.builder(type);
+ b.pushItem(pit, str, output_active);
// Proceed with the rest of the inset.
- InsetCollapsable::addToToc(cpit, output_active, utype);
+ InsetCollapsible::addToToc(cpit, output_active, utype, backend);
+ b.pop();
}
&& !params_.index.empty()
&& params_.index != "idx")
features.require("splitidx");
- InsetCollapsable::validate(features);
+ InsetCollapsible::validate(features);
}
static ParamInfo param_info_;
if (param_info_.empty()) {
param_info_.add("type", ParamInfo::LATEX_OPTIONAL,
- ParamInfo::HANDLING_ESCAPE);
- param_info_.add("name", ParamInfo::LATEX_REQUIRED);
+ ParamInfo::HANDLING_ESCAPE);
+ param_info_.add("name", ParamInfo::LATEX_OPTIONAL,
+ ParamInfo::HANDLING_LATEXIFY);
+ param_info_.add("literal", ParamInfo::LYX_INTERNAL);
}
return param_info_;
}
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);
} else
return InsetCommand::getStatus(cur, cmd, status);
}
-
+
case LFUN_INSET_DIALOG_UPDATE: {
status.setEnabled(buffer().masterBuffer()->params().use_indices);
return true;
}
+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;
features.require("makeidx");
if (buffer().masterBuffer()->params().use_indices)
features.require("splitidx");
+ InsetCommand::validate(features);
}
s.erase(loc);
}
-
+
void extractSubentries(docstring const & entry, docstring & main,
docstring & sub1, docstring & sub2)
{
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);
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;
return (comp < 0);
}
-} // anon namespace
+} // namespace
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();
-
+
shared_ptr<Toc const> toc = buffer().tocBackend().toc("index");
if (toc->empty())
return docstring();
XHTMLStream xs(ods);
xs << html::StartTag("div", tocattr);
- xs << html::StartTag(lay.htmltag(), lay.htmlattr())
+ xs << html::StartTag(lay.htmltag(), lay.htmlattr())
<< translateIfPossible(from_ascii("Index"),
op.local_font->language()->lang())
<< html::EndTag(lay.htmltag());
// 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)) {
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.
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.
// 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.
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