X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Finsets%2FInsetIndex.cpp;h=aff40805d4c360002b2093bb1797d6bdece57e77;hb=f3cb98c784cea4c778ad11496985f452a703d6a2;hp=384e88cb105f8eedfa235c8d3b3fc20f26e18544;hpb=e45427de389bc188f02ebe0de2c052740dcde09c;p=lyx.git

diff --git a/src/insets/InsetIndex.cpp b/src/insets/InsetIndex.cpp
index 384e88cb10..aff40805d4 100644
--- a/src/insets/InsetIndex.cpp
+++ b/src/insets/InsetIndex.cpp
@@ -16,16 +16,19 @@
 #include "BufferParams.h"
 #include "BufferView.h"
 #include "ColorSet.h"
+#include "Cursor.h"
 #include "DispatchResult.h"
 #include "Encoding.h"
 #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 "TextClass.h"
 #include "TocBackend.h"
 
 #include "support/debug.h"
@@ -35,6 +38,7 @@
 
 #include "frontends/alert.h"
 
+#include <algorithm>
 #include <ostream>
 
 using namespace std;
@@ -54,8 +58,7 @@ InsetIndex::InsetIndex(Buffer * buf, InsetIndexParams const & 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;
@@ -63,17 +66,18 @@ 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
+	TexRow texrow;
 	odocstringstream ourlatex;
-	InsetText::latex(ourlatex, runparams);
+	otexstream ots(ourlatex, texrow);
+	InsetText::latex(ots, runparams);
 	odocstringstream ourplain;
 	InsetText::plaintext(ourplain, runparams);
 	docstring latexstr = ourlatex.str();
@@ -131,15 +135,11 @@ int InsetIndex::latex(odocstream & os,
 			// 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"
@@ -149,24 +149,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;
 }
 
 
@@ -204,12 +200,17 @@ void InsetIndex::doDispatch(Cursor & cur, FuncRequest & cmd)
 
 	case LFUN_INSET_MODIFY: {
 		if (cmd.getArg(0) == "changetype") {
+			cur.recordUndoInset(this);
 			params_.index = from_utf8(cmd.getArg(1));
 			break;
 		}
 		InsetIndexParams params;
 		InsetIndex::string2params(to_utf8(cmd.argument()), params);
+		cur.recordUndoInset(this);
 		params_.index = params.index;
+		// what we really want here is a TOC update, but that means
+		// a full buffer update
+		cur.forceBufferUpdate();
 		break;
 	}
 
@@ -240,8 +241,7 @@ bool InsetIndex::getStatus(Cursor & cur, FuncRequest const & cmd,
 				from_utf8(cmd.getArg(1)) == params_.index);
 			return true;
 		}
-		flag.setEnabled(true);
-		return true;
+		return InsetCollapsable::getStatus(cur, cmd, flag);
 
 	case LFUN_INSET_DIALOG_UPDATE: {
 		Buffer const & realbuffer = *buffer().masterBuffer();
@@ -282,11 +282,7 @@ docstring InsetIndex::toolTip(BufferView const &, int, int) const
 		tip += ")";
 	}
 	tip += ": ";
-	OutputParams rp(&buffer().params().encoding());
-	odocstringstream ods;
-	InsetText::plaintext(ods, rp);
-	tip += ods.str();
-	return wrapParas(tip);
+	return toolTipText(tip);
 }
 
 
@@ -315,7 +311,7 @@ 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);
 }
@@ -352,14 +348,20 @@ 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) const
 {
 	DocIterator pit = cpit;
-	pit.push_back(CursorSlice(*this));
-	docstring const item = text().asString(0, 1, AS_STR_LABEL | AS_STR_INSETS);
-	buffer().tocBackend().toc("index").push_back(TocItem(pit, 0, item));
+	pit.push_back(CursorSlice(const_cast<InsetIndex &>(*this)));
+	docstring 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);
+	buffer().tocBackend().toc(type)->push_back(TocItem(pit, 0, str, output_active));
 	// Proceed with the rest of the inset.
