X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Finsets%2FInsetArgument.cpp;h=df1344e6267a5537bcc4e972ea4b0afacb83133f;hb=88034d3d8987a9601b0779bf0115b5105b16fd6e;hp=9ca8b9e194451b6ec740ca1cc5af774866b9e3f0;hpb=7538c953a4dce785c2a62526baf75f2bdfcf7b79;p=lyx.git diff --git a/src/insets/InsetArgument.cpp b/src/insets/InsetArgument.cpp index 9ca8b9e194..df1344e626 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,10 +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" @@ -29,50 +40,56 @@ 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") { - int req = insetlayout ? it.inset().getLayout().requiredArgs() + unsigned int const req = insetlayout ? it.inset().getLayout().requiredArgs() : it.paragraph().layout().requiredArgs(); - int opts = insetlayout ? it.inset().getLayout().optArgs() + unsigned int const opts = insetlayout ? it.inset().getLayout().optArgs() : it.paragraph().layout().optArgs(); - int nr = 0; - int ours = 0; + unsigned int nr = 0; + unsigned 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) { ++nr; - if (parit->inset == this) - ours = nr; + if (parit->inset == this) + ours = nr; } } bool done = false; - int realopts = 0; + unsigned int realopts = 0; if (nr > req) { // We have optional arguments realopts = nr - req; @@ -89,24 +106,64 @@ 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()) { - labelstring_ = translateIfPossible((*lait).second.labelstring); + 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)) @@ -114,18 +171,182 @@ 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()) { + + case LFUN_INSET_MODIFY: { + string const first_arg = cmd.getArg(0); + bool const change_type = first_arg == "changetype"; + if (!change_type) { + // not for us + // this will not be handled higher up + cur.undispatched(); + return; + } + 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: + InsetCollapsible::doDispatch(cur, cmd); + break; + } +} + + +bool InsetArgument::getStatus(Cursor & cur, FuncRequest const & cmd, + FuncStatus & flag) const +{ + switch (cmd.action()) { + + case LFUN_INSET_MODIFY: { + string const first_arg = cmd.getArg(0); + if (first_arg == "changetype") { + string const type = cmd.getArg(1); + flag.setOnOff(type == name_); + if (type == name_) { + flag.setEnabled(true); + return true; + } + Layout::LaTeXArgMap args; + 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(type); + if (lait != args.end()) { + flag.setEnabled(true); + 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 InsetCollapsible::getStatus(cur, cmd, flag); + } + + default: + return InsetCollapsible::getStatus(cur, cmd, flag); + } +} + + +string InsetArgument::contextMenuName() const +{ + 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); }