X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Finsets%2FInsetCitation.cpp;h=d878056cd6a3be952cde07254d49c0c5155a267d;hb=eb294eadb5e7f22880da399ae082f74567bbfc4e;hp=768eb35e8b036eeed4c5a1545da8a09886811707;hpb=ce8929e9b237af569934b434154d199634363268;p=lyx.git diff --git a/src/insets/InsetCitation.cpp b/src/insets/InsetCitation.cpp index 768eb35e8b..d878056cd6 100644 --- a/src/insets/InsetCitation.cpp +++ b/src/insets/InsetCitation.cpp @@ -18,12 +18,16 @@ #include "buffer_funcs.h" #include "BufferParams.h" #include "BufferView.h" +#include "Citation.h" #include "DispatchResult.h" #include "FuncCode.h" #include "FuncRequest.h" #include "FuncStatus.h" #include "LaTeXFeatures.h" +#include "LyX.h" +#include "LyXRC.h" #include "output_xhtml.h" +#include "output_docbook.h" #include "ParIterator.h" #include "texstream.h" #include "TocBackend.h" @@ -42,33 +46,49 @@ using namespace lyx::support; namespace lyx { -ParamInfo InsetCitation::param_info_; - - InsetCitation::InsetCitation(Buffer * buf, InsetCommandParams const & p) : InsetCommand(buf, p) { buffer().removeBiblioTempFiles(); + cleanKeys(); } 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 */) { + 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_; } @@ -117,13 +137,16 @@ CitationStyle InsetCitation::getCitationStyle(BufferParams const & bp, string co void InsetCitation::doDispatch(Cursor & cur, FuncRequest & cmd) { switch (cmd.action()) { + case LFUN_INSET_EDIT: + openCitation(); + break; case LFUN_INSET_MODIFY: { buffer().removeBiblioTempFiles(); cache.recalculate = true; if (cmd.getArg(0) == "toggleparam") { string cmdname = getCmdName(); string const alias = - buffer().params().getCiteAlias(cmdname); + buffer().masterParams().getCiteAlias(cmdname); if (!alias.empty()) cmdname = alias; string const par = cmd.getArg(1); @@ -142,8 +165,76 @@ void InsetCitation::doDispatch(Cursor & cur, FuncRequest & cmd) cmd = FuncRequest(LFUN_INSET_MODIFY, "changetype " + newcmdname); } } + // fall through default: InsetCommand::doDispatch(cur, cmd); + if (cmd.action() == LFUN_INSET_MODIFY) + cleanKeys(); + } +} + +bool InsetCitation::openCitationPossible() const +{ + Buffer const & buf = *buffer_; + // only after the buffer is loaded from file... + if (!buf.isFullyLoaded()) + return false; + + BiblioInfo const & bi = buf.masterBibInfo(); + if (bi.empty()) + return false; + + docstring const & key = getParam("key"); + if (key.empty()) + return false; + + // does bibtex item contains some locator? + vector keys = getVectorFromString(key); + docstring doi, url, file; + for (docstring const & kvar : keys) { + bi.getLocators(kvar, doi, url, file); + if (!file.empty() || !doi.empty() || !url.empty()) + return true; + } + + // last resort: is external script activated? + return lyxrc.citation_search; +} + +void InsetCitation::openCitation() +{ + Buffer const & buf = *buffer_; + BiblioInfo const & bi = buf.masterBibInfo(); + docstring const & key = getParam("key"); + + vector keys = getVectorFromString(key); + docstring titledata, doi, url, file; + for (docstring const & kvar : keys) { + CiteItem ci; + titledata = bi.getInfo(kvar, buffer(), ci, + from_ascii(lyxrc.citation_search_pattern)); + // some cleanup: commas, " and " and " et al.", as used in name lists, + // are not expected in file names + titledata = subst(titledata, from_ascii(","), docstring()); + titledata = subst(titledata, from_ascii(" and "), from_ascii(" ")); + titledata = subst(titledata, from_ascii(" et al."), docstring()); + bi.getLocators(kvar, doi, url, file); + LYXERR(Debug::INSETS, "Locators: doi:" << doi << " url:" + << url << " file:" << file << " title data:" << titledata + << " citation search: " << lyxrc.citation_search + << " citation search pattern: " << lyxrc.citation_search_pattern); + docstring locator; + if (!file.empty()) { + locator = file; + } else if (!doi.empty()) { + locator = doi; + } else if (!url.empty()) { + locator = url; + } else { + locator = "EXTERNAL " + titledata; + } + FuncRequest cmd = FuncRequest(LFUN_CITATION_OPEN, locator); + lyx::dispatch(cmd); } } @@ -157,7 +248,7 @@ bool InsetCitation::getStatus(Cursor & cur, FuncRequest const & cmd, if (cmd.getArg(0) == "changetype") { string cmdname = getCmdName(); string const alias = - buffer().params().getCiteAlias(cmdname); + buffer().masterParams().getCiteAlias(cmdname); if (!alias.empty()) cmdname = alias; if (suffixIs(cmdname, "*")) @@ -169,12 +260,12 @@ bool InsetCitation::getStatus(Cursor & cur, FuncRequest const & cmd, if (cmd.getArg(0) == "toggleparam") { string cmdname = getCmdName(); string const alias = - buffer().params().getCiteAlias(cmdname); + buffer().masterParams().getCiteAlias(cmdname); if (!alias.empty()) cmdname = alias; vector citation_styles = - buffer().params().citeStyles(); - CitationStyle cs = getCitationStyle(buffer().params(), + buffer().masterParams().citeStyles(); + CitationStyle cs = getCitationStyle(buffer().masterParams(), cmdname, citation_styles); if (cmd.getArg(1) == "star") { status.setEnabled(cs.hasStarredVersion); @@ -186,6 +277,8 @@ bool InsetCitation::getStatus(Cursor & cur, FuncRequest const & cmd, } } return true; + case LFUN_INSET_EDIT: + return openCitationPossible(); default: return InsetCommand::getStatus(cur, cmd, status); } @@ -194,7 +287,7 @@ bool InsetCitation::getStatus(Cursor & cur, FuncRequest const & cmd, bool InsetCitation::addKey(string const & key) { - docstring const ukey = from_utf8(key); + docstring const ukey = from_utf8(trim(key)); docstring const & curkeys = getParam("key"); if (curkeys.empty()) { setParam("key", ukey); @@ -203,10 +296,8 @@ bool InsetCitation::addKey(string const & key) } vector keys = getVectorFromString(curkeys); - vector::const_iterator it = keys.begin(); - vector::const_iterator en = keys.end(); - for (; it != en; ++it) { - if (*it == ukey) { + for (auto const & k : keys) { + if (k == ukey) { LYXERR0("Key " << key << " already present."); return false; } @@ -242,8 +333,8 @@ docstring InsetCitation::toolTip(BufferView const & bv, int, int) const docstring tip; tip += "
    "; int count = 0; - for (docstring const & key : keys) { - docstring const key_info = bi.getInfo(key, buffer(), ci); + 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 @@ -306,12 +397,28 @@ inline docstring wrapCitation(docstring const & key, return content; // we have to do the escaping here, because we will ultimately // write this as a raw string, so as not to escape the tags. - return "" + - html::htmlize(content, XHTMLStream::ESCAPE_ALL) + ""; + return "" + + xml::escapeString(content, XMLStream::ESCAPE_ALL) + ""; } } // anonymous namespace + +vector> InsetCitation::getQualifiedLists(docstring const & p) const +{ + vector ps = + getVectorFromString(p, from_ascii("\t")); + QualifiedList res; + for (docstring const & s: ps) { + docstring key = s; + docstring val; + if (contains(s, ' ')) + val = split(s, key, ' '); + res.push_back(make_pair(key, val)); + } + return res; +} + docstring InsetCitation::generateLabel(bool for_xhtml) const { docstring label; @@ -332,14 +439,33 @@ docstring InsetCitation::complexLabel(bool for_xhtml) const if (!buf.isFullyLoaded()) return docstring(); + docstring const & key = getParam("key"); + BiblioInfo const & biblist = buf.masterBibInfo(); - if (biblist.empty()) + + // mark broken citations + setBroken(false); + + if (biblist.empty()) { + setBroken(true); return docstring(); + } - docstring const & key = getParam("key"); if (key.empty()) return _("No citations selected!"); + // check all citations + // 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); + for (auto const & k : keys) { + if (biblist.find(k) == biblist.end()) { + setBroken(true); + break; + } + } + string cite_type = getCmdName(); bool const uppercase = isUpperCase(cite_type[0]); if (uppercase) @@ -349,7 +475,7 @@ docstring InsetCitation::complexLabel(bool for_xhtml) const cite_type = cite_type.substr(0, cite_type.size() - 1); // handle alias - string const alias = buf.params().getCiteAlias(cite_type); + string const alias = buf.masterParams().getCiteAlias(cite_type); if (!alias.empty()) cite_type = alias; @@ -359,13 +485,24 @@ docstring InsetCitation::complexLabel(bool for_xhtml) const buffer().params().documentClass().addCiteMacro("!textafter", to_utf8(after)); */ docstring label; - vector keys = getVectorFromString(key); + CitationStyle cs = getCitationStyle(buffer().masterParams(), + cite_type, buffer().masterParams().citeStyles()); + bool const qualified = cs.hasQualifiedList + && (keys.size() > 1 + || !getParam("pretextlist").empty() + || !getParam("posttextlist").empty()); + QualifiedList pres = getQualifiedLists(getParam("pretextlist")); + QualifiedList 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; @@ -385,8 +522,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); @@ -399,13 +535,25 @@ docstring InsetCitation::basicLabel(bool for_xhtml) const return '[' + label + ']'; } + +bool InsetCitation::forceLTR(OutputParams const & rp) const +{ + // We have to force LTR for numeric references + // [= bibliography, plain BibTeX, numeric natbib + // and biblatex]. Except for XeTeX/bidi. See #3005. + if (rp.useBidiPackage()) + return false; + return (buffer().masterParams().citeEngine() == "basic" + || buffer().masterParams().citeEngineType() == ENGINE_TYPE_NUMERICAL); +} + docstring InsetCitation::screenLabel() const { return cache.screen_label; } -void InsetCitation::updateBuffer(ParIterator const &, UpdateType) +void InsetCitation::updateBuffer(ParIterator const &, UpdateType, bool const /*deleted*/) { if (!cache.recalculate && buffer().citeLabelsValid()) return; @@ -414,23 +562,30 @@ void InsetCitation::updateBuffer(ParIterator const &, UpdateType) cache.recalculate = false; cache.generated_label = glabel; unsigned int const maxLabelChars = 45; - cache.screen_label = glabel.substr(0, maxLabelChars + 1); - support::truncateWithEllipsis(cache.screen_label, maxLabelChars); + cache.screen_label = glabel; + support::truncateWithEllipsis(cache.screen_label, maxLabelChars, true); } 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"); + docstring tocitem; + if (isBroken()) + tocitem = _("BROKEN: "); + tocitem += getParam("key"); + TocBuilder & b = backend.builder("citation"); b.pushItem(cpit, tocitem, output_active); b.pop(); + if (isBroken()) { + shared_ptr toc2 = backend.toc("brokenrefs"); + toc2->push_back(TocItem(cpit, 0, tocitem, output_active)); + } } @@ -441,7 +596,7 @@ int InsetCitation::plaintext(odocstringstream & os, if (cmd == "nocite") return 0; - docstring const label = generateLabel(false); + docstring const label = generateLabel(); os << label; return label.size(); } @@ -449,39 +604,57 @@ int InsetCitation::plaintext(odocstringstream & os, static docstring const cleanupWhitespace(docstring const & citelist) { - docstring::const_iterator it = citelist.begin(); - docstring::const_iterator end = citelist.end(); // Paranoia check: make sure that there is no whitespace in here // -- at least not behind commas or at the beginning docstring result; char_type last = ','; - for (; it != end; ++it) { - if (*it != ' ') - last = *it; - if (*it != ' ' || last != ',') - result += *it; + for (char_type c : citelist) { + if (c != ' ') + last = c; + if (c != ' ' || last != ',') + result += c; } return result; } -int InsetCitation::docbook(odocstream & os, OutputParams const &) const +void InsetCitation::cleanKeys() { + docstring cleankeys = cleanupWhitespace(getParam("key")); + setParam("key", cleankeys); +} + +void InsetCitation::docbook(XMLStream & xs, OutputParams const &) const { - os << from_ascii("") - << cleanupWhitespace(getParam("key")) - << from_ascii(""); - return 0; + if (getCmdName() == "nocite") + return; + + // Split the different citations (on ","), so that one tag can be output for each of them. + // DocBook does not support having multiple citations in one tag, so that we have to deal with formatting here. + docstring citations = getParam("key"); + if (citations.find(',') == string::npos) { + xs << xml::CompTag("biblioref", "endterm=\"" + to_utf8(xml::cleanID(citations)) + "\""); + } else { + size_t pos = 0; + while (pos != string::npos) { + pos = citations.find(','); + xs << xml::CompTag("biblioref", "endterm=\"" + to_utf8(xml::cleanID(citations.substr(0, pos))) + "\""); + citations.erase(0, pos + 1); + + if (pos != string::npos) { + xs << ", "; + } + } + } } -docstring InsetCitation::xhtml(XHTMLStream & xs, OutputParams const &) const +docstring InsetCitation::xhtml(XMLStream & xs, OutputParams const &) const { - string const & cmd = getCmdName(); - if (cmd == "nocite") + if (getCmdName() == "nocite") return docstring(); // have to output this raw, because generateLabel() will include tags - xs << XHTMLStream::ESCAPE_NONE << generateLabel(true); + xs << XMLStream::ESCAPE_NONE << generateLabel(true); return docstring(); } @@ -490,7 +663,7 @@ docstring InsetCitation::xhtml(XHTMLStream & xs, OutputParams const &) const void InsetCitation::toString(odocstream & os) const { odocstringstream ods; - plaintext(ods, OutputParams(0)); + plaintext(ods, OutputParams(nullptr)); os << ods.str(); } @@ -508,35 +681,113 @@ 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(buffer().params(), getCmdName(), citation_styles); - BiblioInfo const & bi = buffer().masterBibInfo(); + // When this is a child compiled on its own, we use the children + // 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, 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) { + QualifiedList pres = getQualifiedLists(getParam("pretextlist")); + QualifiedList posts = getQualifiedLists(getParam("posttextlist")); + for (docstring const & k : keys) { + docstring prenote; + QualifiedList::iterator it = pres.begin(); + for (; it != pres.end() ; ++it) { + if ((*it).first == k) { + prenote = (*it).second; + pres.erase(it); + break; + } + } + docstring bef = params().prepareCommand(runparams, prenote, + pinfo["pretextlist"].handling()); + docstring postnote; + QualifiedList::iterator pit = posts.begin(); + for (; pit != posts.end() ; ++pit) { + if ((*pit).first == k) { + postnote = (*pit).second; + posts.erase(pit); + break; + } + } + docstring aft = params().prepareCommand(runparams, postnote, + 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 << "}"; } +pair InsetCitation::isWords() const +{ + docstring const label = generateLabel(false); + return pair(label.size(), wordCount(label)); +} + + string InsetCitation::contextMenuName() const { return "context-citation";