-	InsetCollapsable::addToToc(cpit);
+	InsetCollapsable::addToToc(cpit, output_active, utype);
 }
 
 
@@ -369,12 +371,13 @@ void InsetIndex::validate(LaTeXFeatures & features) const
 	    && !params_.index.empty()
 	    && params_.index != "idx")
 		features.require("splitidx");
+	InsetCollapsable::validate(features);
 }
 
 
-docstring InsetIndex::contextMenu(BufferView const &, int, int) const
+string InsetIndex::contextMenuName() const
 {
-	return from_ascii("context-index");
+	return "context-index";
 }
 
 
@@ -420,7 +423,7 @@ void InsetIndexParams::read(Lexer & lex)
 ///////////////////////////////////////////////////////////////////////
 
 InsetPrintIndex::InsetPrintIndex(Buffer * buf, InsetCommandParams const & p)
-	: InsetCommand(buf, p, "index_print")
+	: InsetCommand(buf, p)
 {}
 
 
@@ -428,7 +431,8 @@ 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("type", ParamInfo::LATEX_OPTIONAL,
+		                ParamInfo::HANDLING_ESCAPE);
 		param_info_.add("name", ParamInfo::LATEX_REQUIRED);
 	}
 	return param_info_;
@@ -448,7 +452,7 @@ docstring InsetPrintIndex::screenLabel() const
 	Index const * index = indiceslist.findShortcut(getParam("type"));
 	if (!index && !printall)
 		return _("Unknown index type!");
-	docstring res = printall ? _("All indices") : index->index();
+	docstring res = printall ? _("All indexes") : index->index();
 	if (!multind)
 		res += " (" + _("non-active") + ")";
 	else if (contains(getCmdName(), "printsubindex"))
@@ -475,6 +479,7 @@ void InsetPrintIndex::doDispatch(Cursor & cur, FuncRequest & cmd)
 				cmd = subst(cmd, "printindex", "printsubindex");
 			else
 				cmd = subst(cmd, "printsubindex", "printindex");
+			cur.recordUndo();
 			setCmdName(cmd);
 			break;
 		} else if (cmd.argument() == from_ascii("check-printindex*")) {
@@ -482,18 +487,19 @@ void InsetPrintIndex::doDispatch(Cursor & cur, FuncRequest & cmd)
 			if (suffixIs(cmd, '*'))
 				break;
 			cmd += '*';
+			cur.recordUndo();
 			setParam("type", docstring());
 			setCmdName(cmd);
 			break;
 		}
 		InsetCommandParams p(INDEX_PRINT_CODE);
 		// FIXME UNICODE
-		InsetCommand::string2params("index_print",
-			to_utf8(cmd.argument()), p);
+		InsetCommand::string2params(to_utf8(cmd.argument()), p);
 		if (p.getCmdName().empty()) {
-			cur.noUpdate();
+			cur.noScreenUpdate();
 			break;
 		}
+		cur.recordUndo();
 		setParams(p);
 		break;
 	}
@@ -522,8 +528,7 @@ bool InsetPrintIndex::getStatus(Cursor & cur, FuncRequest const & cmd,
 		} if (cmd.getArg(0) == "index_print"
 		    && cmd.getArg(1) == "CommandInset") {
 			InsetCommandParams p(INDEX_PRINT_CODE);
-			InsetCommand::string2params("index_print",
-				to_utf8(cmd.argument()), p);
+			InsetCommand::string2params(to_utf8(cmd.argument()), p);
 			if (suffixIs(p.getCmdName(), '*')) {
 				status.setEnabled(true);
 				status.setOnOff(false);
@@ -551,16 +556,15 @@ bool InsetPrintIndex::getStatus(Cursor & cur, FuncRequest const & cmd,
 }
 
 
-int InsetPrintIndex::latex(odocstream & os, OutputParams const & runparams_in) const
+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;
+		return;
 	}
 	OutputParams runparams = runparams_in;
 	os << getCommand(runparams);
-	return 0;
 }
 
 
