X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Finsets%2FInsetArgument.cpp;h=88085cfb0327a07e21a92b462ed02380b4251f30;hb=997f0621c5346bb623cf86713c4fe1be0c941104;hp=91ae4aa5a64e92e647e568bc6cb533708ab896df;hpb=182d13ee6aa68c306aa3b2788f6d9ed6c1741f51;p=lyx.git diff --git a/src/insets/InsetArgument.cpp b/src/insets/InsetArgument.cpp index 91ae4aa5a6..88085cfb03 100644 --- a/src/insets/InsetArgument.cpp +++ b/src/insets/InsetArgument.cpp @@ -4,6 +4,7 @@ * Licence details can be found in the file COPYING. * * \author Martin Vermeer + * \author Jürgen Spitzmüller * * Full author contact details are available in file CREDITS. */ @@ -12,13 +13,21 @@ #include "InsetArgument.h" +#include "Buffer.h" +#include "BufferParams.h" #include "Cursor.h" #include "FuncStatus.h" #include "FuncRequest.h" +#include "InsetLayout.h" #include "InsetList.h" +#include "Language.h" #include "Layout.h" #include "Lexer.h" #include "ParIterator.h" +#include "TexRow.h" +#include "texstream.h" +#include "TocBackend.h" +#include "xml.h" #include "support/convert.h" #include "support/debug.h" @@ -32,45 +41,52 @@ 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), + free_spacing_(false), pass_thru_chars_(docstring()), is_toc_caption_(false), + newline_cmd_(string()) {} 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) + +void InsetArgument::init(Paragraph const & par) { - 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(); + Inset const & ininset = par.inInset(); + bool const insetlayout = !par.layout().hasArgs(); + Layout::LaTeXArgMap const args = insetlayout ? + ininset.getLayout().args() : par.layout().args(); + pass_thru_context_ = insetlayout ? + ininset.getLayout().isPassThru() : par.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) + // "999" is the conventional name given to those by lyx2lyx if (name_ == "999") { - int req = insetlayout ? it.inset().getLayout().requiredArgs() - : it.paragraph().layout().requiredArgs(); - int opts = insetlayout ? it.inset().getLayout().optArgs() - : it.paragraph().layout().optArgs(); + int const req = insetlayout ? ininset.getLayout().requiredArgs() + : par.layout().requiredArgs(); + int const opts = insetlayout ? ininset.getLayout().optArgs() + : par.layout().optArgs(); int nr = 0; int ours = 0; - InsetList::const_iterator parit = it.paragraph().insetList().begin(); - InsetList::const_iterator parend = it.paragraph().insetList().end(); - for (; parit != parend; ++parit) { - if (parit->inset->lyxCode() == ARG_CODE) { + for (InsetList::Element const & elt : par.insetList()) { + if (elt.inset->lyxCode() == ARG_CODE) { ++nr; - if (parit->inset == this) + if (elt.inset == this) ours = nr; } } @@ -92,26 +108,77 @@ void InsetArgument::updateBuffer(ParIterator const & it, UpdateType utype) name_ = convert(ours); } } - Layout::LaTeXArgMap::const_iterator const lait = - args.find(convert(name_)); + Layout::LaTeXArgMap::const_iterator const lait = args.find(name_); + caption_of_toc_ = string(); if (lait != args.end()) { - docstring label; - support::rsplit(translateIfPossible((*lait).second.labelstring), label, '|'); - labelstring_ = label; + 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; + newline_cmd_ = (*lait).second.newlinecmd; + free_spacing_ = (*lait).second.free_spacing; + docbooktag_ = (*lait).second.docbooktag; + docbooktagtype_ = (*lait).second.docbooktagtype; + docbookattr_ = (*lait).second.docbookattr; + docbookargumentbeforemaintag_ = (*lait).second.docbookargumentbeforemaintag; + docbookargumentaftermaintag_ = (*lait).second.docbookargumentaftermaintag; + pass_thru_local_ = false; + if (lait->second.is_toc_caption) { + is_toc_caption_ = true; + // empty if AddToToc is not set + caption_of_toc_ = insetlayout + ? ininset.getLayout().tocType() + : par.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(); + Language const * l = ininset.buffer().language(); + fixParagraphLanguage(l); + } + setButtonLabel(); - InsetCollapsable::updateBuffer(it, utype); } +void InsetArgument::updateBuffer(ParIterator const & it, UpdateType utype, bool const deleted) +{ + init(it.paragraph()); + InsetCollapsible::updateBuffer(it, utype, deleted); +} + + void InsetArgument::setButtonLabel() { setLabel(labelstring_); } + docstring InsetArgument::toolTip(BufferView const & bv, int, int) const { if (isOpen(bv)) @@ -119,6 +186,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()) { @@ -132,14 +200,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; } } @@ -160,57 +249,139 @@ 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(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(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() == InsetDecoration::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(); +} + + +InsetDecoration InsetArgument::decoration() const +{ + InsetDecoration dec = getLayout().decoration(); + if (!decoration_.empty()) + dec = translateDecoration(decoration_); + return dec == InsetDecoration::DEFAULT ? InsetDecoration::CLASSIC : dec; +} + + +void InsetArgument::docbook(XMLStream & xs, OutputParams const & rp) const { + // Ignore arguments that have already been output or are planned to be output elsewhere. + if (rp.docbook_prepended_arguments.find(this) != rp.docbook_prepended_arguments.end()) + return; + if (rp.docbook_appended_arguments.find(this) != rp.docbook_appended_arguments.end()) + return; + + if (docbooktag_ != from_ascii("NONE") && docbooktag_ != from_ascii("IGNORE")) { + // TODO: implement docbooktagtype_. + xs << xml::StartTag(docbooktag_, docbookattr_); + InsetText::docbook(xs, rp); + xs << xml::EndTag(docbooktag_); + xs << xml::CR(); + } +} + + 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_; + if (!newline_cmd_.empty()) + runparams.newlinecmd = newline_cmd_; + 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.empty() && 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); }