X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Finsets%2FInsetArgument.cpp;h=df1344e6267a5537bcc4e972ea4b0afacb83133f;hb=59e6610d8ad4d5c5a81d9a6b4ef73ae36231489a;hp=943adef319ef345a7024ee213314eea81712908c;hpb=07a01f40f9f1298dd16d0ed84c378b0f83840584;p=lyx.git

diff --git a/src/insets/InsetArgument.cpp b/src/insets/InsetArgument.cpp
index 943adef319..df1344e626 100644
--- a/src/insets/InsetArgument.cpp
+++ b/src/insets/InsetArgument.cpp
@@ -13,13 +13,20 @@
 
 #include "InsetArgument.h"
 
+#include "Buffer.h"
+#include "BufferParams.h"
 #include "Cursor.h"
 #include "FuncStatus.h"
 #include "FuncRequest.h"
 #include "InsetList.h"
+#include "Language.h"
 #include "Layout.h"
 #include "Lexer.h"
+#include "OutputParams.h"
 #include "ParIterator.h"
+#include "TexRow.h"
+#include "texstream.h"
+#include "TocBackend.h"
 
 #include "support/convert.h"
 #include "support/debug.h"
@@ -33,36 +40,42 @@ namespace lyx {
 
 
 InsetArgument::InsetArgument(Buffer * buf, string const & name)
-    : InsetCollapsable(buf), name_(name), labelstring_(docstring())
+    : InsetCollapsible(buf), name_(name), labelstring_(docstring()),
+      font_(inherit_font), labelfont_(inherit_font), decoration_(string()),
+      pass_thru_context_(false), pass_thru_local_(false), pass_thru_(false),
+      pass_thru_chars_(docstring()), is_toc_caption_(false)
 {}
 
 
 void InsetArgument::write(ostream & os) const
 {
 	os << "Argument " << name_ << "\n";
-	InsetCollapsable::write(os);
+	InsetCollapsible::write(os);
 }
 
+
 void InsetArgument::read(Lexer & lex)
 {
 	lex >> name_;
-	InsetCollapsable::read(lex);
+	InsetCollapsible::read(lex);
 }
 
+
 void InsetArgument::updateBuffer(ParIterator const & it, UpdateType utype)
 {
-	Layout::LaTeXArgMap args;
-	bool const insetlayout = &it.inset() && it.paragraph().layout().latexargs().empty();
-	if (insetlayout)
-		args = it.inset().getLayout().latexargs();
-	else
-		args = it.paragraph().layout().latexargs();
+	bool const insetlayout = !it.paragraph().layout().hasArgs();
+	Layout::LaTeXArgMap const args = insetlayout ?
+		it.inset().getLayout().args() : it.paragraph().layout().args();
+	pass_thru_context_ = insetlayout ?
+		it.inset().getLayout().isPassThru() : it.paragraph().layout().pass_thru;
+	// Record PassThru status in order to act on changes.
+	bool const former_pass_thru = pass_thru_;
 
 	// Handle pre 2.1 ArgInsets (lyx2lyx cannot classify them)
 	if (name_ == "999") {
-		unsigned int const req = insetlayout ? it.inset().getLayout().numRequiredArgs()
+		unsigned int const req = insetlayout ? it.inset().getLayout().requiredArgs()
 				      : it.paragraph().layout().requiredArgs();
-		unsigned int const opts = insetlayout ? it.inset().getLayout().numOptArgs()
+		unsigned int const opts = insetlayout ? it.inset().getLayout().optArgs()
 				      : it.paragraph().layout().optArgs();
 		unsigned int nr = 0;
 		unsigned int ours = 0;
@@ -93,27 +106,64 @@ void InsetArgument::updateBuffer(ParIterator const & it, UpdateType utype)
 			name_ = convert<string>(ours);
 		}
 	}
-	Layout::LaTeXArgMap::const_iterator const lait =
-			args.find(convert<unsigned int>(name_));
+	Layout::LaTeXArgMap::const_iterator const lait = args.find(name_);
+	caption_of_toc_ = string();
 	if (lait != args.end()) {
 		docstring label = translateIfPossible((*lait).second.labelstring);
 		docstring striplabel;
 		support::rsplit(label, striplabel, '|');
 		labelstring_ = striplabel.empty() ? label: striplabel;
 		tooltip_ = translateIfPossible((*lait).second.tooltip);
+		font_ = (*lait).second.font;
+		labelfont_ = (*lait).second.labelfont;
+		decoration_ = (*lait).second.decoration;
+		pass_thru_chars_ = (*lait).second.pass_thru_chars;
+		pass_thru_local_ = false;
+		if (lait->second.is_toc_caption) {
+			is_toc_caption_ = true;
+			// empty if AddToToc is not set
+			caption_of_toc_ = insetlayout
+				? it.inset().getLayout().tocType()
+				: it.paragraph().layout().tocType();
+		}
+
+		switch ((*lait).second.passthru) {
+			case PT_INHERITED:
+				pass_thru_ = pass_thru_context_;
+				break;
+			case PT_TRUE:
+				pass_thru_ = true;
+				pass_thru_local_ = true;
+				break;
+			case PT_FALSE:
+				pass_thru_ = false;
+				break;
+		}
 	} else {
 		labelstring_ = _("Unknown Argument");
-		tooltip_ = _("Argument not known in this Layout. Will be supressed in the output.");
+		tooltip_ = _("Argument not known in this Layout. Will be suppressed in the output.");
 	}
+
+	if (former_pass_thru != pass_thru_) {
+		// PassThru status changed. We might need to update
+		// the language of the contents
+		Language const * l  = insetlayout
+			? it.inset().buffer().language()
+			: it.buffer()->language();
+		fixParagraphLanguage(l);
+	}
+
 	setButtonLabel();
-	InsetCollapsable::updateBuffer(it, utype);
+	InsetCollapsible::updateBuffer(it, utype);
 }
 
