X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Finsets%2FInsetListings.cpp;h=f2af5813bd625e30bde7c0729fb8476526a491d8;hb=2d48072e664099385b2442f7166b3c57129799bb;hp=0b37de782907bcfdf513e8bb8e0987ce62fb2f51;hpb=0b082f852a10313761bdf1156b41115170fed45e;p=lyx.git

diff --git a/src/insets/InsetListings.cpp b/src/insets/InsetListings.cpp
index 0b37de7829..f2af5813bd 100644
--- a/src/insets/InsetListings.cpp
+++ b/src/insets/InsetListings.cpp
@@ -23,11 +23,15 @@
 #include "FuncRequest.h"
 #include "FuncStatus.h"
 #include "InsetCaption.h"
-#include "InsetList.h"
 #include "Language.h"
-#include "MetricsInfo.h"
+#include "LaTeXFeatures.h"
+#include "Lexer.h"
 #include "output_latex.h"
+#include "output_xhtml.h"
+#include "OutputParams.h"
 #include "TextClass.h"
+#include "TexRow.h"
+#include "texstream.h"
 
 #include "support/debug.h"
 #include "support/docstream.h"
@@ -38,7 +42,7 @@
 #include "frontends/alert.h"
 #include "frontends/Application.h"
 
-#include <boost/regex.hpp>
+#include "support/regex.h"
 
 #include <sstream>
 
@@ -47,14 +51,11 @@ using namespace lyx::support;
 
 namespace lyx {
 
-using boost::regex;
 
-char const lstinline_delimiters[] =
-	"!*()-=+|;:'\"`,<.>/?QWERTYUIOPASDFGHJKLZXCVBNMqwertyuiopasdfghjklzxcvbnm";
-
-InsetListings::InsetListings(Buffer const & buf, InsetListingsParams const & par)
-	: InsetCollapsable(buf)
+InsetListings::InsetListings(Buffer * buf, InsetListingsParams const & par)
+	: InsetCaptionable(buf,"listing")
 {
+	params_.setMinted(buffer().params().use_minted);
 	status_ = par.status();
 }
 
@@ -71,18 +72,12 @@ Inset::DisplayType InsetListings::display() const
 }
 
 
-void InsetListings::updateLabels(ParIterator const & it)
+docstring InsetListings::layoutName() const
 {
-	Counters & cnts = buffer().masterBuffer()->params().documentClass().counters();
-	string const saveflt = cnts.current_float();
-
-	// Tell to captions what the current float is
-	cnts.current_float("listing");
-
-	InsetCollapsable::updateLabels(it);
-
-	//reset afterwards
-	cnts.current_float(saveflt);
+	if (buffer().params().use_minted)
+		return from_ascii("MintedListings");
+	else
+		return from_ascii("Listings");
 }
 
 
@@ -98,7 +93,7 @@ void InsetListings::write(ostream & os) const
 		os << "inline true\n";
 	else
 		os << "inline false\n";
-	InsetCollapsable::write(os);
+	InsetCaptionable::write(os);
 }
 
 
@@ -120,23 +115,129 @@ void InsetListings::read(Lexer & lex)
 			break;
 		}
 	}
-	InsetCollapsable::read(lex);
+	InsetCaptionable::read(lex);
 }
 
 
-docstring InsetListings::editMessage() const
+Encoding const * InsetListings::forcedEncoding(Encoding const * inner_enc,
+					       Encoding const * outer_enc) const
 {
-	return _("Opened Listing Inset");
+	// The listings package cannot deal with multi-byte-encoded
+	// glyphs, except for Xe/LuaTeX (with non-TeX fonts) or pLaTeX.
+	// Minted can deal with all encodings.
+	if (buffer().params().use_minted
+		|| inner_enc->name() == "utf8-plain"
+		|| inner_enc->package() == Encoding::japanese
+		|| inner_enc->hasFixedWidth())
+		return 0;
+
+	// We try if there's a singlebyte encoding for the outer
+	// language; if not, fall back to latin1.
+	// Power-users can set inputenc to utf8-plain to bypass this workaround
+	// and provide alternatives in the user-preamble.
+	return (outer_enc->hasFixedWidth()) ?
+			outer_enc : encodings.fromLyXName("iso8859-1");
 }
 
 
