X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Finsets%2FInsetCitation.cpp;h=8f697993b143c94d43d011c2a6fbd50bdf5bfa80;hb=9c55af4a223ce4db29d643251109e245665344bd;hp=c1a5145f0e70f5e20623fde57d5f07075addf337;hpb=7287a259c5436b8f3f384c0d0bd7641a2f2601e9;p=lyx.git diff --git a/src/insets/InsetCitation.cpp b/src/insets/InsetCitation.cpp index c1a5145f0e..8f697993b1 100644 --- a/src/insets/InsetCitation.cpp +++ b/src/insets/InsetCitation.cpp @@ -33,6 +33,7 @@ #include "support/lstrings.h" #include +#include using namespace std; using namespace lyx::support; @@ -44,7 +45,16 @@ ParamInfo InsetCitation::param_info_; InsetCitation::InsetCitation(Buffer * buf, InsetCommandParams const & p) : InsetCommand(buf, p) -{} +{ + buffer().removeBiblioTempFiles(); +} + + +InsetCitation::~InsetCitation() +{ + if (isBufferLoaded()) + buffer().removeBiblioTempFiles(); +} ParamInfo const & InsetCitation::findInfo(string const & /* cmdName */) @@ -93,6 +103,8 @@ vector const & possibleCiteCommands() } // anon namespace +// 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(); @@ -103,12 +115,40 @@ bool InsetCitation::isCompatibleCommand(string const & cmd) void InsetCitation::doDispatch(Cursor & cur, FuncRequest & cmd) { - if (cmd.action() == LFUN_INSET_MODIFY) + if (cmd.action() == LFUN_INSET_MODIFY) { + buffer().removeBiblioTempFiles(); cache.recalculate = true; + } InsetCommand::doDispatch(cur, cmd); } +bool InsetCitation::addKey(string const & key) +{ + docstring const ukey = from_utf8(key); + docstring const & curkeys = getParam("key"); + if (curkeys.empty()) { + setParam("key", ukey); + cache.recalculate = true; + return true; + } + + 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; +} + + docstring InsetCitation::toolTip(BufferView const & bv, int, int) const { Buffer const & buf = bv.buffer(); @@ -141,83 +181,48 @@ docstring InsetCitation::toolTip(BufferView const & bv, int, int) const namespace { - -// FIXME See the header for the issue. -string defaultCiteCommand(CiteEngine engine) -{ - 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; - } - return str; -} - -string asValidLatexCommand(string const & input, CiteEngine const engine) + +CitationStyle asValidLatexCommand(string const & input, vector const valid_styles) { - string const default_str = defaultCiteCommand(engine); + CitationStyle cs = valid_styles[0]; + cs.forceUpperCase = false; + cs.fullAuthorList = false; 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 cs; - 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; - - // 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); + string normalized_input = input; + string::size_type const n = input.size() - 1; + if (input[0] == 'C') + normalized_input[0] = 'c'; + if (input[n] == '*') + normalized_input = normalized_input.substr(0, n); + 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) { + cs = *it; break; } } - return output; + cs.forceUpperCase &= input[0] == 'C'; + cs.fullAuthorList &= input[n] == '*'; + + return cs; } -inline docstring wrapCitation(docstring const & key, +inline docstring wrapCitation(docstring const & key, docstring const & content, bool for_xhtml) { 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 "" + + return "" + html::htmlize(content, XHTMLStream::ESCAPE_ALL) + ""; } @@ -247,20 +252,12 @@ docstring InsetCitation::complexLabel(bool for_xhtml) const 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/ - - CiteEngine const engine = buffer().params().citeEngine(); + docstring const & key = getParam("key"); + if (key.empty()) + return _("No citations selected!"); + // We don't currently use the full or forceUCase fields. - string cite_type = asValidLatexCommand(getCmdName(), engine); + 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); @@ -269,171 +266,16 @@ docstring InsetCitation::complexLabel(bool for_xhtml) const cite_type = cite_type.substr(0, cite_type.size() - 1); docstring const & before = getParam("before"); - 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 & after = getParam("after"); - 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; - } - - // 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) + ' '; + // 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(getParam("key")); - 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, for_xhtml); - docstring const citenum = for_xhtml ? biblist.getCiteNumber(*it) : *it; - - if (author.empty() || year.empty()) - // We can't construct a "complex" label without that info. - // So fail safely. - return docstring(); - - // authors1/; ... ; - // authors_last, - if (cite_type == "cite") { - if (engine == ENGINE_BASIC) { - label += wrapCitation(*it, citenum, for_xhtml) + sep_str; - } else if (engine == ENGINE_JURABIB) { - if (it == keys.begin()) - label += wrapCitation(*it, author, for_xhtml) + before_str + sep_str; - else - label += wrapCitation(*it, author, for_xhtml) + 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 + - wrapCitation(*it, year, for_xhtml) + cp + sep_str; - break; - case ENGINE_NATBIB_NUMERICAL: - label += author + op_str + before_str + - wrapCitation(*it, citenum, for_xhtml) + cp + sep_str; - break; - case ENGINE_JURABIB: - label += before_str + author + op_str + - wrapCitation(*it, year, for_xhtml) + 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 += wrapCitation(*it, citenum, for_xhtml) + sep_str; - } else { - label += wrapCitation(*it, author + ", " + year, for_xhtml) + sep_str; - } - - } - // (authors1 year; - // authors_last year, ) - else if (cite_type == "citealt") { - switch (engine) { - case ENGINE_NATBIB_AUTHORYEAR: - label += author + ' ' + before_str + - wrapCitation(*it, year, for_xhtml) + sep_str; - break; - case ENGINE_NATBIB_NUMERICAL: - label += author + ' ' + before_str + '#' + - wrapCitation(*it, citenum, for_xhtml) + sep_str; - break; - case ENGINE_JURABIB: - label += before_str + - wrapCitation(*it, author + ' ' + year, for_xhtml) + sep_str; - break; - case ENGINE_BASIC: - break; - } - - - } - // author; author; ... - else if (cite_type == "citeauthor") { - label += wrapCitation(*it, author, for_xhtml) + sep_str; - } - // year; year; ... - else if (cite_type == "citeyear" || - cite_type == "citeyearpar") { - label += wrapCitation(*it, year, for_xhtml) + 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; - } - } - - if (!before_str.empty() && (cite_type == "citep" || - cite_type == "citealp" || - cite_type == "citeyearpar")) { - label = before_str + label; - } - - if (cite_type == "citep" || cite_type == "citeyearpar" || - (cite_type == "cite" && engine == ENGINE_BASIC) ) - label = op + label + cp; - + vector keys = getVectorFromString(key); + label = biblist.getLabel(keys, buffer(), cite_type, for_xhtml, UINT_MAX, before, after); return label; } @@ -489,22 +331,29 @@ void InsetCitation::updateBuffer(ParIterator const &, UpdateType) } -void InsetCitation::addToToc(DocIterator const & cpit) const +void InsetCitation::addToToc(DocIterator const & cpit, bool output_active) const { // NOTE - // XHTML output uses the TOC to collect the citations - // from the document. So if this gets changed, then we - // will need to change how the citations are collected. + // 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"); Toc & toc = buffer().tocBackend().toc("citation"); - toc.push_back(TocItem(cpit, 0, tocitem)); + 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(); } @@ -550,11 +399,13 @@ docstring InsetCitation::xhtml(XHTMLStream & xs, OutputParams const &) const void InsetCitation::toString(odocstream & os) const { - plaintext(os, OutputParams(0)); + odocstringstream ods; + plaintext(ods, OutputParams(0)); + os << ods.str(); } -void InsetCitation::forToc(docstring & os, size_t) const +void InsetCitation::forOutliner(docstring & os, size_t) const { os += screenLabel(); } @@ -563,25 +414,26 @@ void InsetCitation::forToc(docstring & os, size_t) const // 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[]{} +// 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(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)); - 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 << ']'; if (!bi.isBibtex(getParam("key"))) @@ -595,22 +447,6 @@ void InsetCitation::latex(otexstream & os, OutputParams const & runparams) const } -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; - } -} - - string InsetCitation::contextMenuName() const { return "context-citation";