X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Finsets%2FInsetCitation.cpp;h=4bf6333f2791bd4dd56d2b7a1d0efd8a9e64440d;hb=f16b2cab75752e7b0fbec5520e231b068eb29072;hp=5f6f9189e90c45d0b11c936e14e1a72f29d2458c;hpb=c785e832fba69a94f368f82591d8ea8f5744003c;p=lyx.git

diff --git a/src/insets/InsetCitation.cpp b/src/insets/InsetCitation.cpp
index 5f6f9189e9..4bf6333f27 100644
--- a/src/insets/InsetCitation.cpp
+++ b/src/insets/InsetCitation.cpp
@@ -13,11 +13,13 @@
 
 #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 "LaTeXFeatures.h"
 #include "output_xhtml.h"
@@ -31,6 +33,7 @@
 #include "support/lstrings.h"
 
 #include <algorithm>
+#include <climits>
 
 using namespace std;
 using namespace lyx::support;
@@ -41,8 +44,17 @@ ParamInfo InsetCitation::param_info_;
 
 
 InsetCitation::InsetCitation(Buffer * buf, InsetCommandParams const & p)
-	: InsetCommand(buf, p, "citation")
-{}
+	: InsetCommand(buf, p)
+{
+	buffer().removeBiblioTempFiles();
+}
+
+
+InsetCitation::~InsetCitation()
+{
+	if (isBufferLoaded())
+		buffer().removeBiblioTempFiles();
+}
 
 
 ParamInfo const & InsetCitation::findInfo(string const & /* cmdName */)
@@ -91,6 +103,8 @@ vector<string> 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<string> const & possibles = possibleCiteCommands();
@@ -99,6 +113,42 @@ bool InsetCitation::isCompatibleCommand(string const & cmd)
 }
 
 
+void InsetCitation::doDispatch(Cursor & cur, FuncRequest & cmd)
+{
+	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<docstring> keys = getVectorFromString(curkeys);
+	vector<docstring>::const_iterator it = keys.begin();
+	vector<docstring>::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();
@@ -119,7 +169,7 @@ docstring InsetCitation::toolTip(BufferView const & bv, int, int) const
 	vector<docstring>::const_iterator en = keys.end();
 	docstring tip;
 	for (; it != en; ++it) {
-		docstring const key_info = bi.getInfo(*it);
+		docstring const key_info = bi.getInfo(*it, buffer());
 		if (key_info.empty())
 			continue;
 		if (!tip.empty())
@@ -131,83 +181,49 @@ 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<CitationStyle> 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;
-
-		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;
+		return cs;
 
-		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<CitationStyle>::const_iterator it  = valid_styles.begin();
+	vector<CitationStyle>::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 "<a href='#" + key + "'>" + html::htmlize(content) + "</a>";
+	return "<a href='#LyXCite-" + html::cleanAttr(key) + "'>" +
+			html::htmlize(content, XHTMLStream::ESCAPE_ALL) + "</a>";
 }
 
 } // anonymous namespace
@@ -236,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/<before field>
-
-	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);
@@ -258,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<docstring> keys = getVectorFromString(getParam("key"));
-	vector<docstring>::const_iterator it  = keys.begin();
-	vector<docstring>::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/<before>;  ... ;
-		//  authors_last, <after>
-		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 (<before> year);  ... ;
-		//  authors_last (<before> year, <after>)
-		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 <before> year;
-		//  authors_last <before> year, <after>)
-		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<docstring> keys = getVectorFromString(key);
+	label = biblist.getLabel(keys, buffer(), cite_type, for_xhtml, UINT_MAX, before, after);
 	return label;
 }
 
@@ -456,41 +309,44 @@ docstring InsetCitation::screenLabel() const
 }
 
 
-void InsetCitation::updateLabels(ParIterator const &, UpdateType)
+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, getParam("key")));
+	// 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> 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();
 }
 
 
@@ -528,40 +384,49 @@ docstring InsetCitation::xhtml(XHTMLStream & xs, OutputParams const &) const
 		return docstring();
 
 	// have to output this raw, because generateLabel() will include tags
-	xs << XHTMLStream::NextRaw() << generateLabel(true);
+	xs << XHTMLStream::ESCAPE_NONE << generateLabel(true);
 
 	return docstring();
 }
 
 
-void InsetCitation::tocString(odocstream & os) const
+void InsetCitation::toString(odocstream & os) const
 {
-	plaintext(os, OutputParams(0));
+	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<CitationStyle> 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")))
@@ -572,30 +437,12 @@ int InsetCitation::latex(odocstream & os, OutputParams const & runparams) const
 
 	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";
 }