@@ -572,10 +576,10 @@ void InsetPrintIndex::validate(LaTeXFeatures & features) const
 }
 
 
-docstring InsetPrintIndex::contextMenu(BufferView const &, int, int) const
+string InsetPrintIndex::contextMenuName() const
 {
 	return buffer().masterBuffer()->params().use_indices ?
-		from_ascii("context-indexprint") : docstring();
+		"context-indexprint" : string();
 }
 
 
@@ -662,9 +666,12 @@ 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
@@ -683,21 +690,28 @@ docstring InsetPrintIndex::xhtml(XHTMLStream &, OutputParams const & op) const
 	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
@@ -705,9 +719,10 @@ docstring InsetPrintIndex::xhtml(XHTMLStream &, OutputParams const & op) const
 	odocstringstream ods;
 	XHTMLStream xs(ods);
 
-	xs << html::StartTag("div", "class='index'");
+	xs << html::StartTag("div", tocattr);
 	xs << html::StartTag(lay.htmltag(), lay.htmlattr()) 
-		 << _("Index") 
+		 << translateIfPossible(from_ascii("Index"),
+	                          op.local_font->language()->lang())
 		 << html::EndTag(lay.htmltag());
 	xs << html::StartTag("ul", "class='main'");
 	Font const dummy;
@@ -729,13 +744,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;
 					}
 				}
@@ -746,13 +759,11 @@ docstring InsetPrintIndex::xhtml(XHTMLStream &, OutputParams const & op) const
 				// 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();
+					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;
 					}
 				}
@@ -761,8 +772,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();
 				}
 			}
 
@@ -791,7 +801,7 @@ docstring InsetPrintIndex::xhtml(XHTMLStream &, OutputParams const & op) const
 			if (level == 3) {
 				// another subsubentry
 				xs << html::StartTag("li", "class='subsubentry'") 
-				   << XHTMLStream::NextRaw() << subsub;
+				   << XHTMLStream::ESCAPE_NONE << subsub;
 			} else if (level == 2) {
 				// there are two ways we can be here: 
 				// (i) we can actually be inside a sub-entry already and be about
@@ -805,13 +815,13 @@ docstring InsetPrintIndex::xhtml(XHTMLStream &, OutputParams const & op) const
 				// have a sub-sub-entry.
 				if (eit->sub != last.sub)
 					xs << html::StartTag("li", "class='subentry'") 
-					   << XHTMLStream::NextRaw() << sub;
+					   << 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'") 
+					xs << html::CR()
+					   << html::StartTag("ul", "class='subsubentry'") 
 					   << html::StartTag("li", "class='subsubentry'") 
-					   << XHTMLStream::NextRaw() << subsub;
+					   << XHTMLStream::ESCAPE_NONE << subsub;
 					level = 3;
 				} 
 			} else {
@@ -829,17 +839,17 @@ 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'") 
+					xs << html::CR()
+					   << html::StartTag("ul", "class='subentry'") 
 					   << html::StartTag("li", "class='subentry'") 
-					   << XHTMLStream::NextRaw() << sub;
+					   << XHTMLStream::ESCAPE_NONE << sub;
 					level = 2;
 					if (!subsub.empty()) {
 						// and a sub-sub-entry
-						xs.cr();
-						xs << html::StartTag("ul", "class='subsubentry'") 
+						xs << html::CR()
+						   << html::StartTag("ul", "class='subsubentry'") 
 						   << html::StartTag("li", "class='subsubentry'") 
-						   << XHTMLStream::NextRaw() << subsub;
+						   << XHTMLStream::ESCAPE_NONE << subsub;
 						level = 3;
 					}
 				} 
@@ -854,12 +864,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();
 }