X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Finsets%2FInsetCitation.cpp;h=e47f31189feddf44a1d922466ff7a3c663b60553;hb=eba2f0479eb5af6b61d9a82e89daea253d9b6bf6;hp=8e63c70397e3522e787039631fdaabe9e2639366;hpb=128c2b31d808c62f8e8b6eeb141922c233e31b93;p=lyx.git diff --git a/src/insets/InsetCitation.cpp b/src/insets/InsetCitation.cpp index 8e63c70397..e47f31189f 100644 --- a/src/insets/InsetCitation.cpp +++ b/src/insets/InsetCitation.cpp @@ -13,14 +13,19 @@ #include "InsetCitation.h" +#include "BiblioInfo.h" #include "Buffer.h" #include "buffer_funcs.h" #include "BufferParams.h" #include "BufferView.h" #include "DispatchResult.h" +#include "FuncCode.h" #include "FuncRequest.h" +#include "FuncStatus.h" #include "LaTeXFeatures.h" +#include "output_xhtml.h" #include "ParIterator.h" +#include "texstream.h" #include "TocBackend.h" #include "support/debug.h" @@ -30,471 +35,327 @@ #include "support/lstrings.h" #include +#include using namespace std; using namespace lyx::support; namespace lyx { -namespace { +ParamInfo InsetCitation::param_info_; + -vector const init_possible_cite_commands() +InsetCitation::InsetCitation(Buffer * buf, InsetCommandParams const & p) + : InsetCommand(buf, p) { - 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); + buffer().removeBiblioTempFiles(); } -vector const & possibleCiteCommands() +InsetCitation::~InsetCitation() { - static vector const possible = init_possible_cite_commands(); - return possible; + if (isBufferLoaded()) + buffer().removeBiblioTempFiles(); } -// FIXME See the header for the issue. -string defaultCiteCommand(CiteEngine engine) +ParamInfo const & InsetCitation::findInfo(string const & /* cmdName */) { - string str; - switch (engine) { - case ENGINE_BASIC: - str = "cite"; - break; - case ENGINE_NATBIB_AUTHORYEAR: - str = "citet"; - break; - case ENGINE_NATBIB_NUMERICAL: - str = "citep"; - break; - case ENGINE_JURABIB: - str = "cite"; - break; + // 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("key", ParamInfo::LATEX_REQUIRED); } - return str; + return param_info_; } - -string asValidLatexCommand(string const & input, CiteEngine const engine) + +// 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 &) { - string const default_str = defaultCiteCommand(engine); - if (!InsetCitation::isCompatibleCommand(input)) - return default_str; - - string output; - switch (engine) { - case ENGINE_BASIC: - if (input == "nocite") - output = input; - else - output = default_str; - break; + return true; +} - case ENGINE_NATBIB_AUTHORYEAR: - case ENGINE_NATBIB_NUMERICAL: - if (input == "cite" || input == "citefield" - || input == "citetitle" || input == "cite*") - output = default_str; - else if (prefixIs(input, "foot")) - output = input.substr(4); - else - output = input; - break; - case ENGINE_JURABIB: { - // Jurabib does not support the 'uppercase' natbib style. - if (input[0] == 'C') - output = string(1, 'c') + input.substr(1); - else - output = input; +void InsetCitation::doDispatch(Cursor & cur, FuncRequest & cmd) +{ + if (cmd.action() == LFUN_INSET_MODIFY) { + buffer().removeBiblioTempFiles(); + cache.recalculate = true; + } + InsetCommand::doDispatch(cur, cmd); +} - // Jurabib does not support the 'full' natbib style. - string::size_type const n = output.size() - 1; - if (output != "cite*" && output[n] == '*') - output = output.substr(0, n); - break; +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().params().getCiteAlias(cmdname); + if (!alias.empty()) + cmdname = alias; + string const newtype = cmd.getArg(1); + status.setEnabled(isCompatibleCommand(newtype)); + status.setOnOff(newtype == cmdname); } + status.setEnabled(true); + return true; + default: + return InsetCommand::getStatus(cur, cmd, status); } - - return output; } -docstring complexLabel(Buffer const & buffer, - string const & citeType, docstring const & keyList, - docstring const & before, docstring const & after, - CiteEngine engine) +bool InsetCitation::addKey(string const & key) { - // Only start the process off after the buffer is loaded from file. - if (!buffer.isFullyLoaded()) - return docstring(); - - BiblioInfo const & biblist = buffer.masterBibInfo(); - if (biblist.empty()) - return docstring(); - - // the natbib citation-styles - // CITET: author (year) - // CITEP: (author,year) - // CITEALT: author year - // CITEALP: author, year - // CITEAUTHOR: author - // CITEYEAR: year - // CITEYEARPAR: (year) - // jurabib supports these plus - // CITE: author/ - - // We don't currently use the full or forceUCase fields. - string cite_type = asValidLatexCommand(citeType, engine); - 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 - cite_type = cite_type.substr(0, cite_type.size() - 1); - - docstring before_str; - if (!before.empty()) { - // In CITET and CITEALT mode, the "before" string is - // attached to the label associated with each and every key. - // In CITEP, CITEALP and CITEYEARPAR mode, it is attached - // to the front of the whole only. - // In other modes, it is not used at all. - if (cite_type == "citet" || - cite_type == "citealt" || - cite_type == "citep" || - cite_type == "citealp" || - cite_type == "citeyearpar") - before_str = before + ' '; - // In CITE (jurabib), the "before" string is used to attach - // the annotator (of legal texts) to the author(s) of the - // first reference. - else if (cite_type == "cite") - before_str = '/' + before; + docstring const ukey = from_utf8(key); + docstring const & curkeys = getParam("key"); + if (curkeys.empty()) { + setParam("key", ukey); + cache.recalculate = true; + return true; } - docstring after_str; - // The "after" key is appended only to the end of the whole. - if (cite_type == "nocite") - after_str = " (" + _("not cited") + ')'; - else if (!after.empty()) { - after_str = ", " + after; + vector keys = getVectorFromString(curkeys); + vector::const_iterator it = keys.begin(); + vector::const_iterator en = keys.end(); + for (; it != en; ++it) { + if (*it == ukey) { + LYXERR0("Key " << key << " already present."); + return false; + } } + keys.push_back(ukey); + setParam("key", getStringFromVector(keys)); + cache.recalculate = true; + return true; +} - // One day, these might be tunable (as they are in BibTeX). - char op, cp; // opening and closing parenthesis. - const char * sep; // punctuation mark separating citation entries. - if (engine == ENGINE_BASIC) { - op = '['; - cp = ']'; - sep = ","; - } else { - op = '('; - cp = ')'; - sep = ";"; - } - docstring const op_str = ' ' + docstring(1, op); - docstring const cp_str = docstring(1, cp) + ' '; - docstring const sep_str = from_ascii(sep) + ' '; +docstring InsetCitation::toolTip(BufferView const & bv, int, int) const +{ + Buffer const & buf = bv.buffer(); + // Only after the buffer is loaded from file... + if (!buf.isFullyLoaded()) + return docstring(); - docstring label; - vector keys = getVectorFromString(keyList); - vector::const_iterator it = keys.begin(); - vector::const_iterator end = keys.end(); - for (; it != end; ++it) { - // get the bibdata corresponding to the key - docstring const author(biblist.getAbbreviatedAuthor(*it)); - docstring const year(biblist.getYear(*it)); - - // Something isn't right. Fail safely. - if (author.empty() || year.empty()) - return docstring(); - - // authors1/; ... ; - // authors_last, - if (cite_type == "cite") { - if (engine == ENGINE_BASIC) { - label += *it + sep_str; - } else if (engine == ENGINE_JURABIB) { - if (it == keys.begin()) - label += author + before_str + sep_str; - else - label += author + sep_str; - } - - // nocite - } else if (cite_type == "nocite") { - label += *it + sep_str; - - // (authors1 ( year); ... ; - // authors_last ( year, ) - } else if (cite_type == "citet") { - switch (engine) { - case ENGINE_NATBIB_AUTHORYEAR: - label += author + op_str + before_str + - year + cp + sep_str; - break; - case ENGINE_NATBIB_NUMERICAL: - label += author + op_str + before_str + '#' + *it + cp + sep_str; - break; - case ENGINE_JURABIB: - label += before_str + author + op_str + - year + cp + sep_str; - break; - case ENGINE_BASIC: - break; - } - - // author, year; author, year; ... - } else if (cite_type == "citep" || - cite_type == "citealp") { - if (engine == ENGINE_NATBIB_NUMERICAL) { - label += *it + sep_str; - } else { - label += author + ", " + year + sep_str; - } - - // (authors1 year; - // authors_last year, ) - } else if (cite_type == "citealt") { - switch (engine) { - case ENGINE_NATBIB_AUTHORYEAR: - label += author + ' ' + before_str + - year + sep_str; - break; - case ENGINE_NATBIB_NUMERICAL: - label += author + ' ' + before_str + '#' + *it + sep_str; - break; - case ENGINE_JURABIB: - label += before_str + author + ' ' + - year + sep_str; - break; - case ENGINE_BASIC: - break; - } - - // author; author; ... - } else if (cite_type == "citeauthor") { - label += author + sep_str; - - // year; year; ... - } else if (cite_type == "citeyear" || - cite_type == "citeyearpar") { - label += year + sep_str; - } - } - label = rtrim(rtrim(label), sep); - - if (!after_str.empty()) { - if (cite_type == "citet") { - // insert "after" before last ')' - label.insert(label.size() - 1, after_str); - } else { - bool const add = - !(engine == ENGINE_NATBIB_NUMERICAL && - (cite_type == "citeauthor" || - cite_type == "citeyear")); - if (add) - label += after_str; - } - } + BiblioInfo const & bi = buf.masterBibInfo(); + if (bi.empty()) + return _("No bibliography defined!"); - if (!before_str.empty() && (cite_type == "citep" || - cite_type == "citealp" || - cite_type == "citeyearpar")) { - label = before_str + label; - } + docstring const & key = getParam("key"); + if (key.empty()) + return _("No citations selected!"); - if (cite_type == "citep" || cite_type == "citeyearpar" || - (cite_type == "cite" && engine == ENGINE_BASIC) ) - label = op + label + cp; + CiteItem ci; + ci.richtext = true; + vector keys = getVectorFromString(key); + if (keys.size() == 1) + return bi.getInfo(keys[0], buffer(), ci); - return label; + docstring tip; + tip += "
    "; + for (docstring const & key : keys) { + docstring const key_info = bi.getInfo(key, buffer(), ci); + if (key_info.empty()) + continue; + tip += "
  1. " + key_info + "
    2. "; + } + tip += "