+
 void InsetArgument::setButtonLabel()
 {
 	setLabel(labelstring_);
 }
 
+
 docstring InsetArgument::toolTip(BufferView const & bv, int, int) const
 {
 	if (isOpen(bv))
@@ -121,6 +171,7 @@ docstring InsetArgument::toolTip(BufferView const & bv, int, int) const
 	return toolTipText(tooltip_ + from_ascii(":\n"));
 }
 
+
 void InsetArgument::doDispatch(Cursor & cur, FuncRequest & cmd)
 {
 	switch (cmd.action()) {
@@ -134,14 +185,35 @@ void InsetArgument::doDispatch(Cursor & cur, FuncRequest & cmd)
 			cur.undispatched();
 			return;
 		}
-		cur.recordUndoInset(ATOMIC_UNDO, this);
+		cur.recordUndoInset(this);
 		name_ = cmd.getArg(1);
 		cur.forceBufferUpdate();
 		break;
 	}
 
+	case LFUN_PASTE:
+	case LFUN_CLIPBOARD_PASTE:
+	case LFUN_SELECTION_PASTE:
+	case LFUN_PRIMARY_SELECTION_PASTE:
+	case LFUN_SELF_INSERT:
+		// With (only) inherited pass_thru, call Text::dispatch()
+		// directly to avoid call for fixParagraphsFont() and/or
+		// forcing to latex_language in InsetText::dispatch(),
+		// since this does not play nicely with inherited pass_thru
+		// (see #8471).
+		if (pass_thru_ && !pass_thru_local_) {
+			text().dispatch(cur, cmd);
+			// For the paste operations, check if we have
+			// non-latex_language, and if so, fix.
+			if (cmd.action() != LFUN_SELF_INSERT)
+				fixParagraphLanguage(buffer().params().language);
+		}
+		else
+			InsetCollapsible::doDispatch(cur, cmd);
+		break;
+
 	default:
-		InsetCollapsable::doDispatch(cur, cmd);
+		InsetCollapsible::doDispatch(cur, cmd);
 		break;
 	}
 }
@@ -162,57 +234,119 @@ bool InsetArgument::getStatus(Cursor & cur, FuncRequest const & cmd,
 				return true;
 			}
 			Layout::LaTeXArgMap args;
-			bool const insetlayout = &cur.inset() && cur.paragraph().layout().latexargs().empty();
+			bool const insetlayout = cur.paragraph().layout().latexargs().empty();
 			if (insetlayout)
 				args = cur.inset().getLayout().latexargs();
 			else
 				args = cur.paragraph().layout().latexargs();
