X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Finsets%2FInsetCitation.cpp;h=ba45f691a37cbe0cef69fdab1313ca90e6e2c02a;hb=d6a93143ec2146210d79f58cac42f9608da86100;hp=29a0fbfc072c1b1a8190a16934a90ed7e5c0dbe9;hpb=5fdc577badb1cb133d6a0dc7d831bb1f82576adb;p=lyx.git diff --git a/src/insets/InsetCitation.cpp b/src/insets/InsetCitation.cpp index 29a0fbfc07..ba45f691a3 100644 --- a/src/insets/InsetCitation.cpp +++ b/src/insets/InsetCitation.cpp @@ -21,6 +21,7 @@ #include "DispatchResult.h" #include "FuncCode.h" #include "FuncRequest.h" +#include "FuncStatus.h" #include "LaTeXFeatures.h" #include "output_xhtml.h" #include "ParIterator.h" @@ -41,9 +42,6 @@ using namespace lyx::support; namespace lyx { -ParamInfo InsetCitation::param_info_; - - InsetCitation::InsetCitation(Buffer * buf, InsetCommandParams const & p) : InsetCommand(buf, p) { @@ -54,73 +52,159 @@ InsetCitation::InsetCitation(Buffer * buf, InsetCommandParams const & p) InsetCitation::~InsetCitation() { if (isBufferLoaded()) - buffer().removeBiblioTempFiles(); + /* We do not use buffer() because Coverity believes that this + * may throw an exception. Actually this code path is not + * taken when buffer_ == 0 */ + buffer_->removeBiblioTempFiles(); } +// May well be over-ridden when session settings are loaded +// in GuiCitation. Unfortunately, that will not happen until +// such a dialog is created. +bool InsetCitation::last_literal = true; + + ParamInfo const & InsetCitation::findInfo(string const & /* cmdName */) { - // standard cite does only take one argument if jurabib is - // not used, but jurabib extends this to two arguments, so + static ParamInfo param_info_; + + // standard cite does only take one argument, but biblatex, jurabib + // and natbib extend this to two arguments, so // we have to allow both here. InsetCitation takes care that // LaTeX output is nevertheless correct. if (param_info_.empty()) { - param_info_.add("after", ParamInfo::LATEX_OPTIONAL); - param_info_.add("before", ParamInfo::LATEX_OPTIONAL); + param_info_.add("after", ParamInfo::LATEX_OPTIONAL, + ParamInfo::HANDLING_LATEXIFY); + param_info_.add("before", ParamInfo::LATEX_OPTIONAL, + ParamInfo::HANDLING_LATEXIFY); param_info_.add("key", ParamInfo::LATEX_REQUIRED); + param_info_.add("pretextlist", ParamInfo::LATEX_OPTIONAL, + ParamInfo::HANDLING_LATEXIFY); + param_info_.add("posttextlist", ParamInfo::LATEX_OPTIONAL, + ParamInfo::HANDLING_LATEXIFY); + param_info_.add("literal", ParamInfo::LYX_INTERNAL); } return param_info_; } -namespace { - -vector const init_possible_cite_commands() +// We allow any command here, since we fall back to cite +// anyway if a command is not allowed by a style +bool InsetCitation::isCompatibleCommand(string const &) { - char const * const possible[] = { - "cite", "nocite", "citet", "citep", "citealt", "citealp", - "citeauthor", "citeyear", "citeyearpar", - "citet*", "citep*", "citealt*", "citealp*", "citeauthor*", - "Citet", "Citep", "Citealt", "Citealp", "Citeauthor", - "Citet*", "Citep*", "Citealt*", "Citealp*", "Citeauthor*", - "fullcite", - "footcite", "footcitet", "footcitep", "footcitealt", - "footcitealp", "footciteauthor", "footciteyear", "footciteyearpar", - "citefield", "citetitle", "cite*" - }; - size_t const size_possible = sizeof(possible) / sizeof(possible[0]); - - return vector(possible, possible + size_possible); + return true; } -vector const & possibleCiteCommands() +CitationStyle InsetCitation::getCitationStyle(BufferParams const & bp, string const & input, + vector const & valid_styles) const { - static vector const possible = init_possible_cite_commands(); - return possible; -} + CitationStyle cs = valid_styles[0]; + cs.forceUpperCase = false; + cs.hasStarredVersion = false; + string normalized_input = input; + string::size_type const n = input.size() - 1; + if (isUpperCase(input[0])) + normalized_input[0] = lowercase(input[0]); + if (input[n] == '*') + normalized_input = normalized_input.substr(0, n); -} // anon namespace + string const alias = bp.getCiteAlias(normalized_input); + if (!alias.empty()) + normalized_input = alias; + vector::const_iterator it = valid_styles.begin(); + vector::const_iterator end = valid_styles.end(); + for (; it != end; ++it) { + CitationStyle this_cs = *it; + if (this_cs.name == normalized_input) { + cs = *it; + break; + } + } -// FIXME: use the citeCommands provided by the TextClass -// instead of possibleCiteCommands defined in this file. -bool InsetCitation::isCompatibleCommand(string const & cmd) -{ - vector const & possibles = possibleCiteCommands(); - vector::const_iterator const end = possibles.end(); - return find(possibles.begin(), end, cmd) != end; + return cs; } void InsetCitation::doDispatch(Cursor & cur, FuncRequest & cmd) { - if (cmd.action() == LFUN_INSET_MODIFY) { + switch (cmd.action()) { + case LFUN_INSET_MODIFY: { buffer().removeBiblioTempFiles(); cache.recalculate = true; + if (cmd.getArg(0) == "toggleparam") { + string cmdname = getCmdName(); + string const alias = + buffer().masterParams().getCiteAlias(cmdname); + if (!alias.empty()) + cmdname = alias; + string const par = cmd.getArg(1); + string newcmdname = cmdname; + if (par == "star") { + if (suffixIs(cmdname, "*")) + newcmdname = rtrim(cmdname, "*"); + else + newcmdname = cmdname + "*"; + } else if (par == "casing") { + if (isUpperCase(cmdname[0])) + newcmdname[0] = lowercase(cmdname[0]); + else + newcmdname[0] = uppercase(newcmdname[0]); + } + cmd = FuncRequest(LFUN_INSET_MODIFY, "changetype " + newcmdname); + } + } + // fall through + default: + InsetCommand::doDispatch(cur, cmd); + } +} + + +bool InsetCitation::getStatus(Cursor & cur, FuncRequest const & cmd, + FuncStatus & status) const +{ + switch (cmd.action()) { + // Handle the alias case + case LFUN_INSET_MODIFY: + if (cmd.getArg(0) == "changetype") { + string cmdname = getCmdName(); + string const alias = + buffer().masterParams().getCiteAlias(cmdname); + if (!alias.empty()) + cmdname = alias; + if (suffixIs(cmdname, "*")) + cmdname = rtrim(cmdname, "*"); + string const newtype = cmd.getArg(1); + status.setEnabled(isCompatibleCommand(newtype)); + status.setOnOff(newtype == cmdname); + } + if (cmd.getArg(0) == "toggleparam") { + string cmdname = getCmdName(); + string const alias = + buffer().masterParams().getCiteAlias(cmdname); + if (!alias.empty()) + cmdname = alias; + vector citation_styles = + buffer().masterParams().citeStyles(); + CitationStyle cs = getCitationStyle(buffer().masterParams(), + cmdname, citation_styles); + if (cmd.getArg(1) == "star") { + status.setEnabled(cs.hasStarredVersion); + status.setOnOff(suffixIs(cmdname, "*")); + } + else if (cmd.getArg(1) == "casing") { + status.setEnabled(cs.forceUpperCase); + status.setOnOff(isUpperCase(cmdname[0])); + } + } + return true; + default: + return InsetCommand::getStatus(cur, cmd, status); } - InsetCommand::doDispatch(cur, cmd); } @@ -165,17 +249,29 @@ docstring InsetCitation::toolTip(BufferView const & bv, int, int) const if (key.empty()) return _("No citations selected!"); + CiteItem ci; + ci.richtext = true; vector keys = getVectorFromString(key); if (keys.size() == 1) - return bi.getInfo(keys[0], buffer(), true); + return bi.getInfo(keys[0], buffer(), ci); docstring tip; tip += "
    "; - for (docstring const & key : keys) { - docstring const key_info = bi.getInfo(key, buffer(), true); + int count = 0; + for (docstring const & kvar : keys) { + docstring const key_info = bi.getInfo(kvar, buffer(), ci); + // limit to reasonable size. + if (count > 9 && keys.size() > 11) { + tip.push_back(0x2026);// HORIZONTAL ELLIPSIS + tip += "

    " + + bformat(_("+ %1$d more entries."), int(keys.size() - count)) + + "

    "; + break; + } if (key_info.empty()) continue; tip += "
  1. " + key_info + "
    2. "; + ++count; } tip += "