-int InsetListings::latex(odocstream & os, OutputParams const & runparams) const
+void InsetListings::latex(otexstream & os, OutputParams const & runparams) const
 {
 	string param_string = params().params();
 	// NOTE: I use {} to quote text, which is an experimental feature
 	// of the listings package (see page 25 of the manual)
-	int lines = 0;
-	bool isInline = params().isInline();
+	bool const isInline = params().isInline();
+	bool const use_minted = buffer().params().use_minted;
+	static regex const reg1("(.*)(basicstyle=\\{)([^\\}]*)(\\\\ttfamily)([^\\}]*)(\\})(.*)");
+	static regex const reg2("(.*)(basicstyle=\\{)([^\\}]*)(\\\\rmfamily)([^\\}]*)(\\})(.*)");
+	static regex const reg3("(.*)(basicstyle=\\{)([^\\}]*)(\\\\sffamily)([^\\}]*)(\\})(.*)");
+	static regex const reg4("(.*)(basicstyle=\\{)([^\\}]*)(\\\\(tiny|scriptsize|footnotesize|small|normalsize|large|Large))([^\\}]*)(\\})(.*)");
+	static regex const reg5("(.*)(fontfamily=)(tt|sf|rm)(.*)");
+	static regex const reg6("(.*)(fontsize=\\{)(\\\\(tiny|scriptsize|footnotesize|small|normalsize|large|Large))(\\})(.*)");
+	if (use_minted) {
+		// If params have been entered with "listings", and then the user switched to "minted",
+		// we have params that need to be translated.
+		// FIXME: We should use a backend-abstract syntax in listings params instead!
+		// Substitute fontstyle option
+		smatch sub;
+		if (regex_match(param_string, sub, reg1))
+			param_string = sub.str(1) + "fontfamily=tt," + sub.str(2) + sub.str(3)
+					+ sub.str(5) + sub.str(6) + sub.str(7);
+		if (regex_match(param_string, sub, reg2))
+			param_string = sub.str(1) + "fontfamily=rm," + sub.str(2) + sub.str(3)
+					+ sub.str(5) + sub.str(6) + sub.str(7);
+		if (regex_match(param_string, sub, reg3))
+			param_string = sub.str(1) + "fontfamily=sf," + sub.str(2) + sub.str(3)
+					+ sub.str(5) + sub.str(6) + sub.str(7);
+		// as well as fontsize option
+		if (regex_match(param_string, sub, reg4))
+			param_string = sub.str(1) + "fontsize={" + sub.str(4) + sub.str(3) + sub.str(7) + sub.str(8);
+	} else {
+		// And the same vice versa
+		// Substitute fontstyle option
+		smatch sub;
+		string basicstyle;
+		if (regex_match(param_string, sub, reg5)) {
+			basicstyle = "\\" + sub.str(3) + "family";
+			param_string = sub.str(1) + sub.str(4);
+		}
+		// as well as fontsize option
+		if (regex_match(param_string, sub, reg6)) {
+			basicstyle += sub.str(3);
+			param_string = sub.str(1) + sub.str(6);
+		}
+		if (!basicstyle.empty())
+			param_string = rtrim(param_string, ",") + ",basicstyle={" + basicstyle + "}";
+	}
+	if (runparams.use_polyglossia && runparams.local_font->isRightToLeft()) {
+		// We need to use the *latin switches (#11554)
+		smatch sub;
+		if (regex_match(param_string, sub, reg1))
+			param_string = sub.str(1) + sub.str(2) + sub.str(3) + sub.str(4)
+					+ "latin"  + sub.str(5) + sub.str(6) + sub.str(7);
+		if (regex_match(param_string, sub, reg2))
+			param_string = sub.str(1) + sub.str(2) + sub.str(3) + sub.str(4)
+					+ "latin"  + sub.str(5) + sub.str(6) + sub.str(7);
+		if (regex_match(param_string, sub, reg3))
+			param_string = sub.str(1) + sub.str(2) + sub.str(3) + sub.str(4)
+					+ "latin"  + sub.str(5) + sub.str(6) + sub.str(7);
+	}
+	string minted_language;
+	string float_placement;
+	bool const isfloat = params().isFloat();
+	if (use_minted && (isfloat || contains(param_string, "language="))) {
+		// Get float placement and/or language of the code,
+		// then remove the relative options.
+		vector<string> opts =
+			getVectorFromString(param_string, ",", false);
+		for (size_t i = 0; i < opts.size(); ++i) {
+			if (prefixIs(opts[i], "float")) {
+				if (prefixIs(opts[i], "float="))
+					float_placement = opts[i].substr(6);
+				opts.erase(opts.begin() + int(i--));
+			}
+			else if (prefixIs(opts[i], "language=")) {
+				minted_language = opts[i].substr(9);
+				opts.erase(opts.begin() + int(i--));
+			}
+		}
+		param_string = getStringFromVector(opts, ",");
+	}
+	// Minted needs a language specification
+	if (minted_language.empty()) {
+		// If a language has been set globally, use that,
+		// otherwise use TeX by default
+		string const & blp = buffer().params().listings_params;
+		size_t start = blp.find("language=");
+		if (start != string::npos) {
+			start += strlen("language=");
+			size_t len = blp.find(",", start);
+			if (len != string::npos)
+				len -= start;
+			minted_language = blp.substr(start, len);
+		} else
+			minted_language = "TeX";
+	}
+
 	// get the paragraphs. We can not output them directly to given odocstream
 	// because we can not yet determine the delimiter character of \lstinline
 	docstring code;
@@ -147,78 +248,91 @@ int InsetListings::latex(odocstream & os, OutputParams const & runparams) const
 	bool encoding_switched = false;
 	Encoding const * const save_enc = runparams.encoding;
 
-	if (!runparams.encoding->hasFixedWidth()) {
-		// We need to switch to a singlebyte encoding, since the listings
-		// package cannot deal with multiple-byte-encoded glyphs
-		Language const * const outer_language =
-			(runparams.local_font != 0) ?
-				runparams.local_font->language()
-				: buffer().params().language;
-		// We try if there's a singlebyte encoding for the current
-		// language; if not, fall back to latin1.
-		Encoding const * const lstenc =
-			(outer_language->encoding()->hasFixedWidth()) ?
-				outer_language->encoding() 
-				: encodings.fromLyXName("iso8859-1");
-		pair<bool, int> const c = switchEncoding(os, buffer().params(),
-				runparams, *lstenc, true);
-		runparams.encoding = lstenc;
+	Encoding const * const outer_encoding =
+		(runparams.local_font != 0) ?
+			runparams.local_font->language()->encoding()
+			: buffer().params().language->encoding();
+	Encoding const * fixedlstenc = forcedEncoding(runparams.encoding, outer_encoding);
+	if (fixedlstenc) {
+		// We need to switch to a singlebyte encoding, due to
+		// the restrictions of the listings package (see above).
+		// This needs to be consistent with
+		// LaTeXFeatures::getTClassI18nPreamble().
+		// We need to put this into a group in order to prevent encoding leaks
+		// (happens with cprotect).
+		os << "\\bgroup";
+		switchEncoding(os.os(), buffer().params(), runparams, *fixedlstenc, true);
+		runparams.encoding = fixedlstenc;
 		encoding_switched = true;
 	}
 
+	bool const captionfirst = !isfloat && par->isInset(0)
+				&& par->getInset(0)->lyxCode() == CAPTION_CODE;
+
 	while (par != end) {
-		pos_type siz = par->size();
+		pos_type const siz = par->size();
 		bool captionline = false;
 		for (pos_type i = 0; i < siz; ++i) {
 			if (i == 0 && par->isInset(i) && i + 1 == siz)
 				captionline = true;
 			// ignore all struck out text and (caption) insets
-			if (par->isDeleted(i) || par->isInset(i))
+			if (par->isDeleted(i)
+			    || (par->isInset(i) && par->getInset(i)->lyxCode() == CAPTION_CODE))
 				continue;
+			if (par->isInset(i)) {
+				// Currently, this can only be a quote inset
+				// that is output as plain quote here, but
+				// we use more generic code anyway.
+				otexstringstream ots;
+				OutputParams rp = runparams;
+				rp.pass_thru = true;
+				par->getInset(i)->latex(ots, rp);
+				code += ots.str();
+				continue;
+			}
 			char_type c = par->getChar(i);
 			// we can only output characters covered by the current
 			// encoding!
 			try {
-				if (runparams.encoding->latexChar(c) == docstring(1, c))
+				if (runparams.encoding->encodable(c))
 					code += c;
 				else if (runparams.dryrun) {
 					code += "<" + _("LyX Warning: ")
 					   + _("uncodable character") + " '";
 					code += docstring(1, c);
 					code += "'>";
- 				} else
+				} else
 					uncodable += c;
 			} catch (EncodingException & /* e */) {
- 				if (runparams.dryrun) {
+				if (runparams.dryrun) {
 					code += "<" + _("LyX Warning: ")
 					   + _("uncodable character") + " '";
 					code += docstring(1, c);
 					code += "'>";
- 				} else
+				} else
 					uncodable += c;
 			}
 		}
 		++par;
 		// for the inline case, if there are multiple paragraphs
 		// they are simply joined. Otherwise, expect latex errors.
-		if (par != end && !isInline && !captionline) {
+		if (par != end && !isInline && !captionline)
 			code += "\n";
-			++lines;
-		}
 	}
 	if (isInline) {
-		char const * delimiter = lstinline_delimiters;
-		for (; delimiter != '\0'; ++delimiter)
-			if (!contains(code, *delimiter))
-				break;
+		static const docstring delimiters =
+				from_utf8("!*()-=+|;:'\"`,<.>/?QWERTYUIOPASDFGHJKLZXCVBNMqwertyuiopasdfghjklzxcvbnm");
+
+		size_t pos = delimiters.find_first_not_of(code);
+
 		// This code piece contains all possible special character? !!!
 		// Replace ! with a warning message and use ! as delimiter.
-		if (*delimiter == '\0') {
+		if (pos == string::npos) {
 			docstring delim_error = "<" + _("LyX Warning: ")
 				+ _("no more lstline delimiters available") + ">";
 			code = subst(code, from_ascii("!"), delim_error);
-			delimiter = lstinline_delimiters;
-			if (!runparams.dryrun) {
+			pos = 0;
+			if (!runparams.dryrun && !runparams.silent) {
 				// FIXME: warning should be passed to the error dialog
 				frontend::Alert::warning(_("Running out of delimiters"),
 				_("For inline program listings, one character must be reserved\n"
@@ -228,149 +342,166 @@ int InsetListings::latex(odocstream & os, OutputParams const & runparams) const
 				  "must investigate!"));
 			}
 		}
-		if (param_string.empty())
-			os << "\\lstinline" << *delimiter;
-		else
-			os << "\\lstinline[" << from_utf8(param_string) << "]" << *delimiter;
-                os << code
-                   << *delimiter;
+		docstring const delim(1, delimiters[pos]);
+		if (use_minted) {
+			os << "\\mintinline";
+			if (!param_string.empty())
+				os << "[" << from_utf8(param_string) << "]";
+			os << "{" << ascii_lowercase(minted_language) << "}";
+		} else {
+			os << "\\lstinline";
+			if (!param_string.empty())
+				os << "[" << from_utf8(param_string) << "]";
+			else if (pos >= delimiters.find('Q'))
+				// We need to terminate the command before
+				// the delimiter
+				os << " ";
+		}
+		os << delim << code << delim;
+	} else if (use_minted) {
+		OutputParams rp = runparams;
+		rp.moving_arg = true;
+		TexString caption = getCaption(rp);
+		if (isfloat) {
+			os << breakln << "\\begin{listing}";
+			if (!float_placement.empty())
+				os << '[' << float_placement << "]";
+		} else if (captionfirst && !caption.str.empty()) {
+			os << breakln << "\\lyxmintcaption[t]{"
+			   << move(caption) << "}\n";
+		}
+		os << breakln << "\\begin{minted}";
+		if (!param_string.empty())
+			os << "[" << param_string << "]";
+		os << "{" << ascii_lowercase(minted_language) << "}\n"
+		   << code << breakln << "\\end{minted}\n";
+		if (isfloat) {
+			if (!caption.str.empty())
+				os << "\\caption{" << move(caption) << "}\n";
+			os << "\\end{listing}\n";
+		} else if (!captionfirst && !caption.str.empty()) {
+			os << breakln << "\\lyxmintcaption[b]{"
+			   << move(caption) << "}";
+		}
 	} else {
 		OutputParams rp = runparams;
 		rp.moving_arg = true;
-		docstring const caption = getCaption(rp);
-		runparams.encoding = rp.encoding;
-		if (param_string.empty() && caption.empty())
-			os << "\n\\begin{lstlisting}\n";
+		TexString caption = getCaption(rp);
+		os << breakln << "\\begin{lstlisting}";
+		if (param_string.empty() && caption.str.empty())
+			os << "\n";
 		else {
-			os << "\n\\begin{lstlisting}[";
-			if (!caption.empty()) {
-				os << "caption={" << caption << '}';
+			if (!runparams.nice)
+				os << safebreakln;
+			os << "[";
+			if (!caption.str.empty()) {
+				os << "caption={" << move(caption) << '}';
 				if (!param_string.empty())
 					os << ',';
 			}
 			os << from_utf8(param_string) << "]\n";
 		}
-		lines += 2;
-		os << code << "\n\\end{lstlisting}\n";
-		lines += 2;
+		os << code << breakln << "\\end{lstlisting}\n";
 	}
 
 	if (encoding_switched){
 		// Switch back
-		pair<bool, int> const c = switchEncoding(os, buffer().params(),
-				runparams, *save_enc, true);
+		switchEncoding(os.os(), buffer().params(),
+			       runparams, *save_enc, true, true);
+		os << "\\egroup" << breakln;
 		runparams.encoding = save_enc;
 	}
 
-	if (!uncodable.empty()) {
+	if (!uncodable.empty() && !runparams.silent) {
 		// issue a warning about omitted characters
 		// FIXME: should be passed to the error dialog
-		frontend::Alert::warning(_("Uncodable characters in listings inset"),
-			bformat(_("The following characters in one of the program listings are\n"
-				  "not representable in the current encoding and have been omitted:\n%1$s."),
-			uncodable));
+		if (fixedlstenc)
+			frontend::Alert::warning(_("Uncodable characters in listings inset"),
+				bformat(_("The following characters in one of the program listings are\n"
+					  "not representable in the current encoding and have been omitted:\n%1$s.\n"
+					  "This is due to a restriction of the listings package, which does\n"
+					  "not support your encoding '%2$s'.\n"
+					  "Toggling 'Use non-TeX fonts' in Document > Settings...\n"
+					  "might help."),
+				uncodable, _(runparams.encoding->guiName())));
+		else
+			frontend::Alert::warning(_("Uncodable characters in listings inset"),
+				bformat(_("The following characters in one of the program listings are\n"
+					  "not representable in the current encoding and have been omitted:\n%1$s."),
+				uncodable));
 	}
+}
+
+
+docstring InsetListings::xhtml(XHTMLStream & os, OutputParams const & rp) const
+{
+	odocstringstream ods;
+	XHTMLStream out(ods);
+
+	bool const isInline = params().isInline();
+	if (isInline)
+		out << html::CompTag("br");
+	else {
+		out << html::StartTag("div", "class='float-listings'");
+		docstring caption = getCaptionHTML(rp);
+		if (!caption.empty())
+			out << html::StartTag("div", "class='listings-caption'")
+			    << XHTMLStream::ESCAPE_NONE
+			    << caption << html::EndTag("div");
+	}
+
+	InsetLayout const & il = getLayout();
+	string const & tag = il.htmltag();
+	string attr = "class ='listings";
+	string const lang = params().getParamValue("language");
+	if (!lang.empty())
+		attr += " " + lang;
+	attr += "'";
+	out << html::StartTag(tag, attr);
+	OutputParams newrp = rp;
+	newrp.html_disable_captions = true;
+	// We don't want to convert dashes here. That's the only conversion we
+	// do for XHTML, so this is safe.
+	newrp.pass_thru = true;
+	docstring def = InsetText::insetAsXHTML(out, newrp, InsetText::JustText);
+	out << html::EndTag(tag);
 
-	return lines;
+	if (isInline) {
+		out << html::CompTag("br");
+		// escaping will already have been done
+		os << XHTMLStream::ESCAPE_NONE << ods.str();
+	} else {
+		out << html::EndTag("div");
+		// In this case, this needs to be deferred, but we'll put it
+		// before anything the text itself deferred.
+		def = ods.str() + '\n' + def;
+	}
+	return def;
 }
 
 
-docstring InsetListings::contextMenu(BufferView const &, int, int) const
+string InsetListings::contextMenuName() const
 {
-	return from_ascii("context-listings");
+	return "context-listings";
 }
 
 
 void InsetListings::doDispatch(Cursor & cur, FuncRequest & cmd)
 {
-	switch (cmd.action) {
+	switch (cmd.action()) {
 
 	case LFUN_INSET_MODIFY: {
+		cur.recordUndoInset(this);
 		InsetListings::string2params(to_utf8(cmd.argument()), params());
 		break;
 	}
+
 	case LFUN_INSET_DIALOG_UPDATE:
 		cur.bv().updateDialog("listings", params2string(params()));
 		break;
-	case LFUN_TAB_INSERT:
-		if (cur.selection()) {
-			// If there is a selection, a tab is inserted at the
-			// beginning of each paragraph.
-			cur.recordUndoSelection();
-			pit_type const pit_end = cur.selEnd().pit();
-			for (pit_type pit = cur.selBegin().pit(); pit <= pit_end; pit++) {
-				paragraphs()[pit].insertChar(0, '\t', 
-					buffer().params().trackChanges);
-				// Update the selection pos to make sure the selection does not
-				// change as the inserted tab will increase the logical pos.
-				if (cur.anchor_.pit() == pit)
-					cur.anchor_.forwardPos();
-				if (cur.pit() == pit)
-					cur.forwardPos();
-			}
-			cur.finishUndo();
-		} else {
-			// Maybe we shouldn't allow tabs within a line, because they
-			// are not (yet) aligned as one might do expect.
-			cur.recordUndo();
-			cur.insert(from_ascii("\t"));
-			cur.finishUndo();
-		}
-		break;
-	case LFUN_TAB_DELETE:
-		if (cur.selection()) {
-			// If there is a selection, a tab (if present) is removed from
-			// the beginning of each paragraph.
-			cur.recordUndoSelection();
-			pit_type const pit_end = cur.selEnd().pit();
-			for (pit_type pit = cur.selBegin().pit(); pit <= pit_end; pit++) {
-				Paragraph & par = paragraphs()[pit];
-				if (par.getChar(0) == '\t') {
-					if (cur.pit() == pit)
-						cur.posBackward();
-					if (cur.anchor_.pit() == pit && cur.anchor_.pos() > 0 )
-						cur.anchor_.backwardPos();
-
-					par.eraseChar(0, buffer().params().trackChanges);
-				} else 
-					// If no tab was present, try to remove up to four spaces.
-					for (int n_spaces = 0;
-						par.getChar(0) == ' ' && n_spaces < 4; ++n_spaces) {
-							if (cur.pit() == pit)
-								cur.posBackward();
-							if (cur.anchor_.pit() == pit && cur.anchor_.pos() > 0 )
-								cur.anchor_.backwardPos();
-
-							par.eraseChar(0, buffer().params().trackChanges);
-					}
-			}
-			cur.finishUndo();
-		} else {
-			// If there is no selection, try to remove a tab or some spaces 
-			// before the position of the cursor.
-			Paragraph & par = paragraphs()[cur.pit()];
-			pos_type const pos = cur.pos();
-
-			if (pos == 0)
-				break;
-
-			char_type const c = par.getChar(pos - 1);
-			cur.recordUndo();
-			if (c == '\t') {
-				cur.posBackward();
-				par.eraseChar(cur.pos(), buffer().params().trackChanges);
-			} else
-				for (int n_spaces = 0; cur.pos() > 0
-					&& par.getChar(cur.pos() - 1) == ' ' && n_spaces < 4;
-					++n_spaces) {
-						cur.posBackward();
-						par.eraseChar(cur.pos(), buffer().params().trackChanges);
-				}
-				cur.finishUndo();
-		}
-		break;
+
 	default:
-		InsetCollapsable::doDispatch(cur, cmd);
+		InsetCaptionable::doDispatch(cur, cmd);
 		break;
 	}
 }
@@ -379,20 +510,21 @@ void InsetListings::doDispatch(Cursor & cur, FuncRequest & cmd)
 bool InsetListings::getStatus(Cursor & cur, FuncRequest const & cmd,
 	FuncStatus & status) const
 {
-	switch (cmd.action) {
+	switch (cmd.action()) {
 		case LFUN_INSET_MODIFY:
 		case LFUN_INSET_DIALOG_UPDATE:
 			status.setEnabled(true);
 			return true;
-		case LFUN_CAPTION_INSERT:
-			status.setEnabled(!params().isInline());
-			return true;
-			case LFUN_TAB_INSERT:
-			case LFUN_TAB_DELETE:
-				status.setEnabled(true);
+		case LFUN_CAPTION_INSERT: {
+			// the inset outputs at most one caption
+			if (params().isInline() || getCaptionInset()) {
+				status.setEnabled(false);
 				return true;
+			}
+		}
+		// fall through
 		default:
-			return InsetCollapsable::getStatus(cur, cmd, status);
+			return InsetCaptionable::getStatus(cur, cmd, status);
 	}
 }
 
@@ -409,11 +541,23 @@ docstring const InsetListings::buttonLabel(BufferView const & bv) const
 
 void InsetListings::validate(LaTeXFeatures & features) const
 {
-	features.require("listings");
+	features.useInsetLayout(getLayout());
 	string param_string = params().params();
-	if (param_string.find("\\color") != string::npos)
-		features.require("color");
-	InsetCollapsable::validate(features);
+	if (buffer().params().use_minted) {
+		features.require("minted");
+		OutputParams rp = features.runparams();
+		if (!params().isFloat() && !getCaption(rp).str.empty())
+			features.require("lyxmintcaption");
+		if (features.usePolyglossia() && features.hasRTLLanguage())
+			// minted loads color, but color must be loaded before bidi
+			// (i.e., polyglossia)
+			features.require("color");
+	} else {
+		features.require("listings");
+		if (contains(param_string, "\\color"))
+			features.require("color");
+	}
+	InsetCaptionable::validate(features);
 }
 
 
@@ -425,42 +569,47 @@ bool InsetListings::showInsetDialog(BufferView * bv) const
 }
 
 
-docstring InsetListings::getCaption(OutputParams const & runparams) const
+TexString InsetListings::getCaption(OutputParams const & runparams) const
 {
-	if (paragraphs().empty())
-		return docstring();
-
-	ParagraphList::const_iterator pit = paragraphs().begin();
-	for (; pit != paragraphs().end(); ++pit) {
-		InsetList::const_iterator it = pit->insetList().begin();
-		for (; it != pit->insetList().end(); ++it) {
-			Inset & inset = *it->inset;
-			if (inset.lyxCode() == CAPTION_CODE) {
-				odocstringstream ods;
-				InsetCaption * ins =
-					static_cast<InsetCaption *>(it->inset);
-				ins->getOptArg(ods, runparams);
-				ins->getArgument(ods, runparams);
-				// the caption may contain \label{} but the listings
-				// package prefer caption={}, label={}
-				docstring cap = ods.str();
-				if (!contains(to_utf8(cap), "\\label{"))
-					return cap;
-				// convert from
-				//     blah1\label{blah2} blah3
-				// to
-				//     blah1 blah3},label={blah2
-				// to form options
-				//     caption={blah1 blah3},label={blah2}
-				//
-				// NOTE that } is not allowed in blah2.
-				regex const reg("(.*)\\\\label\\{(.*?)\\}(.*)");
-				string const new_cap("\\1\\3},label={\\2");
-				return from_utf8(regex_replace(to_utf8(cap), reg, new_cap));
-			}
-		}
-	}
-	return docstring();
+	InsetCaption const * ins = getCaptionInset();
+	if (ins == 0)
+		return TexString();
+
+	otexstringstream os;
+	ins->getArgs(os, runparams);
+	ins->getArgument(os, runparams);
+
+	// TODO: The code below should be moved to support, and then the test
+	//       in ../tests should be moved there as well.
+
+	// the caption may contain \label{} but the listings
+	// package prefer caption={}, label={}
+	TexString cap = os.release();
+	if (buffer().params().use_minted
+	    || !contains(cap.str, from_ascii("\\label{")))
+		return cap;
+	// convert from
+	//     blah1\label{blah2} blah3
+	// to
+	//     blah1 blah3},label={blah2
+	// to form options
+	//     caption={blah1 blah3},label={blah2}
+	//
+	// NOTE that } is not allowed in blah2.
+	regex const reg("(.*)\\\\label\\{(.*?)\\}(.*)");
+	string const new_cap("$1$3},label={$2");
+	// Remove potential \protect'ion of \label.
+	docstring capstr = subst(cap.str, from_ascii("\\protect\\label"),
+				 from_ascii("\\label"));
+	// TexString validity: the substitution preserves the number of newlines.
+	// Moreover we assume that $2 does not contain newlines, so that the texrow
+	// information remains accurate.
+	// Replace '\n' with an improbable character from Private Use Area-A
+	// and then return to '\n' after the regex replacement.
+	capstr = subst(capstr, char_type('\n'), 0xffffd);
+	cap.str = subst(from_utf8(regex_replace(to_utf8(capstr), reg, new_cap)),
+			0xffffd, char_type('\n'));
+	return cap;
 }