#include "BiblioInfo.h"
#include "Buffer.h"
+#include "Cursor.h"
#include "buffer_funcs.h"
#include "BufferParams.h"
#include "BufferView.h"
#include "FuncRequest.h"
#include "InsetIterator.h"
#include "InsetList.h"
-#include "Language.h"
+#include "Language.h"
#include "Lexer.h"
#include "output_xhtml.h"
-#include "OutputParams.h"
#include "Paragraph.h"
#include "ParagraphList.h"
#include "ParIterator.h"
#include "frontends/alert.h"
+#include "support/lassert.h"
#include "support/convert.h"
#include "support/debug.h"
#include "support/docstream.h"
#include "support/gettext.h"
#include "support/lstrings.h"
+#include "support/mutex.h"
using namespace std;
using namespace lyx::support;
int InsetBibitem::key_counter = 0;
+static Mutex counter_mutex;
docstring const key_prefix = from_ascii("key-");
InsetBibitem::InsetBibitem(Buffer * buf, InsetCommandParams const & p)
- : InsetCommand(buf, p, "bibitem")
+ : InsetCommand(buf, p)
{
- buffer_->invalidateBibinfoCache();
- if (getParam("key").empty())
+ buffer().invalidateBibinfoCache();
+ if (getParam("key").empty()) {
+ Mutex::Locker lock(&counter_mutex);
setParam("key", key_prefix + convert<docstring>(++key_counter));
+ }
}
InsetBibitem::~InsetBibitem()
{
- if (isBufferValid())
+ if (isBufferLoaded()) {
+ /* 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_->invalidateBibinfoCache();
+ }
}
void InsetBibitem::updateCommand(docstring const & new_key, bool)
{
- docstring const old_key = getParam("key");
docstring key = new_key;
-
vector<docstring> bibkeys = buffer().masterBibInfo().getKeys();
- int i = 1;
-
if (find(bibkeys.begin(), bibkeys.end(), key) != bibkeys.end()) {
+ int i = 1;
// generate unique label
key = new_key + '-' + convert<docstring>(i);
while (find(bibkeys.begin(), bibkeys.end(), key) != bibkeys.end()) {
"it will be changed to %2$s."), new_key, key));
}
setParam("key", key);
-
- buffer().updateLabels();
+ buffer().invalidateBibinfoCache();
}
{
static ParamInfo param_info_;
if (param_info_.empty()) {
- param_info_.add("label", ParamInfo::LATEX_OPTIONAL);
- param_info_.add("key", ParamInfo::LATEX_REQUIRED);
+ param_info_.add("label", ParamInfo::LATEX_OPTIONAL,
+ ParamInfo::HANDLING_LATEXIFY);
+ param_info_.add("key", ParamInfo::LATEX_REQUIRED,
+ ParamInfo::ParamHandling(ParamInfo::HANDLING_ESCAPE
+ | ParamInfo::HANDLING_LTRIM));
+ param_info_.add("literal", ParamInfo::LYX_INTERNAL);
}
return param_info_;
}
void InsetBibitem::doDispatch(Cursor & cur, FuncRequest & cmd)
{
- switch (cmd.action) {
+ switch (cmd.action()) {
case LFUN_INSET_MODIFY: {
InsetCommandParams p(BIBITEM_CODE);
- InsetCommand::string2params("bibitem", to_utf8(cmd.argument()), p);
+ InsetCommand::string2params(to_utf8(cmd.argument()), p);
if (p.getCmdName().empty()) {
- cur.noUpdate();
+ cur.noScreenUpdate();
break;
}
+
+ cur.recordUndo();
+
docstring const & old_key = params()["key"];
+ docstring const & old_label = params()["label"];
+ docstring const & old_literal = params()["literal"];
+ docstring label = p["label"];
+ docstring literal = p["literal"];
+
+ if (old_label != label) {
+ p["label"] = label;
+ cur.forceBufferUpdate();
+ buffer().invalidateBibinfoCache();
+ }
setParam("label", p["label"]);
+
+ if (old_literal != literal) {
+ p["literal"] = literal;
+ cur.forceBufferUpdate();
+ buffer().invalidateBibinfoCache();
+ }
+ setParam("literal", p["literal"]);
+
if (p["key"] != old_key) {
+ // changeRefsIfUnique handles undo
+ cur.bv().buffer().changeRefsIfUnique(old_key, p["key"]);
updateCommand(p["key"]);
- cur.bv().buffer().changeRefsIfUnique(old_key,
- params()["key"], CITE_CODE);
+ cur.forceBufferUpdate();
+ buffer().invalidateBibinfoCache();
}
- buffer_->invalidateBibinfoCache();
break;
}
if (prefixIs(getParam("key"), key_prefix)) {
int const key = convert<int>(getParam("key").substr(key_prefix.length()));
+ Mutex::Locker lock(&counter_mutex);
key_counter = max(key_counter, key);
}
}
docstring InsetBibitem::bibLabel() const
{
- docstring const & label = getParam("label");
+ BufferParams const & bp = buffer().masterBuffer()->params();
+ if (bp.citeEngineType() == ENGINE_TYPE_NUMERICAL)
+ return autolabel_;
+ docstring label = getParam("label");
+ if (!label.empty() && bp.citeEngine() == "natbib") {
+ // Add a space before opening paren
+ label = subst(label, from_ascii("("), from_ascii(" ("));
+ // and strip off long author list
+ docstring striplabel;
+ label = rsplit(label, striplabel, ')');
+ if (!striplabel.empty())
+ label = striplabel + ")";
+ }
return label.empty() ? autolabel_ : label;
}
}
-int InsetBibitem::plaintext(odocstream & os, OutputParams const &) const
+int InsetBibitem::plaintext(odocstringstream & os,
+ OutputParams const &, size_t) const
{
odocstringstream oss;
oss << '[' << bibLabel() << "] ";
docstring const str = oss.str();
os << str;
- return str.size();
-}
-
-
-int InsetBibitem::latex(odocstream & os, OutputParams const & runparams) const
-{
- docstring cmd = '\\' + from_ascii(defaultCommand());
- docstring uncodable;
- if (!getParam("label").empty()) {
- cmd += '[';
- docstring orig = getParam("label");
- for (size_t n = 0; n < orig.size(); ++n) {
- try {
- cmd += runparams.encoding->latexChar(orig[n]);
- } catch (EncodingException & /* e */) {
- LYXERR0("Uncodable character in bibitem!");
- if (runparams.dryrun) {
- cmd += "<" + _("LyX Warning: ")
- + _("uncodable character") + " '";
- cmd += docstring(1, orig[n]);
- cmd += "'>";
- } else
- uncodable += orig[n];
- }
- }
- cmd += ']';
- }
- cmd += '{' + escape(getParam("key")) + '}';
-
- os << cmd;
-
- if (!uncodable.empty()) {
- // issue a warning about omitted characters
- // FIXME: should be passed to the error dialog
- frontend::Alert::warning(_("Uncodable characters in bibliography item"),
- bformat(_("The following characters in one of the bibliography items are\n"
- "not representable in the current encoding and have been omitted:\n%1$s."),
- uncodable));
- }
-
- return 0;
+ return int(str.size());
}
// ale070405
docstring bibitemWidest(Buffer const & buffer, OutputParams const & runparams)
{
+ BufferParams const & bp = buffer.masterBuffer()->params();
+ if (bp.citeEngineType() == ENGINE_TYPE_NUMERICAL)
+ return from_ascii("99");
+
int w = 0;
- InsetBibitem const * bitem = 0;
+ InsetBibitem const * bitem = nullptr;
- // FIXME: this font is used unitialized for now but should be set to
+ // FIXME: this font is used uninitialized for now but should be set to
// a proportional font. Here is what Georg Baum has to say about it:
/*
bibitemWidest() is supposed to find the bibitem with the widest label in the
ParagraphList::const_iterator it = buffer.paragraphs().begin();
ParagraphList::const_iterator end = buffer.paragraphs().end();
+ bool is_literal = false;
for (; it != end; ++it) {
if (it->insetList().empty())
continue;
// So for now we just use the label size in order to be sure
// that GUI and no-GUI gives the same bibitem (even if that is
// potentially the wrong one.
- int const wx = label.size();
+ int const wx = int(label.size());
if (wx > w) {
w = wx;
lbl = label;
+ is_literal = (bitem->getParam("literal") == "true");
}
}
if (!lbl.empty()) {
- docstring latex_lbl;
- for (size_t n = 0; n < lbl.size(); ++n) {
- try {
- latex_lbl += runparams.encoding->latexChar(lbl[n]);
- } catch (EncodingException & /* e */) {
- if (runparams.dryrun) {
- latex_lbl += "<" + _("LyX Warning: ")
- + _("uncodable character") + " '";
- latex_lbl += docstring(1, lbl[n]);
- latex_lbl += "'>";
- }
- }
- }
- return latex_lbl;
+ InsetCommandParams p(BIBITEM_CODE);
+ if (is_literal)
+ p["literal"] = from_ascii("true");
+ return p.prepareCommand(runparams, lbl, ParamInfo::HANDLING_LATEXIFY);
}
return from_ascii("99");
}
-void InsetBibitem::fillWithBibKeys(BiblioInfo & keys, InsetIterator const & it) const
+void InsetBibitem::collectBibKeys(InsetIterator const & it, FileNameList & /*checkedFiles*/) const
{
docstring const key = getParam("key");
+ docstring const label = getParam("label");
BibTeXInfo keyvalmap(false);
- keyvalmap.label(bibLabel());
- DocIterator doc_it(it);
+ keyvalmap.key(key);
+ keyvalmap.label(label);
+
+ BufferParams const & bp = buffer().masterBuffer()->params();
+ Counters & counters = bp.documentClass().counters();
+ docstring const bibitem = from_ascii("bibitem");
+ if (bp.citeEngineType() == ENGINE_TYPE_NUMERICAL || getParam("label").empty()) {
+ if (counters.hasCounter(bibitem))
+ counters.step(bibitem, InternalUpdate);
+ string const & lang = it.paragraph().getParLanguage(bp)->code();
+ keyvalmap.setCiteNumber(counters.theCounter(bibitem, lang));
+ }
+
+ DocIterator doc_it(it);
doc_it.forwardPos();
- keyvalmap[from_ascii("ref")] = doc_it.paragraph().asString();
- keys[key] = keyvalmap;
+ keyvalmap[from_ascii("ref")] = doc_it.paragraph().asString(
+ AS_STR_INSETS | AS_STR_SKIPDELETE);
+ buffer().addBibTeXInfo(key, keyvalmap);
}
// Update the counters of this inset and of its contents
-void InsetBibitem::updateLabels(ParIterator const & it, UpdateType utype)
+void InsetBibitem::updateBuffer(ParIterator const & it, UpdateType utype, bool const /*deleted*/)
{
BufferParams const & bp = buffer().masterBuffer()->params();
Counters & counters = bp.documentClass().counters();
docstring const bibitem = from_ascii("bibitem");
- if (counters.hasCounter(bibitem) && getParam("label").empty()) {
- counters.step(bibitem, utype);
+ if (bp.citeEngineType() == ENGINE_TYPE_NUMERICAL || getParam("label").empty()) {
+ if (counters.hasCounter(bibitem))
+ counters.step(bibitem, utype);
string const & lang = it.paragraph().getParLanguage(bp)->code();
autolabel_ = counters.theCounter(bibitem, lang);
} else {
}
-docstring InsetBibitem::xhtml(XHTMLStream & xs, OutputParams const &) const
+void InsetBibitem::docbook(XMLStream &, OutputParams const &) const
+{
+ // Nothing to do: everything is implemented in makeBibliography.
+}
+
+
+docstring InsetBibitem::xhtml(XMLStream & xs, OutputParams const &) const
{
// FIXME XHTML
// XHTML 1.1 doesn't have the "name" attribute for <a>, so we have to use
- // the "id" atttribute to get the document to validate. Probably, we will
+ // the "id" attribute to get the document to validate. Probably, we will
// need to use "name" anyway, eventually, because some browsers do not
// handle jumping to ids. If we don't do that, though, we can just put the
// id into the span tag.
- string const attrs = "id='" + to_utf8(getParam("key")) + "'";
- xs << html::CompTag("a", attrs);
- xs << html::StartTag("span", "class='bibitemlabel'");
+ string const attrs =
+ "id='LyXCite-" + to_utf8(xml::cleanAttr(getParam("key"))) + "'";
+ xs << xml::CompTag("a", attrs);
+ xs << xml::StartTag("span", "class='bibitemlabel'");
xs << bibLabel();
- xs << html::EndTag("span");
+ xs << xml::EndTag("span");
return docstring();
}
projects / lyx.git / blobdiff