X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Finsets%2FInsetIndex.cpp;h=05da188678e31f0008f13186c8c9f0aad9a9e45b;hb=2777b51c587cb061b3214c670a3cc4b357528e6c;hp=9e33c3e3b5fb01c986a28f2be69d54573ce48997;hpb=9e9c96035cd48e30f658c96a8448c99c868772b3;p=lyx.git

diff --git a/src/insets/InsetIndex.cpp b/src/insets/InsetIndex.cpp
index 9e33c3e3b5..05da188678 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 <ostream>
 #include <algorithm>
+#include <ostream>
 
 using namespace std;
 using namespace lyx::support;
@@ -53,12 +55,11 @@ 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 & os, OutputParams const & runparams_in) const
 {
 	OutputParams runparams(runparams_in);
 	runparams.inIndexEntry = true;
@@ -66,17 +67,19 @@ int InsetIndex::latex(odocstream & 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);
+	// 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);
 	docstring latexstr = ourlatex.str();
@@ -127,22 +130,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<docstring, docstring> 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,24 +151,20 @@ 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;
 }
 
 
@@ -184,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 + "'";
@@ -207,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
@@ -226,7 +221,7 @@ void InsetIndex::doDispatch(Cursor & cur, FuncRequest & cmd)
 		break;
 
 	default:
-		InsetCollapsable::doDispatch(cur, cmd);
+		InsetCollapsible::doDispatch(cur, cmd);
 		break;
 	}
 }
@@ -248,8 +243,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();
@@ -258,7 +252,7 @@ bool InsetIndex::getStatus(Cursor & cur, FuncRequest const & cmd,
 	}
 
 	default:
-		return InsetCollapsable::getStatus(cur, cmd, flag);
+		return InsetCollapsible::getStatus(cur, cmd, flag);
 	}
 }
 
@@ -266,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;
 }
 
@@ -319,16 +313,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,15 +350,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));
+	pit.push_back(CursorSlice(const_cast<InsetIndex &>(*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();
 }
 
 
@@ -374,13 +375,13 @@ void InsetIndex::validate(LaTeXFeatures & features) const
 	    && !params_.index.empty()
 	    && params_.index != "idx")
 		features.require("splitidx");
-	InsetCollapsable::validate(features);
+	InsetCollapsible::validate(features);
 }
 
 
-docstring InsetIndex::contextMenuName() const
+string InsetIndex::contextMenuName() const
 {
-	return from_ascii("context-index");
+	return "context-index";
 }
 
 
@@ -434,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_;
 }
@@ -476,22 +480,22 @@ 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");
+				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);
@@ -501,6 +505,7 @@ void InsetPrintIndex::doDispatch(Cursor & cur, FuncRequest & cmd)
 			cur.noScreenUpdate();
 			break;
 		}
+		cur.recordUndo();
 		setParams(p);
 		break;
 	}
@@ -545,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;
@@ -557,16 +562,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;
 }
 
 
@@ -575,13 +588,14 @@ void InsetPrintIndex::validate(LaTeXFeatures & features) const
 	features.require("makeidx");
 	if (buffer().masterBuffer()->params().use_indices)
 		features.require("splitidx");
+	InsetCommand::validate(features);
 }
 
 
-docstring InsetPrintIndex::contextMenuName() const
+string InsetPrintIndex::contextMenuName() const
 {
 	return buffer().masterBuffer()->params().use_indices ?
-		from_ascii("context-indexprint") : docstring();
+		"context-indexprint" : string();
 }
 
 
@@ -608,7 +622,7 @@ void parseItem(docstring & s, bool for_output)
 		s.erase(loc);
 }
 
-	
+
 void extractSubentries(docstring const & entry, docstring & main,
 		docstring & sub1, docstring & sub2)
 {
@@ -633,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);
@@ -644,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;
@@ -668,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
@@ -688,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 const> 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<IndexEntry> 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
@@ -711,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;
@@ -735,13 +760,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;
 					}
 				}
@@ -751,14 +774,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;
 					}
 				}
@@ -767,8 +788,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();
 				}
 			}
 
@@ -782,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.
@@ -793,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.
@@ -810,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.cr();
-					xs << html::StartTag("ul", "class='subsubentry'") 
-					   << html::StartTag("li", "class='subsubentry'") 
+					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.
@@ -835,20 +855,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'") 
+					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'") 
+						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
@@ -860,12 +880,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();
 }