X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Foutput_latex.cpp;h=bdc7cb28efd40c513460f75581b327debaab38e2;hb=c26c7602e4b5139ad8a98e77d97cf47ba67588d2;hp=2a4f61207f6ff2bd395a787e0eb808e88c10552a;hpb=ead148510bc78116f8367bd061833e05e5e85949;p=lyx.git

diff --git a/src/output_latex.cpp b/src/output_latex.cpp
index 2a4f61207f..bdc7cb28ef 100644
--- a/src/output_latex.cpp
+++ b/src/output_latex.cpp
@@ -85,11 +85,12 @@ OutputState * getOutputState()
 }
 
 
-string const & openPolyglossiaLang(OutputState const * state)
+string const & openLanguageName(OutputState const * state)
 {
 	// Return a reference to the last active language opened with
-	// polyglossia. If none or when using babel, return a reference
-	// to an empty string.
+	// polyglossia or when using begin/end commands. If none or when
+	// using babel with only a begin command, return a reference to
+	// an empty string.
 
 	static string const empty;
 
@@ -102,8 +103,9 @@ string const & openPolyglossiaLang(OutputState const * state)
 bool atSameLastLangSwitchDepth(OutputState const * state)
 {
 	// Return true if the actual nest level is the same at which the
-	// language was switched when using polyglossia. Instead, return
-	// always true when using babel.
+	// language was switched when using polyglossia or begin/end
+	// commands. Instead, return always true when using babel with
+	// only a begin command.
 
 	return state->lang_switch_depth_.size() == 0
 			? true
@@ -113,7 +115,7 @@ bool atSameLastLangSwitchDepth(OutputState const * state)
 
 bool isLocalSwitch(OutputState const * state)
 {
-	// Return true if the language was opened by the \text<lang> command.
+	// Return true if the language was opened by a local command switch.
 
 	return state->lang_switch_depth_.size()
 		&& state->lang_switch_depth_.top() < 0;
@@ -140,11 +142,16 @@ string const getPolyglossiaEnvName(Language const * lang)
 
 
 string const getPolyglossiaBegin(string const & lang_begin_command,
-				 string const & lang, string const & opts)
+				 string const & lang, string const & opts,
+				 bool const localswitch = false)
 {
 	string result;
-	if (!lang.empty())
-		result = subst(lang_begin_command, "$$lang", lang);
+	if (!lang.empty()) {
+		// we need to revert the upcasing done in getPolyglossiaEnvName()
+		// in case we have a local polyglossia command (\textarabic).
+		string language = localswitch ? ascii_lowercase(lang) : lang;
+		result = subst(lang_begin_command, "$$lang", language);
+	}
 	string options = opts.empty() ?
 		    string() : "[" + opts + "]";
 	result = subst(result, "$$opts", options);
@@ -209,10 +216,12 @@ static TeXEnvironmentData prepareEnvironment(Buffer const & buf,
 		"\\begin{$$lang}" : lyxrc.language_command_begin;
 	string const lang_end_command = use_polyglossia ?
 		"\\end{$$lang}" : lyxrc.language_command_end;
+	bool const using_begin_end = use_polyglossia ||
+					!lang_end_command.empty();
 
 	// For polyglossia, switch language outside of environment, if possible.
 	if (par_lang != prev_par_lang) {
-		if ((!use_polyglossia || langOpenedAtThisLevel(state)) &&
+		if ((!using_begin_end || langOpenedAtThisLevel(state)) &&
 		    !lang_end_command.empty() &&
 		    prev_par_lang != doc_lang &&
 		    !prev_par_lang.empty()) {
@@ -222,21 +231,21 @@ static TeXEnvironmentData prepareEnvironment(Buffer const & buf,
 				prev_par_lang))
 			  // the '%' is necessary to prevent unwanted whitespace
 			  << "%\n";
-			if (use_polyglossia)
-				popPolyglossiaLang();
+			if (using_begin_end)
+				popLanguageName();
 		}
 
 		// If no language was explicitly opened and we are using
-		// polyglossia, then the current polyglossia language is
-		// the document language.
-		string const & pol_lang = use_polyglossia
+		// polyglossia or begin/end commands, then the current
+		// language is the document language.
+		string const & cur_lang = using_begin_end
 					  && state->lang_switch_depth_.size()
-						  ? openPolyglossiaLang(state)
+						  ? openLanguageName(state)
 						  : doc_lang;
 
 		if ((lang_end_command.empty() ||
 		    par_lang != doc_lang ||
-		    par_lang != pol_lang) &&
+		    par_lang != cur_lang) &&
 		    !par_lang.empty()) {
 			    string bc = use_polyglossia ?
 					getPolyglossiaBegin(lang_begin_command, par_lang,
@@ -245,8 +254,8 @@ static TeXEnvironmentData prepareEnvironment(Buffer const & buf,
 			    os << bc;
 			    // the '%' is necessary to prevent unwanted whitespace
 			    os << "%\n";
-			    if (use_polyglossia)
-				    pushPolyglossiaLang(par_lang);
+			    if (using_begin_end)
+				    pushLanguageName(par_lang);
 		}
 	}
 
@@ -312,17 +321,20 @@ static void finishEnvironment(otexstream & os, OutputParams const & runparams,
 
 	if (data.style->isEnvironment()) {
 		os << breakln;
-		// Close any polyglossia language opened at this nest level
-		if (runparams.use_polyglossia) {
+		bool const using_begin_end =
+			runparams.use_polyglossia ||
+				!lyxrc.language_command_end.empty();
+		// Close any language opened at this nest level
+		if (using_begin_end) {
 			while (langOpenedAtThisLevel(state)) {
 				if (isLocalSwitch(state)) {
 					os << "}";
 				} else {
 					os << "\\end{"
-					   << openPolyglossiaLang(state)
+					   << openLanguageName(state)
 					   << "}%\n";
 				}
-				popPolyglossiaLang();
+				popLanguageName();
 			}
 		}
 		state->nest_level_ -= 1;
@@ -503,10 +515,10 @@ void getArgInsets(otexstream & os, OutputParams const & runparams, Layout::LaTeX
 }
 
 
-} // namespace anon
+} // namespace
 
 
-void pushPolyglossiaLang(string const & lang_name, bool localswitch)
+void pushLanguageName(string const & lang_name, bool localswitch)
 {
 	OutputState * state = getOutputState();
 
@@ -516,7 +528,7 @@ void pushPolyglossiaLang(string const & lang_name, bool localswitch)
 }
 
 
-void popPolyglossiaLang()
+void popLanguageName()
 {
 	OutputState * state = getOutputState();
 
@@ -525,6 +537,14 @@ void popPolyglossiaLang()
 }
 
 
+string const & openLanguageName()
+{
+	OutputState * state = getOutputState();
+
+	return openLanguageName(state);
+}
+
+
 namespace {
 
 void addArgInsets(Paragraph const & par, string const & prefix,
@@ -556,7 +576,7 @@ void addArgInsets(Paragraph const & par, string const & prefix,
 	}
 }
 
-} // anon namespace
+} // namespace
 
 
 void latexArgInsets(Paragraph const & par, otexstream & os,
@@ -632,7 +652,7 @@ namespace {
 
 // output the proper paragraph start according to latextype.
 void parStartCommand(Paragraph const & par, otexstream & os,
-		     OutputParams const & runparams, Layout const & style) 
+		     OutputParams const & runparams, Layout const & style)
 {
 	switch (style.latextype) {
 	case LATEX_COMMAND:
@@ -659,7 +679,7 @@ void parStartCommand(Paragraph const & par, otexstream & os,
 	}
 }
 
-} // namespace anon
+} // namespace
 
 // FIXME: this should be anonymous
 void TeXOnePar(Buffer const & buf,
@@ -668,7 +688,8 @@ void TeXOnePar(Buffer const & buf,
 	       otexstream & os,
 	       OutputParams const & runparams_in,
 	       string const & everypar,
-	       int start_pos, int end_pos)
+	       int start_pos, int end_pos,
+	       bool const force)
 {
 	BufferParams const & bparams = runparams_in.is_child
 		? buf.masterParams() : buf.params();
@@ -679,7 +700,7 @@ void TeXOnePar(Buffer const & buf,
 	Layout const & style = text.inset().forcePlainLayout() ?
 		bparams.documentClass().plainLayout() : par.layout();
 
-	if (style.inpreamble)
+	if (style.inpreamble && !force)
 		return;
 
 	LYXERR(Debug::LATEX, "TeXOnePar for paragraph " << pit << " ptr " << &par << " '"
@@ -713,18 +734,22 @@ void TeXOnePar(Buffer const & buf,
 				os << '\n';
 		}
 
-		par.latex(bparams, outerfont, os, runparams, start_pos, end_pos);
+		par.latex(bparams, outerfont, os, runparams, start_pos, end_pos, force);
 		return;
 	}
 
 	Paragraph const * nextpar = runparams.isLastPar
 		? 0 : &paragraphs.at(pit + 1);
 
+	bool const intitle_command = style.intitle && style.latextype == LATEX_COMMAND;
+
 	if (style.pass_thru) {
 		Font const outerfont = text.outerFont(pit);
 		parStartCommand(par, os, runparams, style);
+		if (intitle_command)
+			os << '{';
 
-		par.latex(bparams, outerfont, os, runparams, start_pos, end_pos);
+		par.latex(bparams, outerfont, os, runparams, start_pos, end_pos, force);
 
 		// I did not create a parEndCommand for this minuscule
 		// task because in the other user of parStartCommand
@@ -765,6 +790,9 @@ void TeXOnePar(Buffer const & buf,
 	// environment with nesting depth greater than (or equal to, but with
 	// a different layout) the current one. If there is no previous
 	// paragraph, the previous language is the outer language.
+	// Note further that we take the outer language also if the prior par
+	// is PassThru, since in that case it has latex_language, and all secondary
+	// languages have been closed (#10793).
 	bool const use_prev_env_language = state->prev_env_language_ != 0
 			&& priorpar
 			&& priorpar->layout().isEnvironment()
@@ -772,12 +800,11 @@ void TeXOnePar(Buffer const & buf,
 			    || (priorpar->getDepth() == par.getDepth()
 				    && priorpar->layout() != par.layout()));
 	Language const * const prev_language =
-		(pit != 0)
+		(priorpar && !priorpar->isPassThru())
 		? (use_prev_env_language ? state->prev_env_language_
 					 : priorpar->getParLanguage(bparams))
 		: outer_language;
 
-
 	bool const use_polyglossia = runparams.use_polyglossia;
 	string const par_lang = use_polyglossia ?
 		getPolyglossiaEnvName(par_language): par_language->babel();
@@ -794,36 +821,56 @@ void TeXOnePar(Buffer const & buf,
 		"\\end{$$lang}" : lyxrc.language_command_end;
 	// the '%' is necessary to prevent unwanted whitespace
 	string lang_command_termination = "%\n";
+	bool const using_begin_end = use_polyglossia ||
+					!lang_end_command.empty();
 
-	// In some insets (such as Arguments), we cannot use \selectlanguage
+	// For InTitle commands, we need to switch the language inside the command
+	// (see #10849); thus open the command here.
+	if (intitle_command) {
+		parStartCommand(par, os, runparams, style);
+		os << '{';
+	}
+
+	// In some insets (such as Arguments), we cannot use \selectlanguage.
+	// Also, if an RTL language is set via environment in polyglossia,
+	// only a nested \\text<lang> command will reset the direction for LTR
+	// languages (see # 10111).
+	bool const in_polyglossia_rtl_env =
+		use_polyglossia
+		&& runparams.local_font != 0
+		&& outer_language->rightToLeft()
+		&& !par_language->rightToLeft();
 	bool const localswitch = text.inset().forceLocalFontSwitch()
-			|| (use_polyglossia && text.inset().forcePlainLayout());
+			|| (using_begin_end && text.inset().forcePlainLayout())
+			|| in_polyglossia_rtl_env;
 	if (localswitch) {
 		lang_begin_command = use_polyglossia ?
 			    "\\text$$lang$$opts{" : lyxrc.language_command_local;
 		lang_end_command = "}";
 		lang_command_termination.clear();
 	}
-
-	if (par_lang != prev_lang
-		// check if we already put language command in TeXEnvironment()
-		&& !(style.isEnvironment()
-		     && (pit == 0 || (priorpar->layout() != par.layout()
-			                  && priorpar->getDepth() <= par.getDepth())
-		                  || priorpar->getDepth() < par.getDepth())))
-	{
-		if ((!use_polyglossia || langOpenedAtThisLevel(state)) &&
-		    !lang_end_command.empty() &&
-		    prev_lang != outer_lang &&
-		    !prev_lang.empty() &&
-		    (!use_polyglossia || !style.isEnvironment()))
-		{
+	
+	bool const localswitch_needed = localswitch && par_lang != outer_lang;
+
+	// localswitches need to be closed and reopened at each par
+	if ((par_lang != prev_lang || localswitch_needed)
+	     // check if we already put language command in TeXEnvironment()
+	     && !(style.isEnvironment()
+		  && (pit == 0 || (priorpar->layout() != par.layout()
+			           && priorpar->getDepth() <= par.getDepth())
+		      || priorpar->getDepth() < par.getDepth()))) {
+		if (!localswitch
+		    && (!using_begin_end || langOpenedAtThisLevel(state))
+		    && !lang_end_command.empty()
+		    && prev_lang != outer_lang 
+		    && !prev_lang.empty()
+		    && (!using_begin_end || !style.isEnvironment())) {
 			os << from_ascii(subst(lang_end_command,
-				"$$lang",
-				prev_lang))
+					       "$$lang",
+					       prev_lang))
 			   << lang_command_termination;
-			if (use_polyglossia)
-				popPolyglossiaLang();
+			if (using_begin_end)
+				popLanguageName();
 		}
 
 		// We need to open a new language if we couldn't close the previous
@@ -832,7 +879,7 @@ void TeXOnePar(Buffer const & buf,
 		// outer_language (which is currently in effect once the previous one
 		// is closed).
 		if ((lang_end_command.empty() || par_lang != outer_lang
-		     || (!use_polyglossia
+		     || (!using_begin_end
 			 || (style.isEnvironment() && par_lang != prev_lang)))
 			&& !par_lang.empty()) {
 			// If we're inside an inset, and that inset is within an \L or \R
@@ -840,7 +887,7 @@ void TeXOnePar(Buffer const & buf,
 			// language paragraph should appear within an \L or \R (in addition
 			// to, outside of, the normal language switch commands).
 			// This behavior is not correct for ArabTeX, though.
-			if (!use_polyglossia
+			if (!using_begin_end
 			    // not for ArabTeX
 				&& par_language->lang() != "arabic_arabtex"
 				&& outer_language->lang() != "arabic_arabtex"
@@ -873,15 +920,17 @@ void TeXOnePar(Buffer const & buf,
 			}
 			// With CJK, the CJK tag has to be closed first (see below)
 			if (runparams.encoding->package() != Encoding::CJK
-			    && par_lang != openPolyglossiaLang(state)
+			    && (par_lang != openLanguageName(state) || localswitch)
 			    && !par_lang.empty()) {
 				string bc = use_polyglossia ?
-					  getPolyglossiaBegin(lang_begin_command, par_lang, par_language->polyglossiaOpts())
+					  getPolyglossiaBegin(lang_begin_command, par_lang,
+					  		      par_language->polyglossiaOpts(),
+					  		      localswitch)
 					  : subst(lang_begin_command, "$$lang", par_lang);
 				os << bc;
 				os << lang_command_termination;
-				if (use_polyglossia)
-					pushPolyglossiaLang(par_lang, localswitch);
+				if (using_begin_end)
+					pushLanguageName(par_lang, localswitch);
 			}
 		}
 	}
@@ -933,15 +982,17 @@ void TeXOnePar(Buffer const & buf,
 				}
 				// With CJK, the CJK tag had to be closed first (see above)
 				if (runparams.encoding->package() == Encoding::CJK
-				    && par_lang != openPolyglossiaLang(state)
+				    && par_lang != openLanguageName(state)
 				    && !par_lang.empty()) {
-					os << from_ascii(subst(
-						lang_begin_command,
-						"$$lang",
-						par_lang))
-					<< lang_command_termination;
-					if (use_polyglossia)
-						pushPolyglossiaLang(par_lang, localswitch);
+				    	string bc = use_polyglossia ?
+						    getPolyglossiaBegin(lang_begin_command, par_lang,
+						    			par_language->polyglossiaOpts(),
+						    			localswitch)
+						    : subst(lang_begin_command, "$$lang", par_lang);
+					os << bc
+					   << lang_command_termination;
+					if (using_begin_end)
+						pushLanguageName(par_lang, localswitch);
 				}
 				runparams.encoding = encoding;
 			}
@@ -958,34 +1009,39 @@ void TeXOnePar(Buffer const & buf,
 			os << "\n\\appendix\n";
 		}
 
-		if (!par.params().spacing().isDefault()
-			&& (pit == 0 || !priorpar->hasSameLayout(par)))
-		{
-			os << from_ascii(par.params().spacing().writeEnvirBegin(useSetSpace))
-			    << '\n';
-		}
+		// InTitle commands must use switches (not environments)
+		// inside the commands (see #9332)
+		if (style.intitle) {
+			if (!par.params().spacing().isDefault())
+			{
+				if (runparams.moving_arg)
+					os << "\\protect";
+				os << from_ascii(par.params().spacing().writeCmd(useSetSpace));
+			}
+		} else {
+			if (!par.params().spacing().isDefault()
+				&& (pit == 0 || !priorpar->hasSameLayout(par)))
+			{
+				os << from_ascii(par.params().spacing().writeEnvirBegin(useSetSpace))
+				    << '\n';
+			}
 
-		if (style.isCommand()) {
-			os << '\n';
+			if (style.isCommand()) {
+				os << '\n';
+			}
 		}
 	}
 
-	parStartCommand(par, os, runparams, style);
+	// For InTitle commands, we already started the command before
+	// the language switch
+	if (!intitle_command)
+		parStartCommand(par, os, runparams, style);
+
 	Font const outerfont = text.outerFont(pit);
 
 	// FIXME UNICODE
 	os << from_utf8(everypar);
-	par.latex(bparams, outerfont, os, runparams, start_pos, end_pos);
-
-	// Make sure that \\par is done with the font of the last
-	// character if this has another size as the default.
-	// This is necessary because LaTeX (and LyX on the screen)
-	// calculates the space between the baselines according
-	// to this font. (Matthias)
-	//
-	// We must not change the font for the last paragraph
-	// of non-multipar insets, tabular cells or commands,
-	// since this produces unwanted whitespace.
+	par.latex(bparams, outerfont, os, runparams, start_pos, end_pos, force);
 
 	Font const font = par.empty()
 		 ? par.getLayoutFont(bparams, outerfont)
@@ -993,20 +1049,16 @@ void TeXOnePar(Buffer const & buf,
 
 	bool const is_command = style.isCommand();
 
-	if (style.resfont.size() != font.fontInfo().size()
-	    && (nextpar || maintext
-	        || (text.inset().paragraphs().size() > 1
-	            && text.inset().lyxCode() != CELL_CODE))
-	    && !is_command) {
-		os << '{';
-		os << "\\" << from_ascii(font.latexSize()) << " \\par}";
-	} else if (is_command) {
-		os << '}';
-		if (!style.postcommandargs().empty())
-			latexArgInsets(par, os, runparams, style.postcommandargs(), "post:");
-		if (runparams.encoding != prev_encoding) {
-			runparams.encoding = prev_encoding;
-			os << setEncoding(prev_encoding->iconvName());
+	// InTitle commands need to be closed after the language has been closed.
+	if (!intitle_command) {
+		if (is_command) {
+			os << '}';
+			if (!style.postcommandargs().empty())
+				latexArgInsets(par, os, runparams, style.postcommandargs(), "post:");
+			if (runparams.encoding != prev_encoding) {
+				runparams.encoding = prev_encoding;
+				os << setEncoding(prev_encoding->iconvName());
+			}
 		}
 	}
 
@@ -1020,7 +1072,7 @@ void TeXOnePar(Buffer const & buf,
 			     && nextpar->getDepth() == par.getDepth())
 		    || (atSameLastLangSwitchDepth(state) && nextpar
 			    && nextpar->getDepth() < par.getDepth()))
-			close_lang_switch = use_polyglossia;
+			close_lang_switch = using_begin_end;
 		if (nextpar && par.params().depth() < nextpar->params().depth())
 			pending_newline = true;
 		break;
@@ -1030,21 +1082,22 @@ void TeXOnePar(Buffer const & buf,
 		if (nextpar
 		    && ((nextpar->layout() != par.layout()
 			   || nextpar->params().depth() != par.params().depth())
-			|| (!use_polyglossia || par_lang != nextpar_lang)))
+			|| (!using_begin_end || par_lang != nextpar_lang)))
 		{
-			close_lang_switch = use_polyglossia;
+			close_lang_switch = using_begin_end;
 			break;
 		}
 	}
-
-	// fall through possible
+	// possible
+	// fall through
 	default:
-		// we don't need it for the last paragraph!!!
-		if (nextpar)
+		// we don't need it for the last paragraph and in InTitle commands!!!
+		if (nextpar && !intitle_command)
 			pending_newline = true;
 	}
 
-	if (par.allowParagraphCustomization()) {
+	// InTitle commands use switches (not environments) for space settings
+	if (par.allowParagraphCustomization() && !style.intitle) {
 		if (!par.params().spacing().isDefault()
 			&& (runparams.isLastPar || !nextpar->hasSameLayout(par))) {
 			if (pending_newline)
@@ -1060,10 +1113,11 @@ void TeXOnePar(Buffer const & buf,
 		}
 	}
 
-	// Closing the language is needed for the last paragraph; it is also
-	// needed if we're within an \L or \R that we may have opened above (not
-	// necessarily in this paragraph) and are about to close.
-	bool closing_rtl_ltr_environment = !use_polyglossia
+	// Closing the language is needed for the last paragraph in a given language
+	// as well as for any InTitleCommand (since these set the language locally);
+	// it is also needed if we're within an \L or \R that we may have opened above
+	// (not necessarily in this paragraph) and are about to close.
+	bool closing_rtl_ltr_environment = !using_begin_end
 		// not for ArabTeX
 		&& (par_language->lang() != "arabic_arabtex"
 		    && outer_language->lang() != "arabic_arabtex")
@@ -1074,16 +1128,18 @@ void TeXOnePar(Buffer const & buf,
 		&&((nextpar && par_lang != nextpar_lang)
 		   || (runparams.isLastPar && par_lang != outer_lang));
 
-	if (closing_rtl_ltr_environment
+	if (localswitch_needed
+	    || (intitle_command && using_begin_end)
+	    || closing_rtl_ltr_environment
 	    || ((runparams.isLastPar || close_lang_switch)
-	        && (par_lang != outer_lang || (use_polyglossia
+	        && (par_lang != outer_lang || (using_begin_end
 						&& style.isEnvironment()
 						&& par_lang != nextpar_lang)))) {
 		// Since \selectlanguage write the language to the aux file,
 		// we need to reset the language at the end of footnote or
 		// float.
 
-		if (pending_newline || close_lang_switch)
+		if (!localswitch && (pending_newline || close_lang_switch))
 			os << '\n';
 
 		// when the paragraph uses CJK, the language has to be closed earlier
@@ -1099,36 +1155,38 @@ void TeXOnePar(Buffer const & buf,
 					? getPolyglossiaEnvName(current_language)
 					: current_language->babel();
 				if (!current_lang.empty()
-				    && current_lang != openPolyglossiaLang(state)) {
+				    && current_lang != openLanguageName(state)) {
 					string bc = use_polyglossia ?
 						    getPolyglossiaBegin(lang_begin_command, current_lang,
-									current_language->polyglossiaOpts())
+									current_language->polyglossiaOpts(),
+									localswitch)
 						  : subst(lang_begin_command, "$$lang", current_lang);
 					os << bc;
 					pending_newline = !localswitch;
 					unskip_newline = !localswitch;
-					if (use_polyglossia)
-						pushPolyglossiaLang(current_lang, localswitch);
+					if (using_begin_end)
+						pushLanguageName(current_lang, localswitch);
 				}
-			} else if ((!use_polyglossia ||
+			} else if ((!using_begin_end ||
 				    langOpenedAtThisLevel(state)) &&
 				   !par_lang.empty()) {
 				// If we are in an environment, we have to
 				// close the "outer" language afterwards
-				string const & pol_lang = openPolyglossiaLang(state);
+				string const & cur_lang = openLanguageName(state);
 				if (!style.isEnvironment()
 				    || (close_lang_switch
 					&& atSameLastLangSwitchDepth(state)
 					&& par_lang != outer_lang
-					&& (par_lang != pol_lang
-					    || (pol_lang != outer_lang
+					&& (par_lang != cur_lang
+					    || (cur_lang != outer_lang
 						&& nextpar
 						&& style != nextpar->layout())))
 				    || (atSameLastLangSwitchDepth(state)
 					&& state->lang_switch_depth_.size()
-					&& pol_lang != par_lang))
+					&& cur_lang != par_lang)
+				    || in_polyglossia_rtl_env)
 				{
-					if (use_polyglossia && !localswitch)
+					if (using_begin_end && !localswitch)
 						os << breakln;
 					os << from_ascii(subst(
 						lang_end_command,
@@ -1136,8 +1194,8 @@ void TeXOnePar(Buffer const & buf,
 						par_lang));
 					pending_newline = !localswitch;
 					unskip_newline = !localswitch;
-					if (use_polyglossia)
-						popPolyglossiaLang();
+					if (using_begin_end)
+						popLanguageName();
 				}
 			}
 		}
@@ -1145,6 +1203,19 @@ void TeXOnePar(Buffer const & buf,
 	if (closing_rtl_ltr_environment)
 		os << "}";
 
+	// InTitle commands need to be closed after the language has been closed.
+	if (intitle_command) {
+		if (is_command) {
+			os << '}';
+			if (!style.postcommandargs().empty())
+				latexArgInsets(par, os, runparams, style.postcommandargs(), "post:");
+			if (runparams.encoding != prev_encoding) {
+				runparams.encoding = prev_encoding;
+				os << setEncoding(prev_encoding->iconvName());
+			}
+		}
+	}
+
 	bool const last_was_separator =
 		par.size() > 0 && par.isEnvSeparator(par.size() - 1);
 
@@ -1153,7 +1224,7 @@ void TeXOnePar(Buffer const & buf,
 			// prevent unwanted whitespace
 			os << '%';
 		if (!os.afterParbreak() && !last_was_separator)
-			os << breakln;
+			os << '\n';
 	}
 
 	// if this is a CJK-paragraph and the next isn't, close CJK
@@ -1315,6 +1386,10 @@ void latexParagraphs(Buffer const & buf,
 		: bparams.language->babel();
 	string const lang_begin_command = runparams.use_polyglossia ?
 		"\\begin{$$lang}$$opts" : lyxrc.language_command_begin;
+	string const lang_end_command = runparams.use_polyglossia ?
+		"\\end{$$lang}" : lyxrc.language_command_end;
+	bool const using_begin_end = runparams.use_polyglossia ||
+					!lang_end_command.empty();
 
 	if (maintext && !lyxrc.language_auto_begin &&
 	    !mainlang.empty()) {
@@ -1325,8 +1400,8 @@ void latexParagraphs(Buffer const & buf,
 			  : subst(lang_begin_command, "$$lang", mainlang);
 		os << bc;
 		os << '\n';
-		if (runparams.use_polyglossia)
-			pushPolyglossiaLang(mainlang);
+		if (using_begin_end)
+			pushLanguageName(mainlang);
 	}
 
 	ParagraphList const & paragraphs = text.paragraphs();
@@ -1404,7 +1479,7 @@ void latexParagraphs(Buffer const & buf,
 			TeXOnePar(buf, text, pit, os, runparams, everypar);
 			continue;
 		}
-		
+
 		TeXEnvironmentData const data =
 			prepareEnvironment(buf, text, par, os, runparams);
 		// pit can be changed in TeXEnvironment.
@@ -1435,16 +1510,14 @@ void latexParagraphs(Buffer const & buf,
 
 	// if "auto end" is switched off, explicitly close the language at the end
 	// but only if the last par is in a babel or polyglossia language
-	string const lang_end_command = runparams.use_polyglossia ?
-		"\\end{$$lang}" : lyxrc.language_command_end;
 	if (maintext && !lyxrc.language_auto_end && !mainlang.empty() &&
 		paragraphs.at(lastpit).getParLanguage(bparams)->encoding()->package() != Encoding::CJK) {
 		os << from_utf8(subst(lang_end_command,
 					"$$lang",
 					mainlang))
 			<< '\n';
-		if (runparams.use_polyglossia)
-			popPolyglossiaLang();
+		if (using_begin_end)
+			popLanguageName();
 	}
 
 	// If the last paragraph is an environment, we'll have to close
@@ -1453,15 +1526,15 @@ void latexParagraphs(Buffer const & buf,
 		os << "\\end{CJK}\n";
 		state->open_encoding_ = none;
 	}
-	// Likewise for polyglossia
-	string const & pol_lang = openPolyglossiaLang(state);
-	if (maintext && !is_child && !pol_lang.empty()) {
+	// Likewise for polyglossia or when using begin/end commands
+	string const & cur_lang = openLanguageName(state);
+	if (maintext && !is_child && !cur_lang.empty()) {
 		os << from_utf8(subst(lang_end_command,
 					"$$lang",
-					pol_lang))
+					cur_lang))
 		   << '\n';
-		if (runparams.use_polyglossia)
-			popPolyglossiaLang();
+		if (using_begin_end)
+			popLanguageName();
 	}
 
 	// reset inherited encoding
@@ -1486,13 +1559,13 @@ pair<bool, int> switchEncoding(odocstream & os, BufferParams const & bparams,
 	// * with useNonTeXFonts: "utf8plain",
 	// * with XeTeX and TeX fonts: "ascii" (inputenc fails),
 	// * with LuaTeX and TeX fonts: only one encoding accepted by luainputenc.
-	if (runparams.isFullUnicode())
+	if (runparams.isFullUnicode() || newEnc.name() == "inherit")
 		return make_pair(false, 0);
 
 	Encoding const & oldEnc = *runparams.encoding;
 	bool moving_arg = runparams.moving_arg;
 	// If we switch from/to CJK, we need to switch anyway, despite custom inputenc
-	bool const from_to_cjk = 
+	bool const from_to_cjk =
 		(oldEnc.package() == Encoding::CJK && newEnc.package() != Encoding::CJK)
 		|| (oldEnc.package() != Encoding::CJK && newEnc.package() == Encoding::CJK);
 	if (!force && !from_to_cjk