"; return tip; @@ -184,34 +280,36 @@ docstring InsetCitation::toolTip(BufferView const & bv, int, int) const namespace { - -CitationStyle asValidLatexCommand(string const & input, vector const & valid_styles) +CitationStyle asValidLatexCommand(BufferParams const & bp, string const & input, + vector const & valid_styles) { CitationStyle cs = valid_styles[0]; cs.forceUpperCase = false; - cs.fullAuthorList = false; - if (!InsetCitation::isCompatibleCommand(input)) - return cs; + cs.hasStarredVersion = false; string normalized_input = input; string::size_type const n = input.size() - 1; - if (input[0] == 'C') - normalized_input[0] = 'c'; + if (isUpperCase(input[0])) + normalized_input[0] = lowercase(input[0]); if (input[n] == '*') normalized_input = normalized_input.substr(0, n); + string const alias = bp.getCiteAlias(normalized_input); + if (!alias.empty()) + normalized_input = alias; + vector::const_iterator it = valid_styles.begin(); vector::const_iterator end = valid_styles.end(); for (; it != end; ++it) { CitationStyle this_cs = *it; - if (this_cs.cmd == normalized_input) { + if (this_cs.name == normalized_input) { cs = *it; break; } } - cs.forceUpperCase &= input[0] == 'C'; - cs.fullAuthorList &= input[n] == '*'; + cs.forceUpperCase &= input[0] == uppercase(input[0]); + cs.hasStarredVersion &= input[n] == '*'; return cs; } @@ -230,6 +328,20 @@ inline docstring wrapCitation(docstring const & key, } // anonymous namespace + +map InsetCitation::getQualifiedLists(docstring const p) const +{ + vector ps = + getVectorFromString(p, from_ascii("\t")); + std::map res; + for (docstring const & s: ps) { + docstring key; + docstring val = split(s, key, ' '); + res[key] = val; + } + return res; +} + docstring InsetCitation::generateLabel(bool for_xhtml) const { docstring label; @@ -258,17 +370,18 @@ docstring InsetCitation::complexLabel(bool for_xhtml) const if (key.empty()) return _("No citations selected!"); - // We don't currently use the full or forceUCase fields. string cite_type = getCmdName(); - if (cite_type[0] == 'C') - // If we were going to use them, this would mean ForceUCase - cite_type = string(1, 'c') + cite_type.substr(1); - if (cite_type[cite_type.size() - 1] == '*') - // and this would mean FULL + bool const uppercase = isUpperCase(cite_type[0]); + if (uppercase) + cite_type[0] = lowercase(cite_type[0]); + bool const starred = (cite_type[cite_type.size() - 1] == '*'); + if (starred) cite_type = cite_type.substr(0, cite_type.size() - 1); - docstring const & before = getParam("before"); - docstring const & after = getParam("after"); + // handle alias + string const alias = buf.masterParams().getCiteAlias(cite_type); + if (!alias.empty()) + cite_type = alias; // FIXME: allow to add cite macros /* @@ -276,8 +389,34 @@ docstring InsetCitation::complexLabel(bool for_xhtml) const buffer().params().documentClass().addCiteMacro("!textafter", to_utf8(after)); */ docstring label; - vector keys = getVectorFromString(key); - label = biblist.getLabel(keys, buffer(), cite_type, for_xhtml, UINT_MAX, before, after); + // we only really want the last 'false', to suppress trimming, but + // we need to give the other defaults, too, to set it. + vector keys = + getVectorFromString(key, from_ascii(","), false, false); + CitationStyle cs = getCitationStyle(buffer().masterParams(), + cite_type, buffer().masterParams().citeStyles()); + bool const qualified = cs.hasQualifiedList + && (keys.size() > 1 + || !getParam("pretextlist").empty() + || !getParam("posttextlist").empty()); + map pres = getQualifiedLists(getParam("pretextlist")); + map posts = getQualifiedLists(getParam("posttextlist")); + + CiteItem ci; + ci.textBefore = getParam("before"); + ci.textAfter = getParam("after"); + ci.forceUpperCase = uppercase; + ci.Starred = starred; + ci.max_size = UINT_MAX; + ci.isQualified = qualified; + ci.pretexts = pres; + ci.posttexts = posts; + if (for_xhtml) { + ci.max_key_size = UINT_MAX; + ci.context = CiteItem::Export; + } + ci.richtext = for_xhtml; + label = biblist.getLabel(keys, buffer(), cite_type, ci); return label; } @@ -291,8 +430,7 @@ docstring InsetCitation::basicLabel(bool for_xhtml) const do { // if there is no comma, then everything goes into key // and keys will be empty. - keys = trim(split(keys, key, ',')); - key = trim(key); + keys = split(keys, key, ','); if (!label.empty()) label += ", "; label += wrapCitation(key, key, for_xhtml); @@ -326,15 +464,15 @@ void InsetCitation::updateBuffer(ParIterator const &, UpdateType) void InsetCitation::addToToc(DocIterator const & cpit, bool output_active, - UpdateType) const + UpdateType, TocBackend & backend) const { // NOTE - // BiblioInfo::collectCitedEntries() uses the TOC to collect the citations + // BiblioInfo::collectCitedEntries() uses the TOC to collect the citations // from the document. It is used indirectly, via BiblioInfo::makeCitationLables, // by both XHTML and plaintext output. So, if we change what goes into the TOC, // then we will also need to change that routine. docstring const tocitem = getParam("key"); - TocBuilder & b = buffer().tocBackend().builder("citation"); + TocBuilder & b = backend.builder("citation"); b.pushItem(cpit, tocitem, output_active); b.pop(); } @@ -414,29 +552,82 @@ void InsetCitation::forOutliner(docstring & os, size_t const, bool const) const // engine, e.g. \cite[]{} for the basic engine. void InsetCitation::latex(otexstream & os, OutputParams const & runparams) const { - vector citation_styles = buffer().params().citeStyles(); - CitationStyle cs = asValidLatexCommand(getCmdName(), citation_styles); - BiblioInfo const & bi = buffer().masterBibInfo(); + // When this is a child compiled on its own, we use the childs + // own bibinfo, else the master's + BiblioInfo const & bi = runparams.is_child + ? buffer().masterBibInfo() : buffer().bibInfo(); + docstring const key = getParam("key"); + // "keyonly" command: output the plain key and stop. + if (getCmdName() == "keyonly") { + // Special command to only return the key + if (!bi.isBibtex(getParam("key"))) + // escape chars with bibitems + os << escape(cleanupWhitespace(key)); + else + os << cleanupWhitespace(key); + return; + } + vector citation_styles = buffer().masterParams().citeStyles(); + CitationStyle cs = asValidLatexCommand(buffer().masterParams(), + getCmdName(), citation_styles); // FIXME UNICODE - docstring const cite_str = from_utf8(citationStyleToString(cs)); + docstring const cite_str = from_utf8(citationStyleToString(cs, true)); + + // check if we have to do a qualified list + vector keys = getVectorFromString(cleanupWhitespace(key)); + bool const qualified = cs.hasQualifiedList + && (!getParam("pretextlist").empty() + || !getParam("posttextlist").empty()); if (runparams.inulemcmd > 0) os << "\\mbox{"; os << "\\" << cite_str; - docstring const & before = getParam("before"); - docstring const & after = getParam("after"); - if (!before.empty() && cs.textBefore) - os << '[' << before << "][" << after << ']'; - else if (!after.empty() && cs.textAfter) - os << '[' << after << ']'; + if (qualified) + os << "s"; + + ParamInfo const & pinfo = findInfo(string()); + docstring before = params().prepareCommand(runparams, getParam("before"), + pinfo["before"].handling()); + docstring after = params().prepareCommand(runparams, getParam("after"), + pinfo["after"].handling()); + if (!before.empty() && cs.textBefore) { + if (qualified) + os << '(' << protectArgument(before, '(', ')') + << ")(" << protectArgument(after, '(', ')') << ')'; + else + os << '[' << protectArgument(before) << "][" + << protectArgument(after) << ']'; + } else if (!after.empty() && cs.textAfter) { + if (qualified) + os << '(' << protectArgument(after, '(', ')') << ')'; + else + os << '[' << protectArgument(after) << ']'; + } - if (!bi.isBibtex(getParam("key"))) + if (!bi.isBibtex(key)) // escape chars with bibitems - os << '{' << escape(cleanupWhitespace(getParam("key"))) << '}'; - else - os << '{' << cleanupWhitespace(getParam("key")) << '}'; + os << '{' << escape(cleanupWhitespace(key)) << '}'; + else { + if (qualified) { + map pres = getQualifiedLists(getParam("pretextlist")); + map posts = getQualifiedLists(getParam("posttextlist")); + for (docstring const & k: keys) { + docstring bef = params().prepareCommand(runparams, pres[k], + pinfo["pretextlist"].handling()); + docstring aft = params().prepareCommand(runparams, posts[k], + pinfo["posttextlist"].handling()); + if (!bef.empty()) + os << '[' << protectArgument(bef) + << "][" << protectArgument(aft) << ']'; + else if (!aft.empty()) + os << '[' << protectArgument(aft) << ']'; + os << '{' << k << '}'; + } + } else + os << '{' << cleanupWhitespace(key) << '}'; + } if (runparams.inulemcmd) os << "}";