X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Finsets%2FInsetFloatList.cpp;h=6486b390a2e23260d61c07e8a5fcd6aed455e17a;hb=c1e10c71850adf8e5a19160e24e32c696aaf01a6;hp=64336f6660e8f263cf9e88135569ab650056fc8e;hpb=cdf13782003f6fca74b267c6b23d76bb9edaa65c;p=lyx.git

diff --git a/src/insets/InsetFloatList.cpp b/src/insets/InsetFloatList.cpp
index 64336f6660..6486b390a2 100644
--- a/src/insets/InsetFloatList.cpp
+++ b/src/insets/InsetFloatList.cpp
@@ -3,7 +3,7 @@
  * This file is part of LyX, the document processor.
  * Licence details can be found in the file COPYING.
  *
- * \author Lars Gullik Bjønnes
+ * \author Lars Gullik Bjønnes
  *
  * Full author contact details are available in file CREDITS.
  */
@@ -14,88 +14,112 @@
 
 #include "Buffer.h"
 #include "BufferParams.h"
-#include "debug.h"
+#include "BufferView.h"
+#include "Cursor.h"
 #include "DispatchResult.h"
 #include "Floating.h"
 #include "FloatList.h"
+#include "Font.h"
 #include "FuncRequest.h"
-#include "gettext.h"
+#include "Language.h"
 #include "LaTeXFeatures.h"
 #include "Lexer.h"
-#include "MetricsInfo.h"
-#include "TocBackend.h"
+#include "Paragraph.h"
+#include "output_xhtml.h"
+#include "texstream.h"
 #include "TextClass.h"
+#include "TocBackend.h"
 
+#include "support/debug.h"
+#include "support/gettext.h"
 #include "support/lstrings.h"
 
+#include <ostream>
 
