X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Finsets%2Finsetcite.C;h=a8bf9a068e5a87daedc172ce1e9636476a567b06;hb=e28331ed63062dea10d0a21b9ec12034b4b17b9a;hp=0699b955d6fd031b4dee76d03f5ab9c95e56a3d6;hpb=68b7ef25fb7d2da230d3eb11d6737701abfc2e64;p=lyx.git diff --git a/src/insets/insetcite.C b/src/insets/insetcite.C index 0699b955d6..a8bf9a068e 100644 --- a/src/insets/insetcite.C +++ b/src/insets/insetcite.C @@ -15,58 +15,105 @@ #include "buffer.h" #include "bufferparams.h" -#include "BufferView.h" +#include "debug.h" #include "dispatchresult.h" #include "funcrequest.h" #include "LaTeXFeatures.h" #include "frontends/controllers/biblio.h" +#include "support/fs_extras.h" #include "support/lstrings.h" -using lyx::support::ascii_lowercase; -using lyx::support::contains; -using lyx::support::getVectorFromString; -using lyx::support::ltrim; -using lyx::support::rtrim; -using lyx::support::split; +#include +#include +#include + + +namespace lyx { + +using support::ascii_lowercase; +using support::contains; +using support::FileName; +using support::getStringFromVector; +using support::getVectorFromString; +using support::ltrim; +using support::rtrim; +using support::split; +using support::tokenPos; + +using std::endl; +using std::replace; using std::string; using std::ostream; using std::vector; using std::map; +namespace fs = boost::filesystem; + namespace { -string const getNatbibLabel(Buffer const & buffer, +docstring const getNatbibLabel(Buffer const & buffer, string const & citeType, string const & keyList, - string const & before, string const & after, - bool numerical, bool jura) + docstring const & before, docstring const & after, + biblio::CiteEngine engine) { // Only start the process off after the buffer is loaded from file. if (!buffer.fully_loaded()) - return string(); + return docstring(); + // Cache the labels typedef std::map CachedMap; static CachedMap cached_keys; - // build the keylist - typedef vector > InfoType; - InfoType bibkeys; - buffer.fillWithBibKeys(bibkeys); - - InfoType::const_iterator bit = bibkeys.begin(); - InfoType::const_iterator bend = bibkeys.end(); + // and cache the timestamp of the bibliography files. + static std::map bibfileStatus; biblio::InfoMap infomap; - for (; bit != bend; ++bit) { - infomap[bit->first] = bit->second; + + vector const & bibfilesCache = buffer.getBibfilesCache(); + // compare the cached timestamps with the actual ones. + bool changed = false; + for (vector::const_iterator it = bibfilesCache.begin(); + it != bibfilesCache.end(); ++ it) { + FileName const f = *it; + try { + std::time_t lastw = fs::last_write_time(f.toFilesystemEncoding()); + if (lastw != bibfileStatus[f]) { + changed = true; + bibfileStatus[f] = lastw; + } + } + catch (fs::filesystem_error & fserr) { + changed = true; + lyxerr << "Couldn't find or read bibtex file " + << f << endl; + lyxerr[Debug::DEBUG] << "Fs error: " + << fserr.what() << endl; + } } - if (infomap.empty()) - return string(); - cached_keys[&buffer] = infomap; + // build the keylist only if the bibfiles have been changed + if (cached_keys[&buffer].empty() || bibfileStatus.empty() || changed) { + typedef vector > InfoType; + InfoType bibkeys; + buffer.fillWithBibKeys(bibkeys); + + InfoType::const_iterator bit = bibkeys.begin(); + InfoType::const_iterator bend = bibkeys.end(); + + for (; bit != bend; ++bit) + infomap[bit->first] = bit->second; + + cached_keys[&buffer] = infomap; + } else + // use the cached keys + infomap = cached_keys[&buffer]; + + if (infomap.empty()) + return docstring(); // the natbib citation-styles // CITET: author (year) @@ -80,14 +127,13 @@ string const getNatbibLabel(Buffer const & buffer, // CITE: author/ // We don't currently use the full or forceUCase fields. - // bool const forceUCase = citeType[0] == 'C'; - bool const full = citeType[citeType.size() - 1] == '*'; - - string const cite_type = full ? - ascii_lowercase(citeType.substr(0, citeType.size() - 1)) : - ascii_lowercase(citeType); + string cite_type = biblio::asValidLatexCommand(citeType, engine); + if (cite_type[0] == 'C') + cite_type = string(1, 'c') + cite_type.substr(1); + if (cite_type[cite_type.size() - 1] == '*') + cite_type = cite_type.substr(0, cite_type.size() - 1); - string before_str; + 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. @@ -107,7 +153,7 @@ string const getNatbibLabel(Buffer const & buffer, before_str = '/' + before; } - string after_str; + docstring after_str; if (!after.empty()) { // The "after" key is appended only to the end of the whole. after_str = ", " + after; @@ -119,26 +165,26 @@ string const getNatbibLabel(Buffer const & buffer, // puctuation mark separating citation entries. char const * const sep = ";"; - string const op_str(' ' + string(1, op)); - string const cp_str(string(1, cp) + ' '); - string const sep_str(string(sep) + ' '); + docstring const op_str(' ' + docstring(1, op)); + docstring const cp_str(docstring(1, cp) + ' '); + docstring const sep_str(from_ascii(sep) + ' '); - string label; + 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 - string const author(biblio::getAbbreviatedAuthor(infomap, *it)); - string const year(biblio::getYear(infomap, *it)); + docstring const author(biblio::getAbbreviatedAuthor(infomap, *it)); + docstring const year(biblio::getYear(infomap, *it)); // Something isn't right. Fail safely. if (author.empty() || year.empty()) - return string(); + return docstring(); // authors1/; ... ; // authors_last, - if (cite_type == "cite" && jura) { + if (cite_type == "cite" && engine == biblio::ENGINE_JURABIB) { if (it == keys.begin()) label += author + before_str + sep_str; else @@ -147,19 +193,30 @@ string const getNatbibLabel(Buffer const & buffer, // (authors1 ( year); ... ; // authors_last ( year, ) } else if (cite_type == "citet") { - string const tmp = numerical ? '#' + *it : year; - if (!jura) - label += author + op_str + before_str + tmp + - cp + sep_str; - else - label += before_str + author + op_str + tmp + - cp + sep_str; + switch (engine) { + case biblio::ENGINE_NATBIB_AUTHORYEAR: + label += author + op_str + before_str + + year + cp + sep_str; + break; + case biblio::ENGINE_NATBIB_NUMERICAL: + // FIXME UNICODE + label += author + op_str + before_str + + '#' + from_utf8(*it) + cp + sep_str; + break; + case biblio::ENGINE_JURABIB: + label += before_str + author + op_str + + year + cp + sep_str; + break; + case biblio::ENGINE_BASIC: + break; + } // author, year; author, year; ... } else if (cite_type == "citep" || cite_type == "citealp") { - if (numerical) { - label += *it + sep_str; + if (engine == biblio::ENGINE_NATBIB_NUMERICAL) { + // FIXME UNICODE + label += from_utf8(*it) + sep_str; } else { label += author + ", " + year + sep_str; } @@ -167,11 +224,23 @@ string const getNatbibLabel(Buffer const & buffer, // (authors1 year; // authors_last year, ) } else if (cite_type == "citealt") { - string const tmp = numerical ? '#' + *it : year; - if (!jura) - label += author + ' ' + before_str + tmp + sep_str; - else - label += before_str + author + ' ' + tmp + sep_str; + switch (engine) { + case biblio::ENGINE_NATBIB_AUTHORYEAR: + label += author + ' ' + before_str + + year + sep_str; + break; + case biblio::ENGINE_NATBIB_NUMERICAL: + // FIXME UNICODE + label += author + ' ' + before_str + + '#' + from_utf8(*it) + sep_str; + break; + case biblio::ENGINE_JURABIB: + label += before_str + author + ' ' + + year + sep_str; + break; + case biblio::ENGINE_BASIC: + break; + } // author; author; ... } else if (cite_type == "citeauthor") { @@ -190,9 +259,10 @@ string const getNatbibLabel(Buffer const & buffer, // insert "after" before last ')' label.insert(label.size() - 1, after_str); } else { - bool const add = !(numerical && - (cite_type == "citeauthor" || - cite_type == "citeyear")); + bool const add = + !(engine == biblio::ENGINE_NATBIB_NUMERICAL && + (cite_type == "citeauthor" || + cite_type == "citeyear")); if (add) label += after_str; } @@ -205,22 +275,22 @@ string const getNatbibLabel(Buffer const & buffer, } if (cite_type == "citep" || cite_type == "citeyearpar") - label = string(1, op) + label + string(1, cp); + label = op + label + cp; return label; } -string const getBasicLabel(string const & keyList, string const & after) +docstring const getBasicLabel(docstring const & keyList, docstring const & after) { - string keys(keyList); - string label; + docstring keys(keyList); + docstring label; if (contains(keys, ',')) { // Final comma allows while loop to cover all keys keys = ltrim(split(keys, label, ',')) + ','; while (contains(keys, ',')) { - string key; + docstring key; keys = ltrim(split(keys, key, ',')); label += ", " + key; } @@ -241,80 +311,49 @@ InsetCitation::InsetCitation(InsetCommandParams const & p) {} -string const InsetCitation::generateLabel(Buffer const & buffer) const +docstring const InsetCitation::generateLabel(Buffer const & buffer) const { - string const before = getSecOptions(); - string const after = getOptions(); - - string label; - if (buffer.params().use_natbib || buffer.params().use_jurabib) { - string cmd = getCmdName(); - if (buffer.params().use_natbib && cmd == "cite") { - // We may be "upgrading" from an older LyX version. - // If, however, we use "cite" because the necessary - // author/year info is not present in the biblio - // database, then getNatbibLabel will exit gracefully - // and we'll call getBasicLabel. - if (buffer.params().use_numerical_citations) - cmd = "citep"; - else - cmd = "citet"; - } - label = getNatbibLabel(buffer, cmd, getContents(), - before, after, - buffer.params().use_numerical_citations, - buffer.params().use_jurabib); + docstring const before = getParam("before"); + docstring const after = getParam("after"); + + docstring label; + biblio::CiteEngine const engine = buffer.params().cite_engine; + if (engine != biblio::ENGINE_BASIC) { + // FIXME UNICODE + label = getNatbibLabel(buffer, getCmdName(), to_utf8(getParam("key")), + before, after, engine); } // Fallback to fail-safe if (label.empty()) { - label = getBasicLabel(getContents(), after); + label = getBasicLabel(getParam("key"), after); } return label; } -InsetCitation::Cache::Style InsetCitation::getStyle(Buffer const & buffer) const +docstring const InsetCitation::getScreenLabel(Buffer const & buffer) const { - Cache::Style style = Cache::BASIC; - - if (buffer.params().use_natbib) { - if (buffer.params().use_numerical_citations) { - style = Cache::NATBIB_NUM; - } else { - style = Cache::NATBIB_AY; - } - } - - if (buffer.params().use_jurabib) - style = Cache::JURABIB; - - return style; -} - - -string const InsetCitation::getScreenLabel(Buffer const & buffer) const -{ - Cache::Style const style = getStyle(buffer); - if (cache.params == params() && cache.style == style) + biblio::CiteEngine const engine = biblio::getEngine(buffer); + if (cache.params == params() && cache.engine == engine) return cache.screen_label; // The label has changed, so we have to re-create it. string const before = getSecOptions(); string const after = getOptions(); - string const glabel = generateLabel(buffer); + docstring const glabel = generateLabel(buffer); unsigned int const maxLabelChars = 45; - string label = glabel; + docstring label = glabel; if (label.size() > maxLabelChars) { label.erase(maxLabelChars-3); label += "..."; } - cache.style = style; + cache.engine = engine; cache.params = params(); cache.generated_label = glabel; cache.screen_label = label; @@ -323,9 +362,11 @@ string const InsetCitation::getScreenLabel(Buffer const & buffer) const } -int InsetCitation::plaintext(Buffer const & buffer, ostream & os, int) const +int InsetCitation::plaintext(Buffer const & buffer, odocstream & os, + OutputParams const &) const { - if (cache.params == params() && cache.style == getStyle(buffer)) + if (cache.params == params() && + cache.engine == biblio::getEngine(buffer)) os << cache.generated_label; else os << generateLabel(buffer); @@ -333,50 +374,66 @@ int InsetCitation::plaintext(Buffer const & buffer, ostream & os, int) const } +namespace { + +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; + } + return result; +} + +// end anon namyspace +} + +int InsetCitation::docbook(Buffer const &, odocstream & os, OutputParams const &) const +{ + os << "" + << cleanupWhitespace(getParam("key")) + << ""; + return 0; +} + + +int InsetCitation::textString(Buffer const & buf, odocstream & os, + OutputParams const & op) const +{ + return plaintext(buf, os, op); +} + + // 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(Buffer const & buffer, ostream & os, +int InsetCitation::latex(Buffer const & buffer, odocstream & os, OutputParams const &) const { - os << "\\"; - if (buffer.params().use_natbib) - os << getCmdName(); - else if (buffer.params().use_jurabib) { - // jurabib does not (yet) support "force upper case" - // and "full author name". Fallback. - string cmd = getCmdName(); - if (cmd[0] == 'C') - cmd[0] = 'c'; - size_t n = cmd.size() - 1; - if (cmd[n] == '*') - cmd = cmd.substr(0,n); - os << cmd; - } else - os << "cite"; + biblio::CiteEngine const cite_engine = buffer.params().cite_engine; + // FIXME UNICODE + docstring const cite_str = from_utf8( + biblio::asValidLatexCommand(getCmdName(), cite_engine)); - string const before = getSecOptions(); - string const after = getOptions(); - if (!before.empty() - && (buffer.params().use_natbib || buffer.params().use_jurabib)) + os << "\\" << cite_str; + + docstring const & before = getParam("before"); + docstring const & after = getParam("after"); + if (!before.empty() && cite_engine != biblio::ENGINE_BASIC) os << '[' << before << "][" << after << ']'; else if (!after.empty()) os << '[' << after << ']'; - string::const_iterator it = getContents().begin(); - string::const_iterator end = getContents().end(); - // Paranoia check: make sure that there is no whitespace in here - string content; - char last = ','; - for (; it != end; ++it) { - if (*it != ' ') - last = *it; - if (*it != ' ' || last != ',') - content += *it; - } - - os << '{' << content << '}'; + os << '{' << cleanupWhitespace(getParam("key")) << '}'; return 0; } @@ -384,8 +441,28 @@ int InsetCitation::latex(Buffer const & buffer, ostream & os, void InsetCitation::validate(LaTeXFeatures & features) const { - if (features.bufferParams().use_natbib) + switch (features.bufferParams().cite_engine) { + case biblio::ENGINE_BASIC: + break; + case biblio::ENGINE_NATBIB_AUTHORYEAR: + case biblio::ENGINE_NATBIB_NUMERICAL: features.require("natbib"); - else if (features.bufferParams().use_jurabib) + break; + case biblio::ENGINE_JURABIB: features.require("jurabib"); + break; + } } + + +void InsetCitation::replaceContents(string const & from, string const & to) +{ + if (tokenPos(getContents(), ',', from) != -1) { + vector items = getVectorFromString(getContents()); + replace(items.begin(), items.end(), from, to); + setContents(getStringFromVector(items)); + } +} + + +} // namespace lyx