"; + return tip; } -docstring basicLabel(docstring const & keyList, docstring const & after) -{ - docstring keys = keyList; - docstring label; +namespace { - if (contains(keys, ',')) { - // Final comma allows while loop to cover all keys - keys = ltrim(split(keys, label, ',')) + ','; - while (contains(keys, ',')) { - docstring key; - keys = ltrim(split(keys, key, ',')); - label += ", " + key; +CitationStyle asValidLatexCommand(BufferParams const & bp, string const & input, + vector const & valid_styles) +{ + 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); + + 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; } - } else { - label = keys; } - if (!after.empty()) - label += ", " + after; + cs.forceUpperCase &= input[0] == uppercase(input[0]); + cs.hasStarredVersion &= input[n] == '*'; - return '[' + label + ']'; + return cs; } -} // anon namespace - - -ParamInfo InsetCitation::param_info_; - -InsetCitation::InsetCitation(InsetCommandParams const & p) - : InsetCommand(p, "citation") -{} - - -ParamInfo const & InsetCitation::findInfo(string const & /* cmdName */) +inline docstring wrapCitation(docstring const & key, + docstring const & content, bool for_xhtml) { - // standard cite does only take one argument if jurabib is - // not used, but jurabib extends 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("key", ParamInfo::LATEX_REQUIRED); - } - return param_info_; + if (!for_xhtml) + 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) + ""; } +} // anonymous namespace -bool InsetCitation::isCompatibleCommand(string const & cmd) +docstring InsetCitation::generateLabel(bool for_xhtml) const { - vector const & possibles = possibleCiteCommands(); - vector::const_iterator const end = possibles.end(); - return find(possibles.begin(), end, cmd) != end; + docstring label; + label = complexLabel(for_xhtml); + + // Fallback to fail-safe + if (label.empty()) + label = basicLabel(for_xhtml); + + return label; } -docstring InsetCitation::toolTip(BufferView const & bv, int, int) const +docstring InsetCitation::complexLabel(bool for_xhtml) const { - static unsigned int maxwdth = 80; - Buffer const & buf = bv.buffer(); - // Only after the buffer is loaded from file... + Buffer const & buf = buffer(); + // Only start the process off after the buffer is loaded from file. if (!buf.isFullyLoaded()) return docstring(); - BiblioInfo const & bi = buf.masterBibInfo(); - if (bi.empty()) - return _("No bibliography defined!"); + BiblioInfo const & biblist = buf.masterBibInfo(); + if (biblist.empty()) + return docstring(); docstring const & key = getParam("key"); if (key.empty()) return _("No citations selected!"); + string cite_type = getCmdName(); + 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); + + // handle alias + string const alias = buf.params().getCiteAlias(cite_type); + if (!alias.empty()) + cite_type = alias; + + // FIXME: allow to add cite macros + /* + buffer().params().documentClass().addCiteMacro("!textbefore", to_utf8(before)); + buffer().params().documentClass().addCiteMacro("!textafter", to_utf8(after)); + */ + docstring label; vector keys = getVectorFromString(key); - vector::const_iterator it = keys.begin(); - vector::const_iterator en = keys.end(); - docstring tip; - for (; it != en; ++it) { - docstring key_info = bi.getInfo(*it); - if (key_info.empty()) - continue; - if (!tip.empty()) - tip += "\n"; - docstring newkey; - while (key_info.size() > maxwdth) { - int i = maxwdth - 1; - // find the last space - for (; i >= 0; --i) - if (key_info[i] == ' ') - break; - if (i < 0) { - // no space found - key_info = key_info.substr(0, maxwdth - 3) + "..."; - break; - } - if (!newkey.empty()) - newkey += "\n"; - newkey += key_info.substr(0, i); - key_info = " " + key_info.substr(i); - } - if (!newkey.empty()) - newkey += "\n"; - newkey += key_info; - tip += newkey; + CiteItem ci; + ci.textBefore = getParam("before"); + ci.textAfter = getParam("after"); + ci.forceUpperCase = uppercase; + ci.Starred = starred; + ci.max_size = UINT_MAX; + if (for_xhtml) { + ci.max_key_size = UINT_MAX; + ci.context = CiteItem::Export; } - return tip; + ci.richtext = for_xhtml; + label = biblist.getLabel(keys, buffer(), cite_type, ci); + return label; } - -docstring InsetCitation::generateLabel() const +docstring InsetCitation::basicLabel(bool for_xhtml) const { - docstring const before = getParam("before"); - docstring const after = getParam("after"); - + docstring keys = getParam("key"); docstring label; - CiteEngine const engine = buffer().params().citeEngine(); - label = complexLabel(buffer(), getCmdName(), getParam("key"), - before, after, engine); - // Fallback to fail-safe - if (label.empty()) - label = basicLabel(getParam("key"), after); + docstring key; + do { + // if there is no comma, then everything goes into key + // and keys will be empty. + keys = trim(split(keys, key, ',')); + key = trim(key); + if (!label.empty()) + label += ", "; + label += wrapCitation(key, key, for_xhtml); + } while (!keys.empty()); + + docstring const & after = getParam("after"); + if (!after.empty()) + label += ", " + after; - return label; + return '[' + label + ']'; } - docstring InsetCitation::screenLabel() const { return cache.screen_label; } -void InsetCitation::updateLabels(ParIterator const &) +void InsetCitation::updateBuffer(ParIterator const &, UpdateType) { - CiteEngine const engine = buffer().params().citeEngine(); - if (cache.params == params() && cache.engine == engine) + if (!cache.recalculate && buffer().citeLabelsValid()) return; - - // The label has changed, so we have to re-create it. + // The label may have changed, so we have to re-create it. docstring const glabel = generateLabel(); - - unsigned int const maxLabelChars = 45; - - docstring label = glabel; - if (label.size() > maxLabelChars) { - label.erase(maxLabelChars-3); - label += "..."; - } - - cache.engine = engine; - cache.params = params(); + cache.recalculate = false; cache.generated_label = glabel; - cache.screen_label = label; + unsigned int const maxLabelChars = 45; + cache.screen_label = glabel.substr(0, maxLabelChars + 1); + support::truncateWithEllipsis(cache.screen_label, maxLabelChars); } -void InsetCitation::addToToc(DocIterator const & cpit) +void InsetCitation::addToToc(DocIterator const & cpit, bool output_active, + UpdateType) const { - Toc & toc = buffer().tocBackend().toc("citation"); - toc.push_back(TocItem(cpit, 0, cache.screen_label)); + // NOTE + // 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"); + shared_ptr toc = buffer().tocBackend().toc("citation"); + toc->push_back(TocItem(cpit, 0, tocitem, output_active)); } -int InsetCitation::plaintext(odocstream & os, OutputParams const &) const +int InsetCitation::plaintext(odocstringstream & os, + OutputParams const &, size_t) const { - os << cache.generated_label; - return cache.generated_label.size(); + string const & cmd = getCmdName(); + if (cmd == "nocite") + return 0; + + docstring const label = generateLabel(false); + os << label; + return label.size(); } @@ -525,63 +386,72 @@ int InsetCitation::docbook(odocstream & os, OutputParams const &) const } -void InsetCitation::tocString(odocstream & os) const +docstring InsetCitation::xhtml(XHTMLStream & xs, OutputParams const &) const { - plaintext(os, OutputParams(0)); + string const & cmd = getCmdName(); + if (cmd == "nocite") + return docstring(); + + // have to output this raw, because generateLabel() will include tags + xs << XHTMLStream::ESCAPE_NONE << generateLabel(true); + + return docstring(); +} + + +void InsetCitation::toString(odocstream & os) const +{ + odocstringstream ods; + plaintext(ods, OutputParams(0)); + os << ods.str(); +} + + +void InsetCitation::forOutliner(docstring & os, size_t const, bool const) const +{ + os += screenLabel(); } // Have to overwrite the default InsetCommand method in order to check that // the \cite command is valid. Eg, the user has natbib enabled, inputs some // citations and then changes his mind, turning natbib support off. The output -// should revert to \cite[]{} -int InsetCitation::latex(odocstream & os, OutputParams const & runparams) const +// should revert to the default citation command as provided by the citation +// engine, e.g. \cite[]{} for the basic engine. +void InsetCitation::latex(otexstream & os, OutputParams const & runparams) const { - CiteEngine cite_engine = buffer().params().citeEngine(); + vector citation_styles = buffer().params().citeStyles(); + CitationStyle cs = asValidLatexCommand(buffer().params(), getCmdName(), citation_styles); + BiblioInfo const & bi = buffer().masterBibInfo(); // FIXME UNICODE - docstring const cite_str = from_utf8( - asValidLatexCommand(getCmdName(), cite_engine)); + docstring const cite_str = from_utf8(citationStyleToString(cs, true)); - if (runparams.inulemcmd) + if (runparams.inulemcmd > 0) os << "\\mbox{"; os << "\\" << cite_str; docstring const & before = getParam("before"); docstring const & after = getParam("after"); - if (!before.empty() && cite_engine != ENGINE_BASIC) + if (!before.empty() && cs.textBefore) os << '[' << before << "][" << after << ']'; - else if (!after.empty()) + else if (!after.empty() && cs.textAfter) os << '[' << after << ']'; - os << '{' << cleanupWhitespace(getParam("key")) << '}'; + if (!bi.isBibtex(getParam("key"))) + // escape chars with bibitems + os << '{' << escape(cleanupWhitespace(getParam("key"))) << '}'; + else + os << '{' << cleanupWhitespace(getParam("key")) << '}'; if (runparams.inulemcmd) os << "}"; - - return 0; -} - - -void InsetCitation::validate(LaTeXFeatures & features) const -{ - switch (features.bufferParams().citeEngine()) { - case ENGINE_BASIC: - break; - case ENGINE_NATBIB_AUTHORYEAR: - case ENGINE_NATBIB_NUMERICAL: - features.require("natbib"); - break; - case ENGINE_JURABIB: - features.require("jurabib"); - break; - } } -docstring InsetCitation::contextMenu(BufferView const &, int, int) const +string InsetCitation::contextMenuName() const { - return from_ascii("context-citation"); + return "context-citation"; }