-namespace lyx {
+using namespace std;
+using namespace lyx::support;
 
-using support::bformat;
-
-using std::endl;
-using std::string;
-using std::ostream;
+namespace lyx {
 
 
-InsetFloatList::InsetFloatList()
-	: InsetCommand(InsetCommandParams(FLOAT_LIST_CODE), "toc")
+InsetFloatList::InsetFloatList(Buffer * buf)
+	: InsetCommand(buf, InsetCommandParams(FLOAT_LIST_CODE))
 {}
 
 
-InsetFloatList::InsetFloatList(string const & type)
-	: InsetCommand(InsetCommandParams(FLOAT_LIST_CODE), "toc")
+InsetFloatList::InsetFloatList(Buffer * buf, string const & type)
+	: InsetCommand(buf, InsetCommandParams(FLOAT_LIST_CODE))
 {
 	setParam("type", from_ascii(type));
 }
 
 
-CommandInfo const * InsetFloatList::findInfo(std::string const & /* cmdName */)
+ParamInfo const & InsetFloatList::findInfo(string const & /* cmdName */)
 {
-	static const char * const paramnames[] = {"type", ""};
-	static const bool isoptional[] = {false};
-	static const CommandInfo info = {1, paramnames, isoptional};
-	return &info;
+	static ParamInfo param_info_;
+	if (param_info_.empty()) {
+		param_info_.add("type", ParamInfo::LATEX_REQUIRED);
+	}
+	return param_info_;
 }
 
 
 //HACK
-bool InsetFloatList::isCompatibleCommand(std::string const & s) {
-	std::string str = s.substr(0, 6);
+bool InsetFloatList::isCompatibleCommand(string const & s)
+{
+	string str = s.substr(0, 6);
 	return str == "listof";
 }
 
 
-docstring const InsetFloatList::getScreenLabel(Buffer const & buf) const
+docstring InsetFloatList::screenLabel() const
 {
-	FloatList const & floats = buf.params().getTextClass().floats();
+	FloatList const & floats = buffer().params().documentClass().floats();
 	FloatList::const_iterator it = floats[to_ascii(getParam("type"))];
 	if (it != floats.end())
-		return buf.B_(it->second.listName());
+		return buffer().B_(it->second.listName());
 	else
 		return _("ERROR: Nonexistent float type!");
 }
 
 
-void InsetFloatList::write(Buffer const &, ostream & os) const
+void InsetFloatList::doDispatch(Cursor & cur, FuncRequest & cmd) {
+	switch (cmd.action()) {
+	case LFUN_MOUSE_RELEASE:
+		if (!cur.selection() && cmd.button() == mouse_button::button1) {
+			cur.bv().showDialog("toc", params2string(params()));
+			cur.dispatched();
+		}
+		break;
+
+	default:
+		InsetCommand::doDispatch(cur, cmd);
+	}
+}
+
+
+void InsetFloatList::write(ostream & os) const
 {
 	os << "FloatList " << to_ascii(getParam("type")) << "\n";
 }
 
 
-void InsetFloatList::read(Buffer const & buf, Lexer & lex)
+void InsetFloatList::read(Lexer & lex)
 {
-	FloatList const & floats = buf.params().getTextClass().floats();
+	lex.setContext("InsetFloatList::read");
+	FloatList const & floats = buffer().params().documentClass().floats();
 	string token;
 
 	if (lex.eatLine()) {
 		setParam("type", lex.getDocString());
-		LYXERR(Debug::INSETS) << "FloatList::float_type: "
-				      << to_ascii(getParam("type")) << endl;
+		LYXERR(Debug::INSETS, "FloatList::float_type: "
+				      << to_ascii(getParam("type")));
 		if (!floats.typeExist(to_ascii(getParam("type"))))
-			lex.printError("InsetFloatList: Unknown float type: `$$Token'");
-	} else
-		lex.printError("InsetFloatList: Parse error: `$$Token'");
+			lex.printError("Unknown float type");
+	} else {
+		lex.printError("Parse error");
+	}
+
 	while (lex.isOK()) {
 		lex.next();
 		token = lex.getString();
@@ -103,56 +127,156 @@ void InsetFloatList::read(Buffer const & buf, Lexer & lex)
 			break;
 	}
 	if (token != "\\end_inset") {
-		lex.printError("Missing \\end_inset at this point. "
-			       "Read: `$$Token'");
+		lex.printError("Missing \\end_inset at this point.");
 	}
 }
 
 
-int InsetFloatList::latex(Buffer const & buf, odocstream & os,
-			  OutputParams const &) const
+void InsetFloatList::latex(otexstream & os, OutputParams const &) const
 {
-	FloatList const & floats = buf.params().getTextClass().floats();
+	FloatList const & floats = buffer().params().documentClass().floats();
 	FloatList::const_iterator cit = floats[to_ascii(getParam("type"))];
 
 	if (cit != floats.end()) {
-		if (cit->second.builtin()) {
-			// Only two different types allowed here:
-			string const type = cit->second.type();
-			if (type == "table") {
-				os << "\\listoftables\n";
-			} else if (type == "figure") {
-				os << "\\listoffigures\n";
-			} else {
-				os << "%% unknown builtin float\n";
-			}
-		} else {
+		Floating const & fl = cit->second;
+		if (fl.usesFloatPkg()) {
+			docstring const name =
+				buffer().language()->translateLayout(fl.listName());
 			os << "\\listof{" << getParam("type") << "}{"
-			   << buf.B_(cit->second.listName()) << "}\n";
+			   << name << "}\n";
+		} else {
+			if (!fl.listCommand().empty())
+				os << "\\" << from_ascii(fl.listCommand()) << "\n";
+			else
+				os << "%% "
+				   << bformat(_("LyX cannot generate a list of %1$s"), getParam("type"))
+				   << "\n";
 		}
 	} else {
+		string const flName = "List of " + to_utf8(getParam("type"));
+		docstring const name = buffer().language()->translateLayout(flName);
 		os << "%%\\listof{" << getParam("type") << "}{"
-		   << bformat(_("List of %1$s"), from_utf8(cit->second.name()))
-		   << "}\n";
+		   << name << "}\n";
 	}
-	return 1;
 }
 
 
-int InsetFloatList::plaintext(Buffer const & buffer, odocstream & os,
-			      OutputParams const &) const
+int InsetFloatList::plaintext(odocstringstream & os,
+        OutputParams const &, size_t max_length) const
 {
-	os << getScreenLabel(buffer) << "\n\n";
+	os << screenLabel() << "\n\n";
 
-	buffer.tocBackend().writePlaintextTocList(to_ascii(getParam("type")), os);
+	buffer().tocBackend().writePlaintextTocList(to_ascii(getParam("type")), os, max_length);
 
 	return PLAINTEXT_NEWLINE;
 }
 
 
+docstring InsetFloatList::xhtml(XHTMLStream &, OutputParams const & op) const {
+	FloatList const & floats = buffer().params().documentClass().floats();
+	FloatList::const_iterator cit = floats[to_ascii(getParam("type"))];
+
+	if (cit == floats.end()) {
+		LYXERR0("Unknown float type `" << getParam("type") << "' in IFL::xhtml.");
+		return docstring();
+	}
+
+	string toctype;
+	docstring toclabel;
+	// FIXME
+	// Other builtin floats should be handled here. But I'm not sure if that is
+	// even possible yet, since I'm not sure if we have a TOC for such things.
+	// If so, then they should define ListName, as non-builtin floats do, and
+	// then we can use that.
+	// Really, all floats should define that.
+	if (cit->second.isPredefined()) {
+		// Only two different types allowed here:
+		string const type = cit->second.floattype();
+		if (type == "table") {
+			toctype = "table";
+			toclabel = translateIfPossible(from_ascii("List of Tables"),
+			                               op.local_font->language()->lang());
+		} else if (type == "figure") {
+			toctype = "figure";
+			toclabel = translateIfPossible(from_ascii("List of Figures"),
+			                               op.local_font->language()->lang());
+		} else {
+			LYXERR0("Unknown Builtin Float!");
+			return docstring();
+		}
+	} else {
+		toctype = to_utf8(getParam("type"));
+		toclabel = translateIfPossible(from_utf8(cit->second.listName()),
+		                               op.local_font->language()->lang());
+	}
+
+	shared_ptr<Toc const> toc = buffer().tocBackend().toc(toctype);
+	if (toc->empty())
+		return docstring();
+
+	// we want to look like a chapter, section, or whatever.
+	// so we're going to look for the layout with the minimum toclevel
+	// number > 0---because we don't want Part.
+	// we'll take the first one, just because.
+	// FIXME This could be specified in the layout file.
+	DocumentClass const & dc = buffer().params().documentClass();
+	TextClass::LayoutList::const_iterator lit = dc.begin();
+	TextClass::LayoutList::const_iterator len = dc.end();
+	int minlevel = 1000;
+	Layout const * lay = NULL;
+	for (; lit != len; ++lit) {
+		int const level = lit->toclevel;
+		if (level > 0 && (level == Layout::NOT_IN_TOC || level >= minlevel))
+			continue;
+		lay = &*lit;
+		minlevel = level;
+	}
+
+	string const tocclass = lay ? " " + lay->defaultCSSClass(): "";
+	string const tocattr = "class='tochead toc-" + toctype + 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
+	// paragraph, and we don't want to be.
+	odocstringstream ods;
+	XHTMLStream xs(ods);
+
+	InsetLayout const & il = getLayout();
+	string const & tag = il.htmltag();
+	xs << html::StartTag("div", "class='toc toc-floats'");
+	xs << html::StartTag(tag, tocattr)
+		 << toclabel
+		 << html::EndTag(tag);
+
+	Toc::const_iterator it = toc->begin();
+	Toc::const_iterator const en = toc->end();
+	for (; it != en; ++it) {
+		if (it->str().empty())
+			continue;
+		Paragraph const & par = it->dit().innerParagraph();
+		string const attr = "class='lyxtoc-floats lyxtoc-" + toctype + "'";
+		xs << html::StartTag("div", attr);
+		string const parattr = "href='#" + par.magicLabel() + "' class='lyxtoc-floats'";
+		xs << html::StartTag("a", parattr)
+		   << it->str()
+		   << html::EndTag("a");
+		xs << html::EndTag("div");
+	}
+	xs << html::EndTag("div");
+	return ods.str();
+}
+
+
 void InsetFloatList::validate(LaTeXFeatures & features) const
 {
 	features.useFloat(to_ascii(getParam("type")));
+	features.useInsetLayout(getLayout());
+}
+
+
+docstring InsetFloatList::layoutName() const
+{
+	return "FloatList:" + getParam("type");
 }