-			Layout::LaTeXArgMap::const_iterator const lait =
-					args.find(convert<unsigned int>(type));
+			Layout::LaTeXArgMap::const_iterator const lait = args.find(type);
 			if (lait != args.end()) {
 				flag.setEnabled(true);
-				InsetList::const_iterator it = cur.paragraph().insetList().begin();
-				InsetList::const_iterator end = cur.paragraph().insetList().end();
-				for (; it != end; ++it) {
-					if (it->inset->lyxCode() == ARG_CODE) {
-						InsetArgument const * ins =
-							static_cast<InsetArgument const *>(it->inset);
+				for (auto const & table : cur.paragraph().insetList())
+					if (InsetArgument const * ins = table.inset->asInsetArgument())
 						if (ins->name() == type) {
 							// we have this already
 							flag.setEnabled(false);
 							return true;
 						}
-					}
-				}
 			} else
 				flag.setEnabled(false);
 			return true;
 		}
-		return InsetCollapsable::getStatus(cur, cmd, flag);
+		return InsetCollapsible::getStatus(cur, cmd, flag);
 	}
 
 	default:
-		return InsetCollapsable::getStatus(cur, cmd, flag);
+		return InsetCollapsible::getStatus(cur, cmd, flag);
 	}
 }
 
+
 string InsetArgument::contextMenuName() const
 {
-	return "context-argument";
+	if (decoration() == InsetLayout::CONGLOMERATE)
+		return "context-argument-conglomerate";
+	else
+		return "context-argument";
+}
+
+
+FontInfo InsetArgument::getFont() const
+{
+	if (font_ != inherit_font)
+		return font_;
+	return InsetCollapsible::getFont();
 }
 
+
+FontInfo InsetArgument::getLabelfont() const
+{
+	if (labelfont_ != inherit_font)
+		return labelfont_;
+	return InsetCollapsible::getLabelfont();
+}
+
+
+ColorCode InsetArgument::labelColor() const {
+	if (labelfont_.color() != Color_inherit)
+		return labelfont_.color();
+	return InsetCollapsible::labelColor();
+}
+
+
+InsetLayout::InsetDecoration InsetArgument::decoration() const
+{
+	InsetLayout::InsetDecoration dec = getLayout().decoration();
+	if (!decoration_.empty())
+		dec = translateDecoration(decoration_);
+	return dec == InsetLayout::DEFAULT ? InsetLayout::CLASSIC : dec;
+}
+
+
 void InsetArgument::latexArgument(otexstream & os,
-		OutputParams const & runparams, docstring const & ldelim,
-		docstring const & rdelim) const
+		OutputParams const & runparams_in, docstring const & ldelim,
+		docstring const & rdelim, docstring const & presetarg) const
 {
-	TexRow texrow;
-	odocstringstream ss;
-	otexstream ots(ss, texrow);
+	otexstringstream ots;
+	OutputParams runparams = runparams_in;
+	if (!pass_thru_chars_.empty())
+		runparams.pass_thru_chars += pass_thru_chars_;
+	runparams.pass_thru = isPassThru();
 	InsetText::latex(ots, runparams);
-	docstring str = ss.str();
-	if (ldelim != "{" && support::contains(str, rdelim))
-		str = '{' + str + '}';
-	os << ldelim << str << rdelim;
+	TexString ts = ots.release();
+	bool const add_braces = ldelim != "{" && support::contains(ts.str, rdelim);
+	os << ldelim;
+	if (add_braces)
+		os << '{';
+	os << presetarg;
+	if (!presetarg.empty() && !ts.str.empty())
+		os << ", ";
+	os << move(ts);
+	if (add_braces)
+		os << '}';
+	os << rdelim;
+}
+
+
+void InsetArgument::addToToc(DocIterator const & dit, bool output_active,
+                             UpdateType utype, TocBackend & backend) const
+{
+	if (!caption_of_toc_.empty()) {
+		docstring str;
+		text().forOutliner(str, TOC_ENTRY_LENGTH);
+		backend.builder(caption_of_toc_).argumentItem(str);
+	}
+	// Proceed with the rest of the inset.
+	InsetText::addToToc(dit, output_active, utype, backend);
+}
+
+
+void InsetArgument::fixParagraphLanguage(Language const * l)
+{
+	Font font(inherit_font, l);
+	if (pass_thru_)
+		font.setLanguage(latex_language);
+	paragraphs().front().resetFonts(font);
 }